// Package webrtc provides the backend to simulate a WebRTC client to send stream package webrtc import ( "bufio" "fmt" "io" "log" "net" "os/exec" "github.com/pion/rtp" "github.com/pion/webrtc/v3" "gitlab.crans.org/nounous/ghostream/stream/srt" "gitlab.crans.org/nounous/ghostream/stream/telnet" ) var ( ffmpeg = make(map[string]*exec.Cmd) ffmpegInput = make(map[string]io.WriteCloser) ) func ingestFrom(inputChannel chan srt.Packet) { // FIXME Clean code for { var err error = nil srtPacket := <-inputChannel switch srtPacket.PacketType { case "register": go registerStream(&srtPacket) break case "sendData": if _, ok := ffmpegInput[srtPacket.StreamName]; !ok { break } // FIXME send to stream srtPacket.StreamName if _, err := ffmpegInput[srtPacket.StreamName].Write(srtPacket.Data); err != nil { log.Printf("Failed to write data to ffmpeg input: %s", err) } break case "close": log.Printf("WebRTC CloseConnection %s", srtPacket.StreamName) _ = ffmpeg[srtPacket.StreamName].Process.Kill() _ = ffmpegInput[srtPacket.StreamName].Close() delete(ffmpeg, srtPacket.StreamName) delete(ffmpegInput, srtPacket.StreamName) break default: log.Println("Unknown SRT srtPacket type:", srtPacket.PacketType) break } if err != nil { log.Printf("Error occured while receiving SRT srtPacket of type %s: %s", srtPacket.PacketType, err) } } } func registerStream(srtPacket *srt.Packet) { log.Printf("WebRTC RegisterStream %s", srtPacket.StreamName) // Open a UDP Listener for RTP Packets on port 5004 videoListener, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.ParseIP("127.0.0.1"), Port: 5004}) if err != nil { log.Printf("Faited to open UDP listener %s", err) return } audioListener, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.ParseIP("127.0.0.1"), Port: 5005}) if err != nil { log.Printf("Faited to open UDP listener %s", err) return } // FIXME Close UDP listeners at the end of the stream, not the end of the routine /* defer func() { if err = videoListener.Close(); err != nil { log.Printf("Faited to close UDP listener %s", err) } if err = audioListener.Close(); err != nil { log.Printf("Faited to close UDP listener %s", err) } }() */ ffmpegArgs := []string{"-hide_banner", "-loglevel", "error", "-i", "pipe:0", "-an", "-vcodec", "libvpx", "-crf", "10", "-cpu-used", "5", "-b:v", "6000k", "-maxrate", "8000k", "-bufsize", "12000k", // TODO Change bitrate when changing quality "-qmin", "10", "-qmax", "42", "-threads", "4", "-deadline", "1", "-error-resilient", "1", "-auto-alt-ref", "1", "-f", "rtp", "rtp://127.0.0.1:5004", "-vn", "-acodec", "libopus", "-cpu-used", "5", "-deadline", "1", "-qmin", "10", "-qmax", "42", "-error-resilient", "1", "-auto-alt-ref", "1", "-f", "rtp", "rtp://127.0.0.1:5005"} // Export stream to ascii art if telnet.Cfg.Enabled { bitrate := fmt.Sprintf("%dk", telnet.Cfg.Width*telnet.Cfg.Height/telnet.Cfg.Delay) ffmpegArgs = append(ffmpegArgs, "-an", "-vf", fmt.Sprintf("scale=%dx%d", telnet.Cfg.Width, telnet.Cfg.Height), "-b:v", bitrate, "-minrate", bitrate, "-maxrate", bitrate, "-bufsize", bitrate, "-q", "42", "-pix_fmt", "gray", "-f", "rawvideo", "pipe:1") } ffmpeg[srtPacket.StreamName] = exec.Command("ffmpeg", ffmpegArgs...) input, err := ffmpeg[srtPacket.StreamName].StdinPipe() if err != nil { panic(err) } ffmpegInput[srtPacket.StreamName] = input errOutput, err := ffmpeg[srtPacket.StreamName].StderrPipe() if err != nil { panic(err) } // Receive raw video output and convert it to ASCII art, then forward it TCP if telnet.Cfg.Enabled { output, err := ffmpeg[srtPacket.StreamName].StdoutPipe() if err != nil { panic(err) } go telnet.StartASCIIArtStream(srtPacket.StreamName, output) } if err := ffmpeg[srtPacket.StreamName].Start(); err != nil { panic(err) } // Receive video go func() { inboundRTPPacket := make([]byte, 1500) // UDP MTU for { n, _, err := videoListener.ReadFromUDP(inboundRTPPacket) if err != nil { log.Printf("Failed to read from UDP: %s", err) continue } packet := &rtp.Packet{} if err := packet.Unmarshal(inboundRTPPacket[:n]); err != nil { log.Printf("Failed to unmarshal RTP srtPacket: %s", err) continue } if videoTracks[srtPacket.StreamName] == nil { videoTracks[srtPacket.StreamName] = make([]*webrtc.Track, 0) } // Write RTP srtPacket to all video tracks // Adapt payload and SSRC to match destination for _, videoTrack := range videoTracks[srtPacket.StreamName] { packet.Header.PayloadType = videoTrack.PayloadType() packet.Header.SSRC = videoTrack.SSRC() if writeErr := videoTrack.WriteRTP(packet); writeErr != nil { log.Printf("Failed to write to video track: %s", err) continue } } } }() // Receive audio go func() { inboundRTPPacket := make([]byte, 1500) // UDP MTU for { n, _, err := audioListener.ReadFromUDP(inboundRTPPacket) if err != nil { log.Printf("Failed to read from UDP: %s", err) continue } packet := &rtp.Packet{} if err := packet.Unmarshal(inboundRTPPacket[:n]); err != nil { log.Printf("Failed to unmarshal RTP srtPacket: %s", err) continue } if audioTracks[srtPacket.StreamName] == nil { audioTracks[srtPacket.StreamName] = make([]*webrtc.Track, 0) } // Write RTP srtPacket to all audio tracks // Adapt payload and SSRC to match destination for _, audioTrack := range audioTracks[srtPacket.StreamName] { packet.Header.PayloadType = audioTrack.PayloadType() packet.Header.SSRC = audioTrack.SSRC() if writeErr := audioTrack.WriteRTP(packet); writeErr != nil { log.Printf("Failed to write to audio track: %s", err) continue } } } }() go func() { scanner := bufio.NewScanner(errOutput) for scanner.Scan() { log.Printf("[WEBRTC FFMPEG %s] %s", "demo", scanner.Text()) } }() }