rvoip-rtp-core 0.1.8

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
117

//! RTP header extensions functionality
//!
//! This module handles RTP header extensions, including configuration,
//! adding extensions to outgoing packets, and extracting them from incoming packets.

use std::collections::HashMap;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use tokio::sync::Mutex;
use tracing::{debug, warn, info};

use crate::api::common::error::MediaTransportError;
use crate::api::common::extension::ExtensionFormat;
use crate::api::server::transport::HeaderExtension;

/// Check if header extensions are enabled
pub fn is_header_extensions_enabled(
    config_header_extensions_enabled: bool,
) -> bool {
    // Placeholder for the extracted is_header_extensions_enabled functionality
    config_header_extensions_enabled
}

/// Enable header extensions with the specified format
pub async fn enable_header_extensions(
    format: ExtensionFormat,
) -> Result<bool, MediaTransportError> {
    // Placeholder for the extracted enable_header_extensions functionality
    // In a real implementation, this would configure the RTP session to use the specified format
    Ok(true)
}

/// Configure a header extension mapping
pub async fn configure_header_extension(
    id: u8,
    uri: String,
) -> Result<(), MediaTransportError> {
    // Placeholder for the extracted configure_header_extension functionality
    // In a real implementation, this would register the URI for the given ID
    Ok(())
}

/// Configure multiple header extension mappings
pub async fn configure_header_extensions(
    mappings: HashMap<u8, String>,
) -> Result<(), MediaTransportError> {
    // Placeholder for the extracted configure_header_extensions functionality
    // In a real implementation, this would register each URI for its corresponding ID
    Ok(())
}

/// Add a header extension to the next outgoing packet
pub async fn add_header_extension(
    extension: HeaderExtension,
) -> Result<(), MediaTransportError> {
    // Placeholder for the extracted add_header_extension functionality
    // In a real implementation, this would store the extension to be added to the next packet
    Ok(())
}

/// Add audio level header extension
pub async fn add_audio_level_extension(
    voice_activity: bool,
    level: u8,
) -> Result<(), MediaTransportError> {
    // Placeholder for the extracted add_audio_level_extension functionality
    // In a real implementation, this would create and store an audio level extension
    Ok(())
}

/// Add video orientation header extension
pub async fn add_video_orientation_extension(
    camera_front_facing: bool,
    camera_flipped: bool,
    rotation: u16,
) -> Result<(), MediaTransportError> {
    // Placeholder for the extracted add_video_orientation_extension functionality
    // In a real implementation, this would create and store a video orientation extension
    Ok(())
}

/// Add transport-cc header extension
pub async fn add_transport_cc_extension(
    sequence_number: u16,
) -> Result<(), MediaTransportError> {
    // Placeholder for the extracted add_transport_cc_extension functionality
    // In a real implementation, this would create and store a transport-cc extension
    Ok(())
}

/// Get all header extensions received from the remote peer
pub async fn get_received_header_extensions() -> Result<Vec<HeaderExtension>, MediaTransportError> {
    // Placeholder for the extracted get_received_header_extensions functionality
    // In a real implementation, this would return all extensions from the last received packet
    Ok(Vec::new())
}

/// Get audio level header extension received from the remote peer
pub async fn get_received_audio_level() -> Result<Option<(bool, u8)>, MediaTransportError> {
    // Placeholder for the extracted get_received_audio_level functionality
    // In a real implementation, this would extract and return the audio level extension
    Ok(None)
}

/// Get video orientation header extension received from the remote peer
pub async fn get_received_video_orientation() -> Result<Option<(bool, bool, u16)>, MediaTransportError> {
    // Placeholder for the extracted get_received_video_orientation functionality
    // In a real implementation, this would extract and return the video orientation extension
    Ok(None)
}

/// Get transport-cc header extension received from the remote peer
pub async fn get_received_transport_cc() -> Result<Option<u16>, MediaTransportError> {
    // Placeholder for the extracted get_received_transport_cc functionality
    // In a real implementation, this would extract and return the transport-cc extension
    Ok(None)
}