Function setupMediaForwarding

main.go:295–386

(peerConnection *webrtc.PeerConnection)

}

func setupMediaForwarding(peerConnection *webrtc.PeerConnection) (*udpConn, *udpConn) {

	// Prepare udp conns
	// Also update incoming packets with expected PayloadType, the browser may use
	// a different value. We have to modify so our stream matches what rtp-forwarder.sdp expects
	videoUDPConn, err := createUDPConnection(*ForwardingAddress, *RTPVideoForwardingPort, uint8(*RTPVideoPayloadType))

	if err != nil {
		log.Println(fmt.Sprintf("Error creating udp connection for video: " + err.Error()))
	}

	audioUDPConn, err := createUDPConnection(*ForwardingAddress, *RTPAudioForwardingPort, uint8(*RTPAudioPayloadType))

	if err != nil {
		log.Println(fmt.Sprintf("Error creating udp connection for audio: " + err.Error()))
	}

	peerConnection.OnTrack(func(track *webrtc.TrackRemote, receiver *webrtc.RTPReceiver) {

		var trackType string = track.Kind().String()
		fmt.Println(fmt.Sprintf("Got %s track from Unreal Engine Pixel Streaming WebRTC.", trackType))

		var udpConnection *udpConn
		switch trackType {
		case "audio":
			udpConnection = audioUDPConn
		case "video":
			udpConnection = videoUDPConn
		default:
			log.Println(fmt.Sprintf("Unsupported track type from Unreal Engine, track type: %s", trackType))
		}

		// Send RTCP message on an interval to the UE side. a PLI on an interval so that the publisher is pushing a keyframe every rtcpPLIInterval
		go func() {
			ticker := time.NewTicker(time.Millisecond * 2000)
			for range ticker.C {

				// Send PLI (picture loss indicator)
				if *RTCPSendPLI {
					if rtcpErr := peerConnection.WriteRTCP([]rtcp.Packet{&rtcp.PictureLossIndication{MediaSSRC: uint32(track.SSRC())}}); rtcpErr != nil {
						fmt.Println(rtcpErr)
					}
				}

				// Send REMB (receiver-side estimated maximum bandwidth)
				if *RTCPSendREMB {
					if rtcpErr := peerConnection.WriteRTCP([]rtcp.Packet{&rtcp.ReceiverEstimatedMaximumBitrate{Bitrate: *REMB, SSRCs: []uint32{uint32(track.SSRC())}}}); rtcpErr != nil {
						fmt.Println(rtcpErr)
					}
				}
			}
		}()

		b := make([]byte, 1500)
		rtpPacket := &rtp.Packet{}
		for {
			// Read
			n, _, readErr := track.Read(b)