Update version to 0.1-rc.5

README.md

@@ -9,7 +9,7 @@ Ultimate camera streaming application with support RTSP, WebRTC, HomeKit, FFmpeg
 - streaming from [RTSP](#source-rtsp), [RTMP](#source-rtmp), [MJPEG](#source-ffmpeg), [HLS/HTTP](#source-ffmpeg), [USB Cameras](#source-ffmpeg-device) and [other sources](#module-streams)
 - streaming to [RTSP](#module-rtsp), [WebRTC](#module-webrtc), [MSE/MP4](#module-mp4) or [MJPEG](#module-mjpeg)
 - first project in the World with support streaming from [HomeKit Cameras](#source-homekit)
-- first project in the World with support H265 for WebRTC in browser (only Safari)
+- first project in the World with support H265 for WebRTC in browser ([read more](https://github.com/AlexxIT/Blog/issues/5))
 - on the fly transcoding for unsupported codecs via [FFmpeg](#source-ffmpeg)
 - multi-source 2-way [codecs negotiation](#codecs-negotiation)
    - mixing tracks from different sources to single stream
@@ -99,7 +99,8 @@ Available modules:
 - [api](#module-api) - HTTP API (important for WebRTC support)
 - [rtsp](#module-rtsp) - RTSP Server (important for FFmpeg support)
 - [webrtc](#module-webrtc) - WebRTC Server
-- [mp4](#module-mp4) - MSE, MP4 stream and MP4 shapshot
+- [mp4](#module-mp4) - MSE, MP4 stream and MP4 shapshot Server
+- [mjpeg](#module-mjpeg) - MJPEG Server
 - [ffmpeg](#source-ffmpeg) - FFmpeg integration
 - [ngrok](#module-ngrok) - Ngrok integration (external access for private network)
 - [hass](#module-hass) - Home Assistant integration
@@ -112,8 +113,9 @@ Available modules:
 Available source types:
 
 - [rtsp](#source-rtsp) - `RTSP` and `RTSPS` cameras
-- [rtmp](#source-rtmp) - `RTMP` and `HTTP-FLV` streams
-- [ffmpeg](#source-ffmpeg) - FFmpeg integration (`MJPEG`, `HLS`, `files` and others)
+- [rtmp](#source-rtmp) - `RTMP` streams
+- [http](#source-http) - `HTTP-FLV`, `JPEG` (snapshots), `MJPEG` streams 
+- [ffmpeg](#source-ffmpeg) - FFmpeg integration (`HLS`, `files` and many others)
 - [ffmpeg:device](#source-ffmpeg-device) - local USB Camera or Webcam
 - [exec](#source-exec) - advanced FFmpeg and GStreamer integration
 - [echo](#source-echo) - get stream link from bash or python
@@ -148,13 +150,35 @@ streams:
 
 #### Source: RTMP
 
-You can get stream from RTMP server, for example [Frigate](https://docs.frigate.video/configuration/rtmp). Support ONLY `H264` video codec without audio.
+You can get stream from RTMP server, for example [Frigate](https://docs.frigate.video/configuration/rtmp).
 
 ```yaml
 streams:
   rtmp_stream: rtmp://192.168.1.123/live/camera1
 ```
 
+#### Source: HTTP
+
+Support Content-Type:
+
+- **HTTP-FLV** (`video/x-flv`) - same as RTMP, but over HTTP
+- **HTTP-JPEG** (`image/jpeg`) - camera snapshot link, can be converted by go2rtc to MJPEG stream
+- **HTTP-MJPEG** (`multipart/x`) - simple MJPEG stream over HTTP
+
+```yaml
+streams:
+  # [HTTP-FLV] stream in video/x-flv format
+  http_flv: http://192.168.1.123:20880/api/camera/stream/780900131155/657617
+  
+  # [JPEG] snapshots from Dahua camera, will be converted to MJPEG stream
+  dahua_snap: http://admin:password@192.168.1.123/cgi-bin/snapshot.cgi?channel=1
+
+  # [MJPEG] stream will be proxied without modification
+  http_mjpeg: https://mjpeg.sanford.io/count.mjpeg
+```
+
+**PS.** Dahua camera has bug: if you select MJPEG codec for RTSP second stream - snapshot won't work.
+
 #### Source: FFmpeg
 
 You can get any stream or file or device via FFmpeg and push it to go2rtc. The app will automatically start FFmpeg with the proper arguments when someone starts watching the stream.
@@ -330,10 +354,15 @@ You can get any stream as RTSP-stream: `rtsp://192.168.1.123:8554/{stream_name}`
 - you can omit the codec filters, so one first video and one first audio will be selected
 - you can set `?video=copy` or just `?video`, so only one first video without audio will be selected
 - you can set multiple video or audio, so all of them will be selected
+- you can enable external password protection for your RTSP streams
+
+Password protection always disabled for localhost calls (ex. FFmpeg or Hass on same server)
 
 ```yaml
 rtsp:
-  listen: ":8554"
+  listen: ":8554"  # RTSP Server TCP port, default - 8554
+  username: admin  # optional, default - disabled
+  password: pass   # optional, default - disabled
 ```
 
 ### Module: WebRTC
@@ -489,20 +518,32 @@ Provides several features:
 
 1. MSE stream (fMP4 over WebSocket)
 2. Camera snapshots in MP4 format (single frame), can be sent to [Telegram](https://www.telegram.org/)
-3. Progressive MP4 stream - bad format for streaming because of high latency, doesn't work in Safari 
+3. MP4 "file stream" - bad format for streaming because of high latency, doesn't work in Safari 
 
 ### Module: MJPEG
 
-**Important.** For stream as MJPEG format, your source MUST contain the MJPEG codec. If your camera outputs H264/H265 - you SHOULD use transcoding. With this example, your stream will have both H264 and MJPEG codecs:
+**Important.** For stream as MJPEG format, your source MUST contain the MJPEG codec. If your stream has a MJPEG codec - you can receive **MJPEG stream** or **JPEG snapshots** via API.
+
+You can receive an MJPEG stream in several ways:
+
+- some cameras support MJPEG codec inside [RTSP stream](#source-rtsp) (ex. second stream for Dahua cameras)
+- some cameras has HTTP link with [MJPEG stream](#source-http)
+- some cameras has HTTP link with snapshots - go2rtc can convert them to [MJPEG stream](#source-http)
+- you can convert H264/H265 stream from your camera via [FFmpeg integraion](#source-ffmpeg)
+
+With this example, your stream will have both H264 and MJPEG codecs:
 
 ```yaml
 streams:
   camera1:
     - rtsp://rtsp:12345678@192.168.1.123/av_stream/ch0
-    - ffmpeg:rtsp://rtsp:12345678@192.168.1.123/av_stream/ch0#video=mjpeg
+    - ffmpeg:camera1#video=mjpeg
 ```
 
-Example link to MJPEG: `http://192.168.1.123:1984/api/stream.mjpeg?src=camera1`
+API examples:
+
+- MJPEG stream: `http://192.168.1.123:1984/api/stream.mjpeg?src=camera1`
+- JPEG snapshots: `http://192.168.1.123:1984/api/frame.jpeg?src=camera1`
 
 ### Module: Log
 
@@ -549,17 +590,17 @@ PS. Additionally WebRTC opens a lot of random UDP ports for transmit encrypted m
 
 `AVC/H.264` codec can be played almost anywhere. But `HEVC/H.265` has a lot of limitations in supporting with different devices and browsers. It's all about patents and money, you can't do anything about it.
 
-Device | WebRTC | MSE | MP4
--------|--------|-----|----
-*latency*           | best        | medium      | bad
-Desktop Chrome 107+ | H264        | H264, H265* | H264, H265*
-Desktop Safari      | H264, H265* | H264, H265  | **no!**
-Desktop Edge        | H264        | H264, H265* | H264, H265*
-Desktop Firefox     | H264        | H264        | H264
-iPad Safari 13+     | H264, H265* | H264, H265  | **no!**
-iPhone Safari 13+   | H264, H265* | **no!**     | **no!**
-Android Chrome 107+ | H264        | H264, H265* | H264
-masOS Hass App      | no          | no          | no
+| Device              | WebRTC      | MSE         | MP4         |
+|---------------------|-------------|-------------|-------------|
+| *latency*           | best        | medium      | bad         |
+| Desktop Chrome 107+ | H264        | H264, H265* | H264, H265* |
+| Desktop Edge        | H264        | H264, H265* | H264, H265* |
+| Desktop Safari      | H264, H265* | H264, H265  | **no!**     |
+| Desktop Firefox     | H264        | H264        | H264        |
+| Android Chrome 107+ | H264        | H264, H265* | H264        |
+| iPad Safari 13+     | H264, H265* | H264, H265  | **no!**     |
+| iPhone Safari 13+   | H264, H265* | **no!**     | **no!**     |
+| masOS Hass App      | no          | no          | no          |
 
 - Chrome H265: [read this](https://chromestatus.com/feature/5186511939567616) and [read this](https://github.com/StaZhu/enable-chromium-hevc-hardware-decoding)
 - Edge H265: [read this](https://www.reddit.com/r/MicrosoftEdge/comments/v9iw8k/enable_hevc_support_in_edge/)

cmd/api/api.go

@@ -4,8 +4,6 @@ import (
 	"encoding/json"
 	"github.com/AlexxIT/go2rtc/cmd/app"
 	"github.com/AlexxIT/go2rtc/cmd/streams"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
-	"github.com/gorilla/websocket"
 	"github.com/rs/zerolog"
 	"net"
 	"net/http"
@@ -78,13 +76,10 @@ func HandleFunc(pattern string, handler http.HandlerFunc) {
 	http.HandleFunc(pattern, handler)
 }
 
-func HandleWS(msgType string, handler WSHandler) {
-	wsHandlers[msgType] = handler
-}
+const StreamNotFound = "stream not found"
 
 var basePath string
 var log zerolog.Logger
-var wsHandlers = make(map[string]WSHandler)
 
 func middlewareLog(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -129,29 +124,3 @@ func streamsHandler(w http.ResponseWriter, r *http.Request) {
 	e.SetIndent("", "  ")
 	_ = e.Encode(v)
 }
-
-func apiWS(w http.ResponseWriter, r *http.Request) {
-	ctx := new(Context)
-	if err := ctx.Upgrade(w, r); err != nil {
-		log.Error().Err(err).Msg("[api.ws] upgrade")
-		return
-	}
-	defer ctx.Close()
-
-	for {
-		msg := new(streamer.Message)
-		if err := ctx.Conn.ReadJSON(msg); err != nil {
-			if websocket.IsUnexpectedCloseError(
-				err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure,
-			) {
-				log.Error().Err(err).Msg("[api.ws] readJSON")
-			}
-			return
-		}
-
-		handler := wsHandlers[msg.Type]
-		if handler != nil {
-			handler(ctx, msg)
-		}
-	}
-}

cmd/api/ws.go

@@ -1,69 +1,138 @@
 package api
 
 import (
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/gorilla/websocket"
 	"net/http"
+	"net/url"
+	"strings"
 	"sync"
 )
 
+// Message - struct for data exchange in Web API
+type Message struct {
+	Type  string      `json:"type"`
+	Value interface{} `json:"value,omitempty"`
+}
+
+type WSHandler func(tr *Transport, msg *Message) error
+
+func HandleWS(msgType string, handler WSHandler) {
+	wsHandlers[msgType] = handler
+}
+
+var wsHandlers = make(map[string]WSHandler)
+
 func initWS(origin string) {
 	wsUp = &websocket.Upgrader{
 		ReadBufferSize:  1024,
 		WriteBufferSize: 512000,
 	}
 
-	if origin == "*" {
+	switch origin {
+	case "":
+		// same origin + ignore port
+		wsUp.CheckOrigin = func(r *http.Request) bool {
+			origin := r.Header["Origin"]
+			if len(origin) == 0 {
+				return true
+			}
+			o, err := url.Parse(origin[0])
+			if err != nil {
+				return false
+			}
+			if o.Host == r.Host {
+				return true
+			}
+			log.Trace().Msgf("[api.ws] origin=%s, host=%s", o.Host, r.Host)
+			// https://github.com/AlexxIT/go2rtc/issues/118
+			if i := strings.IndexByte(o.Host, ':'); i > 0 {
+				return o.Host[:i] == r.Host
+			}
+			return false
+		}
+	case "*":
+		// any origin
 		wsUp.CheckOrigin = func(r *http.Request) bool {
 			return true
 		}
 	}
 }
 
+func apiWS(w http.ResponseWriter, r *http.Request) {
+	ws, err := wsUp.Upgrade(w, r, nil)
+	if err != nil {
+		origin := r.Header.Get("Origin")
+		log.Error().Err(err).Caller().Msgf("host=%s origin=%s", r.Host, origin)
+		return
+	}
+
+	tr := &Transport{Request: r}
+	tr.OnWrite(func(msg interface{}) {
+		if data, ok := msg.([]byte); ok {
+			_ = ws.WriteMessage(websocket.BinaryMessage, data)
+		} else {
+			_ = ws.WriteJSON(msg)
+		}
+	})
+
+	for {
+		msg := new(Message)
+		if err = ws.ReadJSON(msg); err != nil {
+			log.Trace().Err(err).Caller().Send()
+			_ = ws.Close()
+			break
+		}
+
+		if handler := wsHandlers[msg.Type]; handler != nil {
+			go func() {
+				if err = handler(tr, msg); err != nil {
+					tr.Write(&Message{Type: "error", Value: msg.Type + ": " + err.Error()})
+				}
+			}()
+		}
+	}
+
+	tr.Close()
+}
+
 var wsUp *websocket.Upgrader
 
-type WSHandler func(ctx *Context, msg *streamer.Message)
-
-type Context struct {
-	Conn     *websocket.Conn
+type Transport struct {
 	Request  *http.Request
 	Consumer interface{} // TODO: rewrite
 
-	onClose []func()
-	mu      sync.Mutex
+	mx sync.Mutex
+
+	onChange func()
+	onWrite  func(msg interface{})
+	onClose  []func()
 }
 
-func (ctx *Context) Upgrade(w http.ResponseWriter, r *http.Request) (err error) {
-	ctx.Conn, err = wsUp.Upgrade(w, r, nil)
-	ctx.Request = r
-	return
+func (t *Transport) OnWrite(f func(msg interface{})) {
+	t.mx.Lock()
+	if t.onChange != nil {
+		t.onChange()
+	}
+	t.onWrite = f
+	t.mx.Unlock()
 }
 
-func (ctx *Context) Close() {
-	for _, f := range ctx.onClose {
+func (t *Transport) Write(msg interface{}) {
+	t.mx.Lock()
+	t.onWrite(msg)
+	t.mx.Unlock()
+}
+
+func (t *Transport) Close() {
+	for _, f := range t.onClose {
 		f()
 	}
-	_ = ctx.Conn.Close()
 }
 
-func (ctx *Context) Write(msg interface{}) {
-	ctx.mu.Lock()
-
-	if data, ok := msg.([]byte); ok {
-		_ = ctx.Conn.WriteMessage(websocket.BinaryMessage, data)
-	} else {
-		_ = ctx.Conn.WriteJSON(msg)
-	}
-
-	ctx.mu.Unlock()
+func (t *Transport) OnChange(f func()) {
+	t.onChange = f
 }
 
-func (ctx *Context) Error(err error) {
-	ctx.Write(&streamer.Message{
-		Type: "error", Value: err.Error(),
-	})
-}
-
-func (ctx *Context) OnClose(f func()) {
-	ctx.onClose = append(ctx.onClose, f)
+func (t *Transport) OnClose(f func()) {
+	t.onClose = append(t.onClose, f)
 }

cmd/app/app.go

@@ -10,7 +10,7 @@ import (
 	"runtime"
 )
 
-var Version = "0.1-rc.4"
+var Version = "0.1-rc.5"
 var UserAgent = "go2rtc/" + Version
 
 func Init() {

cmd/http/http.go

@@ -0,0 +1,56 @@
+package http
+
+import (
+	"errors"
+	"fmt"
+	"github.com/AlexxIT/go2rtc/cmd/streams"
+	"github.com/AlexxIT/go2rtc/pkg/mjpeg"
+	"github.com/AlexxIT/go2rtc/pkg/rtmp"
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/AlexxIT/go2rtc/pkg/tcp"
+	"net/http"
+	"strings"
+)
+
+func Init() {
+	streams.HandleFunc("http", handle)
+	streams.HandleFunc("https", handle)
+}
+
+func handle(url string) (streamer.Producer, error) {
+	// first we get the Content-Type to define supported producer
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := tcp.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	if res.StatusCode != http.StatusOK {
+		return nil, errors.New(res.Status)
+	}
+
+	ct := res.Header.Get("Content-Type")
+	if i := strings.IndexByte(ct, ';'); i > 0 {
+		ct = ct[:i]
+	}
+
+	switch ct {
+	case "image/jpeg", "multipart/x-mixed-replace":
+		return mjpeg.NewClient(res), nil
+	case "video/x-flv":
+		var conn *rtmp.Client
+		if conn, err = rtmp.Accept(res); err != nil {
+			return nil, err
+		}
+		if err = conn.Describe(); err != nil {
+			return nil, err
+		}
+		return conn, nil
+	}
+
+	return nil, fmt.Errorf("unsupported Content-Type: %s", ct)
+}

cmd/mjpeg/mjpeg.go

@@ -1,6 +1,7 @@
 package mjpeg
 
 import (
+	"errors"
 	"github.com/AlexxIT/go2rtc/cmd/api"
 	"github.com/AlexxIT/go2rtc/cmd/streams"
 	"github.com/AlexxIT/go2rtc/pkg/mjpeg"
@@ -12,12 +13,15 @@ import (
 func Init() {
 	api.HandleFunc("api/frame.jpeg", handlerKeyframe)
 	api.HandleFunc("api/stream.mjpeg", handlerStream)
+
+	api.HandleWS("mjpeg", handlerWS)
 }
 
 func handlerKeyframe(w http.ResponseWriter, r *http.Request) {
 	src := r.URL.Query().Get("src")
 	stream := streams.GetOrNew(src)
 	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
 		return
 	}
 
@@ -40,8 +44,12 @@ func handlerKeyframe(w http.ResponseWriter, r *http.Request) {
 
 	stream.RemoveConsumer(cons)
 
-	w.Header().Set("Content-Type", "image/jpeg")
-	w.Header().Set("Content-Length", strconv.Itoa(len(data)))
+	h := w.Header()
+	h.Set("Content-Type", "image/jpeg")
+	h.Set("Content-Length", strconv.Itoa(len(data)))
+	h.Set("Cache-Control", "no-cache")
+	h.Set("Connection", "close")
+	h.Set("Pragma", "no-cache")
 
 	if _, err := w.Write(data); err != nil {
 		log.Error().Err(err).Caller().Send()
@@ -54,23 +62,25 @@ func handlerStream(w http.ResponseWriter, r *http.Request) {
 	src := r.URL.Query().Get("src")
 	stream := streams.GetOrNew(src)
 	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
 		return
 	}
 
-	exit := make(chan struct{})
+	flusher := w.(http.Flusher)
 
 	cons := &mjpeg.Consumer{}
 	cons.Listen(func(msg interface{}) {
 		switch msg := msg.(type) {
 		case []byte:
 			data := []byte(header + strconv.Itoa(len(msg)))
-			data = append(data, 0x0D, 0x0A, 0x0D, 0x0A)
+			data = append(data, '\r', '\n', '\r', '\n')
 			data = append(data, msg...)
-			data = append(data, 0x0D, 0x0A)
+			data = append(data, '\r', '\n')
 
-			if _, err := w.Write(data); err != nil {
-				exit <- struct{}{}
-			}
+			// Chrome bug: mjpeg image always shows the second to last image
+			// https://bugs.chromium.org/p/chromium/issues/detail?id=527446
+			_, _ = w.Write(data)
+			flusher.Flush()
 		}
 	})
 
@@ -79,11 +89,41 @@ func handlerStream(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	w.Header().Set("Content-Type", `multipart/x-mixed-replace; boundary=frame`)
+	h := w.Header()
+	h.Set("Content-Type", "multipart/x-mixed-replace; boundary=frame")
+	h.Set("Cache-Control", "no-cache")
+	h.Set("Connection", "close")
+	h.Set("Pragma", "no-cache")
 
-	<-exit
+	<-r.Context().Done()
 
 	stream.RemoveConsumer(cons)
 
 	//log.Trace().Msg("[api.mjpeg] close")
 }
+
+func handlerWS(tr *api.Transport, _ *api.Message) error {
+	src := tr.Request.URL.Query().Get("src")
+	stream := streams.GetOrNew(src)
+	if stream == nil {
+		return errors.New(api.StreamNotFound)
+	}
+
+	cons := &mjpeg.Consumer{}
+	cons.Listen(func(msg interface{}) {
+		if data, ok := msg.([]byte); ok {
+			tr.Write(data)
+		}
+	})
+
+	if err := stream.AddConsumer(cons); err != nil {
+		log.Error().Err(err).Caller().Send()
+		return err
+	}
+
+	tr.OnClose(func() {
+		stream.RemoveConsumer(cons)
+	})
+
+	return nil
+}

cmd/mp4/mp4.go

@@ -15,7 +15,8 @@ import (
 func Init() {
 	log = app.GetLogger("mp4")
 
-	api.HandleWS(MsgTypeMSE, handlerWS)
+	api.HandleWS("mse", handlerWSMSE)
+	api.HandleWS("mp4", handlerWSMP4)
 
 	api.HandleFunc("api/frame.mp4", handlerKeyframe)
 	api.HandleFunc("api/stream.mp4", handlerMP4)
@@ -31,12 +32,13 @@ func handlerKeyframe(w http.ResponseWriter, r *http.Request) {
 	src := r.URL.Query().Get("src")
 	stream := streams.GetOrNew(src)
 	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
 		return
 	}
 
 	exit := make(chan []byte)
 
-	cons := &mp4.Keyframe{}
+	cons := &mp4.Segment{OnlyKeyframe: true}
 	cons.Listen(func(msg interface{}) {
 		if data, ok := msg.([]byte); ok && exit != nil {
 			exit <- data
@@ -63,7 +65,7 @@ func handlerKeyframe(w http.ResponseWriter, r *http.Request) {
 }
 
 func handlerMP4(w http.ResponseWriter, r *http.Request) {
-	log.Trace().Msgf("[api.mp4] %s %+v", r.Method, r.Header)
+	log.Trace().Msgf("[mp4] %s %+v", r.Method, r.Header)
 
 	if isChromeFirst(w, r) || isSafari(w, r) {
 		return
@@ -72,6 +74,7 @@ func handlerMP4(w http.ResponseWriter, r *http.Request) {
 	src := r.URL.Query().Get("src")
 	stream := streams.GetOrNew(src)
 	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
 		return
 	}
 

cmd/mp4/ws.go

@@ -1,6 +1,7 @@
 package mp4
 
 import (
+	"errors"
 	"github.com/AlexxIT/go2rtc/cmd/api"
 	"github.com/AlexxIT/go2rtc/cmd/streams"
 	"github.com/AlexxIT/go2rtc/pkg/mp4"
@@ -8,60 +9,91 @@ import (
 	"strings"
 )
 
-const MsgTypeMSE = "mse" // fMP4
-
 const packetSize = 8192
 
-func handlerWS(ctx *api.Context, msg *streamer.Message) {
-	src := ctx.Request.URL.Query().Get("src")
+func handlerWSMSE(tr *api.Transport, msg *api.Message) error {
+	src := tr.Request.URL.Query().Get("src")
 	stream := streams.GetOrNew(src)
 	if stream == nil {
-		return
+		return errors.New(api.StreamNotFound)
 	}
 
 	cons := &mp4.Consumer{}
-	cons.UserAgent = ctx.Request.UserAgent()
-	cons.RemoteAddr = ctx.Request.RemoteAddr
+	cons.UserAgent = tr.Request.UserAgent()
+	cons.RemoteAddr = tr.Request.RemoteAddr
 
 	if codecs, ok := msg.Value.(string); ok {
-		cons.Medias = parseMedias(codecs)
+		log.Trace().Str("codecs", codecs).Msgf("[mp4] new WS/MSE consumer")
+		cons.Medias = parseMedias(codecs, true)
 	}
 
 	cons.Listen(func(msg interface{}) {
 		if data, ok := msg.([]byte); ok {
 			for len(data) > packetSize {
-				ctx.Write(data[:packetSize])
+				tr.Write(data[:packetSize])
 				data = data[packetSize:]
 			}
-			ctx.Write(data)
+			tr.Write(data)
 		}
 	})
 
 	if err := stream.AddConsumer(cons); err != nil {
 		log.Warn().Err(err).Caller().Send()
-		ctx.Error(err)
-		return
+		return err
 	}
 
-	ctx.OnClose(func() {
+	tr.OnClose(func() {
 		stream.RemoveConsumer(cons)
 	})
 
-	ctx.Write(&streamer.Message{Type: MsgTypeMSE, Value: cons.MimeType()})
+	tr.Write(&api.Message{Type: "mse", Value: cons.MimeType()})
 
 	data, err := cons.Init()
 	if err != nil {
 		log.Warn().Err(err).Caller().Send()
-		ctx.Error(err)
-		return
+		return err
 	}
 
-	ctx.Write(data)
+	tr.Write(data)
 
 	cons.Start()
+
+	return nil
 }
 
-func parseMedias(codecs string) (medias []*streamer.Media) {
+func handlerWSMP4(tr *api.Transport, msg *api.Message) error {
+	src := tr.Request.URL.Query().Get("src")
+	stream := streams.GetOrNew(src)
+	if stream == nil {
+		return errors.New(api.StreamNotFound)
+	}
+
+	cons := &mp4.Segment{}
+
+	if codecs, ok := msg.Value.(string); ok {
+		log.Trace().Str("codecs", codecs).Msgf("[mp4] new WS/MP4 consumer")
+		cons.Medias = parseMedias(codecs, false)
+	}
+
+	cons.Listen(func(msg interface{}) {
+		if data, ok := msg.([]byte); ok {
+			tr.Write(data)
+		}
+	})
+
+	if err := stream.AddConsumer(cons); err != nil {
+		log.Error().Err(err).Caller().Send()
+		return err
+	}
+
+	tr.OnClose(func() {
+		stream.RemoveConsumer(cons)
+	})
+
+	return nil
+}
+
+func parseMedias(codecs string, parseAudio bool) (medias []*streamer.Media) {
 	var videos []*streamer.Codec
 	var audios []*streamer.Codec
 
@@ -88,7 +120,7 @@ func parseMedias(codecs string) (medias []*streamer.Media) {
 		medias = append(medias, media)
 	}
 
-	if audios != nil {
+	if audios != nil && parseAudio {
 		media := &streamer.Media{
 			Kind:      streamer.KindAudio,
 			Direction: streamer.DirectionRecvonly,

cmd/rtmp/rtmp.go

@@ -8,8 +8,6 @@ import (
 
 func Init() {
 	streams.HandleFunc("rtmp", handle)
-	streams.HandleFunc("http", handle)
-	streams.HandleFunc("https", handle)
 }
 
 func handle(url string) (streamer.Producer, error) {
@@ -17,5 +15,8 @@ func handle(url string) (streamer.Producer, error) {
 	if err := conn.Dial(); err != nil {
 		return nil, err
 	}
+	if err := conn.Describe(); err != nil {
+		return nil, err
+	}
 	return conn, nil
 }

cmd/rtsp/rtsp.go

@@ -14,7 +14,9 @@ import (
 func Init() {
 	var conf struct {
 		Mod struct {
-			Listen string `yaml:"listen"`
+			Listen   string `yaml:"listen"`
+			Username string `yaml:"username"`
+			Password string `yaml:"password"`
 		} `yaml:"rtsp"`
 	}
 
@@ -52,7 +54,13 @@ func Init() {
 			if err != nil {
 				return
 			}
-			go tcpHandler(conn)
+
+			c := rtsp.NewServer(conn)
+			// skip check auth for localhost
+			if conf.Mod.Username != "" && !conn.RemoteAddr().(*net.TCPAddr).IP.IsLoopback() {
+				c.Auth(conf.Mod.Username, conf.Mod.Password)
+			}
+			go tcpHandler(c)
 		}
 	}()
 }
@@ -121,13 +129,12 @@ func rtspHandler(url string) (streamer.Producer, error) {
 	return conn, nil
 }
 
-func tcpHandler(c net.Conn) {
+func tcpHandler(conn *rtsp.Conn) {
 	var name string
 	var closer func()
 
 	trace := log.Trace().Enabled()
 
-	conn := rtsp.NewServer(c)
 	conn.Listen(func(msg interface{}) {
 		if trace {
 			switch msg := msg.(type) {

cmd/streams/stream.go

@@ -3,7 +3,9 @@ package streams
 import (
 	"encoding/json"
 	"errors"
+	"fmt"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"strings"
 	"sync"
 )
 
@@ -55,6 +57,8 @@ func (s *Stream) AddConsumer(cons streamer.Consumer) (err error) {
 	consumer := &Consumer{element: cons}
 	var producers []*Producer // matched producers for consumer
 
+	var codecs string
+
 	// Step 1. Get consumer medias
 	for icc, consMedia := range cons.GetMedias() {
 		log.Trace().Stringer("media", consMedia).
@@ -67,6 +71,8 @@ func (s *Stream) AddConsumer(cons streamer.Consumer) (err error) {
 				log.Trace().Stringer("media", prodMedia).
 					Msgf("[streams] producer=%d candidate=%d", ip, ipc)
 
+				collectCodecs(prodMedia, &codecs)
+
 				// Step 3. Match consumer/producer codecs list
 				prodCodec := prodMedia.MatchMedia(consMedia)
 				if prodCodec != nil {
@@ -93,7 +99,11 @@ func (s *Stream) AddConsumer(cons streamer.Consumer) (err error) {
 
 	if len(producers) == 0 {
 		s.stopProducers()
-		return errors.New("couldn't find the matching tracks")
+		if len(codecs) > 0 {
+			return errors.New("codecs not match: " + codecs)
+		} else {
+			return fmt.Errorf("sources unavailable: %d", len(s.producers))
+		}
 	}
 
 	s.mu.Lock()
@@ -216,3 +226,19 @@ func (s *Stream) removeProducer(i int) {
 		s.producers = append(s.producers[:i], s.producers[i+1:]...)
 	}
 }
+
+func collectCodecs(media *streamer.Media, codecs *string) {
+	for _, codec := range media.Codecs {
+		name := codec.Name
+		if name == streamer.CodecAAC {
+			name = "AAC"
+		}
+		if strings.Contains(*codecs, name) {
+			continue
+		}
+		if len(*codecs) > 0 {
+			*codecs += ","
+		}
+		*codecs += name
+	}
+}

cmd/webrtc/candidates.go

@@ -2,7 +2,6 @@ package webrtc
 
 import (
 	"github.com/AlexxIT/go2rtc/cmd/api"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/AlexxIT/go2rtc/pkg/webrtc"
 	"github.com/pion/sdp/v3"
 )
@@ -13,7 +12,7 @@ func AddCandidate(address string) {
 	candidates = append(candidates, address)
 }
 
-func asyncCandidates(ctx *api.Context) {
+func asyncCandidates(tr *api.Transport) {
 	for _, address := range candidates {
 		address, err := webrtc.LookupIP(address)
 		if err != nil {
@@ -29,7 +28,7 @@ func asyncCandidates(ctx *api.Context) {
 
 		log.Trace().Str("candidate", cand).Msg("[webrtc] config")
 
-		ctx.Write(&streamer.Message{Type: webrtc.MsgTypeCandidate, Value: cand})
+		tr.Write(&api.Message{Type: "webrtc/candidate", Value: cand})
 	}
 }
 
@@ -79,12 +78,14 @@ func syncCanditates(answer string) (string, error) {
 	return string(data), nil
 }
 
-func candidateHandler(ctx *api.Context, msg *streamer.Message) {
-	if ctx.Consumer == nil {
-		return
+func candidateHandler(tr *api.Transport, msg *api.Message) error {
+	if tr.Consumer == nil {
+		return nil
 	}
-	if conn := ctx.Consumer.(*webrtc.Conn); conn != nil {
-		log.Trace().Str("candidate", msg.Value.(string)).Msg("[webrtc] remote")
-		conn.Push(msg)
+	if conn := tr.Consumer.(*webrtc.Conn); conn != nil {
+		s := msg.Value.(string)
+		log.Trace().Str("candidate", s).Msg("[webrtc] remote")
+		conn.AddCandidate(s)
 	}
+	return nil
 }

cmd/webrtc/webrtc.go

@@ -1,14 +1,14 @@
 package webrtc
 
 import (
+	"errors"
 	"github.com/AlexxIT/go2rtc/cmd/api"
 	"github.com/AlexxIT/go2rtc/cmd/app"
 	"github.com/AlexxIT/go2rtc/cmd/streams"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/AlexxIT/go2rtc/pkg/webrtc"
 	pion "github.com/pion/webrtc/v3"
 	"github.com/rs/zerolog"
-	"io/ioutil"
+	"io"
 	"net"
 	"net/http"
 )
@@ -55,8 +55,8 @@ func Init() {
 
 	candidates = cfg.Mod.Candidates
 
-	api.HandleWS(webrtc.MsgTypeOffer, asyncHandler)
-	api.HandleWS(webrtc.MsgTypeCandidate, candidateHandler)
+	api.HandleWS("webrtc/offer", asyncHandler)
+	api.HandleWS("webrtc/candidate", candidateHandler)
 
 	api.HandleFunc("api/webrtc", syncHandler)
 }
@@ -66,11 +66,11 @@ var log zerolog.Logger
 
 var NewPConn func() (*pion.PeerConnection, error)
 
-func asyncHandler(ctx *api.Context, msg *streamer.Message) {
-	src := ctx.Request.URL.Query().Get("src")
+func asyncHandler(tr *api.Transport, msg *api.Message) error {
+	src := tr.Request.URL.Query().Get("src")
 	stream := streams.Get(src)
 	if stream == nil {
-		return
+		return errors.New(api.StreamNotFound)
 	}
 
 	log.Debug().Str("url", src).Msg("[webrtc] new consumer")
@@ -81,21 +81,23 @@ func asyncHandler(ctx *api.Context, msg *streamer.Message) {
 	conn := new(webrtc.Conn)
 	conn.Conn, err = NewPConn()
 	if err != nil {
-		log.Error().Err(err).Caller().Msg("NewPConn")
-		return
+		log.Error().Err(err).Caller().Send()
+		return err
 	}
 
-	conn.UserAgent = ctx.Request.UserAgent()
+	conn.UserAgent = tr.Request.UserAgent()
 	conn.Listen(func(msg interface{}) {
 		switch msg := msg.(type) {
 		case pion.PeerConnectionState:
 			if msg == pion.PeerConnectionStateClosed {
 				stream.RemoveConsumer(conn)
 			}
-		case *streamer.Message:
-			// subscribe on webrtc server candidates
-			log.Trace().Str("candidate", msg.Value.(string)).Msg("[webrtc] local")
-			ctx.Write(msg)
+		case *pion.ICECandidate:
+			if msg != nil {
+				s := msg.ToJSON().Candidate
+				log.Trace().Str("candidate", s).Msg("[webrtc] local")
+				tr.Write(&api.Message{Type: "webrtc/candidate", Value: s})
+			}
 		}
 	})
 
@@ -104,36 +106,35 @@ func asyncHandler(ctx *api.Context, msg *streamer.Message) {
 	log.Trace().Msgf("[webrtc] offer:\n%s", offer)
 
 	if err = conn.SetOffer(offer); err != nil {
-		log.Warn().Err(err).Caller().Msg("conn.SetOffer")
-		ctx.Error(err)
-		return
+		log.Warn().Err(err).Caller().Send()
+		return err
 	}
 
 	// 2. AddConsumer, so we get new tracks
 	if err = stream.AddConsumer(conn); err != nil {
-		log.Warn().Err(err).Caller().Msg("stream.AddConsumer")
+		log.Warn().Err(err).Caller().Send()
 		_ = conn.Conn.Close()
-		ctx.Error(err)
-		return
+		return err
 	}
 
 	conn.Init()
 
-	// exchange sdp without waiting all candidates
+	// 3. Exchange SDP without waiting all candidates
 	answer, err := conn.GetAnswer()
 	log.Trace().Msgf("[webrtc] answer\n%s", answer)
 
 	if err != nil {
-		log.Error().Err(err).Caller().Msg("conn.GetAnswer")
-		ctx.Error(err)
-		return
+		log.Error().Err(err).Caller().Send()
+		return err
 	}
 
-	ctx.Consumer = conn
+	tr.Consumer = conn
 
-	ctx.Write(&streamer.Message{Type: webrtc.MsgTypeAnswer, Value: answer})
+	tr.Write(&api.Message{Type: "webrtc/answer", Value: answer})
 
-	asyncCandidates(ctx)
+	asyncCandidates(tr)
+
+	return nil
 }
 
 func syncHandler(w http.ResponseWriter, r *http.Request) {
@@ -144,7 +145,7 @@ func syncHandler(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// get offer
-	offer, err := ioutil.ReadAll(r.Body)
+	offer, err := io.ReadAll(r.Body)
 	if err != nil {
 		log.Error().Err(err).Caller().Msg("ioutil.ReadAll")
 		return

go.mod

@@ -1,6 +1,6 @@
 module github.com/AlexxIT/go2rtc
 
-go 1.17
+go 1.19
 
 require (
 	github.com/brutella/hap v0.0.17
@@ -26,6 +26,7 @@ require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/go-chi/chi v1.5.4 // indirect
 	github.com/google/uuid v1.3.0 // indirect
+	github.com/kr/pretty v0.2.1 // indirect
 	github.com/mattn/go-colorable v0.1.12 // indirect
 	github.com/mattn/go-isatty v0.0.14 // indirect
 	github.com/miekg/dns v1.1.50 // indirect
@@ -41,12 +42,11 @@ require (
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/xiam/to v0.0.0-20200126224905-d60d31e03561 // indirect
 	golang.org/x/crypto v0.0.0-20220516162934-403b01795ae8 // indirect
-	golang.org/x/mod v0.4.2 // indirect
+	golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 // indirect
 	golang.org/x/net v0.0.0-20220630215102-69896b714898 // indirect
-	golang.org/x/sys v0.0.0-20220622161953-175b2fd9d664 // indirect
+	golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab // indirect
 	golang.org/x/text v0.3.7 // indirect
-	golang.org/x/tools v0.1.6-0.20210726203631-07bc1bf47fb2 // indirect
-	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
+	golang.org/x/tools v0.1.11 // indirect
 )
 
 replace (

go.sum

@@ -4,7 +4,6 @@ github.com/AlexxIT/vdk v0.0.18-0.20221108193131-6168555b4f92 h1:cIeYMGaAirSZnrKR
 github.com/AlexxIT/vdk v0.0.18-0.20221108193131-6168555b4f92/go.mod h1:7ydHfSkflMZxBXfWR79dMjrT54xzvLxnPaByOa9Jpzg=
 github.com/brutella/dnssd v1.2.3 h1:4fBLjZjPH7SbcHhEcIJhZcC9nOhIDZ0m3rn9bjl1/i0=
 github.com/brutella/dnssd v1.2.3/go.mod h1:JoW2sJUrmVIef25G6lrLj7HS6Xdwh6q8WUIvMkkBYXs=
-github.com/cheekybits/genny v1.0.0/go.mod h1:+tQajlRqAUrPI7DOSpB0XAqZYtQakVtB7wXkRAgjxjQ=
 github.com/coreos/go-systemd/v22 v22.3.3-0.20220203105225-a9a7ef127534/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
@@ -15,7 +14,6 @@ github.com/go-chi/chi v1.5.4 h1:QHdzF2szwjqVV4wmByUnTcsbIg7UGaQ0tPF2t5GcAIs=
 github.com/go-chi/chi v1.5.4/go.mod h1:uaf8YgoFazUOkPBG7fxPftUylNumIev9awIWOENIuEg=
 github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
-github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
 github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
@@ -29,7 +27,6 @@ github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMyw
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
 github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
@@ -37,13 +34,12 @@ github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/ad
 github.com/hashicorp/mdns v1.0.5 h1:1M5hW1cunYeoXOqHwEb/GBDDHAFo0Yqb/uz/beC6LbE=
 github.com/hashicorp/mdns v1.0.5/go.mod h1:mtBihi+LeNXGtG8L9dX59gAEa12BDtBQSp4v/YAJqrc=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
-github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI=
+github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/lucas-clemente/quic-go v0.7.1-0.20190401152353-907071221cf9/go.mod h1:PpMmPfPKO9nKJ/psF49ESTAGQSdfXxlg1otPbEB2nOw=
-github.com/marten-seemann/qtls v0.2.3/go.mod h1:xzjG7avBwGGbdZ8dTGxlBnLArsVKLvwmjgmPuiQEcYk=
 github.com/mattn/go-colorable v0.1.12 h1:jF+Du6AlPIjs2BiUiQlKOX0rt3SujHxPnksPKZbaA40=
 github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
 github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
@@ -54,74 +50,49 @@ github.com/miekg/dns v1.1.50/go.mod h1:e3IlAVfNqAllflbibAZEWOXOQ+Ynzk/dDozDxY7Xn
 github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
 github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
 github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0=
 github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU=
-github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
 github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
 github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY=
-github.com/pion/datachannel v1.4.21/go.mod h1:oiNyP4gHx2DIwRzX/MFyH0Rz/Gz05OgBlayAI2hAWjg=
 github.com/pion/datachannel v1.5.2 h1:piB93s8LGmbECrpO84DnkIVWasRMk3IimbcXkTQLE6E=
 github.com/pion/datachannel v1.5.2/go.mod h1:FTGQWaHrdCwIJ1rw6xBIfZVkslikjShim5yr05XFuCQ=
-github.com/pion/dtls/v2 v2.0.1/go.mod h1:uMQkz2W0cSqY00xav7WByQ4Hb+18xeQh2oH2fRezr5U=
-github.com/pion/dtls/v2 v2.0.2/go.mod h1:27PEO3MDdaCfo21heT59/vsdmZc0zMt9wQPcSlLu/1I=
 github.com/pion/dtls/v2 v2.1.3/go.mod h1:o6+WvyLDAlXF7YiPB/RlskRoeK+/JtuaZa5emwQcWus=
 github.com/pion/dtls/v2 v2.1.5 h1:jlh2vtIyUBShchoTDqpCCqiYCyRFJ/lvf/gQ8TALs+c=
 github.com/pion/dtls/v2 v2.1.5/go.mod h1:BqCE7xPZbPSubGasRoDFJeTsyJtdD1FanJYL0JGheqY=
-github.com/pion/ice v0.7.18 h1:KbAWlzWRUdX9SmehBh3gYpIFsirjhSQsCw6K2MjYMK0=
-github.com/pion/ice v0.7.18/go.mod h1:+Bvnm3nYC6Nnp7VV6glUkuOfToB/AtMRZpOU8ihuf4c=
 github.com/pion/ice/v2 v2.2.6 h1:R/vaLlI1J2gCx141L5PEwtuGAGcyS6e7E0hDeJFq5Ig=
 github.com/pion/ice/v2 v2.2.6/go.mod h1:SWuHiOGP17lGromHTFadUe1EuPgFh/oCU6FCMZHooVE=
 github.com/pion/interceptor v0.1.11 h1:00U6OlqxA3FFB50HSg25J/8cWi7P6FbSzw4eFn24Bvs=
 github.com/pion/interceptor v0.1.11/go.mod h1:tbtKjZY14awXd7Bq0mmWvgtHB5MDaRN7HV3OZ/uy7s8=
 github.com/pion/logging v0.2.2 h1:M9+AIj/+pxNsDfAT64+MAVgJO0rsyLnoJKCqf//DoeY=
 github.com/pion/logging v0.2.2/go.mod h1:k0/tDVsRCX2Mb2ZEmTqNa7CWsQPc+YYCB7Q+5pahoms=
-github.com/pion/mdns v0.0.4/go.mod h1:R1sL0p50l42S5lJs91oNdUL58nm0QHrhxnSegr++qC0=
 github.com/pion/mdns v0.0.5 h1:Q2oj/JB3NqfzY9xGZ1fPzZzK7sDSD8rZPOvcIQ10BCw=
 github.com/pion/mdns v0.0.5/go.mod h1:UgssrvdD3mxpi8tMxAXbsppL3vJ4Jipw1mTCW+al01g=
-github.com/pion/quic v0.1.1/go.mod h1:zEU51v7ru8Mp4AUBJvj6psrSth5eEFNnVQK5K48oV3k=
-github.com/pion/randutil v0.0.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8=
 github.com/pion/randutil v0.1.0 h1:CFG1UdESneORglEsnimhUjf33Rwjubwj6xfiOXBa3mA=
 github.com/pion/randutil v0.1.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8=
-github.com/pion/rtcp v1.2.3/go.mod h1:zGhIv0RPRF0Z1Wiij22pUt5W/c9fevqSzT4jje/oK7I=
 github.com/pion/rtcp v1.2.9 h1:1ujStwg++IOLIEoOiIQ2s+qBuJ1VN81KW+9pMPsif+U=
 github.com/pion/rtcp v1.2.9/go.mod h1:qVPhiCzAm4D/rxb6XzKeyZiQK69yJpbUDJSF7TgrqNo=
-github.com/pion/rtp v1.6.0/go.mod h1:QgfogHsMBVE/RFNno467U/KBqfUywEH+HK+0rtnwsdI=
 github.com/pion/rtp v1.7.13 h1:qcHwlmtiI50t1XivvoawdCGTP4Uiypzfrsap+bijcoA=
 github.com/pion/rtp v1.7.13/go.mod h1:bDb5n+BFZxXx0Ea7E5qe+klMuqiBrP+w8XSjiWtCUko=
-github.com/pion/sctp v1.7.10/go.mod h1:EhpTUQu1/lcK3xI+eriS6/96fWetHGCvBi9MSsnaBN0=
 github.com/pion/sctp v1.8.0/go.mod h1:xFe9cLMZ5Vj6eOzpyiKjT9SwGM4KpK/8Jbw5//jc+0s=
 github.com/pion/sctp v1.8.2 h1:yBBCIrUMJ4yFICL3RIvR4eh/H2BTTvlligmSTy+3kiA=
 github.com/pion/sctp v1.8.2/go.mod h1:xFe9cLMZ5Vj6eOzpyiKjT9SwGM4KpK/8Jbw5//jc+0s=
-github.com/pion/sdp/v2 v2.4.0/go.mod h1:L2LxrOpSTJbAns244vfPChbciR/ReU1KWfG04OpkR7E=
 github.com/pion/sdp/v3 v3.0.5 h1:ouvI7IgGl+V4CrqskVtr3AaTrPvPisEOxwgpdktctkU=
 github.com/pion/sdp/v3 v3.0.5/go.mod h1:iiFWFpQO8Fy3S5ldclBkpXqmWy02ns78NOKoLLL0YQw=
-github.com/pion/srtp v1.5.1 h1:9Q3jAfslYZBt+C69SI/ZcONJh9049JUHZWYRRf5KEKw=
-github.com/pion/srtp v1.5.1/go.mod h1:B+QgX5xPeQTNc1CJStJPHzOlHK66ViMDWTT0HZTCkcA=
-github.com/pion/srtp/v2 v2.0.9/go.mod h1:5TtM9yw6lsH0ppNCehB/EjEUli7VkUgKSPJqWVqbhQ4=
 github.com/pion/srtp/v2 v2.0.10 h1:b8ZvEuI+mrL8hbr/f1YiJFB34UMrOac3R3N1yq2UN0w=
 github.com/pion/srtp/v2 v2.0.10/go.mod h1:XEeSWaK9PfuMs7zxXyiN252AHPbH12NX5q/CFDWtUuA=
 github.com/pion/stun v0.3.5 h1:uLUCBCkQby4S1cf6CGuR9QrVOKcvUwFeemaC865QHDg=
 github.com/pion/stun v0.3.5/go.mod h1:gDMim+47EeEtfWogA37n6qXZS88L5V6LqFcf+DZA2UA=
-github.com/pion/transport v0.6.0/go.mod h1:iWZ07doqOosSLMhZ+FXUTq+TamDoXSllxpbGcfkCmbE=
-github.com/pion/transport v0.8.10/go.mod h1:tBmha/UCjpum5hqTWhfAEs3CO4/tHSg0MYRhSzR+CZ8=
-github.com/pion/transport v0.10.0/go.mod h1:BnHnUipd0rZQyTVB2SBGojFHT9CBt5C5TcsJSQGkvSE=
-github.com/pion/transport v0.10.1/go.mod h1:PBis1stIILMiis0PewDw91WJeLJkyIMcEk+DwKOzf4A=
 github.com/pion/transport v0.12.2/go.mod h1:N3+vZQD9HlDP5GWkZ85LohxNsDcNgofQmyL6ojX5d8Q=
 github.com/pion/transport v0.12.3/go.mod h1:OViWW9SP2peE/HbwBvARicmAVnesphkNkCVZIWJ6q9A=
 github.com/pion/transport v0.13.0/go.mod h1:yxm9uXpK9bpBBWkITk13cLo1y5/ur5VQpG22ny6EP7g=
 github.com/pion/transport v0.13.1 h1:/UH5yLeQtwm2VZIPjxwnNFxjS4DFhyLfS4GlfuKUzfA=
 github.com/pion/transport v0.13.1/go.mod h1:EBxbqzyv+ZrmDb82XswEE0BjfQFtuw1Nu6sjnjWCsGg=
-github.com/pion/turn/v2 v2.0.4/go.mod h1:1812p4DcGVbYVBTiraUmP50XoKye++AMkbfp+N27mog=
 github.com/pion/turn/v2 v2.0.8 h1:KEstL92OUN3k5k8qxsXHpr7WWfrdp7iJZHx99ud8muw=
 github.com/pion/turn/v2 v2.0.8/go.mod h1:+y7xl719J8bAEVpSXBXvTxStjJv3hbz9YFflvkpcGPw=
-github.com/pion/udp v0.1.0/go.mod h1:BPELIjbwE9PRbd/zxI/KYBnbo7B6+oA6YuEaNE8lths=
 github.com/pion/udp v0.1.1 h1:8UAPvyqmsxK8oOjloDk4wUt63TzFe9WEJkg5lChlj7o=
 github.com/pion/udp v0.1.1/go.mod h1:6AFo+CMdKQm7UiA0eUPA8/eVCTx8jBIITLZHc9DWX5M=
-github.com/pion/webrtc/v2 v2.2.26/go.mod h1:XMZbZRNHyPDe1gzTIHFcQu02283YO45CbiwFgKvXnmc=
-github.com/pion/webrtc/v3 v3.1.42/go.mod h1:ffD9DulDrPxyWvDPUIPAOSAWx9GUlOExiJPf7cCcMLA=
 github.com/pion/webrtc/v3 v3.1.43 h1:YT3ZTO94UT4kSBvZnRAH82+0jJPUruiKr9CEstdlQzk=
 github.com/pion/webrtc/v3 v3.1.43/go.mod h1:G/J8k0+grVsjC/rjCZ24AKoCCxcFFODgh7zThNZGs0M=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
@@ -132,7 +103,6 @@ github.com/rs/zerolog v1.27.0 h1:1T7qCieN22GVc8S4Q2yuexzBb1EqjbgjSH9RohbMjKs=
 github.com/rs/zerolog v1.27.0/go.mod h1:7frBqO0oezxmnO7GF86FY++uy8I0Tk/If5ni1G9Qc0U=
 github.com/sclevine/agouti v3.0.0+incompatible/go.mod h1:b4WX9W9L1sfQKXeJf1mUTLZKJ48R1S7H23Ji7oFO5Bw=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
@@ -145,28 +115,21 @@ github.com/xiam/to v0.0.0-20200126224905-d60d31e03561 h1:SVoNK97S6JlaYlHcaC+79tg
 github.com/xiam/to v0.0.0-20200126224905-d60d31e03561/go.mod h1:cqbG7phSzrbdg3aj+Kn63bpVruzwDZi58CpxlZkjwzw=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
-golang.org/x/crypto v0.0.0-20190228161510-8dd112bcdc25/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200602180216-279210d13fed/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20200709230013-948cd5f35899/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20220131195533-30dcbda58838/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/crypto v0.0.0-20220427172511-eb4f295cb31f/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/crypto v0.0.0-20220516162934-403b01795ae8 h1:y+mHpWoQJNAHt26Nhh6JP7hvM71IRZureyvZhoVALIs=
 golang.org/x/crypto v0.0.0-20220516162934-403b01795ae8/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.4.2 h1:Gz96sIWK3OalVv/I/qNygP42zyoKp3xptRVCWRFEBvo=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 h1:6zppjxzCulZykYSLyVDYbneBfbaBIQPYMevg0bEwv2s=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20191126235420-ef20fe5d7933/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200602114024-627f9648deb9/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20201201195509-5d6afe98e0b7/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
@@ -190,13 +153,11 @@ golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cO
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190228124157-a34e9553db1e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200724161237-0e2f3a69832c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -210,8 +171,9 @@ golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220608164250-635b8c9b7f68/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220622161953-175b2fd9d664 h1:wEZYwx+kK+KlZ0hpvP2Ls1Xr4+RWnlzGFwPP0aiDjIU=
 golang.org/x/sys v0.0.0-20220622161953-175b2fd9d664/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab h1:2QkjZIsXupsJbJIdSjjUOgWK3aEtzyuh2mPt3l/CkeU=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -222,12 +184,12 @@ golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.1.6-0.20210726203631-07bc1bf47fb2 h1:BonxutuHCTL0rBDnZlKjpGIQFTjyUVTexFOdWkB6Fg0=
 golang.org/x/tools v0.1.6-0.20210726203631-07bc1bf47fb2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.1.11 h1:loJ25fNOEhSXfHrpoGj91eCUThwdNX6u24rO1xnNteY=
+golang.org/x/tools v0.1.11/go.mod h1:SgwaegtQh8clINPpECJMqnxLv9I09HLqnW3RMqW0CA4=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
 google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
@@ -242,7 +204,6 @@ gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogR
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
-gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

main.go

@@ -9,6 +9,7 @@ import (
 	"github.com/AlexxIT/go2rtc/cmd/ffmpeg"
 	"github.com/AlexxIT/go2rtc/cmd/hass"
 	"github.com/AlexxIT/go2rtc/cmd/homekit"
+	"github.com/AlexxIT/go2rtc/cmd/http"
 	"github.com/AlexxIT/go2rtc/cmd/ivideon"
 	"github.com/AlexxIT/go2rtc/cmd/mjpeg"
 	"github.com/AlexxIT/go2rtc/cmd/mp4"
@@ -40,6 +41,7 @@ func main() {
 	webrtc.Init()
 	mp4.Init()
 	mjpeg.Init()
+	http.Init()
 
 	srtp.Init()
 	homekit.Init()

pkg/h265/rtp.go

@@ -4,7 +4,6 @@ import (
 	"encoding/binary"
 	"github.com/AlexxIT/go2rtc/pkg/h264"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
-	"github.com/deepch/vdk/codec/h265parser"
 	"github.com/pion/rtp"
 )
 
@@ -69,68 +68,80 @@ func RTPDepay(track *streamer.Track) streamer.WrapperFunc {
 }
 
 // SafariPay - generate Safari friendly payload for H265
+// https://github.com/AlexxIT/Blog/issues/5
 func SafariPay(mtu uint16) streamer.WrapperFunc {
 	sequencer := rtp.NewRandomSequencer()
 	size := int(mtu - 12) // rtp.Header size
 
-	var buffer []byte
-
 	return func(push streamer.WriterFunc) streamer.WriterFunc {
 		return func(packet *rtp.Packet) error {
 			if packet.Version != h264.RTPPacketVersionAVC {
 				return push(packet)
 			}
 
-			data := packet.Payload
-			data[0] = 0
-			data[1] = 0
-			data[2] = 0
-			data[3] = 1
+			// protect original packets from modification
+			au := make([]byte, len(packet.Payload))
+			copy(au, packet.Payload)
 
 			var start byte
 
-			nuType := (data[4] >> 1) & 0b111111
-			//fmt.Printf("[H265] nut: %2d, size: %6d, data: %16x\n", nut, len(data), data[4:20])
-			switch {
-			case nuType >= h265parser.NAL_UNIT_VPS && nuType <= h265parser.NAL_UNIT_PPS:
-				buffer = append(buffer, data...)
-				return nil
-			case nuType >= h265parser.NAL_UNIT_CODED_SLICE_BLA_W_LP && nuType <= h265parser.NAL_UNIT_CODED_SLICE_CRA:
-				buffer = append([]byte{3}, buffer...)
-				data = append(buffer, data...)
-				start = 1
-			default:
-				data = append([]byte{2}, data...)
-				start = 0
+			for i := 0; i < len(au); {
+				size := int(binary.BigEndian.Uint32(au[i:])) + 4
+
+				// convert AVC to Annex-B
+				au[i] = 0
+				au[i+1] = 0
+				au[i+2] = 0
+				au[i+3] = 1
+
+				switch NALUType(au[i:]) {
+				case NALUTypeIFrame, NALUTypeIFrame2, NALUTypeIFrame3:
+					start = 3
+				default:
+					if start == 0 {
+						start = 2
+					}
+				}
+
+				i += size
 			}
 
-			for len(data) > size {
+			// rtp.Packet payload
+			b := make([]byte, 1, size)
+			size-- // minus header byte
+
+			for au != nil {
+				b[0] = start
+
+				if start > 1 {
+					start -= 2
+				}
+
+				if len(au) > size {
+					b = append(b, au[:size]...)
+					au = au[size:]
+				} else {
+					b = append(b, au...)
+					au = nil
+				}
+
 				clone := rtp.Packet{
 					Header: rtp.Header{
 						Version:        2,
-						Marker:         false,
+						Marker:         au == nil,
 						SequenceNumber: sequencer.NextSequenceNumber(),
 						Timestamp:      packet.Timestamp,
 					},
-					Payload: data[:size],
+					Payload: b,
 				}
 				if err := push(&clone); err != nil {
 					return err
 				}
 
-				data = append([]byte{start}, data[size:]...)
+				b = b[:1] // clear buffer
 			}
 
-			clone := rtp.Packet{
-				Header: rtp.Header{
-					Version:        2,
-					Marker:         true,
-					SequenceNumber: sequencer.NextSequenceNumber(),
-					Timestamp:      packet.Timestamp,
-				},
-				Payload: data,
-			}
-			return push(&clone)
+			return nil
 		}
 	}
 }

pkg/httpflv/httpflv.go

@@ -22,13 +22,17 @@ func Dial(uri string) (*Conn, error) {
 		return nil, err
 	}
 
+	return Accept(res)
+}
+
+func Accept(res *http.Response) (*Conn, error) {
 	c := Conn{
 		conn:   res.Body,
 		reader: bufio.NewReaderSize(res.Body, pio.RecommendBufioSize),
 		buf:    make([]byte, 256),
 	}
 
-	if _, err = io.ReadFull(c.reader, c.buf[:flvio.FileHeaderLength]); err != nil {
+	if _, err := io.ReadFull(c.reader, c.buf[:flvio.FileHeaderLength]); err != nil {
 		return nil, err
 	}
 
@@ -49,9 +53,9 @@ func Dial(uri string) (*Conn, error) {
 }
 
 type Conn struct {
-	conn      io.ReadCloser
-	reader    *bufio.Reader
-	buf       []byte
+	conn   io.ReadCloser
+	reader *bufio.Reader
+	buf    []byte
 }
 
 func (c *Conn) Streams() ([]av.CodecData, error) {

pkg/ivideon/client.go

@@ -165,7 +165,7 @@ func (c *Client) getTracks() error {
 					Name:        streamer.CodecH264,
 					ClockRate:   90000,
 					FmtpLine:    "profile-level-id=" + msg.CodecString[i+1:],
-					PayloadType: streamer.PayloadTypeMP4,
+					PayloadType: streamer.PayloadTypeRAW,
 				}
 
 				i = bytes.Index(msg.Data, []byte("avcC")) - 4

pkg/mjpeg/README.md

@@ -2,3 +2,4 @@
 
 - https://www.rfc-editor.org/rfc/rfc2435
 - https://github.com/GStreamer/gst-plugins-good/blob/master/gst/rtp/gstrtpjpegdepay.c
+- https://mjpeg.sanford.io/

pkg/mjpeg/client.go

@@ -0,0 +1,152 @@
+package mjpeg
+
+import (
+	"bufio"
+	"errors"
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/AlexxIT/go2rtc/pkg/tcp"
+	"github.com/pion/rtp"
+	"io"
+	"net/http"
+	"net/textproto"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type Client struct {
+	streamer.Element
+
+	UserAgent  string
+	RemoteAddr string
+
+	closed bool
+	res    *http.Response
+
+	track *streamer.Track
+}
+
+func NewClient(res *http.Response) *Client {
+	codec := &streamer.Codec{
+		Name: streamer.CodecJPEG, ClockRate: 90000, PayloadType: streamer.PayloadTypeRAW,
+	}
+	return &Client{
+		res:   res,
+		track: streamer.NewTrack(codec, streamer.DirectionSendonly),
+	}
+}
+
+func (c *Client) GetMedias() []*streamer.Media {
+	return []*streamer.Media{{
+		Kind:      streamer.KindVideo,
+		Direction: streamer.DirectionSendonly,
+		Codecs:    []*streamer.Codec{c.track.Codec},
+	}}
+}
+
+func (c *Client) GetTrack(media *streamer.Media, codec *streamer.Codec) *streamer.Track {
+	return c.track
+}
+
+func (c *Client) Start() error {
+	ct := c.res.Header.Get("Content-Type")
+
+	if ct == "image/jpeg" {
+		return c.startJPEG()
+	}
+
+	// added in go1.18
+	if _, s, ok := strings.Cut(ct, "boundary="); ok {
+		return c.startMJPEG(s)
+	}
+
+	return errors.New("wrong Content-Type: " + ct)
+}
+
+func (c *Client) Stop() error {
+	c.closed = true
+	return nil
+}
+
+func (c *Client) startJPEG() error {
+	buf, err := io.ReadAll(c.res.Body)
+	if err != nil {
+		return err
+	}
+
+	packet := &rtp.Packet{Header: rtp.Header{Timestamp: now()}, Payload: buf}
+	_ = c.track.WriteRTP(packet)
+
+	req := c.res.Request
+
+	for !c.closed {
+		res, err := tcp.Do(req)
+		if err != nil {
+			return err
+		}
+
+		if res.StatusCode != http.StatusOK {
+			return errors.New("wrong status: " + res.Status)
+		}
+
+		buf, err = io.ReadAll(res.Body)
+		if err != nil {
+			return err
+		}
+
+		packet = &rtp.Packet{Header: rtp.Header{Timestamp: now()}, Payload: buf}
+		_ = c.track.WriteRTP(packet)
+	}
+
+	return nil
+}
+
+func (c *Client) startMJPEG(boundary string) error {
+	boundary = "--" + boundary
+
+	r := bufio.NewReader(c.res.Body)
+	tp := textproto.NewReader(r)
+
+	for !c.closed {
+		s, err := tp.ReadLine()
+		if err != nil {
+			return err
+		}
+		if s != boundary {
+			return errors.New("wrong boundary: " + s)
+		}
+
+		header, err := tp.ReadMIMEHeader()
+		if err != nil {
+			return err
+		}
+
+		s = header.Get("Content-Length")
+		if s == "" {
+			return errors.New("no content length")
+		}
+
+		size, err := strconv.Atoi(s)
+		if err != nil {
+			return err
+		}
+
+		buf := make([]byte, size)
+		if _, err = io.ReadFull(r, buf); err != nil {
+			return err
+		}
+
+		packet := &rtp.Packet{Header: rtp.Header{Timestamp: now()}, Payload: buf}
+		_ = c.track.WriteRTP(packet)
+
+		if _, err = r.Discard(2); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func now() uint32 {
+	return uint32(time.Now().UnixMilli() * 90)
+}

pkg/mjpeg/consumer.go

@@ -26,70 +26,15 @@ func (c *Consumer) GetMedias() []*streamer.Media {
 }
 
 func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *streamer.Track {
-	var header, payload []byte
-
 	push := func(packet *rtp.Packet) error {
-		//fmt.Printf(
-		//	"[RTP] codec: %s, size: %6d, ts: %10d, pt: %2d, ssrc: %d, seq: %d, mark: %v\n",
-		//	track.Codec.Name, len(packet.Payload), packet.Timestamp,
-		//	packet.PayloadType, packet.SSRC, packet.SequenceNumber, packet.Marker,
-		//)
-
-		// https://www.rfc-editor.org/rfc/rfc2435#section-3.1
-		b := packet.Payload
-
-		// 3.1.  JPEG header
-		t := b[4]
-
-		// 3.1.7.  Restart Marker header
-		if 64 <= t && t <= 127 {
-			b = b[12:] // skip it
-		} else {
-			b = b[8:]
-		}
-
-		if header == nil {
-			var lqt, cqt []byte
-
-			// 3.1.8.  Quantization Table header
-			q := packet.Payload[5]
-			if q >= 128 {
-				lqt = b[4:68]
-				cqt = b[68:132]
-				b = b[132:]
-			} else {
-				lqt, cqt = MakeTables(q)
-			}
-
-			// https://www.rfc-editor.org/rfc/rfc2435#section-3.1.5
-			// The maximum width is 2040 pixels.
-			w := uint16(packet.Payload[6]) << 3
-			h := uint16(packet.Payload[7]) << 3
-
-			// fix 2560x1920 and 2560x1440
-			if w == 512 && (h == 1920 || h == 1440) {
-				w = 2560
-			}
-
-			//fmt.Printf("t: %d, q: %d, w: %d, h: %d\n", t, q, w, h)
-			header = MakeHeaders(t, w, h, lqt, cqt)
-		}
-
-		// 3.1.9.  JPEG Payload
-		payload = append(payload, b...)
-
-		if packet.Marker {
-			b = append(header, payload...)
-			if end := b[len(b)-2:]; end[0] != 0xFF && end[1] != 0xD9 {
-				b = append(b, 0xFF, 0xD9)
-			}
-			c.Fire(b)
-
-			header = nil
-			payload = nil
-		}
-
+		c.Fire(packet.Payload)
 		return nil
 	}
+
+	if track.Codec.IsRTP() {
+		wrapper := RTPDepay(track)
+		push = wrapper(push)
+	}
+
 	return track.Bind(push)
 }

pkg/mjpeg/rtp.go

@@ -0,0 +1,212 @@
+package mjpeg
+
+import (
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/pion/rtp"
+)
+
+func RTPDepay(track *streamer.Track) streamer.WrapperFunc {
+	var header, payload []byte
+
+	return func(push streamer.WriterFunc) streamer.WriterFunc {
+		return func(packet *rtp.Packet) error {
+			//log.Printf("[RTP] codec: %s, size: %6d, ts: %10d, pt: %2d, ssrc: %d, seq: %d, mark: %v", track.Codec.Name, len(packet.Payload), packet.Timestamp, packet.PayloadType, packet.SSRC, packet.SequenceNumber, packet.Marker)
+
+			// https://www.rfc-editor.org/rfc/rfc2435#section-3.1
+			b := packet.Payload
+
+			// 3.1.  JPEG header
+			t := b[4]
+
+			// 3.1.7.  Restart Marker header
+			if 64 <= t && t <= 127 {
+				b = b[12:] // skip it
+			} else {
+				b = b[8:]
+			}
+
+			if header == nil {
+				var lqt, cqt []byte
+
+				// 3.1.8.  Quantization Table header
+				q := packet.Payload[5]
+				if q >= 128 {
+					lqt = b[4:68]
+					cqt = b[68:132]
+					b = b[132:]
+				} else {
+					lqt, cqt = MakeTables(q)
+				}
+
+				// https://www.rfc-editor.org/rfc/rfc2435#section-3.1.5
+				// The maximum width is 2040 pixels.
+				w := uint16(packet.Payload[6]) << 3
+				h := uint16(packet.Payload[7]) << 3
+
+				// fix 2560x1920 and 2560x1440
+				if w == 512 && (h == 1920 || h == 1440) {
+					w = 2560
+				}
+
+				//fmt.Printf("t: %d, q: %d, w: %d, h: %d\n", t, q, w, h)
+				header = MakeHeaders(t, w, h, lqt, cqt)
+			}
+
+			// 3.1.9.  JPEG Payload
+			payload = append(payload, b...)
+
+			if !packet.Marker {
+				return nil
+			}
+
+			b = append(header, payload...)
+			if end := b[len(b)-2:]; end[0] != 0xFF && end[1] != 0xD9 {
+				b = append(b, 0xFF, 0xD9)
+			}
+
+			header = nil
+			payload = nil
+
+			packet.Payload = b
+			return push(packet)
+		}
+	}
+}
+
+func RTPPay() streamer.WrapperFunc {
+	return func(push streamer.WriterFunc) streamer.WriterFunc {
+		return func(packet *rtp.Packet) error {
+			return nil
+		}
+	}
+}
+
+//func RTPPay() streamer.WrapperFunc {
+//	const packetSize = 1436
+//
+//	sequencer := rtp.NewRandomSequencer()
+//
+//	return func(push streamer.WriterFunc) streamer.WriterFunc {
+//		return func(packet *rtp.Packet) error {
+//			// reincode image to more common form
+//			img, err := jpeg.Decode(bytes.NewReader(packet.Payload))
+//			if err != nil {
+//				return err
+//			}
+//
+//			wh := img.Bounds().Size()
+//			w := wh.X
+//			h := wh.Y
+//
+//			if w > 2040 {
+//				w = 2040
+//			} else if w&3 > 0 {
+//				w &= 3
+//			}
+//			if h > 2040 {
+//				h = 2040
+//			} else if h&3 > 0 {
+//				h &= 3
+//			}
+//
+//			if w != wh.X || h != wh.Y {
+//				x0 := (wh.X - w) / 2
+//				y0 := (wh.Y - h) / 2
+//				rect := image.Rect(x0, y0, x0+w, y0+h)
+//				img = img.(*image.YCbCr).SubImage(rect)
+//			}
+//
+//			buf := bytes.NewBuffer(nil)
+//			if err = jpeg.Encode(buf, img, nil); err != nil {
+//				return err
+//			}
+//
+//			h1 := make([]byte, 8)
+//			h1[4] = 1   // Type
+//			h1[5] = 255 // Q
+//
+//			// MBZ=0, Precision=0, Length=128
+//			h2 := make([]byte, 4, 132)
+//			h2[3] = 128
+//
+//			var jpgData []byte
+//
+//			p := buf.Bytes()
+//
+//			for jpgData == nil {
+//				// 2 bytes h1
+//				if p[0] != 0xFF {
+//					return nil
+//				}
+//
+//				size := binary.BigEndian.Uint16(p[2:]) + 2
+//
+//				// 2 bytes payload size (include 2 bytes)
+//				switch p[1] {
+//				case 0xD8: // 0. Start Of Image (size=0)
+//					p = p[2:]
+//					continue
+//				case 0xDB: // 1. Define Quantization Table (size=130)
+//					for i := uint16(4 + 1); i < size; i += 1 + 64 {
+//						h2 = append(h2, p[i:i+64]...)
+//					}
+//				case 0xC0: // 2. Start Of Frame (size=15)
+//					if p[4] != 8 {
+//						return nil
+//					}
+//					h := binary.BigEndian.Uint16(p[5:])
+//					w := binary.BigEndian.Uint16(p[7:])
+//					h1[6] = uint8(w >> 3)
+//					h1[7] = uint8(h >> 3)
+//				case 0xC4: // 3. Define Huffman Table (size=416)
+//				case 0xDA: // 4. Start Of Scan (size=10)
+//					jpgData = p[size:]
+//				}
+//
+//				p = p[size:]
+//			}
+//
+//			offset := 0
+//			p = make([]byte, 0)
+//
+//			for jpgData != nil {
+//				p = p[:0]
+//
+//				if offset > 0 {
+//					h1[1] = byte(offset >> 16)
+//					h1[2] = byte(offset >> 8)
+//					h1[3] = byte(offset)
+//					p = append(p, h1...)
+//				} else {
+//					p = append(p, h1...)
+//					p = append(p, h2...)
+//				}
+//
+//				dataLen := packetSize - len(p)
+//				if dataLen < len(jpgData) {
+//					p = append(p, jpgData[:dataLen]...)
+//					jpgData = jpgData[dataLen:]
+//					offset += dataLen
+//				} else {
+//					p = append(p, jpgData...)
+//					jpgData = nil
+//				}
+//
+//				clone := rtp.Packet{
+//					Header: rtp.Header{
+//						Version:        2,
+//						Marker:         jpgData == nil,
+//						SequenceNumber: sequencer.NextSequenceNumber(),
+//						Timestamp:      packet.Timestamp,
+//					},
+//					Payload: p,
+//				}
+//				if err := push(&clone); err != nil {
+//					return err
+//				}
+//			}
+//
+//			return nil
+//		}
+//	}
+//}

pkg/mp4/consumer.go

@@ -18,11 +18,17 @@ type Consumer struct {
 
 	muxer  *Muxer
 	codecs []*streamer.Codec
-	start  bool
+	wait   byte
 
 	send int
 }
 
+const (
+	waitNone byte = iota
+	waitKeyframe
+	waitInit
+)
+
 func (c *Consumer) GetMedias() []*streamer.Media {
 	if c.Medias != nil {
 		return c.Medias
@@ -55,13 +61,18 @@ func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 	codec := track.Codec
 	switch codec.Name {
 	case streamer.CodecH264:
+		c.wait = waitInit
+
 		push := func(packet *rtp.Packet) error {
 			if packet.Version != h264.RTPPacketVersionAVC {
 				return nil
 			}
 
-			if !c.start {
-				return nil
+			if c.wait != waitNone {
+				if c.wait == waitInit || !h264.IsKeyframe(packet.Payload) {
+					return nil
+				}
+				c.wait = waitNone
 			}
 
 			buf := c.muxer.Marshal(trackID, packet)
@@ -72,23 +83,28 @@ func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 		}
 
 		var wrapper streamer.WrapperFunc
-		if codec.IsMP4() {
-			wrapper = h264.RepairAVC(track)
-		} else {
+		if codec.IsRTP() {
 			wrapper = h264.RTPDepay(track)
+		} else {
+			wrapper = h264.RepairAVC(track)
 		}
 		push = wrapper(push)
 
 		return track.Bind(push)
 
 	case streamer.CodecH265:
+		c.wait = waitInit
+
 		push := func(packet *rtp.Packet) error {
 			if packet.Version != h264.RTPPacketVersionAVC {
 				return nil
 			}
 
-			if !c.start {
-				return nil
+			if c.wait != waitNone {
+				if c.wait == waitInit || !h265.IsKeyframe(packet.Payload) {
+					return nil
+				}
+				c.wait = waitNone
 			}
 
 			buf := c.muxer.Marshal(trackID, packet)
@@ -98,7 +114,7 @@ func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 			return nil
 		}
 
-		if !codec.IsMP4() {
+		if codec.IsRTP() {
 			wrapper := h265.RTPDepay(track)
 			push = wrapper(push)
 		}
@@ -107,7 +123,7 @@ func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 
 	case streamer.CodecAAC:
 		push := func(packet *rtp.Packet) error {
-			if !c.start {
+			if c.wait != waitNone {
 				return nil
 			}
 
@@ -118,7 +134,7 @@ func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 			return nil
 		}
 
-		if !codec.IsMP4() {
+		if codec.IsRTP() {
 			wrapper := aac.RTPDepay(track)
 			push = wrapper(push)
 		}
@@ -139,7 +155,9 @@ func (c *Consumer) Init() ([]byte, error) {
 }
 
 func (c *Consumer) Start() {
-	c.start = true
+	if c.wait == waitInit {
+		c.wait = waitKeyframe
+	}
 }
 
 //

pkg/mp4/muxer.go

@@ -19,8 +19,6 @@ type Muxer struct {
 	fragIndex uint32
 	dts       []uint64
 	pts       []uint32
-	//data      []byte
-	//total     int
 }
 
 func (m *Muxer) MimeType(codecs []*streamer.Codec) string {
@@ -185,10 +183,13 @@ func (m *Muxer) GetInit(codecs []*streamer.Codec) ([]byte, error) {
 	return append(FTYP(), data...), nil
 }
 
-//func (m *Muxer) Rewind() {
-//	m.dts = 0
-//	m.pts = 0
-//}
+func (m *Muxer) Reset() {
+	m.fragIndex = 0
+	for i := range m.dts {
+		m.dts[i] = 0
+		m.pts[i] = 0
+	}
+}
 
 func (m *Muxer) Marshal(trackID byte, packet *rtp.Packet) []byte {
 	run := &mp4fio.TrackFragRun{
@@ -218,15 +219,16 @@ func (m *Muxer) Marshal(trackID byte, packet *rtp.Packet) []byte {
 	}
 
 	entry := mp4io.TrackFragRunEntry{
-		//Duration: 90000,
 		Size: uint32(len(packet.Payload)),
 	}
 
 	newTime := packet.Timestamp
 	if m.pts[trackID] > 0 {
-		//m.dts += uint64(newTime - m.pts)
 		entry.Duration = newTime - m.pts[trackID]
 		m.dts[trackID] += uint64(entry.Duration)
+	} else {
+		// important, or Safari will fail with first frame
+		entry.Duration = 1
 	}
 	m.pts[trackID] = newTime
 

pkg/mp4/segment.go

@@ -7,13 +7,20 @@ import (
 	"github.com/pion/rtp"
 )
 
-type Keyframe struct {
+type Segment struct {
 	streamer.Element
 
-	MimeType string
+	Medias       []*streamer.Media
+	MimeType     string
+	OnlyKeyframe bool
 }
 
-func (c *Keyframe) GetMedias() []*streamer.Media {
+func (c *Segment) GetMedias() []*streamer.Media {
+	if c.Medias != nil {
+		return c.Medias
+	}
+
+	// default medias
 	return []*streamer.Media{
 		{
 			Kind:      streamer.KindVideo,
@@ -26,7 +33,7 @@ func (c *Keyframe) GetMedias() []*streamer.Media {
 	}
 }
 
-func (c *Keyframe) AddTrack(media *streamer.Media, track *streamer.Track) *streamer.Track {
+func (c *Segment) AddTrack(media *streamer.Media, track *streamer.Track) *streamer.Track {
 	muxer := &Muxer{}
 
 	codecs := []*streamer.Codec{track.Codec}
@@ -40,22 +47,53 @@ func (c *Keyframe) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 
 	switch track.Codec.Name {
 	case streamer.CodecH264:
-		push := func(packet *rtp.Packet) error {
-			if !h264.IsKeyframe(packet.Payload) {
+		var push streamer.WriterFunc
+
+		if c.OnlyKeyframe {
+			push = func(packet *rtp.Packet) error {
+				if !h264.IsKeyframe(packet.Payload) {
+					return nil
+				}
+
+				buf := muxer.Marshal(0, packet)
+				c.Fire(append(init, buf...))
+
 				return nil
 			}
+		} else {
+			var buf []byte
 
-			buf := muxer.Marshal(0, packet)
-			c.Fire(append(init, buf...))
+			push = func(packet *rtp.Packet) error {
+				if h264.IsKeyframe(packet.Payload) {
+					// fist frame - send only IFrame
+					// other frames - send IFrame and all PFrames
+					if buf == nil {
+						buf = append(buf, init...)
+						b := muxer.Marshal(0, packet)
+						buf = append(buf, b...)
+					}
 
-			return nil
+					c.Fire(buf)
+
+					buf = buf[:0]
+					buf = append(buf, init...)
+					muxer.Reset()
+				}
+
+				if buf != nil {
+					b := muxer.Marshal(0, packet)
+					buf = append(buf, b...)
+				}
+
+				return nil
+			}
 		}
 
 		var wrapper streamer.WrapperFunc
-		if track.Codec.IsMP4() {
-			wrapper = h264.RepairAVC(track)
-		} else {
+		if track.Codec.IsRTP() {
 			wrapper = h264.RTPDepay(track)
+		} else {
+			wrapper = h264.RepairAVC(track)
 		}
 		push = wrapper(push)
 
@@ -73,7 +111,7 @@ func (c *Keyframe) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 			return nil
 		}
 
-		if !track.Codec.IsMP4() {
+		if track.Codec.IsRTP() {
 			wrapper := h265.RTPDepay(track)
 			push = wrapper(push)
 		}

pkg/mp4f/consumer.go

@@ -89,7 +89,7 @@ func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 			return nil
 		}
 
-		if !codec.IsMP4() {
+		if !codec.IsRAW() {
 			wrapper := h264.RTPDepay(track)
 			push = wrapper(push)
 		}
@@ -146,7 +146,7 @@ func (c *Consumer) Init() ([]byte, error) {
 	return data, nil
 }
 
-func (c *Consumer) Start()  {
+func (c *Consumer) Start() {
 	c.start = true
 }
 

pkg/rtmp/client.go

@@ -11,7 +11,7 @@ import (
 	"github.com/deepch/vdk/codec/h264parser"
 	"github.com/deepch/vdk/format/rtmp"
 	"github.com/pion/rtp"
-	"strings"
+	"net/http"
 	"time"
 )
 
@@ -41,16 +41,20 @@ func NewClient(uri string) *Client {
 }
 
 func (c *Client) Dial() (err error) {
-	if strings.HasPrefix(c.URI, "http") {
-		c.conn, err = httpflv.Dial(c.URI)
-	} else {
-		c.conn, err = rtmp.Dial(c.URI)
-	}
+	c.conn, err = rtmp.Dial(c.URI)
+	return
+}
 
+// Accept - convert http.Response to Client
+func Accept(res *http.Response) (*Client, error) {
+	conn, err := httpflv.Accept(res)
 	if err != nil {
-		return
+		return nil, err
 	}
+	return &Client{URI: res.Request.URL.String(), conn: conn}, nil
+}
 
+func (c *Client) Describe() (err error) {
 	// important to get SPS/PPS
 	streams, err := c.conn.Streams()
 	if err != nil {
@@ -73,7 +77,7 @@ func (c *Client) Dial() (err error) {
 				Name:        streamer.CodecH264,
 				ClockRate:   90000,
 				FmtpLine:    fmtp,
-				PayloadType: streamer.PayloadTypeMP4,
+				PayloadType: streamer.PayloadTypeRAW,
 			}
 
 			media := &streamer.Media{
@@ -96,7 +100,7 @@ func (c *Client) Dial() (err error) {
 				Channels:  uint16(cd.Config.ChannelConfig),
 				//  a=fmtp:97 streamtype=5;profile-level-id=1;mode=AAC-hbr;sizelength=13;indexlength=3;indexdeltalength=3;config=1588
 				FmtpLine:    "streamtype=5;profile-level-id=1;mode=AAC-hbr;sizelength=13;indexlength=3;indexdeltalength=3;config=" + hex.EncodeToString(cd.ConfigBytes),
-				PayloadType: streamer.PayloadTypeMP4,
+				PayloadType: streamer.PayloadTypeRAW,
 			}
 
 			media := &streamer.Media{

pkg/rtsp/conn.go

@@ -9,6 +9,7 @@ import (
 	"fmt"
 	"github.com/AlexxIT/go2rtc/pkg/aac"
 	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/mjpeg"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/AlexxIT/go2rtc/pkg/tcp"
 	"github.com/pion/rtcp"
@@ -99,6 +100,11 @@ func NewServer(conn net.Conn) *Conn {
 	return c
 }
 
+func (c *Conn) Auth(username, password string) {
+	info := url.UserPassword(username, password)
+	c.auth = tcp.NewAuth(info)
+}
+
 func (c *Conn) parseURI() (err error) {
 	c.URL, err = url.Parse(c.uri)
 	if err != nil {
@@ -398,6 +404,12 @@ func (c *Conn) SetupMedia(
 		}
 	}
 
+	// in case the track has already been setup before
+	if codec == nil {
+		c.state = StateSetup
+		return nil, nil
+	}
+
 	// we send our `interleaved`, but camera can answer with another
 
 	// Transport: RTP/AVP/TCP;unicast;interleaved=10-11;ssrc=10117CB7
@@ -490,6 +502,17 @@ func (c *Conn) Accept() error {
 
 		c.Fire(req)
 
+		if !c.auth.Validate(req) {
+			res := &tcp.Response{
+				Status: "401 Unauthorized",
+				Header: map[string][]string{"Www-Authenticate": {`Basic realm="go2rtc"`}},
+			}
+			if err = c.Response(res); err != nil {
+				return err
+			}
+			continue
+		}
+
 		// Receiver: OPTIONS > DESCRIBE > SETUP... > PLAY > TEARDOWN
 		// Sender: OPTIONS > ANNOUNCE > SETUP... > RECORD > TEARDOWN
 		switch req.Method {
@@ -760,6 +783,8 @@ func (c *Conn) bindTrack(
 
 		size := packet.MarshalSize()
 
+		//log.Printf("[RTP] codec: %s, size: %6d, ts: %10d, pt: %2d, ssrc: %d, seq: %d, mark: %v", track.Codec.Name, len(packet.Payload), packet.Timestamp, packet.PayloadType, packet.SSRC, packet.SequenceNumber, packet.Marker)
+
 		data := make([]byte, 4+size)
 		data[0] = '$'
 		data[1] = channel
@@ -778,7 +803,7 @@ func (c *Conn) bindTrack(
 		return nil
 	}
 
-	if track.Codec.IsMP4() {
+	if !track.Codec.IsRTP() {
 		switch track.Codec.Name {
 		case streamer.CodecH264:
 			wrapper := h264.RTPPay(1500)
@@ -786,6 +811,9 @@ func (c *Conn) bindTrack(
 		case streamer.CodecAAC:
 			wrapper := aac.RTPPay(1500)
 			push = wrapper(push)
+		case streamer.CodecJPEG:
+			wrapper := mjpeg.RTPPay()
+			push = wrapper(push)
 		}
 	}
 

pkg/rtsp/streamer.go

@@ -20,9 +20,10 @@ func (c *Conn) GetTrack(media *streamer.Media, codec *streamer.Codec) *streamer.
 		}
 	}
 
-	// can't setup new tracks from play state
+	// can't setup new tracks from play state - forcing a reconnection feature
 	if c.state == StatePlay {
-		return nil
+		go c.Close()
+		return streamer.NewTrack(codec, media.Direction)
 	}
 
 	track, err := c.SetupMedia(media, codec)

pkg/streamer/helpers.go

@@ -12,14 +12,6 @@ const (
 	JSONSend       = "send"
 )
 
-// Message - struct for data exchange in Web API
-type Message struct {
-	Type  string      `json:"type"`
-	Value interface{} `json:"value,omitempty"`
-}
-
-// other
-
 func Between(s, sub1, sub2 string) string {
 	i := strings.Index(s, sub1)
 	if i < 0 {

pkg/streamer/media.go

@@ -37,7 +37,7 @@ const (
 	CodecELD = "ELD" // AAC-ELD
 )
 
-const PayloadTypeMP4 byte = 255
+const PayloadTypeRAW byte = 255
 
 func GetKind(name string) string {
 	switch name {
@@ -139,8 +139,8 @@ func (c *Codec) String() string {
 	return s
 }
 
-func (c *Codec) IsMP4() bool {
-	return c.PayloadType == PayloadTypeMP4
+func (c *Codec) IsRTP() bool {
+	return c.PayloadType != PayloadTypeRAW
 }
 
 func (c *Codec) Clone() *Codec {

pkg/tcp/auth.go

@@ -80,6 +80,24 @@ func (a *Auth) Write(req *Request) {
 	}
 }
 
+func (a *Auth) Validate(req *Request) bool {
+	if a == nil {
+		return true
+	}
+
+	header := req.Header.Get("Authorization")
+	if header == "" {
+		return false
+	}
+
+	if a.Method == AuthUnknown {
+		a.Method = AuthBasic
+		a.header = "Basic " + B64(a.user, a.pass)
+	}
+
+	return header == a.header
+}
+
 func Between(s, sub1, sub2 string) string {
 	i := strings.Index(s, sub1)
 	if i < 0 {

pkg/tcp/request.go

@@ -0,0 +1,68 @@
+package tcp
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// Do - http.Client with support Digest Authorization
+func Do(req *http.Request) (*http.Response, error) {
+	// need to create new client each time to reset timeout
+	client := http.Client{Timeout: time.Second * 5000}
+	res, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	if res.StatusCode == http.StatusUnauthorized && req.URL.User != nil {
+		auth := res.Header.Get("WWW-Authenticate")
+		if !strings.HasPrefix(auth, "Digest") {
+			return nil, errors.New("unsupported auth: " + auth)
+		}
+
+		realm := Between(auth, `realm="`, `"`)
+		nonce := Between(auth, `nonce="`, `"`)
+		qop := Between(auth, `qop="`, `"`)
+
+		user := req.URL.User
+		username := user.Username()
+		password, _ := user.Password()
+		ha1 := HexMD5(username, realm, password)
+
+		uri := req.URL.RequestURI()
+		ha2 := HexMD5(req.Method, uri)
+
+		var header string
+
+		switch qop {
+		case "":
+			response := HexMD5(ha1, nonce, ha2)
+			header = fmt.Sprintf(
+				`Digest username="%s", realm="%s", nonce="%s", uri="%s", response="%s"`,
+				user, realm, nonce, uri, response,
+			)
+		case "auth":
+			nc := "00000001"
+			cnonce := "00000001" // TODO: random...
+			response := HexMD5(ha1, nonce, nc, cnonce, qop, ha2)
+			header = fmt.Sprintf(
+				`Digest username="%s", realm="%s", nonce="%s", uri="%s", qop=%s, nc=%s, cnonce="%s", response="%s"`,
+				username, realm, nonce, uri, qop, nc, cnonce, response,
+			)
+		default:
+			return nil, errors.New("unsupported qop: " + auth)
+		}
+
+		req.Header.Set("Authorization", header)
+
+		res, err = client.Do(req)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return res, nil
+}

pkg/webrtc/conn.go

@@ -5,13 +5,6 @@ import (
 	"github.com/pion/webrtc/v3"
 )
 
-const (
-	MsgTypeOffer         = "webrtc/offer"
-	MsgTypeOfferComplete = "webrtc/offer-complete"
-	MsgTypeAnswer        = "webrtc/answer"
-	MsgTypeCandidate     = "webrtc/candidate"
-)
-
 type Conn struct {
 	streamer.Element
 
@@ -28,11 +21,7 @@ type Conn struct {
 
 func (c *Conn) Init() {
 	c.Conn.OnICECandidate(func(candidate *webrtc.ICECandidate) {
-		if candidate != nil {
-			c.Fire(&streamer.Message{
-				Type: MsgTypeCandidate, Value: candidate.ToJSON().Candidate,
-			})
-		}
+		c.Fire(candidate)
 	})
 
 	c.Conn.OnTrack(func(remote *webrtc.TrackRemote, receiver *webrtc.RTPReceiver) {
@@ -60,6 +49,10 @@ func (c *Conn) Init() {
 		//fmt.Printf("TODO: webrtc ontrack %+v\n", remote)
 	})
 
+	c.Conn.OnDataChannel(func(channel *webrtc.DataChannel) {
+		c.Fire(channel)
+	})
+
 	// OK connection:
 	// 15:01:46 ICE connection state changed: checking
 	// 15:01:46 peer connection state changed: connected

pkg/webrtc/consumer.go

@@ -57,10 +57,10 @@ func (c *Conn) AddTrack(media *streamer.Media, track *streamer.Track) *streamer.
 			wrapper := h264.RTPPay(1200)
 			push = wrapper(push)
 
-			if codec.IsMP4() {
-				wrapper = h264.RepairAVC(track)
-			} else {
+			if codec.IsRTP() {
 				wrapper = h264.RTPDepay(track)
+			} else {
+				wrapper = h264.RepairAVC(track)
 			}
 			push = wrapper(push)
 
@@ -108,14 +108,8 @@ func (c *Conn) AddTrack(media *streamer.Media, track *streamer.Track) *streamer.
 
 //
 
-func (c *Conn) Push(msg interface{}) {
-	if msg := msg.(*streamer.Message); msg != nil {
-		if msg.Type == MsgTypeCandidate {
-			_ = c.Conn.AddICECandidate(webrtc.ICECandidateInit{
-				Candidate: msg.Value.(string),
-			})
-		}
-	}
+func (c *Conn) AddCandidate(candidate string) {
+	_ = c.Conn.AddICECandidate(webrtc.ICECandidateInit{Candidate: candidate})
 }
 
 func (c *Conn) MarshalJSON() ([]byte, error) {

scripts/README.md

@@ -2,6 +2,7 @@
 
 - UPX-3.96 pack broken bin for `linux_mipsel`
 - UPX-3.95 pack broken bin for `mac_amd64`
+- UPX pack broken bin for `mac_arm64`
 - UPX windows pack is recognised by anti-viruses as malicious
 - `aarch64` = `arm64`
 - `armv7` = `arm`

scripts/build.cmd

@@ -10,38 +10,43 @@ go build -ldflags "-s -w" -trimpath && 7z a -sdel %FILENAME% go2rtc.exe
 @SET FILENAME=go2rtc_win32.zip
 go build -ldflags "-s -w" -trimpath && 7z a -sdel %FILENAME% go2rtc.exe
 
+@SET GOOS=windows
+@SET GOARCH=arm64
+@SET FILENAME=go2rtc_win_arm64.zip
+go build -ldflags "-s -w" -trimpath && 7z a -sdel %FILENAME% go2rtc.exe
+
 @SET GOOS=linux
 @SET GOARCH=amd64
 @SET FILENAME=go2rtc_linux_amd64
-go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx-3.96 %FILENAME%
+go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx %FILENAME%
 
 @SET GOOS=linux
 @SET GOARCH=386
 @SET FILENAME=go2rtc_linux_i386
-go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx-3.96 %FILENAME%
+go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx %FILENAME%
 
 @SET GOOS=linux
 @SET GOARCH=arm64
 @SET FILENAME=go2rtc_linux_arm64
-go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx-3.96 %FILENAME%
+go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx %FILENAME%
 
 @SET GOOS=linux
 @SET GOARCH=arm
 @SET GOARM=7
 @SET FILENAME=go2rtc_linux_arm
-go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx-3.96 %FILENAME%
+go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx %FILENAME%
 
 @SET GOOS=linux
 @SET GOARCH=mipsle
 @SET FILENAME=go2rtc_linux_mipsel
-go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx-3.95 %FILENAME%
+go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx %FILENAME%
 
 @SET GOOS=darwin
 @SET GOARCH=amd64
-@SET FILENAME=go2rtc_mac_amd64
-go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx-3.96 %FILENAME%
+@SET FILENAME=go2rtc_mac_amd64.zip
+go build -ldflags "-s -w" -trimpath && 7z a -sdel %FILENAME% go2rtc
 
 @SET GOOS=darwin
 @SET GOARCH=arm64
-@SET FILENAME=go2rtc_mac_arm64
-go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx-3.96 %FILENAME%
+@SET FILENAME=go2rtc_mac_arm64.zip
+go build -ldflags "-s -w" -trimpath && 7z a -sdel %FILENAME% go2rtc

scripts/build_linux_amd64.cmd

@@ -1,5 +0,0 @@
-@SET GOOS=linux
-@SET GOARCH=amd64
-@cd ..
-del go2rtc
-go build -ldflags "-s -w" -trimpath

scripts/build_linux_arm.cmd

@@ -1,5 +0,0 @@
-@SET GOOS=linux
-@SET GOARCH=arm
-@cd ..
-del go2rtc
-go build -ldflags "-s -w" -trimpath

scripts/build_linux_mips.cmd

@@ -1,5 +0,0 @@
-@ECHO OFF
-@SET GOOS=linux
-@SET GOARCH=mipsle
-cd ..
-go build -ldflags "-s -w" -trimpath && upx-3.95 go2rtc

scripts/build_mac_amd64.cmd

@@ -1,5 +0,0 @@
-@SET GOOS=darwin
-@SET GOARCH=amd64
-@cd ..
-del go2rtc
-go build -ldflags "-s -w" -trimpath

scripts/build_win64.cmd

@@ -1,4 +0,0 @@
-@SET GOOS=windows
-@SET GOARCH=amd64
-cd ..
-go build -ldflags "-w -s" -trimpath

www/index.html

@@ -8,6 +8,10 @@
     <title>go2rtc</title>
 
     <style>
+        body {
+            font-family: Arial, Helvetica, sans-serif;
+        }
+
         table {
             background-color: white;
             text-align: left;
@@ -36,9 +40,23 @@
             text-align: center;
         }
 
+        label {
+            display: flex;
+            align-items: center;
+        }
+
         .header {
             padding: 5px 5px;
         }
+
+        .controls {
+            display: flex;
+            padding: 5px;
+        }
+
+        .controls > label {
+            margin-left: 10px;
+        }
     </style>
 </head>
 <body>
@@ -47,6 +65,13 @@
     <input id="src" type="text" placeholder="url">
     <a id="add" href="#">add</a>
 </div>
+<div class="controls">
+    <button>stream</button>
+    <label><input type="checkbox" name="webrtc" checked>webrtc</label>
+    <label><input type="checkbox" name="mse" checked>mse</label>
+    <label><input type="checkbox" name="mp4" checked>mp4</label>
+    <label><input type="checkbox" name="mjpeg" checked>mjpeg</label>
+</div>
 <table id="streams">
     <thead>
     <tr>
@@ -59,50 +84,71 @@
     </tbody>
 </table>
 <script>
-    const baseUrl = location.origin + location.pathname.substr(
-        0, location.pathname.lastIndexOf("/")
-    );
-
-    const links = [
-        '<a href="webrtc.html?src={name}">webrtc</a>',
-        '<a href="mse.html?src={name}">mse</a>',
-        // '<a href="video.html?src={name}">video</a>',
+    const templates = [
+        '<a href="stream.html?src={name}">stream</a>',
+        '<a href="webrtc.html?src={name}">2-way-aud</a>',
         '<a href="api/stream.mp4?src={name}">mp4</a>',
-        '<a href="api/frame.mp4?src={name}">frame</a>',
-        `<a href="rtsp://${location.hostname}:8554/{name}">rtsp</a>`,
         '<a href="api/stream.mjpeg?src={name}">mjpeg</a>',
+        `<a href="rtsp://${location.hostname}:8554/{name}">rtsp</a>`,
         '<a href="api/streams?src={name}">info</a>',
+        '<a href="#" data-name="{name}">delete</a>',
     ];
 
-    function reload() {
-        fetch(`${baseUrl}/api/streams`).then(r => {
-            r.json().then(data => {
-                let html = '';
+    document.querySelector("#add")
+        .addEventListener("click", () => {
+            const src = document.querySelector("#src");
+            const url = new URL("api/streams", location.href);
+            url.searchParams.set("src", src.value);
+            fetch(url, {method: "PUT"}).then(reload);
+        });
 
-                for (const [name, value] of Object.entries(data)) {
-                    const online = value !== null ? value.length : 0
-                    html += `<tr><td>${name || 'default'}</td><td>${online}</td><td>`;
-                    links.forEach(link => {
-                        html += link.replace('{name}', encodeURIComponent(name)) + ' ';
-                    })
-                    html += `<a href="#" onclick="deleteStream('${name}')">delete</a>`;
-                    html += `</td></tr>`;
-                }
+    document.querySelector(".controls > button")
+        .addEventListener("click", () => {
+            const url = new URL("stream.html", location.href);
 
-                let content = document.getElementById('streams').getElementsByTagName('tbody')[0];
-                content.innerHTML = html
+            const streams = document.querySelectorAll("#streams input");
+            streams.forEach(i => {
+                if (i.checked) url.searchParams.append("src", i.name);
             });
-        })
-    }
 
-    function deleteStream(src) {
-        fetch(`${baseUrl}/api/streams?src=${encodeURIComponent(src)}`, {method: 'DELETE'}).then(reload);
-    }
+            if (!url.searchParams.has("src")) return;
 
-    const addButton = document.querySelector('a#add');
-    addButton.onclick = () => {
-        let src = document.querySelector('input#src');
-        fetch(`${baseUrl}/api/streams?src=${encodeURIComponent(src.value)}`, {method: 'PUT'}).then(reload);
+            let mode = document.querySelectorAll(".controls input");
+            mode = Array.from(mode).filter(i => i.checked).map(i => i.name).join(",");
+
+            window.location.href = `${url}&mode=${mode}`;
+        });
+
+    const tbody = document.querySelector("#streams > tbody");
+    tbody.addEventListener("click", ev => {
+        if (ev.target.innerText !== "delete") return;
+
+        ev.preventDefault();
+
+        const url = new URL("api/streams", location.href);
+        url.searchParams.set("src", ev.target.dataset.name);
+        fetch(url, {method: "DELETE"}).then(reload);
+    });
+
+    function reload() {
+        const url = new URL("api/streams", location.href);
+        fetch(url).then(r => r.json()).then(data => {
+            tbody.innerHTML = "";
+
+            for (const [name, value] of Object.entries(data)) {
+                const online = value ? value.length : 0;
+                const links = templates.map(link => {
+                    return link.replace("{name}", encodeURIComponent(name));
+                }).join(" ");
+
+                const tr = document.createElement("tr");
+                tr.dataset["id"] = name;
+                tr.innerHTML =
+                    `<td><label><input type="checkbox" name="${name}">${name}</label></td>` +
+                    `<td>${online}</td><td>${links}</td>`;
+                tbody.appendChild(tr);
+            }
+        });
     }
 
     reload();

www/mse.html

@@ -1,28 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <title>go2rtc - MSE</title>
-    <script src="video-rtc.js"></script>
-    <style>
-        body {
-            background: black;
-            margin: 0;
-            padding: 0;
-        }
-
-        html, body, video {
-            height: 100%;
-            width: 100%;
-        }
-    </style>
-</head>
-<body>
-<script>
-    const url = new URL("api/ws" + location.search, location.href);
-    const video = document.createElement("video-rtc");
-    video.src = url.toString();
-    document.body.appendChild(video);
-</script>
-</body>
-</html>

www/stream.html

@@ -0,0 +1,61 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>go2rtc - Stream</title>
+    <script src="video-rtc.js"></script>
+    <style>
+        body {
+            background: black;
+            margin: 0;
+            padding: 0;
+            display: flex;
+        }
+
+        html, body {
+            height: 100%;
+            width: 100%;
+        }
+
+        .flex {
+            flex-wrap: wrap;
+            align-content: flex-start;
+            align-items: flex-start;
+        }
+    </style>
+</head>
+<body>
+<script>
+    const params = new URLSearchParams(location.search);
+
+    // support multiple streams and multiple modes
+    const streams = params.getAll("src");
+    const modes = params.getAll("mode");
+    if (modes.length === 0) modes.push("");
+
+    while (modes.length > streams.length) {
+        streams.push(streams[0]);
+    }
+    while (streams.length > modes.length) {
+        modes.push(modes[0]);
+    }
+
+    if (streams.length > 1) {
+        document.body.className = "flex";
+    }
+
+    const background = params.get("background") === "true";
+    const width = "1 0 " + (params.get("width") || "320px");
+
+    for (let i = 0; i < streams.length; i++) {
+        /** @type {VideoRTC} */
+        const video = document.createElement("video-rtc");
+        video.background = background;
+        video.mode = modes[i] || video.mode;
+        video.style.flex = width;
+        video.src = new URL("api/ws?src=" + streams[i], location.href);
+        document.body.appendChild(video);
+    }
+</script>
+</body>
+</html>

www/video-rtc.js

@@ -1,62 +1,3 @@
-/**
- * Common function for processing MSE and MSE2 data.
- * @param ms MediaSource
- */
-function MediaSourceHandler(ms) {
-    let sb, qb = [];
-
-    return ev => {
-        if (typeof ev.data === "string") {
-            const msg = JSON.parse(ev.data);
-            if (msg.type === "mse") {
-                if (!MediaSource.isTypeSupported(msg.value)) {
-                    console.warn("Not supported: " + msg.value)
-                    return;
-                }
-
-                sb = ms.addSourceBuffer(msg.value);
-                sb.mode = "segments"; // segments or sequence
-                sb.addEventListener("updateend", () => {
-                    if (!sb.updating && qb.length > 0) {
-                        try {
-                            sb.appendBuffer(qb.shift());
-                        } catch (e) {
-                            // console.warn(e);
-                        }
-                    }
-                });
-            }
-        } else if (sb.updating || qb.length > 0) {
-            qb.push(ev.data);
-            // console.debug("buffer:", qb.length);
-        } else {
-            try {
-                sb.appendBuffer(ev.data);
-            } catch (e) {
-                // console.warn(e);
-            }
-        }
-    }
-}
-
-/**
- * Dedicated Worker Handler for MSE2 https://chromestatus.com/feature/5177263249162240
- */
-if (typeof importScripts == "function") {
-    // protect below code (class VideoRTC) from fail inside Worker
-    HTMLElement = Object;
-    customElements = {define: Function()};
-
-    const ms = new MediaSource();
-    ms.addEventListener("sourceopen", ev => {
-        postMessage({type: ev.type});
-    }, {once: true});
-
-    onmessage = MediaSourceHandler(ms);
-
-    postMessage({type: "handle", value: ms.handle}, [ms.handle]);
-}
-
 /**
  * Video player for MSE and WebRTC connections.
  *
@@ -65,116 +6,131 @@ if (typeof importScripts == "function") {
  * Support:
  * - RTCPeerConnection for Safari iOS 11.0+
  * - IntersectionObserver for Safari iOS 12.2+
- * - MediaSource in Workers for Chrome 108+
  *
  * Doesn't support:
  * - MediaSource for Safari iOS all
  * - Customized built-in elements (extends HTMLVideoElement) because all Safari
+ * - Public class fields because old Safari (before 14.0)
  */
 class VideoRTC extends HTMLElement {
-    DISCONNECT_TIMEOUT = 5000;
-    RECONNECT_TIMEOUT = 30000;
-
-    CODECS = [
-        "avc1.640029",      // H.264 high 4.1 (Chromecast 1st and 2nd Gen)
-        "avc1.64002A",      // H.264 high 4.2 (Chromecast 3rd Gen)
-        "hvc1.1.6.L153.B0", // H.265 main 5.1 (Chromecast Ultra)
-        "mp4a.40.2",        // AAC LC
-        "mp4a.40.5",        // AAC HE
-        "mp4a.69",          // MP3
-        "mp4a.6B",          // MP3
-    ];
-
-    /**
-     * Enable MediaSource in Workers mode.
-     * @type {boolean}
-     */
-    MSE2 = true;
-
-    /**
-     * Run stream when not displayed on the screen. Default `false`.
-     * @type {boolean}
-     */
-    background = false;
-
-    /**
-     * Run stream only when player in the viewport. Stop when user scroll out player.
-     * Value is percentage of visibility from `0` (not visible) to `1` (full visible).
-     * Default `0` - disable;
-     * @type {number}
-     */
-    intersectionThreshold = 0;
-
-    /**
-     * Run stream only when browser page on the screen. Stop when user change browser
-     * tab or minimise browser windows.
-     * @type {boolean}
-     */
-    visibilityCheck = true;
-
-    /**
-     * @type {HTMLVideoElement}
-     */
-    video = null;
-
-    /**
-     * @type {RTCPeerConnection}
-     */
-    pc = null;
-
-    /**
-     * @type {WebSocket}
-     */
-    ws = null;
-
-    /**
-     * Internal WebSocket connection state. Values: CLOSED, CONNECTING, OPEN
-     * @type {number}
-     */
-    wsState = WebSocket.CLOSED;
-
-    /**
-     * Internal WebSocket URL.
-     * @type {string}
-     */
-    wsURL = "";
-
-    /**
-     * Internal disconnect TimeoutID.
-     * @type {number}
-     */
-    disconnectTimeout = 0;
-
-    /**
-     * Internal reconnect TimeoutID.
-     * @type {number}
-     */
-    reconnectTimeout = 0;
-
     constructor() {
         super();
 
-        console.debug("this.constructor");
+        this.DISCONNECT_TIMEOUT = 5000;
+        this.RECONNECT_TIMEOUT = 30000;
 
-        this.video = document.createElement("video");
-        this.video.controls = true;
-        this.video.playsInline = true;
+        this.CODECS = [
+            "avc1.640029",      // H.264 high 4.1 (Chromecast 1st and 2nd Gen)
+            "avc1.64002A",      // H.264 high 4.2 (Chromecast 3rd Gen)
+            "avc1.640033",      // H.264 high 5.1 (Chromecast with Google TV)
+            "hvc1.1.6.L153.B0", // H.265 main 5.1 (Chromecast Ultra)
+            "mp4a.40.2",        // AAC LC
+            "mp4a.40.5",        // AAC HE
+            "mp4a.69",          // MP3
+            "mp4a.6B",          // MP3
+        ];
+
+        /**
+         * Supported modes (webrtc, mse, mp4, mjpeg).
+         * @type {string}
+         */
+        this.mode = "webrtc,mse,mp4,mjpeg";
+
+        /**
+         * Run stream when not displayed on the screen. Default `false`.
+         * @type {boolean}
+         */
+        this.background = false;
+
+        /**
+         * Run stream only when player in the viewport. Stop when user scroll out player.
+         * Value is percentage of visibility from `0` (not visible) to `1` (full visible).
+         * Default `0` - disable;
+         * @type {number}
+         */
+        this.intersectionThreshold = 0;
+
+        /**
+         * Run stream only when browser page on the screen. Stop when user change browser
+         * tab or minimise browser windows.
+         * @type {boolean}
+         */
+        this.visibilityCheck = true;
+
+        /**
+         * @type {HTMLVideoElement}
+         */
+        this.video = null;
+
+        /**
+         * @type {WebSocket}
+         */
+        this.ws = null;
+
+        /**
+         * Internal WebSocket connection state. Values: CONNECTING, OPEN, CLOSED
+         * @type {number}
+         */
+        this.wsState = WebSocket.CLOSED;
+
+        /**
+         * Internal WebSocket URL.
+         * @type {string|URL}
+         */
+        this.url = "";
+
+        /**
+         * @type {RTCPeerConnection}
+         */
+        this.pc = null;
+
+        /**
+         * @type {number}
+         */
+        this.pcState = WebSocket.CLOSED;
+
+        this.pcConfig = {iceServers: [{urls: "stun:stun.l.google.com:19302"}]};
+
+        /**
+         * Internal disconnect TimeoutID.
+         * @type {number}
+         */
+        this.disconnectTimeout = 0;
+
+        /**
+         * Internal reconnect TimeoutID.
+         * @type {number}
+         */
+        this.reconnectTimeout = 0;
+
+        /**
+         * Handler for receiving Binary from WebSocket
+         * @type {Function}
+         */
+        this.ondata = null;
+
+        /**
+         * Handlers list for receiving JSON from WebSocket
+         * @type {Object.<string,Function>}}
+         */
+        this.onmessage = null;
     }
 
     /** public properties **/
 
     /**
      * Set video source (WebSocket URL). Support relative path.
-     * @param value
+     * @param {string|URL} value
      */
     set src(value) {
-        if (value.startsWith("/")) {
-            value = "ws" + location.origin.substr(4) + value;
-        } else if (value.startsWith("http")) {
-            value = "ws" + value.substr(4);
+        if (typeof value !== "string") value = value.toString();
+        if (value.startsWith("http")) {
+            value = "ws" + value.substring(4);
+        } else if (value.startsWith("/")) {
+            value = "ws" + location.origin.substring(4) + value;
         }
 
-        this.wsURL = value;
+        this.url = value;
 
         if (this.isConnected) this.connectedCallback();
     }
@@ -187,15 +143,28 @@ class VideoRTC extends HTMLElement {
         this.video.play().catch(er => {
             if (er.name === "NotAllowedError" && !this.video.muted) {
                 this.video.muted = true;
-                this.video.play();
+                this.video.play().catch(() => console.debug);
             }
         });
     }
 
-    get codecs() {
-        return this.CODECS.filter(value => {
-            return MediaSource.isTypeSupported(`video/mp4; codecs="${value}"`);
-        }).join();
+    /**
+     * Send message to server via WebSocket
+     * @param {Object} value
+     */
+    send(value) {
+        if (this.ws) this.ws.send(JSON.stringify(value));
+    }
+
+    get closed() {
+        return this.wsState === WebSocket.CLOSED && this.pcState === WebSocket.CLOSED;
+    }
+
+    codecs(type) {
+        const test = type === "mse"
+            ? codec => MediaSource.isTypeSupported(`video/mp4; codecs="${codec}"`)
+            : codec => this.video.canPlayType(`video/mp4; codecs="${codec}"`);
+        return this.CODECS.filter(test).join();
     }
 
     /**
@@ -203,26 +172,29 @@ class VideoRTC extends HTMLElement {
      * document-connected element.
      */
     connectedCallback() {
-        console.debug("this.connectedCallback", this.wsState);
+        console.debug("VideoRTC.connectedCallback", this.wsState, this.pcState);
+
         if (this.disconnectTimeout) {
             clearTimeout(this.disconnectTimeout);
             this.disconnectTimeout = 0;
         }
 
         // because video autopause on disconnected from DOM
-        const seek = this.video.seekable;
-        if (seek.length > 0) {
-            this.video.currentTime = seek.end(seek.length - 1);
-            this.play();
+        if (this.video) {
+            const seek = this.video.seekable;
+            if (seek.length > 0) {
+                this.video.currentTime = seek.end(seek.length - 1);
+                this.play();
+            }
         }
 
-        if (!this.wsURL || this.wsState !== WebSocket.CLOSED) return;
+        if (!this.url || !this.closed) return;
 
         // CLOSED => CONNECTING
         this.wsState = WebSocket.CONNECTING;
 
         this.internalInit();
-        this.internalConnect();
+        this.internalWS();
     }
 
     /**
@@ -230,9 +202,9 @@ class VideoRTC extends HTMLElement {
      * document's DOM.
      */
     disconnectedCallback() {
-        console.debug("this.disconnectedCallback", this.wsState);
-        if (this.background || this.disconnectTimeout ||
-            this.wsState === WebSocket.CLOSED) return;
+        console.debug("VideoRTC.disconnectedCallback", this.wsState, this.pcState);
+
+        if (this.background || this.disconnectTimeout || this.closed) return;
 
         this.disconnectTimeout = setTimeout(() => {
             if (this.reconnectTimeout) {
@@ -241,21 +213,39 @@ class VideoRTC extends HTMLElement {
             }
 
             this.disconnectTimeout = 0;
-            // CONNECTING, OPEN => CLOSED
-            this.wsState = WebSocket.CLOSED;
 
+            this.wsState = WebSocket.CLOSED;
             if (this.ws) {
                 this.ws.close();
                 this.ws = null;
             }
+
+            this.pcState = WebSocket.CLOSED;
+            if (this.pc) {
+                this.pc.close();
+                this.pc = null;
+            }
         }, this.DISCONNECT_TIMEOUT);
     }
 
     internalInit() {
         if (this.childElementCount) return;
 
+        this.video = document.createElement("video");
+        this.video.controls = true;
+        this.video.playsInline = true;
+        this.video.preload = "auto";
+
         this.appendChild(this.video);
 
+        // important for second video for mode MP4
+        this.style.display = "block";
+        this.style.position = "relative";
+
+        this.video.style.display = "block"; // fix bottom margin 4px
+        this.video.style.width = "100%";
+        this.video.style.height = "100%"
+
         if (this.background) return;
 
         if ("hidden" in document && this.visibilityCheck) {
@@ -282,24 +272,65 @@ class VideoRTC extends HTMLElement {
         }
     }
 
-    internalConnect() {
+    internalWS() {
         if (this.wsState !== WebSocket.CONNECTING) return;
         if (this.ws) throw "connect with non null WebSocket";
 
         const ts = Date.now();
 
-        this.ws = new WebSocket(this.wsURL);
+        this.ws = new WebSocket(this.url);
         this.ws.binaryType = "arraybuffer";
 
         this.ws.addEventListener("open", () => {
-            console.debug("ws.open", this.wsState);
-            if (this.wsState !== WebSocket.CONNECTING) return;
+            console.debug("VideoRTC.ws.open", this.wsState);
 
             // CONNECTING => OPEN
             this.wsState = WebSocket.OPEN;
+
+            this.ws.addEventListener("message", ev => {
+                if (typeof ev.data === "string") {
+                    const msg = JSON.parse(ev.data);
+                    for (const mode in this.onmessage) {
+                        this.onmessage[mode](msg);
+                    }
+                } else {
+                    this.ondata(ev.data);
+                }
+            });
+
+            this.ondata = null;
+            this.onmessage = {};
+
+            let firstMode = "";
+
+            if (this.mode.indexOf("mse") >= 0 && "MediaSource" in window) { // iPhone
+                firstMode ||= "mse";
+                this.internalMSE();
+            } else if (this.mode.indexOf("mp4") >= 0) {
+                firstMode ||= "mp4";
+                this.internalMP4();
+            }
+
+            if (this.mode.indexOf("webrtc") >= 0 && "RTCPeerConnection" in window) { // macOS Desktop app
+                firstMode ||= "webrtc";
+                this.internalRTC();
+            }
+
+            if (this.mode.indexOf("mjpeg") >= 0) {
+                if (firstMode) {
+                    this.onmessage["mjpeg"] = msg => {
+                        if (msg.type !== "error" || msg.value.indexOf(firstMode) !== 0) return;
+                        this.internalMJPEG();
+                    }
+                } else {
+                    this.internalMJPEG();
+                }
+            }
         });
+
         this.ws.addEventListener("close", () => {
-            console.debug("ws.close", this.wsState);
+            console.debug("VideoRTC.ws.close", this.wsState);
+
             if (this.wsState === WebSocket.CLOSED) return;
 
             // CONNECTING, OPEN => CONNECTING
@@ -311,63 +342,242 @@ class VideoRTC extends HTMLElement {
 
             this.reconnectTimeout = setTimeout(() => {
                 this.reconnectTimeout = 0;
-                this.internalConnect();
+                this.internalWS();
             }, delay);
         });
-
-        if ("MediaSource" in window && this.MSE2) {
-            if (MediaSource.canConstructInDedicatedWorker) {
-                this.internalMSE2();
-            } else {
-                this.internalMSE();
-            }
-        }
-
-        // TODO: this.internalRTC();
     }
 
     internalMSE() {
-        console.debug("this.internalMSE");
-        this.ws.addEventListener("open", () => {
-            const ms = new MediaSource();
-            ms.addEventListener("sourceopen", () => {
-                URL.revokeObjectURL(this.video.src);
-                this.ws.send(JSON.stringify({type: "mse", value: this.codecs}));
-            }, {once: true});
+        console.debug("VideoRTC.internalMSE");
 
-            this.video.src = URL.createObjectURL(ms);
-            this.play();
+        const ms = new MediaSource();
+        ms.addEventListener("sourceopen", () => {
+            console.debug("VideoRTC.ms.sourceopen");
+            URL.revokeObjectURL(this.video.src);
+            this.send({type: "mse", value: this.codecs("mse")});
+        }, {once: true});
 
-            this.ws.addEventListener("message", MediaSourceHandler(ms));
-        });
-    }
+        this.video.src = URL.createObjectURL(ms);
+        this.video.srcObject = null;
+        this.play();
 
-    internalMSE2() {
-        console.debug("this.internalMSE2");
-        const worker = new Worker("video-rtc.js");
-        worker.addEventListener("message", ev => {
-            if (ev.data.type === "handle") {
-                this.video.srcObject = ev.data.value;
-                this.play();
-            } else if (ev.data.type === "sourceopen") {
-                this.ws.send(JSON.stringify({type: "mse", value: this.codecs}));
+        this.onmessage["mse"] = msg => {
+            if (msg.type !== "mse") return;
+
+            const sb = ms.addSourceBuffer(msg.value);
+            sb.mode = "segments"; // segments or sequence
+            sb.addEventListener("updateend", () => {
+                if (sb.updating) return;
+                if (bufLen > 0) {
+                    try {
+                        sb.appendBuffer(buf.slice(0, bufLen));
+                    } catch (e) {
+                        console.debug(e);
+                    }
+                    bufLen = 0;
+                } else if (sb.buffered.length) {
+                    const end = sb.buffered.end(sb.buffered.length - 1) - 5;
+                    const start = sb.buffered.start(0);
+                    if (end > start) {
+                        sb.remove(start, end);
+                        ms.setLiveSeekableRange(end, end + 5);
+                    }
+                    // console.debug("VideoRTC.buffered", start, end);
+                }
+            });
+
+            const buf = new Uint8Array(2 * 1024 * 1024);
+            let bufLen = 0;
+
+            this.ondata = data => {
+                if (sb.updating || bufLen > 0) {
+                    const b = new Uint8Array(data);
+                    buf.set(b, bufLen);
+                    bufLen += b.byteLength;
+                    // console.debug("VideoRTC.buffer", b.byteLength, bufLen);
+                } else {
+                    try {
+                        sb.appendBuffer(data);
+                    } catch (e) {
+                        // console.debug(e);
+                    }
+                }
             }
-        });
-
-        this.ws.addEventListener("message", ev => {
-            if (typeof ev.data === "string") {
-                worker.postMessage(ev.data);
-            } else {
-                worker.postMessage(ev.data, [ev.data]);
-            }
-        });
-        this.ws.addEventListener("close", () => {
-            worker.terminate();
-        });
+        }
     }
 
     internalRTC() {
-        if (!("RTCPeerConnection" in window)) return; // macOS Desktop app
+        console.debug("VideoRTC.internalRTC");
+
+        const pc = new RTCPeerConnection(this.pcConfig);
+
+        let mseCodecs = "";
+
+        /** @type {HTMLVideoElement} */
+        const video2 = document.createElement("video");
+        video2.addEventListener("loadeddata", () => {
+            console.debug("VideoRTC.video.loadeddata", video2.readyState, pc.connectionState);
+
+            if (pc.connectionState === "connected" || pc.connectionState === "connecting") {
+                // Video+Audio > Video, H265 > H264, Video > Audio, WebRTC > MSE
+                let rtcPriority = 0, msePriority = 0;
+
+                /** @type {MediaStream} */
+                const rtc = video2.srcObject;
+                if (rtc.getVideoTracks().length > 0) rtcPriority += 0x220;
+                if (rtc.getAudioTracks().length > 0) rtcPriority += 0x102;
+
+                if (mseCodecs.indexOf("hvc1.") >= 0) msePriority += 0x230;
+                if (mseCodecs.indexOf("avc1.") >= 0) msePriority += 0x210;
+                if (mseCodecs.indexOf("mp4a.") >= 0) msePriority += 0x101;
+
+                if (rtcPriority >= msePriority) {
+                    console.debug("VideoRTC.select RTC mode", rtcPriority, msePriority);
+
+                    this.video.controls = true;
+                    this.video.srcObject = rtc;
+                    this.play();
+
+                    this.pcState = WebSocket.OPEN;
+
+                    this.wsState = WebSocket.CLOSED;
+                    this.ws.close();
+                    this.ws = null;
+                } else {
+                    console.debug("VideoRTC.select MSE mode", rtcPriority, msePriority);
+
+                    pc.close();
+
+                    this.pcState = WebSocket.CLOSED;
+                    this.pc = null;
+                }
+            }
+
+            video2.srcObject = null;
+        }, {once: true});
+
+        pc.addEventListener("icecandidate", ev => {
+            const candidate = ev.candidate ? ev.candidate.toJSON().candidate : "";
+            this.send({type: "webrtc/candidate", value: candidate});
+        });
+
+        pc.addEventListener("track", ev => {
+            console.debug("VideoRTC.pc.track", ev.streams.length);
+
+            // when stream already init
+            if (video2.srcObject !== null) return;
+
+            // when audio track not exist in Chrome
+            if (ev.streams.length === 0) return;
+
+            // when audio track not exist in Firefox
+            if (ev.streams[0].id[0] === '{') return;
+
+            video2.srcObject = ev.streams[0];
+        });
+
+        pc.addEventListener("connectionstatechange", () => {
+            console.debug("VideoRTC.pc.connectionstatechange", this.pc.connectionState);
+
+            if (pc.connectionState === "failed" || pc.connectionState === "disconnected") {
+                pc.close(); // stop next events
+
+                this.pcState = WebSocket.CLOSED;
+                this.pc = null;
+
+                if (this.wsState === WebSocket.CLOSED && this.isConnected) {
+                    this.connectedCallback();
+                }
+            }
+        });
+
+        this.onmessage["webrtc"] = msg => {
+            switch (msg.type) {
+                case "webrtc/candidate":
+                    pc.addIceCandidate({candidate: msg.value, sdpMid: ""}).catch(() => console.debug);
+                    break;
+                case "webrtc/answer":
+                    pc.setRemoteDescription({type: "answer", sdp: msg.value}).catch(() => console.debug);
+                    break;
+                case "mse":
+                    mseCodecs = msg.value;
+                    break;
+                case "error":
+                    if (msg.value.indexOf("webrtc/offer") < 0) return;
+                    pc.close();
+            }
+        };
+
+        // Safari doesn't support "offerToReceiveVideo"
+        pc.addTransceiver("video", {direction: "recvonly"});
+        pc.addTransceiver("audio", {direction: "recvonly"});
+
+        pc.createOffer().then(offer => {
+            pc.setLocalDescription(offer).then(() => {
+                this.send({type: "webrtc/offer", value: offer.sdp});
+            });
+        });
+
+        this.pcState = WebSocket.CONNECTING;
+        this.pc = pc;
+    }
+
+    internalMJPEG() {
+        console.debug("VideoRTC.internalMJPEG");
+
+        this.ondata = data => {
+            this.video.poster = "data:image/jpeg;base64," + VideoRTC.btoa(data);
+        };
+
+        this.send({type: "mjpeg"});
+        this.video.controls = false;
+    }
+
+    internalMP4() {
+        console.debug("VideoRTC.internalMP4");
+
+        /** @type {HTMLVideoElement} */
+        let video2;
+
+        this.ondata = data => {
+            // first video with default position (set container size)
+            // second video with position=absolute and top=0px
+            if (video2) {
+                this.removeChild(this.video);
+                this.video.src = "";
+                this.video = video2;
+                video2.style.position = "";
+                video2.style.top = "";
+            }
+
+            video2 = this.video.cloneNode();
+            video2.style.position = "absolute";
+            video2.style.top = "0px";
+            this.appendChild(video2);
+
+            video2.src = "data:video/mp4;base64," + VideoRTC.btoa(data);
+            video2.play().catch(() => console.log);
+        };
+
+        this.ws.addEventListener("close", () => {
+            if (!video2) return;
+
+            this.removeChild(video2);
+            video2.src = "";
+        });
+
+        this.send({type: "mp4", value: this.codecs("mp4")});
+        this.video.controls = false;
+    }
+
+    static btoa(buffer) {
+        const bytes = new Uint8Array(buffer);
+        const len = bytes.byteLength;
+        let binary = "";
+        for (let i = 0; i < len; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return window.btoa(binary);
     }
 }
 

www/video.html

@@ -1,53 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <title>go2rtc - WebRTC</title>
-    <style>
-        body {
-            margin: 0;
-            padding: 0;
-        }
-
-        html, body {
-            height: 100%;
-            width: 100%;
-        }
-
-        #video {
-            /* video "container" size */
-            width: 100%;
-            height: 100%;
-            background: black;
-        }
-    </style>
-</head>
-<body>
-<video id="video" autoplay controls playsinline muted></video>
-<!--<video id="video" preload="auto" controls playsinline muted></video>-->
-<script>
-    const baseUrl = location.origin + location.pathname.substr(
-        0, location.pathname.lastIndexOf("/")
-    );
-    const video = document.getElementById('video');
-
-    video.oncanplay = ev => console.log(ev.type, ev);
-    video.onplaying = ev => console.log(ev.type, ev);
-    video.onwaiting = ev => console.log(ev.type, ev);
-    video.onseeking = ev => console.log(ev.type, ev);
-    video.onloadeddata = ev => console.log(ev.type, ev);
-    video.oncanplaythrough = ev => console.log(ev.type, ev);
-    // video.ondurationchange = ev => console.log(ev.type, ev);
-    // video.ontimeupdate = ev => console.log(ev.type, ev);
-    video.onplay = ev => console.log(ev.type, ev);
-    video.onpause = ev => console.log(ev.type, ev);
-    video.onsuspended = ev => console.log(ev.type, ev);
-    video.onemptied = ev => console.log(ev.type, ev);
-    video.onstalled = ev => console.log(ev.type, ev);
-
-    console.log("start");
-
-    video.src = baseUrl + "/api/stream.mp4" + location.search;
-</script>
-</body>
-</html>