add: signal server
This commit is contained in:
Charles Hathaway
+27
-2
@@ -1,7 +1,32 @@
|
||||
package main
|
||||
|
||||
import "fmt"
|
||||
import (
|
||||
"fmt"
|
||||
"log"
|
||||
"net/http"
|
||||
|
||||
"connectrpc.com/grpcreflect"
|
||||
servicepb "github.com/chathaway-codes/home-sensors/v2/gen/genconnect"
|
||||
"github.com/chathaway-codes/home-sensors/v2/pkg/signaler"
|
||||
)
|
||||
|
||||
func main() {
|
||||
fmt.Printf("Hello world!\n")
|
||||
mux := http.NewServeMux()
|
||||
reflector := grpcreflect.NewStaticReflector(
|
||||
servicepb.SignalerServiceName,
|
||||
)
|
||||
path, _ := grpcreflect.NewHandlerV1(reflector)
|
||||
fmt.Printf("Got path %s\n", path)
|
||||
mux.Handle(grpcreflect.NewHandlerV1(reflector))
|
||||
path, _ = grpcreflect.NewHandlerV1Alpha(reflector)
|
||||
fmt.Printf("Got path %s\n", path)
|
||||
mux.Handle(grpcreflect.NewHandlerV1Alpha(reflector))
|
||||
|
||||
path, _ = servicepb.NewSignalerServiceHandler(signaler.New())
|
||||
fmt.Printf("Got path %s\n", path)
|
||||
mux.Handle(servicepb.NewSignalerServiceHandler(signaler.New()))
|
||||
|
||||
if err := http.ListenAndServe("127.0.0.1:8080", mux); err != nil {
|
||||
log.Fatalf("Failed to listen for HTTP traffic: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,229 @@
|
||||
//go:build !js
|
||||
// +build !js
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"io"
|
||||
"log"
|
||||
"net/http"
|
||||
"os"
|
||||
"time"
|
||||
|
||||
"connectrpc.com/connect"
|
||||
pb "github.com/chathaway-codes/home-sensors/v2/gen"
|
||||
servicepb "github.com/chathaway-codes/home-sensors/v2/gen/genconnect"
|
||||
"github.com/pion/webrtc/v3"
|
||||
"github.com/pion/webrtc/v3/pkg/media"
|
||||
"github.com/pion/webrtc/v3/pkg/media/h264reader"
|
||||
"google.golang.org/protobuf/proto"
|
||||
)
|
||||
|
||||
const (
|
||||
videoFileName = "/home/charles/Downloads/simpsons_movie_1080p_hddvd_trailer/The Simpsons Movie - 1080p Trailer.mp4"
|
||||
oggPageDuration = time.Millisecond * 20
|
||||
h264FrameDuration = time.Millisecond * 33
|
||||
)
|
||||
|
||||
func main() { //nolint
|
||||
ctx := context.Background()
|
||||
client := servicepb.NewSignalerServiceClient(&http.Client{}, "http://localhost:8080/")
|
||||
// Assert that we have an audio or video file
|
||||
_, err := os.Stat(videoFileName)
|
||||
haveVideoFile := !os.IsNotExist(err)
|
||||
|
||||
// Create a new RTCPeerConnection
|
||||
peerConnection, err := webrtc.NewPeerConnection(webrtc.Configuration{
|
||||
ICEServers: []webrtc.ICEServer{
|
||||
{
|
||||
URLs: []string{"stun:stun.l.google.com:19302"},
|
||||
},
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
defer func() {
|
||||
if cErr := peerConnection.Close(); cErr != nil {
|
||||
fmt.Printf("cannot close peerConnection: %v\n", cErr)
|
||||
}
|
||||
}()
|
||||
|
||||
iceConnectedCtx, iceConnectedCtxCancel := context.WithCancel(context.Background())
|
||||
|
||||
if haveVideoFile {
|
||||
// Create a video track
|
||||
videoTrack, videoTrackErr := webrtc.NewTrackLocalStaticSample(webrtc.RTPCodecCapability{MimeType: webrtc.MimeTypeH264}, "video", "pion")
|
||||
if videoTrackErr != nil {
|
||||
panic(videoTrackErr)
|
||||
}
|
||||
|
||||
rtpSender, videoTrackErr := peerConnection.AddTrack(videoTrack)
|
||||
if videoTrackErr != nil {
|
||||
panic(videoTrackErr)
|
||||
}
|
||||
|
||||
// Read incoming RTCP packets
|
||||
// Before these packets are returned they are processed by interceptors. For things
|
||||
// like NACK this needs to be called.
|
||||
go func() {
|
||||
rtcpBuf := make([]byte, 1500)
|
||||
for {
|
||||
if _, _, rtcpErr := rtpSender.Read(rtcpBuf); rtcpErr != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
}()
|
||||
|
||||
go func() {
|
||||
// Open a H264 file and start reading using our IVFReader
|
||||
file, h264Err := os.Open(videoFileName)
|
||||
if h264Err != nil {
|
||||
panic(h264Err)
|
||||
}
|
||||
|
||||
h264, h264Err := h264reader.NewReader(file)
|
||||
if h264Err != nil {
|
||||
panic(h264Err)
|
||||
}
|
||||
|
||||
// Wait for connection established
|
||||
<-iceConnectedCtx.Done()
|
||||
|
||||
// Send our video file frame at a time. Pace our sending so we send it at the same speed it should be played back as.
|
||||
// This isn't required since the video is timestamped, but we will such much higher loss if we send all at once.
|
||||
//
|
||||
// It is important to use a time.Ticker instead of time.Sleep because
|
||||
// * avoids accumulating skew, just calling time.Sleep didn't compensate for the time spent parsing the data
|
||||
// * works around latency issues with Sleep (see https://github.com/golang/go/issues/44343)
|
||||
ticker := time.NewTicker(h264FrameDuration)
|
||||
for ; true; <-ticker.C {
|
||||
nal, h264Err := h264.NextNAL()
|
||||
if h264Err == io.EOF {
|
||||
fmt.Printf("All video frames parsed and sent")
|
||||
os.Exit(0)
|
||||
}
|
||||
if h264Err != nil {
|
||||
panic(h264Err)
|
||||
}
|
||||
|
||||
if h264Err = videoTrack.WriteSample(media.Sample{Data: nal.Data, Duration: h264FrameDuration}); h264Err != nil {
|
||||
panic(h264Err)
|
||||
}
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
// 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())
|
||||
if connectionState == webrtc.ICEConnectionStateConnected {
|
||||
iceConnectedCtxCancel()
|
||||
}
|
||||
})
|
||||
|
||||
// Set the handler for Peer connection state
|
||||
// This will notify you when the peer has connected/disconnected
|
||||
peerConnection.OnConnectionStateChange(func(s webrtc.PeerConnectionState) {
|
||||
fmt.Printf("Peer Connection State has changed: %s\n", s.String())
|
||||
|
||||
if s == webrtc.PeerConnectionStateFailed {
|
||||
// Wait until PeerConnection has had no network activity for 30 seconds or another failure. It may be reconnected using an ICE Restart.
|
||||
// Use webrtc.PeerConnectionStateDisconnected if you are interested in detecting faster timeout.
|
||||
// Note that the PeerConnection may come back from PeerConnectionStateDisconnected.
|
||||
fmt.Println("Peer Connection has gone to failed exiting")
|
||||
os.Exit(0)
|
||||
}
|
||||
})
|
||||
|
||||
var iceCandidates []*pb.IceCandidate
|
||||
peerConnection.OnICECandidate(func(i *webrtc.ICECandidate) {
|
||||
if i == nil {
|
||||
return
|
||||
}
|
||||
c := i.ToJSON()
|
||||
iceCandidates = append(iceCandidates, &pb.IceCandidate{
|
||||
Candidate: c.Candidate,
|
||||
SdpMid: c.SDPMid,
|
||||
SdpLineIndex: proto.Int32(int32(*c.SDPMLineIndex)),
|
||||
UsernameFragment: proto.String(*c.UsernameFragment),
|
||||
})
|
||||
})
|
||||
|
||||
// Wait for a session request
|
||||
var session *pb.Session
|
||||
for session == nil {
|
||||
resp, err := client.ListSessions(ctx, connect.NewRequest(&pb.ListSessionsRequest{}))
|
||||
if err != nil {
|
||||
log.Fatalf("error creating session: %v", err)
|
||||
}
|
||||
if len(resp.Msg.Sessions) > 0 {
|
||||
session = resp.Msg.Sessions[0]
|
||||
}
|
||||
time.Sleep(time.Millisecond * 500)
|
||||
}
|
||||
|
||||
// Add ICE candidates from remote
|
||||
for _, candidate := range session.GetClientIceCandidates() {
|
||||
var sdpMLine *uint16
|
||||
if candidate.SdpLineIndex != nil {
|
||||
t := uint16(candidate.GetSdpLineIndex())
|
||||
sdpMLine = &t
|
||||
}
|
||||
peerConnection.AddICECandidate(webrtc.ICECandidateInit{
|
||||
Candidate: candidate.GetCandidate(),
|
||||
SDPMid: candidate.SdpMid,
|
||||
SDPMLineIndex: sdpMLine,
|
||||
})
|
||||
}
|
||||
|
||||
cameraOffer, err := peerConnection.CreateOffer(nil)
|
||||
if err != nil {
|
||||
log.Fatalf("error creating session: %v", err)
|
||||
}
|
||||
|
||||
// Set the remote SessionDescription
|
||||
if err = peerConnection.SetRemoteDescription(cameraOffer); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
// Create channel that is blocked until ICE Gathering is complete
|
||||
gatherComplete := webrtc.GatheringCompletePromise(peerConnection)
|
||||
// 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
|
||||
log.Printf("Waiting to gather ICE")
|
||||
<-gatherComplete
|
||||
log.Printf("Done gathering ICE")
|
||||
|
||||
session.CameraIceCandidates = iceCandidates
|
||||
session.CameraOffer = &pb.IceSessionDescription{
|
||||
SdpType: int64(cameraOffer.Type),
|
||||
Sdp: cameraOffer.SDP,
|
||||
}
|
||||
|
||||
// Send it back
|
||||
resp, err := client.UpdateSession(ctx, connect.NewRequest(&pb.UpdateSessionRequest{
|
||||
Session: session,
|
||||
WaitForUpdate: true,
|
||||
}))
|
||||
if err != nil {
|
||||
log.Fatalf("error creating session: %v", err)
|
||||
}
|
||||
|
||||
answer := webrtc.SessionDescription{
|
||||
Type: webrtc.SDPType(resp.Msg.ClientAnswer.SdpType),
|
||||
SDP: resp.Msg.ClientAnswer.Sdp,
|
||||
}
|
||||
|
||||
// Sets the LocalDescription, and starts our UDP listeners
|
||||
if err = peerConnection.SetLocalDescription(answer); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
// Block forever
|
||||
select {}
|
||||
}
|
||||
Reference in New Issue
Block a user