hyperspeed-broadcast 0.0.6

FTL media ingest server and WebSocket signaling server.
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

use std::num::{NonZeroU32, NonZeroU8};

use mediasoup::direct_transport::DirectTransportOptions;
use mediasoup::producer::{Producer, ProducerOptions};
use mediasoup::router::Router;
use mediasoup::transport::Transport;
use mediasoup::rtp_parameters::{MediaKind, RtpCodecParameters, RtpEncodingParameters, RtpParameters};

use crate::rtc::codecs::{AudioCodec, VideoCodec};

use super::routers::DataSource;

pub async fn init_producers(router: &Router, source: &DataSource) -> Vec<Producer> {
    let mut producers = Vec::new();

    match source {
        DataSource::Ftl(handshake) => {
            // Prepare transport options
            let transport_options = DirectTransportOptions::default();

            // Create direct transport
            let direct_transport = router
                .create_direct_transport(transport_options)
                .await.unwrap();

            // Initialise video producer
            if let Some(video) = &handshake.video {
                let VideoCodec { mime_type, clock_rate, parameters, rtcp_feedback }
                    = VideoCodec::from(&video.codec);

                let mut video_rtp_params = RtpParameters::default();
                video_rtp_params.codecs = vec![
                    RtpCodecParameters::Video {
                        mime_type,
                        payload_type: video.payload_type,
                        clock_rate: NonZeroU32::new(clock_rate).unwrap(),
                        parameters,
                        rtcp_feedback
                    }
                ];

                video_rtp_params.encodings = vec![
                    RtpEncodingParameters {
                        ssrc: Some(video.ssrc),
                        ..RtpEncodingParameters::default()
                    }
                ];

                producers.push(
                    direct_transport.produce(
                        ProducerOptions::new(MediaKind::Video, video_rtp_params)
                    ).await.unwrap()
                );
            }

            // Initialise audio producer
            if let Some(audio) = &handshake.audio {
                let AudioCodec { mime_type, clock_rate, parameters, rtcp_feedback }
                    = AudioCodec::from(&audio.codec);

                let mut audio_rtp_params = RtpParameters::default();
                audio_rtp_params.codecs = vec![
                    RtpCodecParameters::Audio {
                        mime_type,
                        payload_type: audio.payload_type,
                        clock_rate: NonZeroU32::new(clock_rate).unwrap(),
                        channels: NonZeroU8::new(2).unwrap(),
                        parameters,
                        rtcp_feedback,
                    }
                ];
            
                audio_rtp_params.encodings = vec![
                    RtpEncodingParameters {
                        ssrc: Some(audio.ssrc),
                        ..RtpEncodingParameters::default()
                    }
                ];

                producers.push(
                    direct_transport.produce(
                        ProducerOptions::new(MediaKind::Audio, audio_rtp_params)
                    ).await.unwrap()
                );
            }
        }
    }

    return producers;
}