rvoip-rtp-core 0.2.0

RTP/RTCP protocol implementation for the rvoip stack
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

//! Network transport for RTP/RTCP
//!
//! This module provides abstractions for sending and receiving RTP/RTCP packets over the network.

use async_trait::async_trait;
use std::net::SocketAddr;
use tokio::sync::broadcast;

use crate::packet::rtcp::RtcpPacket;
use crate::packet::RtpPacket;
use crate::traits::RtpEvent;
use crate::Result;

/// Trait for RTP transport implementations
#[async_trait]
pub trait RtpTransport: Send + Sync {
    /// Get the local address for RTP
    fn local_rtp_addr(&self) -> Result<SocketAddr>;

    /// Get the local RTCP address (if available)
    fn local_rtcp_addr(&self) -> Result<Option<SocketAddr>>;

    /// Send an RTP packet
    async fn send_rtp(&self, packet: &RtpPacket, dest: SocketAddr) -> Result<()>;

    /// Send raw RTP bytes
    async fn send_rtp_bytes(&self, bytes: &[u8], dest: SocketAddr) -> Result<()>;

    /// Send an RTCP packet
    async fn send_rtcp(&self, packet: &RtcpPacket, dest: SocketAddr) -> Result<()>;

    /// Send raw RTCP bytes
    async fn send_rtcp_bytes(&self, bytes: &[u8], dest: SocketAddr) -> Result<()>;

    /// Receive a packet into the provided buffer
    ///
    /// Returns the number of bytes read and the source address
    async fn receive_packet(&self, buffer: &mut [u8]) -> Result<(usize, SocketAddr)>;

    /// Subscribe to transport events
    ///
    /// This allows receiving both RTP and RTCP packets as events
    fn subscribe(&self) -> broadcast::Receiver<RtpEvent>;

    /// Get a reference to this object as Any
    fn as_any(&self) -> &dyn std::any::Any;

    /// Close the transport
    async fn close(&self) -> Result<()>;
}

/// RTP transport configuration
#[derive(Debug, Clone)]
pub struct RtpTransportConfig {
    /// Local address for RTP
    pub local_rtp_addr: SocketAddr,

    /// Local address for RTCP
    pub local_rtcp_addr: Option<SocketAddr>,

    /// Enable symmetric RTP
    pub symmetric_rtp: bool,

    /// Enable RTCP multiplexing (RFC 5761)
    ///
    /// When enabled, RTCP packets will be sent and received on the same port as RTP packets.
    /// This is recommended for WebRTC and modern VoIP applications.
    pub rtcp_mux: bool,

    /// Session ID for port allocation tracking (optional)
    pub session_id: Option<String>,

    /// Use the global port allocator
    pub use_port_allocator: bool,
}

impl Default for RtpTransportConfig {
    fn default() -> Self {
        Self {
            local_rtp_addr: "0.0.0.0:0".parse().unwrap(),
            local_rtcp_addr: None,
            symmetric_rtp: true,
            rtcp_mux: true, // Enable by default as it's the modern approach
            session_id: None,
            // Don't use port allocator by default - let the caller decide
            use_port_allocator: false,
        }
    }
}

/// Port allocation strategy
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PortPairingStrategy {
    /// Use adjacent port numbers (even for RTP, odd for RTCP)
    Adjacent,
    /// Use the same port for both RTP and RTCP (requires RTCP-MUX)
    Muxed,
}

// Re-export submodules
mod allocator;
pub mod recv_pool;
pub mod security_transport;
mod tcp;
mod udp;
mod validation;

// Re-export transport implementations
pub use allocator::{
    AllocationStrategy, GlobalPortAllocator, PairingStrategy, PortAllocator, PortAllocatorConfig,
    DEFAULT_RTP_PORT_RANGE_END, DEFAULT_RTP_PORT_RANGE_START, MIN_PORT,
};
pub use security_transport::SecurityRtpTransport;
pub use tcp::TcpRtpTransport;
pub use udp::{set_diagnostics as set_udp_diagnostics, UdpRtpTransport};
pub use validation::{PlatformSocketStrategy, PlatformType, RtpSocketValidator};