rvoip-rtp-core 0.2.4

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

//! 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 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)
}