Charles
400 lines
11 KiB
Go
400 lines
11 KiB
Go
//go:build !js
|
|
// +build !js
|
|
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"flag"
|
|
"fmt"
|
|
"net/http"
|
|
"sync"
|
|
"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/chathaway-codes/home-sensors/v2/internal/h264video"
|
|
"github.com/chathaway-codes/home-sensors/v2/internal/sensors"
|
|
"github.com/chathaway-codes/home-sensors/v2/internal/watcher/config"
|
|
"github.com/pion/webrtc/v3"
|
|
"github.com/pion/webrtc/v3/pkg/media"
|
|
"github.com/rs/zerolog/log"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
"google.golang.org/protobuf/proto"
|
|
)
|
|
|
|
var (
|
|
signalerServer = flag.String("signaler_address", "home.chathaway.codes", "address of the signaler")
|
|
)
|
|
|
|
func withAuth[T any](token string, v *T) *connect.Request[T] {
|
|
req := connect.NewRequest[T](v)
|
|
req.Header().Add("Authorization", "Bearer "+token)
|
|
return req
|
|
}
|
|
|
|
func main() {
|
|
flag.Parse()
|
|
ctx := context.Background()
|
|
|
|
cfg, err := config.Default.Get()
|
|
if err != nil {
|
|
log.Fatal().Err(err).Msg("failed to get config")
|
|
}
|
|
|
|
client := servicepb.NewSignalerServiceClient(
|
|
http.DefaultClient,
|
|
fmt.Sprintf("https://%s/", *signalerServer),
|
|
connect.WithGRPC(),
|
|
)
|
|
|
|
vid, err := h264video.Default.Get()
|
|
if err != nil {
|
|
log.Fatal().Err(err).Msg("failed to get default video")
|
|
}
|
|
|
|
sensors, err := sensors.Default.Get()
|
|
if err != nil {
|
|
log.Fatal().Err(err).Msg("failed to get default sensor")
|
|
}
|
|
|
|
go vid.Run()
|
|
defer vid.Done()
|
|
|
|
go sensors.Run()
|
|
defer sensors.Done()
|
|
|
|
sensorCh, sensorDone := sensors.Join()
|
|
defer sensorDone()
|
|
|
|
token, err := getAuthToken(ctx, client, cfg)
|
|
if err != nil {
|
|
log.Fatal().Err(err).Msg("failed to get auth token")
|
|
}
|
|
|
|
go handleSensor(ctx, client, token, sensorCh)
|
|
|
|
// Create a new RTCPeerConnection
|
|
log.Info().Msg("waiting for connections")
|
|
|
|
for {
|
|
// Wait for a session request
|
|
session, err := client.PopSession(ctx, withAuth(token, &pb.PopSessionRequest{}))
|
|
if err != nil {
|
|
code, hasCode := status.FromError(err)
|
|
if hasCode && code.Code() == codes.NotFound {
|
|
// try getting a new token
|
|
token, err = getAuthToken(ctx, client, cfg)
|
|
if err != nil {
|
|
log.Fatal().Err(err).Msg("failed to recreate auth token")
|
|
}
|
|
continue
|
|
}
|
|
log.Error().Err(err).Str("code", fmt.Sprintf("code %d", code.Code())).Bool("has code", hasCode).Msg("error creating session")
|
|
continue
|
|
}
|
|
if session.Msg.GetId() == nil {
|
|
continue
|
|
}
|
|
go handleSession(ctx, client, token, session, vid)
|
|
}
|
|
}
|
|
|
|
func getAuthToken(ctx context.Context, client servicepb.SignalerServiceClient, cfg *config.Config) (string, error) {
|
|
authToken, err := client.CreateAuthToken(ctx, connect.NewRequest(&pb.CreateAuthTokenRequest{
|
|
Home: cfg.HomeName,
|
|
Type: &pb.CreateAuthTokenRequest_Camera_{
|
|
Camera: &pb.CreateAuthTokenRequest_Camera{
|
|
Id: cfg.CameraName,
|
|
},
|
|
},
|
|
}))
|
|
if err != nil {
|
|
return "", fmt.Errorf("CreateAuthToken failed: %w", err)
|
|
}
|
|
token := authToken.Msg.GetToken()
|
|
return token, nil
|
|
}
|
|
|
|
func handleSensor(ctx context.Context, client servicepb.SignalerServiceClient, token string, ch <-chan *pb.Sample) {
|
|
for {
|
|
var sample *pb.Sample
|
|
select {
|
|
case sample = <-ch:
|
|
// proceed
|
|
case <-ctx.Done():
|
|
return
|
|
}
|
|
if _, err := client.CreateSample(ctx, withAuth(token, &pb.CreateSampleRequest{
|
|
Sample: sample,
|
|
})); err != nil {
|
|
log.Error().Err(err).Msg("failed to create sample")
|
|
}
|
|
}
|
|
}
|
|
|
|
func getIceConnection(ctx context.Context, peerConnection *webrtc.PeerConnection, client servicepb.SignalerServiceClient, token string, session *connect.Response[pb.Session]) (context.Context, error) {
|
|
// We use the cancel func to signal that the stream is ready
|
|
iceConnectedCtx, iceConnectedCtxCancel := context.WithCancel(context.Background())
|
|
iceDisconnectedCtx, iceDeconnectedCtxCancel := context.WithCancel(ctx)
|
|
readyToSend := sync.WaitGroup{}
|
|
readyToSend.Add(1)
|
|
|
|
// Set the handler for ICE connection state
|
|
// This will notify you when the peer has connected/disconnected
|
|
peerConnection.OnICEConnectionStateChange(func(connectionState webrtc.ICEConnectionState) {
|
|
log.Debug().Msgf("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) {
|
|
log.Debug().Msgf("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.
|
|
iceDeconnectedCtxCancel()
|
|
}
|
|
})
|
|
|
|
peerConnection.OnICECandidate(func(i *webrtc.ICECandidate) {
|
|
readyToSend.Wait()
|
|
if i == nil {
|
|
if _, err := client.CreateIceMessage(ctx, withAuth(token, &pb.CreateIceMessageRequest{
|
|
SessionIdentifier: session.Msg.GetId(),
|
|
IceMessage: &pb.IceMessage{
|
|
Type: &pb.IceMessage_NoMoreCandidates{},
|
|
},
|
|
})); err != nil {
|
|
log.Warn().Err(err).Msg("error sending done w/ candidates")
|
|
}
|
|
return
|
|
}
|
|
c := i.ToJSON()
|
|
var usernameFragment *string
|
|
if c.UsernameFragment != nil {
|
|
usernameFragment = proto.String(*c.UsernameFragment)
|
|
}
|
|
log.Info().Msgf("got candidate %+v", c)
|
|
client.CreateIceMessage(ctx, withAuth(token, &pb.CreateIceMessageRequest{
|
|
SessionIdentifier: session.Msg.GetId(),
|
|
IceMessage: &pb.IceMessage{
|
|
Type: &pb.IceMessage_Candidate{
|
|
Candidate: &pb.IceCandidate{
|
|
Candidate: c.Candidate,
|
|
SdpMid: c.SDPMid,
|
|
SdpLineIndex: proto.Int32(int32(*c.SDPMLineIndex)),
|
|
UsernameFragment: usernameFragment,
|
|
},
|
|
},
|
|
},
|
|
}))
|
|
})
|
|
|
|
// Get the offer from the other
|
|
msg, err := client.PopIceMessage(iceDisconnectedCtx, withAuth(token, &pb.PopIceMessageRequest{
|
|
SessionIdentifier: session.Msg.GetId(),
|
|
}))
|
|
if err != nil {
|
|
log.Info().Err(err).Msg("failed to pop ice message")
|
|
}
|
|
iceSession := msg.Msg.GetSession()
|
|
|
|
switch iceSession.SdpType {
|
|
case int64(webrtc.SDPTypeOffer):
|
|
offer := webrtc.SessionDescription{
|
|
Type: webrtc.SDPType(iceSession.SdpType),
|
|
SDP: iceSession.Sdp,
|
|
}
|
|
|
|
if err := peerConnection.SetRemoteDescription(offer); err != nil {
|
|
log.Warn().Err(err).Msg("failed to set remote description")
|
|
}
|
|
default:
|
|
log.Info().Msgf("unexpected sdp type: %v", webrtc.SDPType(iceSession.SdpType).String())
|
|
}
|
|
log.Info().Msg("Accepted promise!")
|
|
|
|
// Send back an answer
|
|
answer, err := peerConnection.CreateAnswer(nil)
|
|
if err != nil {
|
|
log.Debug().Err(err).Msg("Candidate failed")
|
|
}
|
|
|
|
if err := peerConnection.SetLocalDescription(answer); err != nil {
|
|
log.Info().Err(err).Msg("Failed to set local description")
|
|
}
|
|
|
|
_, err = client.CreateIceMessage(iceDisconnectedCtx, withAuth(token, &pb.CreateIceMessageRequest{
|
|
SessionIdentifier: session.Msg.GetId(),
|
|
IceMessage: &pb.IceMessage{
|
|
Type: &pb.IceMessage_Session{
|
|
Session: &pb.IceSessionDescription{
|
|
SdpType: int64(answer.Type),
|
|
Sdp: answer.SDP,
|
|
},
|
|
},
|
|
},
|
|
}))
|
|
if err != nil {
|
|
log.Info().Err(err).Msg("Failed to send answer")
|
|
}
|
|
readyToSend.Done()
|
|
|
|
// TODO: do we add the video right here?
|
|
|
|
// Go into a loop processing ice candidates
|
|
|
|
// Add ICE candidates from remote
|
|
go func() {
|
|
for {
|
|
select {
|
|
case <-iceDisconnectedCtx.Done():
|
|
return
|
|
default:
|
|
// check for another message
|
|
}
|
|
msg, err := client.PopIceMessage(iceDisconnectedCtx, withAuth(token, &pb.PopIceMessageRequest{
|
|
SessionIdentifier: session.Msg.GetId(),
|
|
}))
|
|
if err != nil {
|
|
log.Info().Err(err).Msg("failed to pop ice message")
|
|
continue
|
|
}
|
|
switch msg.Msg.Type.(type) {
|
|
case *pb.IceMessage_Candidate:
|
|
candidate := msg.Msg.GetCandidate()
|
|
var sdpMLine *uint16
|
|
if candidate.SdpLineIndex != nil {
|
|
t := uint16(candidate.GetSdpLineIndex())
|
|
sdpMLine = &t
|
|
}
|
|
if err := peerConnection.AddICECandidate(webrtc.ICECandidateInit{
|
|
Candidate: candidate.GetCandidate(),
|
|
SDPMid: candidate.SdpMid,
|
|
SDPMLineIndex: sdpMLine,
|
|
}); err != nil {
|
|
log.Warn().Err(err).Msg("failed to add ice candidate")
|
|
}
|
|
case *pb.IceMessage_Session:
|
|
|
|
case *pb.IceMessage_NoMoreCandidates:
|
|
// do nothing
|
|
}
|
|
}
|
|
}()
|
|
|
|
select {
|
|
case <-iceConnectedCtx.Done():
|
|
// Success; return the connection
|
|
return iceDisconnectedCtx, nil
|
|
case <-iceDisconnectedCtx.Done():
|
|
// No connection; return error
|
|
return ctx, fmt.Errorf("failed to create connection: ICE disconnected")
|
|
}
|
|
}
|
|
|
|
func handleSession(ctx context.Context, client servicepb.SignalerServiceClient, token string, session *connect.Response[pb.Session], vid *h264video.Video) {
|
|
log.Debug().Msg("new session")
|
|
|
|
// connect to the video stream; the cleanup is done in the goroutine which
|
|
// consumes the framess
|
|
ch, trackCodec, cleanUp := vid.Join()
|
|
defer cleanUp()
|
|
|
|
// Create a video track
|
|
videoTrack, err := webrtc.NewTrackLocalStaticSample(webrtc.RTPCodecCapability{MimeType: trackCodec}, "video", "pion")
|
|
if err != nil {
|
|
log.Info().Err(err).Msg("Failed to create video track")
|
|
return
|
|
}
|
|
|
|
peerConnection, err := webrtc.NewPeerConnection(webrtc.Configuration{
|
|
ICEServers: []webrtc.ICEServer{
|
|
{
|
|
URLs: []string{"stun:stun.l.google.com:19302"},
|
|
},
|
|
},
|
|
})
|
|
if err != nil {
|
|
log.Err(err).Msg("failed to make connection")
|
|
}
|
|
|
|
rtpSender, err := peerConnection.AddTrack(videoTrack)
|
|
if err != nil {
|
|
log.Info().Err(err).Msg("Failed to add track to connection")
|
|
return
|
|
}
|
|
|
|
disconnectedCtx, err := getIceConnection(ctx, peerConnection, client, token, session)
|
|
if err != nil {
|
|
log.Err(err).Msg("failed creating ice connection")
|
|
}
|
|
|
|
log.Info().Msgf("State is %+v", rtpSender.Transport().State())
|
|
|
|
// 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 {
|
|
select {
|
|
case <-disconnectedCtx.Done():
|
|
return
|
|
default:
|
|
// do nothing
|
|
}
|
|
if _, _, err := rtpSender.Read(rtcpBuf); err != nil {
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
|
|
// Start a routine to send frames from a buffer
|
|
var frame []byte
|
|
var frameLock sync.Mutex
|
|
go func() {
|
|
ticker := time.NewTicker(time.Millisecond * 30)
|
|
for {
|
|
select {
|
|
case <-disconnectedCtx.Done():
|
|
return
|
|
case <-ticker.C:
|
|
// do nothing
|
|
}
|
|
frameLock.Lock()
|
|
myFrame := frame
|
|
frame = nil
|
|
frameLock.Unlock()
|
|
if myFrame == nil {
|
|
continue
|
|
}
|
|
if err := videoTrack.WriteSample(media.Sample{Data: myFrame, Duration: time.Millisecond * 33}); err != nil {
|
|
log.Err(err).Msg("failed to write sample")
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
|
|
for myFrame := range ch {
|
|
select {
|
|
case <-disconnectedCtx.Done():
|
|
return
|
|
default:
|
|
// do nothing
|
|
}
|
|
frameLock.Lock()
|
|
frame = myFrame
|
|
frameLock.Unlock()
|
|
}
|
|
// TODO: Video ended; close the connection
|
|
}
|