Add rtmp-to-webrtc

Example that demonstrates how you can pull from a RTMP server and send
into the browser.

Resolves pion/webrtc#1644

Author: Sean-Der

rtmp-to-webrtc/README.md

@@ -0,0 +1,43 @@
+# rtmp-to-webrtc
+rtmp-to-webrtc demonstrates how you could re-stream media from a RTMP server to WebRTC.
+This example was heavily inspired by [rtp-to-webrtc](https://github.com/pion/webrtc/tree/master/examples/rtp-to-webrtc)
+
+This example re-encodes to VP8. Pion WebRTC supports H264, but browser support is inconsistent. To switch video codecs replace all occurrences
+of VP8 with H264 in `main.go`
+
+## Instructions
+### Download rtmp-to-webrtc
+```
+export GO111MODULE=on
+go get github.com/pion/webrtc/v3/examples/rtmp-to-webrtc
+```
+
+### Open jsfiddle example page
+[jsfiddle.net](https://jsfiddle.net/z7ms3u5r/) you should see two text-areas and a 'Start Session' button
+
+
+### Run rtmp-to-webrtc with your browsers SessionDescription as stdin
+In the jsfiddle the top textarea is your browser's SessionDescription, copy that and:
+
+#### Linux/macOS
+Run `echo $BROWSER_SDP | rtmp-to-webrtc`
+
+#### Windows
+1. Paste the SessionDescription into a file.
+1. Run `rtmp-to-webrtc < my_file`
+
+### Send RTP to listening socket
+On startup you will get a message `Waiting for RTP Packets`, you can use any software to send VP8 packets to port 5004 and Opus packets to port 5006. We have an example using ffmpeg below
+
+#### ffmpeg
+```
+ffmpeg -i '$RTMP_URL' -an -vcodec libvpx -cpu-used 5 -deadline 1 -g 10 -error-resilient 1 -auto-alt-ref 1 -f rtp rtp://127.0.0.1:5004 -vn -c:a libopus -f rtp rtp:/127.0.0.1:5006
+```
+
+### Input rtmp-to-webrtc's SessionDescription into your browser
+Copy the text that `rtmp-to-webrtc` just emitted and copy into second text area
+
+### Hit 'Start Session' in jsfiddle, enjoy your video!
+A video should start playing in your browser above the input boxes.
+
+Congrats, you have used Pion WebRTC! Now start building something cool

rtmp-to-webrtc/main.go

@@ -0,0 +1,147 @@
+// +build !js
+
+package main
+
+import (
+	"fmt"
+	"net"
+
+	"github.com/pion/example-webrtc-applications/internal/signal"
+	"github.com/pion/rtp"
+	"github.com/pion/rtp/codecs"
+	"github.com/pion/webrtc/v3"
+	"github.com/pion/webrtc/v3/pkg/media/samplebuilder"
+)
+
+func main() {
+	peerConnection, err := webrtc.NewPeerConnection(webrtc.Configuration{
+		ICEServers: []webrtc.ICEServer{
+			{
+				URLs: []string{"stun:stun.l.google.com:19302"},
+			},
+		},
+	})
+	if err != nil {
+		panic(err)
+	}
+
+	// Create a video track
+	videoTrack, err := webrtc.NewTrackLocalStaticSample(webrtc.RTPCodecCapability{MimeType: "video/vp8"}, "video", "pion")
+	if err != nil {
+		panic(err)
+	}
+	rtpSender, err := peerConnection.AddTrack(videoTrack)
+	if err != nil {
+		panic(err)
+	}
+	processRTCP(rtpSender)
+
+	// Create a video track
+	audioTrack, err := webrtc.NewTrackLocalStaticSample(webrtc.RTPCodecCapability{MimeType: "audio/opus"}, "audio", "pion")
+	if err != nil {
+		panic(err)
+	}
+	rtpSender, err = peerConnection.AddTrack(audioTrack)
+	if err != nil {
+		panic(err)
+	}
+	processRTCP(rtpSender)
+
+	// Set the handler for ICE connection state
+	// This will notify you when the peer has connected/disconnected
+	peerConnection.OnICEConnectionStateChange(func(connectionState webrtc.ICEConnectionState) {
+		fmt.Printf("Connection State has changed %s \n", connectionState.String())
+	})
+
+	// Wait for the offer to be pasted
+	offer := webrtc.SessionDescription{}
+	signal.Decode(signal.MustReadStdin(), &offer)
+
+	// Set the remote SessionDescription
+	if err = peerConnection.SetRemoteDescription(offer); err != nil {
+		panic(err)
+	}
+
+	// Create answer
+	answer, err := peerConnection.CreateAnswer(nil)
+	if err != nil {
+		panic(err)
+	}
+
+	// Create channel that is blocked until ICE Gathering is complete
+	gatherComplete := webrtc.GatheringCompletePromise(peerConnection)
+
+	// Sets the LocalDescription, and starts our UDP listeners
+	if err = peerConnection.SetLocalDescription(answer); err != nil {
+		panic(err)
+	}
+
+	// Block until ICE Gathering is complete, disabling trickle ICE
+	// we do this because we only can exchange one signaling message
+	// in a production application you should exchange ICE Candidates via OnICECandidate
+	<-gatherComplete
+
+	// Output the answer in base64 so we can paste it in browser
+	fmt.Println(signal.Encode(*peerConnection.LocalDescription()))
+
+	go rtpToTrack(videoTrack, &codecs.VP8Packet{}, 90000, 5004)
+	rtpToTrack(audioTrack, &codecs.OpusPacket{}, 48000, 5006)
+}
+
+// Listen for incoming packets on a port and write them to a Track
+func rtpToTrack(track *webrtc.TrackLocalStaticSample, depacketizer rtp.Depacketizer, sampleRate uint32, port int) {
+	// Open a UDP Listener for RTP Packets on port 5004
+	listener, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.ParseIP("127.0.0.1"), Port: port})
+	if err != nil {
+		panic(err)
+	}
+	defer func() {
+		if err = listener.Close(); err != nil {
+			panic(err)
+		}
+	}()
+
+	sampleBuffer := samplebuilder.New(10, depacketizer, sampleRate)
+
+	// Read RTP packets forever and send them to the WebRTC Client
+	for {
+		inboundRTPPacket := make([]byte, 1500) // UDP MTU
+		packet := &rtp.Packet{}
+
+		n, _, err := listener.ReadFrom(inboundRTPPacket)
+		if err != nil {
+			panic(fmt.Sprintf("error during read: %s", err))
+		}
+
+		if err = packet.Unmarshal(inboundRTPPacket[:n]); err != nil {
+			panic(err)
+		}
+
+		sampleBuffer.Push(packet)
+		for {
+			sample := sampleBuffer.Pop()
+			if sample == nil {
+				break
+			}
+
+			if writeErr := track.WriteSample(*sample); writeErr != nil {
+				panic(writeErr)
+			}
+		}
+	}
+}
+
+// Read incoming RTCP packets
+// Before these packets are retuned they are processed by interceptors. For things
+// like NACK this needs to be called.
+func processRTCP(rtpSender *webrtc.RTPSender) {
+	go func() {
+		rtcpBuf := make([]byte, 1500)
+
+		for {
+			if _, _, rtcpErr := rtpSender.Read(rtcpBuf); rtcpErr != nil {
+				return
+			}
+		}
+	}()
+}