Rust实时传输控制协议(RTCP)库rtcp-types的使用，RTCP数据包类型解析与序列化工具

许可证

rtcp-types采用双重许可：

• MIT许可证
• Apache 2.0许可证

贡献

欢迎任何形式的贡献，可以通过提交pull request参与项目。

安装

在项目目录中运行以下Cargo命令：

cargo add rtcp-types

或者在Cargo.toml中添加：

rtcp-types = "0.2.0"

使用示例

以下是一个完整的RTCP数据包解析和序列化示例：

use rtcp_types::{RtcpPacket, SdesChunk, SdesItem, SdesItemType};

fn main() {
    // 创建一个SDES RTCP包
    let sdes_chunk = SdesChunk {
        ssrc: 12345678,
        items: vec![
            SdesItem {
                type_: SdesItemType::Cname,
                text: "example@test".into(),
            },
        ],
    };
    
    let sdes_packet = RtcpPacket::Sdes(vec![sdes_chunk]);
    
    // 序列化RTCP包
    let mut buf = vec![0; 1024];
    let len = sdes_packet.serialize_into(&mut buf).unwrap();
    let serialized = &buf[..len];
    
    println!("Serialized RTCP packet ({} bytes): {:?}", len, serialized);
    
    // 解析RTCP包
    let parsed = RtcpPacket::parse(serialized).unwrap();
    println!("Parsed RTCP packet: {:?}", parsed);
    
    match parsed {
        RtcpPacket::Sdes(chunks) => {
            println!("SDES packet with {} chunks", chunks.len());
            for chunk in chunks {
                println!(" SSRC: {}", chunk.ssrc);
                for item in &chunk.items {
                    println!("  {}: {:?}", item.type_, item.text);
                }
            }
        }
        _ => println!("Not an SDES packet"),
    }
}

完整示例代码

use rtcp_types::{
    App, Bye, ReportBlock, ReceiverReport, RtcpPacket, SdesChunk, SdesItem, 
    SdesItemType, SenderReport
};

fn main() {
    // 1. 创建不同类型的RTCP包
    
    // 创建发送方报告(SR)
    let sr_packet = RtcpPacket::SenderReport(SenderReport {
        ssrc: 123456789,
        ntp_timestamp: 0,
        rtp_timestamp: 0,
        packet_count: 100,
        octet_count: 5000,
        reports: vec![
            ReportBlock {
                ssrc: 987654321,
                fraction_lost: 0,
                packets_lost: 0,
                highest_sequence: 100,
                jitter: 0,
                last_sr: 0,
                delay_since_last_sr: 0,
            },
        ],
    });

    // 创建接收方报告(RR)
    let rr_packet = RtcpPacket::ReceiverReport(ReceiverReport {
        ssrc: 123456789,
        reports: vec![
            ReportBlock {
                ssrc: 987654321,
                fraction_lost: 0,
                packets_lost: 0,
                highest_sequence: 100,
                jitter: 0,
                last_sr: 0,
                delay_since_last_sr: 0,
            },
        ],
    });

    // 创建源描述(SDES)
    let sdes_packet = RtcpPacket::Sdes(vec![
        SdesChunk {
            ssrc: 123456789,
            items: vec![
                SdesItem {
                    type_: SdesItemType::Cname,
                    text: "example@test".into(),
                },
                SdesItem {
                    type_: SdesItemType::Name,
                    text: "Test Stream".into(),
                },
            ],
        },
    ]);

    // 创建再见(BYE)包
    let bye_packet = RtcpPacket::Bye(Bye {
        sources: vec![123456789],
        reason: Some("Stream ended".into()),
    });

    // 创建应用定义(APP)包
    let app_packet = RtcpPacket::App(App {
        ssrc: 123456789,
        name: [b'T', b'E', b'S', b'T'],
        data: b"Application data".to_vec(),
    });

    // 2. 序列化并解析各种RTCP包
    let packets = vec![sr_packet, rr_packet, sdes_packet, bye_packet, app_packet];
    
    for packet in packets {
        println!("\nProcessing packet: {:?}", packet);
        
        // 序列化
        let mut buf = vec![0; 1024];
        let len = packet.serialize_into(&mut buf).unwrap();
        let serialized = &buf[..len];
        println!("Serialized ({} bytes): {:02X?}", len, serialized);
        
        // 解析
        let parsed = RtcpPacket::parse(serialized).unwrap();
        println!("Parsed: {:?}", parsed);
        
        // 打印详细信息
        match &parsed {
            RtcpPacket::SenderReport(sr) => {
                println!("Sender Report:");
                println!(" SSRC: {}", sr.ssrc);
                println!(" Packet count: {}", sr.packet_count);
            },
            RtcpPacket::ReceiverReport(rr) => {
                println!("Receiver Report:");
                println!(" SSRC: {}", rr.ssrc);
                println!(" Reports count: {}", rr.reports.len());
            },
            RtcpPacket::Sdes(chunks) => {
                println!("SDES:");
                for chunk in chunks {
                    println!(" Chunk SSRC: {}", chunk.ssrc);
                    for item in &chunk.items {
                        println!("  {:?}: {}", item.type_, item.text);
                    }
                }
            },
            RtcpPacket::Bye(bye) => {
                println!("BYE:");
                println!(" Sources: {:?}", bye.sources);
                if let Some(reason) = &bye.reason {
                    println!(" Reason: {}", reason);
                }
            },
            RtcpPacket::App(app) => {
                println!("APP:");
                println!(" SSRC: {}", app.ssrc);
                println!(" Name: {:?}", std::str::from_utf8(&app.name).unwrap());
                println!(" Data length: {}", app.data.len());
            },
            _ => println!("Unknown packet type"),
        }
    }
}

功能说明

1. 支持RFC 3550定义的RTCP协议
2. 提供RTCP数据包的解析和写入功能
3. 支持多种RTCP包类型：
   • 发送方报告(SR)
   • 接收方报告(RR)
   • 源描述(SDES)
   • 再见(BYE)
   • 应用定义(APP)