use crate::media::depacketizer::{Depacketizer, DepacketizerFactory};

use crate::media::track::{MediaStreamTrack, SampleStreamSource, SampleStreamTrack, sample_track};

use crate::rtp::{

FirRequest, FullIntraRequest, GenericNack, PictureLossIndication, RtcpPacket, RtpPacket,

SenderReport,

};

use crate::stats::{StatsReport, gather_once};

use crate::stats_collector::StatsCollector;

#[cfg(feature = "t38")]

use crate::t38::endpoint::FaxEndpoint;

#[cfg(feature = "t38")]

use crate::t38::t30::{T30FaxConfig, T30Session};

use crate::transports::dtls::{self, DtlsTransport};

use crate::transports::get_local_ip;

use crate::transports::ice::stun::random_u32;

use crate::transports::ice::{IceCandidate, IceGathererState, IceTransport, conn::IceConn};

use crate::transports::rtp::{RtpRewriteBridgeParams, RtpTransport};

use crate::transports::sctp::SctpTransport;

use crate::transports::udptl::UdtlTransport;

use crate::{

Attribute, AudioCapability, Direction, MediaKind, MediaSection, Origin, RtcConfiguration,

RtcError, RtcResult, SdpType, SessionDescription, TransportMode, VideoCapability,

};

use base64::prelude::*;

use parking_lot::{Mutex, RwLock};

use std::collections::{HashMap, VecDeque};

use std::net::IpAddr;

use std::{

sync::{

Arc,

atomic::{AtomicBool, AtomicU8, AtomicU16, AtomicU32, AtomicU64, Ordering},

},

time::{SystemTime, UNIX_EPOCH},

};

use tokio::sync::{broadcast, mpsc, watch};

use tracing::{debug, info, trace, warn};

use async_trait::async_trait;

use futures::stream::{FuturesUnordered, StreamExt};

use std::future::Future;

use std::pin::Pin;

use std::sync::Weak;

#[async_trait]

pub trait RtpSenderInterceptor: Send + Sync {

async fn on_packet_sent(&self, _packet: &RtpPacket) {}

async fn on_rtcp_received(&self, _packet: &RtcpPacket, _transport: Arc<RtpTransport>) {}

fn as_nack_stats(self: Arc<Self>) -> Option<Arc<dyn NackStats>> {

None

}

}

#[async_trait]

pub trait RtpReceiverInterceptor: Send + Sync {

async fn on_packet_received(&self, _packet: &RtpPacket) -> Option<RtcpPacket> {

None

}

async fn on_rtcp_received(&self, _packet: &RtcpPacket, _transport: Arc<RtpTransport>) {}

fn as_nack_stats(self: Arc<Self>) -> Option<Arc<dyn NackStats>> {

None

}

}

const RTP_RECEIVER_SAMPLE_CAPACITY: usize = 64;

const RTP_RECEIVER_PACKET_CAPACITY: usize = 64;

pub trait NackStats: Send + Sync {

fn get_nack_count(&self) -> u64;

fn get_recovered_count(&self) -> u64 {

0

}

}

pub struct DefaultRtpSenderNackHandler {

buffer: Mutex<VecDeque<RtpPacket>>,

max_size: usize,

pub nack_recv_count: AtomicU64,

}

pub struct DefaultRtpSenderBitrateHandler;

impl DefaultRtpSenderBitrateHandler {

pub fn new() -> Self {

Self

}

}

#[async_trait]

impl RtpSenderInterceptor for DefaultRtpSenderBitrateHandler {

async fn on_rtcp_received(&self, packet: &RtcpPacket, _transport: Arc<RtpTransport>) {

if let RtcpPacket::RemoteBitrateEstimate(remb) = packet {

debug!("Received REMB: {} bps", remb.bitrate_bps);

}

}

}

impl DefaultRtpSenderNackHandler {

pub fn new(max_size: usize) -> Self {

Self {

buffer: Mutex::new(VecDeque::with_capacity(max_size)),

max_size,

nack_recv_count: AtomicU64::new(0),

}

}

}

#[async_trait]

impl RtpSenderInterceptor for DefaultRtpSenderNackHandler {

async fn on_packet_sent(&self, packet: &RtpPacket) {

let mut buffer = self.buffer.lock();

buffer.push_back(packet.clone());

if buffer.len() > self.max_size {

buffer.pop_front();

}

}

async fn on_rtcp_received(&self, packet: &RtcpPacket, transport: Arc<RtpTransport>) {

if let RtcpPacket::GenericNack(nack) = packet {

debug!(

"NACK: received NACK for {} packets",

nack.lost_packets.len()

);

self.nack_recv_count

.fetch_add(nack.lost_packets.len() as u64, Ordering::Relaxed);

let to_resend = {

let buffer = self.buffer.lock();

let mut packets = Vec::new();

for seq in &nack.lost_packets {

if let Some(packet) = buffer.iter().find(|p| p.header.sequence_number == *seq) {

packets.push(packet.clone());

}

}

packets

};

for packet in to_resend {

let seq_num = packet.header.sequence_number;

debug!("NACK: retransmitting packet seq={}", seq_num);

let _ = transport.send_rtp(packet).await;

}

}

}

fn as_nack_stats(self: Arc<Self>) -> Option<Arc<dyn NackStats>> {

Some(self)

}

}

impl NackStats for DefaultRtpSenderNackHandler {

fn get_nack_count(&self) -> u64 {

self.nack_recv_count.load(Ordering::Relaxed)

}

}

pub struct DefaultRtpReceiverNackHandler {

last_seq: AtomicU16,

last_ssrc: AtomicU32,

initialized: std::sync::atomic::AtomicBool,

pub nack_sent_count: AtomicU64,

pub nack_recovered_count: AtomicU64,

}

impl DefaultRtpReceiverNackHandler {

pub fn new() -> Self {

Self {

last_seq: AtomicU16::new(0),

last_ssrc: AtomicU32::new(0),

initialized: std::sync::atomic::AtomicBool::new(false),

nack_sent_count: AtomicU64::new(0),

nack_recovered_count: AtomicU64::new(0),

}

}

}

#[async_trait]

impl RtpReceiverInterceptor for DefaultRtpReceiverNackHandler {

async fn on_packet_received(&self, packet: &RtpPacket) -> Option<RtcpPacket> {

let seq = packet.header.sequence_number;

let ssrc = packet.header.ssrc;

// Check if SSRC changed - indicates stream switch

let last_ssrc = self.last_ssrc.load(Ordering::SeqCst);

if last_ssrc != 0 && last_ssrc != ssrc {

debug!(

"NACK: SSRC changed from {} to {}, resetting state",

last_ssrc, ssrc

);

self.last_ssrc.store(ssrc, Ordering::SeqCst);

self.last_seq.store(seq, Ordering::SeqCst);

return None; // Don't send NACK on stream switch

}

if !self.initialized.swap(true, Ordering::SeqCst) {

self.last_ssrc.store(ssrc, Ordering::SeqCst);

self.last_seq.store(seq, Ordering::SeqCst);

return None;

}

let last = self.last_seq.load(Ordering::SeqCst);

let diff = seq.wrapping_sub(last);

if diff > 1 && diff < 32768 {

let mut lost = Vec::new();

let mut s = last.wrapping_add(1);

while s != seq {

lost.push(s);

s = s.wrapping_add(1);

}

debug!(

"NACK: detected gap from {} to {}, lost {} packets",

last,

seq,

lost.len()

);

self.nack_sent_count

.fetch_add(lost.len() as u64, Ordering::Relaxed);

self.last_seq.store(seq, Ordering::SeqCst);

return Some(RtcpPacket::GenericNack(GenericNack {

sender_ssrc: 0, // Will be filled by receiver

media_ssrc: packet.header.ssrc,

lost_packets: lost,

}));

}

if diff < 32768 {

self.last_seq.store(seq, Ordering::SeqCst);

} else if diff > 32768 {

debug!("NACK: received old packet seq={}, last={}", seq, last);

self.nack_recovered_count.fetch_add(1, Ordering::Relaxed);

}

None

}

fn as_nack_stats(self: Arc<Self>) -> Option<Arc<dyn NackStats>> {

Some(self)

}

}

impl NackStats for DefaultRtpReceiverNackHandler {

fn get_nack_count(&self) -> u64 {

self.nack_sent_count.load(Ordering::Relaxed)

}

fn get_recovered_count(&self) -> u64 {

self.nack_recovered_count.load(Ordering::Relaxed)

}

}

enum ReceiverCommand {

AddTrack {

rid: Option<String>,

packet_rx: mpsc::Receiver<(crate::rtp::RtpPacket, std::net::SocketAddr)>,

feedback_rx:

std::sync::Arc<tokio::sync::Mutex<mpsc::Receiver<crate::media::track::FeedbackEvent>>>,

source: std::sync::Arc<crate::media::track::SampleStreamSource>,

simulcast_ssrc: std::sync::Arc<Mutex<Option<u32>>>,

},

}

enum LoopEvent {

Packet(

Option<(crate::rtp::RtpPacket, std::net::SocketAddr)>,

Option<String>,

mpsc::Receiver<(crate::rtp::RtpPacket, std::net::SocketAddr)>,

Box<dyn Depacketizer>,

),

Feedback(Option<crate::media::track::FeedbackEvent>, Option<String>),

}

#[derive(Clone)]

pub enum PeerConnectionEvent {

DataChannel(Arc<crate::transports::sctp::DataChannel>),

Track(Arc<RtpTransceiver>),

}

#[derive(Clone)]

pub struct PeerConnection {

inner: Arc<PeerConnectionInner>,

}

struct PeerConnectionInner {

config: RtcConfiguration,

signaling_state: watch::Sender<SignalingState>,

_signaling_state_rx: watch::Receiver<SignalingState>,

peer_state: watch::Sender<PeerConnectionState>,

_peer_state_rx: watch::Receiver<PeerConnectionState>,

ice_connection_state: watch::Sender<IceConnectionState>,

_ice_connection_state_rx: watch::Receiver<IceConnectionState>,

ice_gathering_state: watch::Sender<IceGatheringState>,

_ice_gathering_state_rx: watch::Receiver<IceGatheringState>,

local_description: Mutex<Option<SessionDescription>>,

remote_description: Mutex<Option<SessionDescription>>,

transceivers: Mutex<Vec<Arc<RtpTransceiver>>>,

next_mid: AtomicU16,

ice_transport: IceTransport,

certificate: Arc<dtls::Certificate>,

dtls_fingerprint: String,

remote_dtls_fingerprint: Mutex<Option<String>>,

dtls_transport: Mutex<Option<Arc<DtlsTransport>>>,

rtp_transport: Mutex<Option<Arc<RtpTransport>>>,

rtp_media_ice_transports: Mutex<HashMap<u64, IceTransport>>,

rtp_media_transports: Mutex<HashMap<u64, Arc<RtpTransport>>>,

sctp_transport: Mutex<Option<Arc<SctpTransport>>>,

data_channels: Arc<Mutex<Vec<std::sync::Weak<crate::transports::sctp::DataChannel>>>>,

event_tx: mpsc::UnboundedSender<PeerConnectionEvent>,

event_rx: tokio::sync::Mutex<mpsc::UnboundedReceiver<PeerConnectionEvent>>,

dtls_role: watch::Sender<Option<bool>>,

_dtls_role_rx: watch::Receiver<Option<bool>>,

stats_collector: Arc<StatsCollector>,

ssrc_generator: AtomicU32,

disconnect_reason: watch::Sender<Option<DisconnectReason>>,

_disconnect_reason_rx: watch::Receiver<Option<DisconnectReason>>,

}

pub(crate) fn generate_sdes_key_params() -> String {

let mut key_salt = [0u8; 30];

rand::fill(&mut key_salt);

let encoded = BASE64_STANDARD.encode(&key_salt);

format!("inline:{}", encoded)

}

pub(crate) fn parse_sdes_key_params(params: &str) -> RtcResult<Vec<u8>> {

if !params.starts_with("inline:") {

return Err(RtcError::Internal("Unsupported key params".into()));

}

let key_salt_base64 = &params[7..];

let key_salt_base64 = key_salt_base64.split('|').next().ok_or_else(|| {

RtcError::Internal("Empty key params after 'inline:' prefix".into())

})?;

if key_salt_base64.is_empty() {

return Err(RtcError::Internal("Empty key params after 'inline:' prefix".into()));

}

BASE64_STANDARD

.decode(key_salt_base64)

.map_err(|e| RtcError::Internal(format!("Invalid base64 key: {}", e)))

}

pub(crate) fn map_crypto_suite(suite: &str) -> RtcResult<crate::srtp::SrtpProfile> {

match suite {

"AES_CM_128_HMAC_SHA1_80" => Ok(crate::srtp::SrtpProfile::Aes128Sha1_80),

"AES_CM_128_HMAC_SHA1_32" => Ok(crate::srtp::SrtpProfile::Aes128Sha1_32),

"AEAD_AES_128_GCM" => Ok(crate::srtp::SrtpProfile::AeadAes128Gcm),

_ => Err(RtcError::Internal(format!(

"Unsupported crypto suite: {}",

suite

))),

}

}

impl PeerConnection {

pub fn new(config: RtcConfiguration) -> Self {

let is_rtp_mode = config.transport_mode == TransportMode::Rtp;

let (ice_transport, ice_runner) = IceTransport::new(config.clone());

let certificate =

Arc::new(dtls::generate_certificate().expect("failed to generate certificate"));

let dtls_fingerprint = dtls::fingerprint(&certificate);

let (signaling_state_tx, signaling_state_rx) = watch::channel(SignalingState::Stable);

let (peer_state_tx, peer_state_rx) = watch::channel(PeerConnectionState::New);

let (ice_connection_state_tx, ice_connection_state_rx) =

watch::channel(IceConnectionState::New);

let (ice_gathering_state_tx, ice_gathering_state_rx) =

watch::channel(IceGatheringState::New);

let (dtls_role_tx, dtls_role_rx) = watch::channel(None);

let ssrc_generator = AtomicU32::new(config.ssrc_start);

let (event_tx, event_rx) = mpsc::unbounded_channel();

let (disconnect_reason_tx, disconnect_reason_rx) = watch::channel(None);

let inner = PeerConnectionInner {

config,

signaling_state: signaling_state_tx,

_signaling_state_rx: signaling_state_rx,

peer_state: peer_state_tx,

_peer_state_rx: peer_state_rx,

ice_connection_state: ice_connection_state_tx,

_ice_connection_state_rx: ice_connection_state_rx,

ice_gathering_state: ice_gathering_state_tx,

_ice_gathering_state_rx: ice_gathering_state_rx,

local_description: Mutex::new(None),

remote_description: Mutex::new(None),

transceivers: Mutex::new(Vec::new()),

next_mid: AtomicU16::new(0),

ice_transport,

certificate,

dtls_fingerprint,

remote_dtls_fingerprint: Mutex::new(None),

dtls_transport: Mutex::new(None),

rtp_transport: Mutex::new(None),

rtp_media_ice_transports: Mutex::new(HashMap::new()),

rtp_media_transports: Mutex::new(HashMap::new()),

sctp_transport: Mutex::new(None),

data_channels: Arc::new(Mutex::new(Vec::new())),

event_tx,

event_rx: tokio::sync::Mutex::new(event_rx),

dtls_role: dtls_role_tx,

_dtls_role_rx: dtls_role_rx.clone(),

stats_collector: Arc::new(StatsCollector::new()),

ssrc_generator,

disconnect_reason: disconnect_reason_tx,

_disconnect_reason_rx: disconnect_reason_rx,

};

let pc = Self {

inner: Arc::new(inner),

};

if is_rtp_mode {

// RTP mode: skip ICE gathering/connectivity/DTLS loops entirely.

// Only run the ice_runner for socket read loops (needed to receive packets).

// The ICE state machine and DTLS loop are handled directly via

// setup_direct_rtp / complete_direct_rtp.

let inner_weak = Arc::downgrade(&pc.inner);

let ice_transport = pc.inner.ice_transport.clone();

let ice_connection_state_tx = pc.inner.ice_connection_state.clone();

tokio::spawn(async move {

let rtp_ice_loop =

run_rtp_direct_loop(ice_transport, ice_connection_state_tx, inner_weak);

tokio::join!(rtp_ice_loop, ice_runner);

});

} else {

let inner_weak = Arc::downgrade(&pc.inner);

let ice_transport = pc.inner.ice_transport.clone();

let dtls_role_rx = dtls_role_rx;

let ice_connection_state_tx = pc.inner.ice_connection_state.clone();

let ice_transport_gathering = ice_transport.clone();

let ice_gathering_state_tx = pc.inner.ice_gathering_state.clone();

let inner_weak_gathering = inner_weak.clone();

tokio::spawn(async move {

let gathering_loop = run_gathering_loop(

ice_transport_gathering,

ice_gathering_state_tx,

inner_weak_gathering,

);

let dtls_loop = run_ice_dtls_loop(

ice_transport,

ice_connection_state_tx,

dtls_role_rx,

inner_weak,

);

tokio::join!(gathering_loop, dtls_loop, ice_runner);

});

}

pc

}

pub fn config(&self) -> &RtcConfiguration {

&self.inner.config

}

pub fn bridge_rtp_with_rewrite_to(

&self,

dst: &PeerConnection,

params: RtpRewriteBridgeParams,

) -> RtcResult<()> {

let src = self.inner.rtp_transport.lock().clone().ok_or_else(|| {

RtcError::InvalidState("RTP transport is not ready for source PeerConnection".into())

})?;

let dst = dst.inner.rtp_transport.lock().clone().ok_or_else(|| {

RtcError::InvalidState(

"RTP transport is not ready for destination PeerConnection".into(),

)

})?;

src.bridge_rewrite_to(dst, params);

Ok(())

}

pub fn bridge_rtp_with_rewrite_to_self(&self, params: RtpRewriteBridgeParams) -> RtcResult<()> {

let transport = self.inner.rtp_transport.lock().clone().ok_or_else(|| {

RtcError::InvalidState("RTP transport is not ready for PeerConnection".into())

})?;

transport.bridge_rewrite_to(transport.clone(), params);

Ok(())

}

pub fn clear_rtp_rewrite_bridge(&self) {

if let Some(transport) = self.inner.rtp_transport.lock().clone() {

transport.clear_bridge_rewrite();

}

for transport in self.inner.rtp_media_transports.lock().values() {

transport.clear_bridge_rewrite();

}

}

pub async fn wait_for_rtp_transport_ready(

&self,

timeout: std::time::Duration,

) -> RtcResult<()> {

let deadline = tokio::time::Instant::now() + timeout;

while tokio::time::Instant::now() < deadline {

if self.inner.rtp_transport.lock().is_some() {

return Ok(());

}

tokio::time::sleep(std::time::Duration::from_millis(10)).await;

}

Err(RtcError::InvalidState(

"timed out waiting for RTP transport".into(),

))

}

pub fn ice_transport(&self) -> IceTransport {

self.inner.ice_transport.clone()

}

fn rtp_transport_for_transceiver_or(

&self,

transceiver: &Arc<RtpTransceiver>,

default: Arc<RtpTransport>,

) -> Arc<RtpTransport> {

self.inner

.rtp_media_transports

.lock()

.get(&transceiver.id())

.cloned()

.unwrap_or(default)

}

fn attach_rtp_transport_to_transceiver(

&self,

transceiver: &Arc<RtpTransceiver>,

transport: Arc<RtpTransport>,

) {

transceiver.set_rtp_transport(Arc::downgrade(&transport));

let extmap = transceiver.get_extmap();

let _ = transceiver.update_extmap(extmap);

let sender_arc = transceiver.sender.lock().clone();

let receiver_arc = transceiver.receiver.lock().clone();

if let Some(sender) = &sender_arc {

sender.set_transport(transport.clone());

}

if let Some(receiver) = &receiver_arc {

receiver.set_transport(

transport,

Some(self.inner.event_tx.clone()),

Some(Arc::downgrade(transceiver)),

);

if let Some(sender) = &sender_arc {

receiver.set_feedback_ssrc(sender.ssrc());

}

}

}

pub fn add_transceiver(

&self,

kind: MediaKind,

direction: TransceiverDirection,

) -> Arc<RtpTransceiver> {

let transceiver = Arc::new(RtpTransceiver::new(kind, direction));

let mut builder = RtpReceiverBuilder::new(kind, 0)

.payload_map(transceiver.payload_map.clone())

.interceptor(self.inner.stats_collector.clone())

.depacketizer_factory(self.inner.config.depacketizer_strategy.factory.clone());

let nack_enabled = if let Some(caps) = &self.inner.config.media_capabilities {

match kind {

MediaKind::Audio => caps

.audio

.iter()

.any(|c| c.rtcp_fbs.contains(&"nack".to_string())),

MediaKind::Video => caps

.video

.iter()

.any(|c| c.rtcp_fbs.contains(&"nack".to_string())),

MediaKind::Application => false,

MediaKind::Image => false,

}

} else {

match kind {

MediaKind::Audio => AudioCapability::default()

.rtcp_fbs

.contains(&"nack".to_string()),

MediaKind::Video => VideoCapability::default()

.rtcp_fbs

.contains(&"nack".to_string()),

MediaKind::Application => false,

MediaKind::Image => false,

}

};

if nack_enabled {

builder = builder.nack();

}

let receiver = builder.build();

if direction.sends() {

let rand_val = random_u32();

let ssrc = self

.inner

.ssrc_generator

.fetch_add(1 + rand_val, Ordering::Relaxed);

*transceiver.sender_ssrc.lock() = Some(ssrc);

*transceiver.sender_stream_id.lock() = Some("default".to_string());

*transceiver.sender_track_id.lock() = Some(format!("track-{}", transceiver.id()));

}

transceiver.set_receiver(Some(receiver));

let mut list = self.inner.transceivers.lock();

list.push(transceiver.clone());

transceiver

}

pub fn add_track(

&self,

track: Arc<dyn MediaStreamTrack>,

params: RtpCodecParameters,

) -> RtcResult<Arc<RtpSender>> {

let stream_id = format!("{}", track.id());

self.add_track_with_stream_id(track, stream_id, params)

}

pub fn add_track_with_stream_id(

&self,

track: Arc<dyn MediaStreamTrack>,

stream_id: String,

params: RtpCodecParameters,

) -> RtcResult<Arc<RtpSender>> {

let kind = match track.kind() {

crate::media::frame::MediaKind::Audio => MediaKind::Audio,

crate::media::frame::MediaKind::Video => MediaKind::Video,

};

// Reuse a transceiver created from the remote offer (WHEP/answerer path).

// Otherwise add_track would create a second same-kind transceiver without the

// offer MID, and create_answer would bind the offer m-line to the empty one.

let transceiver = {

let list = self.inner.transceivers.lock();

if let Some(existing) = list.iter().find(|t| {

t.kind() == kind && t.mid().is_some() && t.sender.lock().is_none()

}) {

info!(

"add_track: reusing offer transceiver kind={:?} mid={:?}",

kind,

existing.mid()

);

existing.clone()

} else {

drop(list);

self.add_transceiver(kind, TransceiverDirection::SendRecv)

}

};

let ssrc = (*transceiver.sender_ssrc.lock())

.unwrap_or_else(|| self.inner.ssrc_generator.fetch_add(1, Ordering::Relaxed));

let mut builder = RtpSenderBuilder::new(track, ssrc)

.stream_id(stream_id)

.params(params)

.interceptor(self.inner.stats_collector.clone());

if let Some(ref cname) = self.inner.config.cname {

builder = builder.cname(cname.clone());

}

let nack_enabled = if let Some(caps) = &self.inner.config.media_capabilities {

match kind {

MediaKind::Audio => caps

.audio

.iter()

.any(|c| c.rtcp_fbs.contains(&"nack".to_string())),

MediaKind::Video => caps

.video

.iter()

.any(|c| c.rtcp_fbs.contains(&"nack".to_string())),

MediaKind::Application => false,

MediaKind::Image => false,

}

} else {

match kind {

MediaKind::Audio => AudioCapability::default()

.rtcp_fbs

.contains(&"nack".to_string()),

MediaKind::Video => VideoCapability::default()

.rtcp_fbs

.contains(&"nack".to_string()),

MediaKind::Application => false,

MediaKind::Image => false,

}

};

if nack_enabled {

builder = builder

.nack(self.inner.config.nack_buffer_size)

.bitrate_controller();

}

let sender = builder.build();

// Update transceiver's pre-allocated info to match the actual sender

*transceiver.sender_ssrc.lock() = Some(sender.ssrc());

*transceiver.sender_stream_id.lock() = Some(sender.stream_id().to_string());

*transceiver.sender_track_id.lock() = Some(sender.track_id().to_string());

// If transport is already established, attach the new transceiver

// immediately. In direct RTP mode, only attach to an explicit media

// transport; falling back to the primary transport would put a newly

// added non-BUNDLE video sender on the audio socket until SDP setup

// catches up.

let transport = self

.inner

.rtp_media_transports

.lock()

.get(&transceiver.id())

.cloned()

.or_else(|| {

if self.inner.config.transport_mode == TransportMode::Rtp {

None

} else {

self.inner.rtp_transport.lock().clone()

}

});

transceiver.set_sender(Some(sender.clone()));

if let Some(transport) = transport {

self.attach_rtp_transport_to_transceiver(&transceiver, transport);

}

Ok(sender)

}

pub fn get_transceivers(&self) -> Vec<Arc<RtpTransceiver>> {

self.inner.transceivers.lock().clone()

}

pub async fn create_offer(&self) -> RtcResult<SessionDescription> {

let state = &self.inner.signaling_state;

if *state.borrow() != SignalingState::Stable {

return Err(RtcError::InvalidState(format!(

"cannot create offer while in state {:?}",

*state.borrow()

)));

}

let should_set_controlling = {

let local = self.inner.local_description.lock();

let remote = self.inner.remote_description.lock();

local.is_none() && remote.is_none()

};

if should_set_controlling {

self.inner

.ice_transport

.set_role(crate::transports::ice::IceRole::Controlling);

}

let desc = self

.inner

.build_description(SdpType::Offer, |dir| dir)

.await?;

if self.inner.config.transport_mode == TransportMode::Rtp && !Self::sdp_has_bundle(&desc) {

for (media_index, (transceiver, _)) in self

.matched_rtp_media_sections(&desc)

.into_iter()

.enumerate()

{

if media_index == 0 {

continue;

}

let ice_transport = self.inner.direct_rtp_ice_transport(transceiver.id(), false);

self.ensure_direct_rtp_media_transport(&transceiver, &ice_transport, None, None)

.await;

}

}

Ok(desc)

}

pub async fn create_answer(&self) -> RtcResult<SessionDescription> {

let state = &self.inner.signaling_state;

if *state.borrow() != SignalingState::HaveRemoteOffer {

return Err(RtcError::InvalidState(

"create_answer requires remote offer".into(),

));

}

self.inner

.ice_transport

.set_role(crate::transports::ice::IceRole::Controlled);

self.inner

.build_description(SdpType::Answer, |dir| dir.answer_direction())

.await

}

pub fn set_local_description(&self, desc: SessionDescription) -> RtcResult<()> {

self.inner.validate_sdp_type(&desc.sdp_type)?;

// For Offerer: extract parameters from local offer (our intended changes)

// This allows Offerer to immediately update transceivers with new parameters

// that will be confirmed when answer is received

if desc.sdp_type == SdpType::Offer {

let is_reinvite = {

let local = self.inner.local_description.lock();

local.is_some()

};

if is_reinvite {

debug!("Offerer: extracting parameters from local reinvite offer");

// Extract parameters from our offer for transceivers

let transceivers = self.inner.transceivers.lock().clone();

for section in &desc.media_sections {

let mut matched_transceiver = transceivers

.iter()

.find(|t| t.mid().as_ref() == Some(&section.mid))

.map(|t| t.clone());

// If not found by MID, try to match with mid-less transceiver (e.g. manual SDP)

if matched_transceiver.is_none() {

if let Some(t) = transceivers

.iter()

.find(|t| t.mid().is_none() && t.kind() == section.kind)

{

t.set_mid(section.mid.clone());

matched_transceiver = Some(t.clone());

}

}

if let Some(t) = matched_transceiver {

let payload_map = Self::extract_payload_map(section);

if !payload_map.is_empty() {

let _ = t.update_payload_map(payload_map);

}

let extmap = Self::extract_extmap(section);

let _ = t.update_extmap(extmap);

}

}

} else {

// Initial offer: ensure MIDs are assigned if we match unassigned transceivers

// This covers manual SDP creation (skipped create_offer)

let transceivers = self.inner.transceivers.lock().clone();

for section in &desc.media_sections {

if transceivers

.iter()

.any(|t| t.mid().as_ref() == Some(&section.mid))

{

continue;

}

// Assign to first matching unassigned transceiver

if let Some(t) = transceivers

.iter()

.find(|t| t.mid().is_none() && t.kind() == section.kind)

{

t.set_mid(section.mid.clone());

}

}

}

}

{

let state = &self.inner.signaling_state;

match desc.sdp_type {

SdpType::Offer => {

if *state.borrow() != SignalingState::Stable {

return Err(RtcError::InvalidState(

"set_local_description(offer) requires stable signaling state".into(),

));

}

let _ = state.send(SignalingState::HaveLocalOffer);

}

SdpType::Answer => {

if *state.borrow() != SignalingState::HaveRemoteOffer {

return Err(RtcError::InvalidState(

"set_local_description(answer) requires remote offer".into(),

));

}

let _ = state.send(SignalingState::Stable);

}

SdpType::Pranswer => {

if *state.borrow() != SignalingState::HaveRemoteOffer {

return Err(RtcError::InvalidState(

"set_local_description(pranswer) requires remote offer".into(),

));

}

// Stay in HaveRemoteOffer.

}

SdpType::Rollback => {

return Err(RtcError::NotImplemented("rollback"));

}

}

}

let mut local = self.inner.local_description.lock();

*local = Some(desc);

Ok(())

}

pub async fn set_remote_description(&self, desc: SessionDescription) -> RtcResult<()> {

self.inner.validate_sdp_type(&desc.sdp_type)?;

let remote_dtls_fingerprint = if self.config().transport_mode == TransportMode::WebRtc {

match desc.dtls_fingerprint() {

Ok(Some(fingerprint)) if fingerprint.algorithm == "sha-256" => {

Some(fingerprint.value)

}

Ok(Some(fingerprint)) => {

return Err(RtcError::InvalidConfiguration(format!(

"unsupported DTLS fingerprint algorithm: {}",

fingerprint.algorithm

)));

}

Ok(None) => {

return Err(RtcError::InvalidConfiguration(

"remote SDP in WebRTC mode must contain a DTLS fingerprint".into(),

));

}

Err(err) => {

return Err(RtcError::InvalidConfiguration(format!(

"invalid DTLS fingerprint in remote SDP: {}",

err

)));

}

}

} else {

None

};

// Check if this is a reinvite (not first negotiation)

let is_reinvite = {

let remote = self.inner.remote_description.lock();

remote.is_some()

};

if is_reinvite {

// Apply reinvite at correct timing based on role

let current_state = *self.inner.signaling_state.borrow();

match (desc.sdp_type, current_state) {

// Answerer receiving offer: apply immediately

(SdpType::Offer, SignalingState::Stable) => {

debug!("Answerer: applying reinvite from offer");

self.handle_reinvite(&desc).await?;

}

(SdpType::Answer | SdpType::Pranswer, SignalingState::HaveLocalOffer) => {

debug!("Offerer: applying reinvite from answer/pranswer");

self.handle_reinvite(&desc).await?;

}

// Invalid states for reinvite

(SdpType::Offer, _) => {

return Err(RtcError::InvalidState(

"Cannot handle reinvite offer in non-stable state (glare?)".into(),

));

}

_ => {}

}

}

// Update next_mid to avoid collisions with remote MIDs

for section in &desc.media_sections {

if let Ok(mid_val) = section.mid.parse::<u16>() {

self.inner.next_mid.fetch_max(mid_val + 1, Ordering::SeqCst);

}

}

{

let state = &self.inner.signaling_state;

match desc.sdp_type {

SdpType::Offer => {

if *state.borrow() != SignalingState::Stable {

return Err(RtcError::InvalidState(

"set_remote_description(offer) requires stable signaling state".into(),

));

}

let _ = state.send(SignalingState::HaveRemoteOffer);

}

SdpType::Answer => {

if *state.borrow() != SignalingState::HaveLocalOffer {

return Err(RtcError::InvalidState(

"set_remote_description(answer) requires local offer".into(),

));

}

let _ = state.send(SignalingState::Stable);

}

SdpType::Pranswer => {

// Provisional answer (SIP 183 early media): set up media transport like an

// answer but keep signaling state in HaveLocalOffer so the final 200 OK

// answer can still arrive and complete the negotiation.

if *state.borrow() != SignalingState::HaveLocalOffer {

return Err(RtcError::InvalidState(

"set_remote_description(pranswer) requires local offer".into(),

));

}

// Do NOT transition to Stable – stay in HaveLocalOffer.

}

SdpType::Rollback => {

return Err(RtcError::NotImplemented("rollback"));

}

}

}

{

let current_role = *self.inner.dtls_role.borrow();

if current_role.is_none() {

let mut new_role = None;

if self.config().transport_mode == TransportMode::Rtp

|| self.config().transport_mode == TransportMode::Srtp

{

new_role = Some(true);

} else {

for section in &desc.media_sections {

for attr in &section.attributes {

if attr.key == "setup"

&& let Some(val) = &attr.value

{

let is_client = match val.as_str() {

"active" => false,

"passive" => true,