home-sensors/cmd/watcher/main.go

//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 {}
}