Update version to 1.0.1

PATH api/config method for merge configuration

.github/workflows/docker.yml

@@ -1,4 +1,4 @@
-name: ci
+name: docker
 
 on:
   workflow_dispatch:
@@ -19,7 +19,7 @@ jobs:
         id: meta
         uses: docker/metadata-action@v4
         with:
-          images: alexxit/go2rtc
+          images: ${{ github.repository }}
           tags: |
             type=ref,event=branch
             type=semver,pattern={{version}},enable=false
@@ -29,7 +29,7 @@ jobs:
         id: meta-hw
         uses: docker/metadata-action@v4
         with:
-          images: alexxit/go2rtc
+          images: ${{ github.repository }}
           flavor: |
             suffix=-hardware
             latest=false

.github/workflows/release.yml

@@ -0,0 +1,92 @@
+name: release
+
+on:
+  workflow_dispatch:
+#  push:
+#    tags:
+#      - 'v*'
+
+jobs:
+  build-and-release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Generate changelog
+        run: |
+          echo -e "$(git log $(git describe --tags --abbrev=0)..HEAD --oneline | awk '{print "- "$0}')" > CHANGELOG.md
+      - name: Build Go binaries
+        run: |
+          #!/bin/bash
+          
+          esport CGO_ENABLED=0
+          
+          mkdir artifacts
+          export GOOS=windows
+          export GOARCH=amd64
+          export FILENAME=artifacts/go2rtc_win64.zip
+          go build -ldflags "-s -w" -trimpath && 7z a -mx9 -sdel "$FILENAME" go2rtc.exe
+          
+          export GOOS=windows
+          export GOARCH=386
+          export FILENAME=artifacts/go2rtc_win32.zip
+          go build -ldflags "-s -w" -trimpath && 7z a -mx9 -sdel "$FILENAME" go2rtc.exe
+          
+          export GOOS=windows
+          export GOARCH=arm64
+          export FILENAME=artifacts/go2rtc_win_arm64.zip
+          go build -ldflags "-s -w" -trimpath && 7z a -mx9 -sdel "$FILENAME" go2rtc.exe
+          
+          export GOOS=linux 
+          export GOARCH=amd64
+          export FILENAME=artifacts/go2rtc_linux_amd64
+          go build -ldflags "-s -w" -trimpath -o "$FILENAME"
+          
+          export GOOS=linux
+          export GOARCH=386
+          export FILENAME=artifacts/go2rtc_linux_i386
+          go build -ldflags "-s -w" -trimpath -o "$FILENAME"
+          
+          export GOOS=linux
+          export GOARCH=arm64
+          export FILENAME=artifacts/go2rtc_linux_arm64
+          go build -ldflags "-s -w" -trimpath -o "$FILENAME"
+          
+          export GOOS=linux
+          export GOARCH=arm
+          export GOARM=7
+          export FILENAME=artifacts/go2rtc_linux_arm
+          go build -ldflags "-s -w" -trimpath -o "$FILENAME"
+          
+          export GOOS=linux
+          export GOARCH=mipsle
+          export FILENAME=artifacts/go2rtc_linux_mipsel
+          go build -ldflags "-s -w" -trimpath -o "$FILENAME"
+          
+          export GOOS=darwin
+          export GOARCH=amd64
+          export FILENAME=artifacts/go2rtc_mac_amd64.zip
+          go build -ldflags "-s -w" -trimpath && 7z a -mx9 -sdel "$FILENAME" go2rtc
+          
+          export GOOS=darwin
+          export GOARCH=arm64
+          export FILENAME=artifacts/go2rtc_mac_arm64.zip
+          go build -ldflags "-s -w" -trimpath && 7z a -mx9 -sdel "$FILENAME" go2rtc
+          
+          parallel --jobs $(nproc) "upx {}" ::: artifacts/go2rtc_linux_*
+      - name: Setup tmate session
+        uses: mxschmitt/action-tmate@v3
+        if: ${{ failure() }}
+      - name: Set env
+        run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
+      - name: Create GitHub release
+        uses: softprops/action-gh-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          files: artifacts/*
+          generate_release_notes: true
+          name: Release ${{ env.RELEASE_VERSION }}
+          body_path: CHANGELOG.md
+          draft: false
+          prerelease: false

Dockerfile

@@ -33,13 +33,12 @@ FROM scratch AS rootfs
 
 COPY --from=build /build/go2rtc /usr/local/bin/
 COPY --from=ngrok /bin/ngrok /usr/local/bin/
-COPY ./build/docker/run.sh /
 
 
 # 3. Final image
 FROM base
 
-# Install ffmpeg, bash (for run.sh), tini (for signal handling),
+# Install ffmpeg, tini (for signal handling),
 # and other common tools for the echo source.
 RUN apk add --no-cache tini ffmpeg bash curl jq
 
@@ -55,8 +54,8 @@ RUN if [ "${TARGETARCH}" = "amd64" ]; then apk add --no-cache libva-intel-driver
 
 COPY --from=rootfs / /
 
-RUN chmod a+x /run.sh && mkdir -p /config
-
 ENTRYPOINT ["/sbin/tini", "--"]
+VOLUME /config
+WORKDIR /config
 
-CMD ["/run.sh"]
+CMD ["go2rtc", "-config", "/config/go2rtc.yaml"]

README.md

@@ -9,7 +9,7 @@ Ultimate camera streaming application with support RTSP, WebRTC, HomeKit, FFmpeg
 - streaming from [RTSP](#source-rtsp), [RTMP](#source-rtmp), [HTTP](#source-http) (FLV/MJPEG/JPEG), [FFmpeg](#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 ([read more](https://github.com/AlexxIT/Blog/issues/5))
+- first project in the World with support H265 for WebRTC in browser (Safari only, [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
@@ -27,6 +27,40 @@ Ultimate camera streaming application with support RTSP, WebRTC, HomeKit, FFmpeg
 - [MediaSoup](https://mediasoup.org/) framework routing idea
 - HomeKit Accessory Protocol from [@brutella](https://github.com/brutella/hap)
 
+---
+
+* [Fast start](#fast-start)
+  * [go2rtc: Binary](#go2rtc-binary)
+  * [go2rtc: Home Assistant Add-on](#go2rtc-home-assistant-add-on)
+  * [go2rtc: Docker](#go2rtc-docker)
+* [Configuration](#configuration)
+  * [Module: Streams](#module-streams)
+    * [Source: RTSP](#source-rtsp)
+    * [Source: RTMP](#source-rtmp)
+    * [Source: HTTP](#source-http)
+    * [Source: FFmpeg](#source-ffmpeg)
+    * [Source: FFmpeg Device](#source-ffmpeg-device)
+    * [Source: Exec](#source-exec)
+    * [Source: Echo](#source-echo)
+    * [Source: HomeKit](#source-homekit)
+    * [Source: Ivideon](#source-ivideon)
+    * [Source: Hass](#source-hass)
+  * [Module: API](#module-api)
+  * [Module: RTSP](#module-rtsp)
+  * [Module: WebRTC](#module-webrtc)
+  * [Module: Ngrok](#module-ngrok)
+  * [Module: Hass](#module-hass)
+    * [From go2rtc to Hass](#from-go2rtc-to-hass)
+    * [From Hass to go2rtc](#from-hass-to-go2rtc)
+  * [Module: MP4](#module-mp4)
+  * [Module: MJPEG](#module-mjpeg)
+  * [Module: Log](#module-log)
+* [Security](#security)
+* [Codecs madness](#codecs-madness)
+* [Codecs negotiation](#codecs-negotiation)
+* [TIPS](#tips)
+* [FAQ](#faq)
+
 ## Fast start
 
 1. Download [binary](#go2rtc-binary) or use [Docker](#go2rtc-docker) or [Home Assistant Add-on](#go2rtc-home-assistant-add-on)
@@ -36,8 +70,6 @@ Ultimate camera streaming application with support RTSP, WebRTC, HomeKit, FFmpeg
 
 - add your [streams](#module-streams) to [config](#configuration) file
 - setup [external access](#module-webrtc) to webrtc
-- setup [external access](#module-ngrok) to web interface
-- install [ffmpeg](#source-ffmpeg) for transcoding
 
 **Developers:**
 
@@ -50,7 +82,6 @@ Download binary for your OS from [latest release](https://github.com/AlexxIT/go2
 
 - `go2rtc_win64.zip` - Windows 64-bit
 - `go2rtc_win32.zip` - Windows 32-bit
-- `go2rtc_win_arm64.zip` - Windows ARM 64-bit
 - `go2rtc_linux_amd64` - Linux 64-bit
 - `go2rtc_linux_i386` - Linux 32-bit
 - `go2rtc_linux_arm64` - Linux ARM 64-bit (ex. Raspberry 64-bit OS)
@@ -72,27 +103,17 @@ Don't forget to fix the rights `chmod +x go2rtc_xxx_xxx` on Linux and Mac.
 
 ### go2rtc: Docker
 
-Container [alexxit/go2rtc](https://hub.docker.com/r/alexxit/go2rtc) with support `amd64`, `386`, `arm64`, `arm`. This container same as [Home Assistant Add-on](#go2rtc-home-assistant-add-on), but can be used separately from the Home Assistant. Container has preinstalled [FFmpeg](#source-ffmpeg), [Ngrok](#module-ngrok) and [Python](#source-echo).
+Container [alexxit/go2rtc](https://hub.docker.com/r/alexxit/go2rtc) with support `amd64`, `386`, `arm64`, `arm`. This container is the same as [Home Assistant Add-on](#go2rtc-home-assistant-add-on), but can be used separately from Home Assistant. Container has preinstalled [FFmpeg](#source-ffmpeg), [Ngrok](#module-ngrok) and [Python](#source-echo).
-
-```yaml
-services:
-  go2rtc:
-    image: alexxit/go2rtc
-    network_mode: host
-    restart: always
-    volumes:
-      - "~/go2rtc.yaml:/config/go2rtc.yaml"
-```
 
 ## Configuration
 
-Create file `go2rtc.yaml` next to the app.
+- by default go2rtc will search `go2rtc.yaml` in the current work dirrectory
+- `api` server will start on default **1984 port** (TCP)
+- `rtsp` server will start on default **8554 port** (TCP)
+- `webrtc` will use port **8555** (TCP/UDP) for connections
+- `ffmpeg` will use default transcoding options
 
-- by default, you need to config only your `streams` links
+Configuration options and a complete list of settings can be found in [the wiki](https://github.com/AlexxIT/go2rtc/wiki/Configuration).
-- `api` server will start on default **1984 port**
-- `rtsp` server will start on default **8554 port**
-- `webrtc` will use random UDP port for each connection
-- `ffmpeg` will use default transcoding options (you may install it [manually](https://ffmpeg.org/))
 
 Available modules:
 
@@ -216,7 +237,7 @@ But you can override them via YAML config. You can also add your own formats to
 
 ```yaml
 ffmpeg:
-  bin: ffmpeg                                        # path to ffmpeg binary
+  bin: ffmpeg  # path to ffmpeg binary
   h264: "-codec:v libx264 -g:v 30 -preset:v superfast -tune:v zerolatency -profile:v main -level:v 4.1"
   mycodec: "-any args that support ffmpeg..."
 ```
@@ -224,8 +245,11 @@ ffmpeg:
 - You can use `video` and `audio` params multiple times (ex. `#video=copy#audio=copy#audio=pcmu`)
 - You can use go2rtc stream name as ffmpeg input (ex. `ffmpeg:camera1#video=h264`)
 - You can use `rotate` params with `90`, `180`, `270` or `-90` values, important with transcoding (ex. `#video=h264#rotate=90`)
+- You can use `width` and/or `height` params, important with transcoding (ex. `#video=h264#width=1280`)
 - You can use `raw` param for any additional FFmpeg arguments (ex. `#raw=-vf transpose=1`).
 
+Read more about encoding [hardware acceleration](https://github.com/AlexxIT/go2rtc/wiki/Hardware-acceleration).
+
 #### Source: FFmpeg Device
 
 You can get video from any USB-camera or Webcam as RTSP or WebRTC stream. This is part of FFmpeg integration.
@@ -366,18 +390,19 @@ go2rtc has simple HTML page (`stream.html`) with support params in URL:
 ```yaml
 api:
   listen: ":1984"    # default ":1984", HTTP API port ("" - disabled)
+  username: "admin"  # default "", Basic auth for WebUI
+  password: "pass"   # default "", Basic auth for WebUI
   base_path: "/rtc"  # default "", API prefix for serve on suburl (/api => /rtc/api)
   static_dir: "www"  # default "", folder for static files (custom web interface)
   origin: "*"        # default "", allow CORS requests (only * supported)
 ```
 
-**PS. go2rtc** doesn't provide HTTPS or password protection. Use [Nginx](https://nginx.org/) or [Ngrok](#module-ngrok) or [Home Assistant Add-on](#go2rtc-home-assistant-add-on) for this tasks.
+**PS:**
 
-**PS2.** You can access microphone (for 2-way audio) only with HTTPS ([read more](https://stackoverflow.com/questions/52759992/how-to-access-camera-and-microphone-in-chrome-without-https)).
+- go2rtc doesn't provide HTTPS. Use [Nginx](https://nginx.org/) or [Ngrok](#module-ngrok) or [Home Assistant Add-on](#go2rtc-home-assistant-add-on) for this tasks
-
+- you can access microphone (for 2-way audio) only with HTTPS ([read more](https://stackoverflow.com/questions/52759992/how-to-access-camera-and-microphone-in-chrome-without-https))
-**PS3.** MJPEG over WebSocket plays better than native MJPEG because Chrome [bug](https://bugs.chromium.org/p/chromium/issues/detail?id=527446).
+- MJPEG over WebSocket plays better than native MJPEG because Chrome [bug](https://bugs.chromium.org/p/chromium/issues/detail?id=527446)
-
+- MP4 over WebSocket was created only for Apple iOS because it doesn't support MSE and native MP4
-**PS4.** MP4 over WebSocket was created only for Apple iOS because it doesn't support MSE and native MP4.
 
 ### Module: RTSP
 
@@ -392,54 +417,52 @@ Password protection always disabled for localhost calls (ex. FFmpeg or Hass on s
 
 ```yaml
 rtsp:
-  listen: ":8554"  # RTSP Server TCP port, default - 8554
+  listen: ":8554"    # RTSP Server TCP port, default - 8554
-  username: admin  # optional, default - disabled
+  username: "admin"  # optional, default - disabled
-  password: pass   # optional, default - disabled
+  password: "pass"   # optional, default - disabled
 ```
 
 ### Module: WebRTC
 
 WebRTC usually works without problems in the local network. But external access may require additional settings. It depends on what type of Internet do you have.
 
-- by default, WebRTC use two random UDP ports for each connection (video and audio)
+- by default, WebRTC uses both TCP and UDP on port 8555 for connections
-- you can enable one additional TCP port for all connections and use it for external access
+- you can use this port for external access
+- you can change the port in YAML config:
+
+```yaml
+webrtc:
+  listen: ":8555"  # address of your local server and port (TCP/UDP)
+```
 
 **Static public IP**
 
-- add some TCP port to YAML config (ex. 8555)
+- forward the port 8555 on your router (you can use same 8555 port or any other as external port)
-- forward this port on your router (you can use same 8555 port or any other)
 - add your external IP-address and external port to YAML config
 
 ```yaml
 webrtc:
-  listen: ":8555"  # address of your local server (TCP)
   candidates:
     - 216.58.210.174:8555  # if you have static public IP-address
 ```
 
 **Dynamic public IP**
 
-- add some TCP port to YAML config (ex. 8555)
+- forward the port 8555 on your router (you can use same 8555 port or any other as the external port)
-- forward this port on your router (you can use same 8555 port or any other)
 - add `stun` word and external port to YAML config
   - go2rtc automatically detects your external address with STUN-server
 
 ```yaml
 webrtc:
-  listen: ":8555"  # address of your local server (TCP)
   candidates:
     - stun:8555  # if you have dynamic public IP-address
 ```
 
 **Private IP**
 
-- add some TCP port to YAML config (ex. 8555)
 - setup integration with [Ngrok service](#module-ngrok)
 
 ```yaml
-webrtc:
-  listen: ":8555"  # address of your local server (TCP)
-
 ngrok:
   command: ...
 ```
@@ -550,8 +573,13 @@ PS. Default Home Assistant lovelace cards don't support 2-way audio. You can use
 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/)
+2. Camera snapshots in MP4 format (single frame), can be sent to [Telegram](https://github.com/AlexxIT/go2rtc/wiki/Snapshot-to-Telegram)
-3. MP4 "file 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 start delay, doesn't work in Safari 
+
+API examples:
+
+- MP4 stream: `http://192.168.1.123:1984/api/stream.mp4?src=camera1`
+- MP4 snapshot: `http://192.168.1.123:1984/api/frame.mp4?src=camera1`
 
 ### Module: MJPEG
 
@@ -595,7 +623,7 @@ log:
 
 ## Security
 
-By default `go2rtc` start Web interface on port `1984` and RTSP on port `8554`. Both ports are accessible from your local network. So anyone on your local network can watch video from your cameras without authorization. The same rule applies to the Home Assistant Add-on.
+By default `go2rtc` starts the Web interface on port `1984` and RTSP on port `8554`, as well as use port `8555` for WebRTC connections. The three ports are accessible from your local network. So anyone on your local network can watch video from your cameras without authorization. The same rule applies to the Home Assistant Add-on.
 
 This is not a problem if you trust your local network as much as I do. But you can change this behaviour with a `go2rtc.yaml` config:
 
@@ -607,7 +635,7 @@ rtsp:
   listen: "127.0.0.1:8554" # localhost
 
 webrtc:
-  listen: ":8555" # external TCP port
+  listen: ":8555" # external TCP/UDP port
 ```
 
 - local access to RTSP is not a problem for [FFmpeg](#source-ffmpeg) integration, because it runs locally on your server
@@ -617,7 +645,7 @@ webrtc:
 
 If you need Web interface protection without Home Assistant Add-on - you need to use reverse proxy, like [Nginx](https://nginx.org/), [Caddy](https://caddyserver.com/), [Ngrok](https://ngrok.com/), etc.
 
-PS. Additionally WebRTC opens a lot of random UDP ports for transmit encrypted media. They work without problems on the local network. And sometimes work for external access, even if you haven't opened ports on your router. But for stable external WebRTC access, you need to configure the TCP port.
+PS. Additionally WebRTC will try to use the 8555 UDP port for transmit encrypted media. It works without problems on the local network. And sometimes also works for external access, even if you haven't opened this port on your router ([read more](https://en.wikipedia.org/wiki/UDP_hole_punching)). But for stable external WebRTC access, you need to open the 8555 port on your router for both TCP and UDP.
 
 ## Codecs madness
 
@@ -687,6 +715,10 @@ streams:
 - `ffplay -fflags nobuffer -flags low_delay "rtsp://192.168.1.123:8554/camera1"`
 - VLC > Preferences > Input / Codecs > Default Caching Level: Lowest Latency
 
+**Snapshots to Telegram**
+
+[read more](https://github.com/AlexxIT/go2rtc/wiki/Snapshot-to-Telegram)
+
 ## FAQ
 
 **Q. What's the difference between go2rtc, WebRTC Camera and RTSPtoWebRTC?**

cmd/api/api.go

@@ -3,16 +3,21 @@ package api
 import (
 	"encoding/json"
 	"github.com/AlexxIT/go2rtc/cmd/app"
-	"github.com/AlexxIT/go2rtc/cmd/streams"
 	"github.com/rs/zerolog"
 	"net"
 	"net/http"
+	"os"
+	"strconv"
+	"strings"
+	"sync"
 )
 
 func Init() {
 	var cfg struct {
 		Mod struct {
 			Listen    string `yaml:"listen"`
+			Username  string `yaml:"username"`
+			Password  string `yaml:"password"`
 			BasePath  string `yaml:"base_path"`
 			StaticDir string `yaml:"static_dir"`
 			Origin    string `yaml:"origin"`
@@ -35,7 +40,9 @@ func Init() {
 	initStatic(cfg.Mod.StaticDir)
 	initWS(cfg.Mod.Origin)
 
-	HandleFunc("api/streams", streamsHandler)
+	HandleFunc("api", apiHandler)
+	HandleFunc("api/config", configHandler)
+	HandleFunc("api/exit", exitHandler)
 	HandleFunc("api/ws", apiWS)
 
 	// ensure we can listen without errors
@@ -48,14 +55,18 @@ func Init() {
 	log.Info().Str("addr", cfg.Mod.Listen).Msg("[api] listen")
 
 	s := http.Server{}
-	s.Handler = http.DefaultServeMux
+	s.Handler = http.DefaultServeMux // 4th
-
-	if log.Trace().Enabled() {
-		s.Handler = middlewareLog(s.Handler)
-	}
 
 	if cfg.Mod.Origin == "*" {
-		s.Handler = middlewareCORS(s.Handler)
+		s.Handler = middlewareCORS(s.Handler) // 3rd
+	}
+
+	if cfg.Mod.Username != "" {
+		s.Handler = middlewareAuth(cfg.Mod.Username, cfg.Mod.Password, s.Handler) // 2nd
+	}
+
+	if log.Trace().Enabled() {
+		s.Handler = middlewareLog(s.Handler) // 1st
 	}
 
 	go func() {
@@ -83,7 +94,22 @@ var log zerolog.Logger
 
 func middlewareLog(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		log.Trace().Msgf("[api] %s %s", r.Method, r.URL)
+		log.Trace().Msgf("[api] %s %s %s", r.Method, r.URL, r.RemoteAddr)
+		next.ServeHTTP(w, r)
+	})
+}
+
+func middlewareAuth(username, password string, next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if !strings.HasPrefix(r.RemoteAddr, "127.") && !strings.HasPrefix(r.RemoteAddr, "[::1]") {
+			user, pass, ok := r.BasicAuth()
+			if !ok || user != username || pass != password {
+				w.Header().Set("Www-Authenticate", `Basic realm="go2rtc"`)
+				http.Error(w, "Unauthorized", http.StatusUnauthorized)
+				return
+			}
+		}
+
 		next.ServeHTTP(w, r)
 	})
 }
@@ -96,31 +122,25 @@ func middlewareCORS(next http.Handler) http.Handler {
 	})
 }
 
-func streamsHandler(w http.ResponseWriter, r *http.Request) {
+var mu sync.Mutex
-	src := r.URL.Query().Get("src")
-	name := r.URL.Query().Get("name")
 
-	if name == "" {
+func apiHandler(w http.ResponseWriter, r *http.Request) {
-		name = src
+	mu.Lock()
+	app.Info["host"] = r.Host
+	mu.Unlock()
+
+	if err := json.NewEncoder(w).Encode(app.Info); err != nil {
+		log.Warn().Err(err).Caller().Send()
 	}
-
+}
-	switch r.Method {
+
-	case "PUT":
+func exitHandler(w http.ResponseWriter, r *http.Request) {
-		streams.New(name, src)
+	if r.Method != "POST" {
-		return
+		http.Error(w, "", http.StatusBadRequest)
-	case "DELETE":
+		return
-		streams.Delete(src)
+	}
-		return
+
-	}
+	s := r.URL.Query().Get("code")
-
+	code, _ := strconv.Atoi(s)
-	var v interface{}
+	os.Exit(code)
-	if src != "" {
-		v = streams.Get(src)
-	} else {
-		v = streams.All()
-	}
-
-	e := json.NewEncoder(w)
-	e.SetIndent("", "  ")
-	_ = e.Encode(v)
 }

cmd/api/config.go

@@ -0,0 +1,102 @@
+package api
+
+import (
+	"github.com/AlexxIT/go2rtc/cmd/app"
+	"gopkg.in/yaml.v3"
+	"io"
+	"net/http"
+	"os"
+)
+
+func configHandler(w http.ResponseWriter, r *http.Request) {
+	if app.ConfigPath == "" {
+		http.Error(w, "", http.StatusGone)
+		return
+	}
+
+	switch r.Method {
+	case "GET":
+		data, err := os.ReadFile(app.ConfigPath)
+		if err != nil {
+			http.Error(w, "", http.StatusNotFound)
+			return
+		}
+		if _, err = w.Write(data); err != nil {
+			log.Warn().Err(err).Caller().Send()
+		}
+
+	case "POST", "PATCH":
+		data, err := io.ReadAll(r.Body)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		if r.Method == "PATCH" {
+			// no need to validate after merge
+			data, err = mergeYAML(app.ConfigPath, data)
+			if err != nil {
+				http.Error(w, err.Error(), http.StatusBadRequest)
+				return
+			}
+		} else {
+			// validate config
+			var tmp struct{}
+			if err = yaml.Unmarshal(data, &tmp); err != nil {
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+				return
+			}
+		}
+
+		if err = os.WriteFile(app.ConfigPath, data, 0644); err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	}
+}
+
+func mergeYAML(file1 string, yaml2 []byte) ([]byte, error) {
+	// Read the contents of the first YAML file
+	data1, err := os.ReadFile(file1)
+	if err != nil {
+		return nil, err
+	}
+
+	// Unmarshal the first YAML file into a map
+	var config1 map[string]interface{}
+	if err = yaml.Unmarshal(data1, &config1); err != nil {
+		return nil, err
+	}
+
+	// Unmarshal the second YAML document into a map
+	var config2 map[string]interface{}
+	if err = yaml.Unmarshal(yaml2, &config2); err != nil {
+		return nil, err
+	}
+
+	// Merge the two maps
+	config1 = merge(config1, config2)
+
+	// Marshal the merged map into YAML
+	return yaml.Marshal(&config1)
+}
+
+func merge(dst, src map[string]interface{}) map[string]interface{} {
+	for k, v := range src {
+		if vv, ok := dst[k]; ok {
+			switch vv := vv.(type) {
+			case map[string]interface{}:
+				v := v.(map[string]interface{})
+				dst[k] = merge(vv, v)
+			case []interface{}:
+				v := v.([]interface{})
+				dst[k] = v
+			default:
+				dst[k] = v
+			}
+		} else {
+			dst[k] = v
+		}
+	}
+	return dst
+}

cmd/api/ws.go

@@ -6,6 +6,7 @@ import (
 	"net/url"
 	"strings"
 	"sync"
+	"time"
 )
 
 // Message - struct for data exchange in Web API
@@ -68,6 +69,8 @@ func apiWS(w http.ResponseWriter, r *http.Request) {
 
 	tr := &Transport{Request: r}
 	tr.OnWrite(func(msg interface{}) {
+		_ = ws.SetWriteDeadline(time.Now().Add(time.Second * 5))
+
 		if data, ok := msg.([]byte); ok {
 			_ = ws.WriteMessage(websocket.BinaryMessage, data)
 		} else {
@@ -78,7 +81,9 @@ func apiWS(w http.ResponseWriter, r *http.Request) {
 	for {
 		msg := new(Message)
 		if err = ws.ReadJSON(msg); err != nil {
-			log.Trace().Err(err).Caller().Send()
+			if !websocket.IsCloseError(err, websocket.CloseNoStatusReceived) {
+				log.Trace().Err(err).Caller().Send()
+			}
 			_ = ws.Close()
 			break
 		}
@@ -101,7 +106,9 @@ type Transport struct {
 	Request  *http.Request
 	Consumer interface{} // TODO: rewrite
 
-	mx sync.Mutex
+	closed bool
+	mx     sync.Mutex
+	wrmx   sync.Mutex
 
 	onChange func()
 	onWrite  func(msg interface{})
@@ -118,21 +125,32 @@ func (t *Transport) OnWrite(f func(msg interface{})) {
 }
 
 func (t *Transport) Write(msg interface{}) {
-	t.mx.Lock()
+	t.wrmx.Lock()
 	t.onWrite(msg)
-	t.mx.Unlock()
+	t.wrmx.Unlock()
 }
 
 func (t *Transport) Close() {
+	t.mx.Lock()
 	for _, f := range t.onClose {
 		f()
 	}
+	t.closed = true
+	t.mx.Unlock()
 }
 
 func (t *Transport) OnChange(f func()) {
+	t.mx.Lock()
 	t.onChange = f
+	t.mx.Unlock()
 }
 
 func (t *Transport) OnClose(f func()) {
-	t.onClose = append(t.onClose, f)
+	t.mx.Lock()
+	if t.closed {
+		f()
+	} else {
+		t.onClose = append(t.onClose, f)
+	}
+	t.mx.Unlock()
 }

cmd/app/app.go

@@ -2,46 +2,76 @@ package app
 
 import (
 	"flag"
+	"github.com/AlexxIT/go2rtc/pkg/shell"
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
 	"gopkg.in/yaml.v3"
 	"io"
 	"os"
+	"path/filepath"
 	"runtime"
+	"strings"
+	"time"
 )
 
-var Version = "0.1-rc.7"
+var Version = "1.0.1"
 var UserAgent = "go2rtc/" + Version
 
-func Init() {
+var ConfigPath string
-	config := flag.String(
+var Info = map[string]interface{}{
-		"config",
+	"version": Version,
-		"go2rtc.yaml",
+}
-		"Path to go2rtc configuration file",
-	)
 
+func Init() {
+	var confs Config
+
+	flag.Var(&confs, "config", "go2rtc config (path to file or raw text), support multiple")
 	flag.Parse()
 
-	data, _ = os.ReadFile(*config)
+	if confs == nil {
+		confs = []string{"go2rtc.yaml"}
+	}
+
+	for _, conf := range confs {
+		if conf[0] != '{' {
+			// config as file
+			if ConfigPath == "" {
+				ConfigPath = conf
+			}
+
+			data, _ := os.ReadFile(conf)
+			if data == nil {
+				continue
+			}
+
+			data = []byte(shell.ReplaceEnvVars(string(data)))
+			configs = append(configs, data)
+		} else {
+			// config as raw YAML
+			configs = append(configs, []byte(conf))
+		}
+	}
+
+	if ConfigPath != "" {
+		if !filepath.IsAbs(ConfigPath) {
+			if cwd, err := os.Getwd(); err == nil {
+				ConfigPath = filepath.Join(cwd, ConfigPath)
+			}
+		}
+		Info["config_path"] = ConfigPath
+	}
 
 	var cfg struct {
 		Mod map[string]string `yaml:"log"`
 	}
 
-	if data != nil {
+	LoadConfig(&cfg)
-		if err := yaml.Unmarshal(data, &cfg); err != nil {
-			println("ERROR: " + err.Error())
-		}
-	}
 
 	log.Logger = NewLogger(cfg.Mod["format"], cfg.Mod["level"])
 
 	modules = cfg.Mod
 
 	log.Info().Msgf("go2rtc version %s %s/%s", Version, runtime.GOOS, runtime.GOARCH)
-
-	path, _ := os.Getwd()
-	log.Debug().Str("cwd", path).Send()
 }
 
 func NewLogger(format string, level string) zerolog.Logger {
@@ -54,7 +84,7 @@ func NewLogger(format string, level string) zerolog.Logger {
 		}
 	}
 
-	zerolog.TimeFieldFormat = zerolog.TimeFormatUnixMs
+	zerolog.TimeFieldFormat = time.RFC3339Nano
 
 	lvl, err := zerolog.ParseLevel(level)
 	if err != nil || lvl == zerolog.NoLevel {
@@ -65,7 +95,7 @@ func NewLogger(format string, level string) zerolog.Logger {
 }
 
 func LoadConfig(v interface{}) {
-	if data != nil {
+	for _, data := range configs {
 		if err := yaml.Unmarshal(data, v); err != nil {
 			log.Warn().Err(err).Msg("[app] read config")
 		}
@@ -86,8 +116,18 @@ func GetLogger(module string) zerolog.Logger {
 
 // internal
 
-// data - config content
+type Config []string
-var data []byte
+
+func (c *Config) String() string {
+	return strings.Join(*c, " ")
+}
+
+func (c *Config) Set(value string) error {
+	*c = append(*c, value)
+	return nil
+}
+
+var configs [][]byte
 
 // modules log levels
 var modules map[string]string

cmd/debug/debug.go

@@ -4,24 +4,14 @@ import (
 	"github.com/AlexxIT/go2rtc/cmd/api"
 	"github.com/AlexxIT/go2rtc/cmd/streams"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
-	"net/http"
-	"os"
-	"strconv"
 )
 
 func Init() {
 	api.HandleFunc("api/stack", stackHandler)
-	api.HandleFunc("api/exit", exitHandler)
 
 	streams.HandleFunc("null", nullHandler)
 }
 
-func exitHandler(_ http.ResponseWriter, r *http.Request) {
-	s := r.URL.Query().Get("code")
-	code, _ := strconv.Atoi(s)
-	os.Exit(code)
-}
-
 func nullHandler(string) (streamer.Producer, error) {
 	return nil, nil
 }

cmd/debug/stack.go

@@ -25,6 +25,7 @@ var stackSkip = [][]byte{
 
 	// webrtc/api.go
 	[]byte("created by github.com/pion/ice/v2.NewTCPMuxDefault"),
+	[]byte("created by github.com/pion/ice/v2.NewUDPMuxDefault"),
 }
 
 func stackHandler(w http.ResponseWriter, r *http.Request) {

cmd/exec/exec.go

@@ -34,8 +34,13 @@ func Init() {
 			return false
 		}
 
-		waiter <- conn
+		// unblocking write to channel
-		return true
+		select {
+		case waiter <- conn:
+			return true
+		default:
+			return false
+		}
 	})
 
 	streams.HandleFunc("exec", Handle)
@@ -86,7 +91,13 @@ func Handle(url string) (streamer.Producer, error) {
 	chErr := make(chan error)
 
 	go func() {
-		chErr <- cmd.Wait()
+		err := cmd.Wait()
+		// unblocking write to channel
+		select {
+		case chErr <- err:
+		default:
+			log.Trace().Str("url", url).Msg("[exec] close")
+		}
 	}()
 
 	select {

cmd/mjpeg/mjpeg.go

@@ -27,7 +27,10 @@ func handlerKeyframe(w http.ResponseWriter, r *http.Request) {
 
 	exit := make(chan []byte)
 
-	cons := &mjpeg.Consumer{}
+	cons := &mjpeg.Consumer{
+		RemoteAddr: r.RemoteAddr,
+		UserAgent:  r.UserAgent(),
+	}
 	cons.Listen(func(msg interface{}) {
 		switch msg := msg.(type) {
 		case []byte:
@@ -68,7 +71,10 @@ func handlerStream(w http.ResponseWriter, r *http.Request) {
 
 	flusher := w.(http.Flusher)
 
-	cons := &mjpeg.Consumer{}
+	cons := &mjpeg.Consumer{
+		RemoteAddr: r.RemoteAddr,
+		UserAgent:  r.UserAgent(),
+	}
 	cons.Listen(func(msg interface{}) {
 		switch msg := msg.(type) {
 		case []byte:
@@ -109,7 +115,10 @@ func handlerWS(tr *api.Transport, _ *api.Message) error {
 		return errors.New(api.StreamNotFound)
 	}
 
-	cons := &mjpeg.Consumer{}
+	cons := &mjpeg.Consumer{
+		RemoteAddr: tr.Request.RemoteAddr,
+		UserAgent:  tr.Request.UserAgent(),
+	}
 	cons.Listen(func(msg interface{}) {
 		if data, ok := msg.([]byte); ok {
 			tr.Write(data)

cmd/mp4/mp4.go

@@ -80,7 +80,10 @@ func handlerMP4(w http.ResponseWriter, r *http.Request) {
 
 	exit := make(chan error)
 
-	cons := &mp4.Consumer{}
+	cons := &mp4.Consumer{
+		RemoteAddr: r.RemoteAddr,
+		UserAgent:  r.UserAgent(),
+	}
 	cons.Listen(func(msg interface{}) {
 		if data, ok := msg.([]byte); ok {
 			if _, err := w.Write(data); err != nil && exit != nil {

cmd/mp4/ws.go

@@ -18,7 +18,10 @@ func handlerWSMSE(tr *api.Transport, msg *api.Message) error {
 		return errors.New(api.StreamNotFound)
 	}
 
-	cons := &mp4.Consumer{}
+	cons := &mp4.Consumer{
+		RemoteAddr: tr.Request.RemoteAddr,
+		UserAgent:  tr.Request.UserAgent(),
+	}
 	cons.UserAgent = tr.Request.UserAgent()
 	cons.RemoteAddr = tr.Request.RemoteAddr
 
@@ -38,7 +41,7 @@ func handlerWSMSE(tr *api.Transport, msg *api.Message) error {
 	})
 
 	if err := stream.AddConsumer(cons); err != nil {
-		log.Warn().Err(err).Caller().Send()
+		log.Debug().Err(err).Msg("[mp4] add consumer")
 		return err
 	}
 
@@ -68,7 +71,11 @@ func handlerWSMP4(tr *api.Transport, msg *api.Message) error {
 		return errors.New(api.StreamNotFound)
 	}
 
-	cons := &mp4.Segment{}
+	cons := &mp4.Segment{
+		RemoteAddr:   tr.Request.RemoteAddr,
+		UserAgent:    tr.Request.UserAgent(),
+		OnlyKeyframe: true,
+	}
 
 	if codecs, ok := msg.Value.(string); ok {
 		log.Trace().Str("codecs", codecs).Msgf("[mp4] new WS/MP4 consumer")

cmd/rtsp/rtsp.go

@@ -14,9 +14,9 @@ import (
 func Init() {
 	var conf struct {
 		Mod struct {
-			Listen   string `yaml:"listen"`
+			Listen   string `yaml:"listen" json:"listen"`
-			Username string `yaml:"username"`
+			Username string `yaml:"username" json:"-"`
-			Password string `yaml:"password"`
+			Password string `yaml:"password" json:"-"`
 		} `yaml:"rtsp"`
 	}
 
@@ -24,6 +24,7 @@ func Init() {
 	conf.Mod.Listen = ":8554"
 
 	app.LoadConfig(&conf)
+	app.Info["rtsp"] = conf.Mod
 
 	log = app.GetLogger("rtsp")
 
@@ -161,6 +162,8 @@ func tcpHandler(conn *rtsp.Conn) {
 
 			log.Debug().Str("stream", name).Msg("[rtsp] new consumer")
 
+			conn.SessionName = app.UserAgent
+
 			initMedias(conn)
 
 			if err := stream.AddConsumer(conn); err != nil {
@@ -200,6 +203,9 @@ func tcpHandler(conn *rtsp.Conn) {
 
 	if err := conn.Accept(); err != nil {
 		log.Warn().Err(err).Caller().Send()
+		if closer != nil {
+			closer()
+		}
 		_ = conn.Close()
 		return
 	}
@@ -212,7 +218,7 @@ func tcpHandler(conn *rtsp.Conn) {
 
 	if closer != nil {
 		if err := conn.Handle(); err != nil {
-			log.Debug().Err(err).Caller().Send()
+			log.Debug().Msgf("[rtsp] handle=%s", err)
 		}
 
 		closer()

cmd/streams/consumer.go

@@ -0,0 +1,15 @@
+package streams
+
+import (
+	"encoding/json"
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+)
+
+type Consumer struct {
+	element streamer.Consumer
+	tracks  []*streamer.Track
+}
+
+func (c *Consumer) MarshalJSON() ([]byte, error) {
+	return json.Marshal(c.element)
+}

cmd/streams/producer.go

@@ -1,6 +1,7 @@
 package streams
 
 import (
+	"encoding/json"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"strings"
 	"sync"
@@ -27,9 +28,9 @@ type Producer struct {
 	lastErr error
 	tracks  []*streamer.Track
 
-	state   state
+	state    state
-	mu      sync.Mutex
+	mu       sync.Mutex
-	restart *time.Timer
+	workerID int
 }
 
 func (p *Producer) SetSource(s string) {
@@ -91,6 +92,15 @@ func (p *Producer) GetTrack(media *streamer.Media, codec *streamer.Codec) *strea
 	return track
 }
 
+func (p *Producer) MarshalJSON() ([]byte, error) {
+	if p.element != nil {
+		return json.Marshal(p.element)
+	}
+
+	info := streamer.Info{URL: p.url}
+	return json.Marshal(info)
+}
+
 // internals
 
 func (p *Producer) start() {
@@ -104,20 +114,32 @@ func (p *Producer) start() {
 	log.Debug().Msgf("[streams] start producer url=%s", p.url)
 
 	p.state = stateStart
-	go func() {
+	p.workerID++
-		// safe read element while mu locked
+
-		if err := p.element.Start(); err != nil {
+	go p.worker(p.element, p.workerID)
-			log.Warn().Err(err).Str("url", p.url).Caller().Send()
-		}
-		p.reconnect()
-	}()
 }
 
-func (p *Producer) reconnect() {
+func (p *Producer) worker(element streamer.Producer, workerID int) {
+	if err := element.Start(); err != nil {
+		p.mu.Lock()
+		closed := p.workerID != workerID
+		p.mu.Unlock()
+
+		if closed {
+			return
+		}
+
+		log.Warn().Err(err).Str("url", p.url).Caller().Send()
+	}
+
+	p.reconnect(workerID)
+}
+
+func (p *Producer) reconnect(workerID int) {
 	p.mu.Lock()
 	defer p.mu.Unlock()
 
-	if p.state != stateStart {
+	if p.workerID != workerID {
 		log.Trace().Msgf("[streams] stop reconnect url=%s", p.url)
 		return
 	}
@@ -126,9 +148,11 @@ func (p *Producer) reconnect() {
 
 	p.element, p.lastErr = GetProducer(p.url)
 	if p.lastErr != nil || p.element == nil {
-		log.Debug().Err(p.lastErr).Caller().Send()
+		log.Debug().Msgf("[streams] producer=%s", p.lastErr)
 		// TODO: dynamic timeout
-		p.restart = time.AfterFunc(30*time.Second, p.reconnect)
+		time.AfterFunc(30*time.Second, func() {
+			p.reconnect(workerID)
+		})
 		return
 	}
 
@@ -152,12 +176,7 @@ func (p *Producer) reconnect() {
 		}
 	}
 
-	go func() {
+	go p.worker(p.element, workerID)
-		if err := p.element.Start(); err != nil {
-			log.Debug().Err(err).Caller().Send()
-		}
-		p.reconnect()
-	}()
 }
 
 func (p *Producer) stop() {
@@ -171,6 +190,8 @@ func (p *Producer) stop() {
 	case stateNone:
 		log.Debug().Msgf("[streams] can't stop none producer")
 		return
+	case stateStart:
+		p.workerID++
 	}
 
 	log.Debug().Msgf("[streams] stop producer url=%s", p.url)
@@ -179,10 +200,6 @@ func (p *Producer) stop() {
 		_ = p.element.Stop()
 		p.element = nil
 	}
-	if p.restart != nil {
-		p.restart.Stop()
-		p.restart = nil
-	}
 
 	p.state = stateNone
 	p.tracks = nil

cmd/streams/stream.go

@@ -7,18 +7,14 @@ import (
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"strings"
 	"sync"
+	"sync/atomic"
 )
 
-type Consumer struct {
-	element streamer.Consumer
-	tracks  []*streamer.Track
-}
-
 type Stream struct {
 	producers []*Producer
 	consumers []*Consumer
 	mu        sync.Mutex
-	wg        sync.WaitGroup
+	requests  int32
 }
 
 func NewStream(source interface{}) *Stream {
@@ -53,6 +49,9 @@ func (s *Stream) SetSource(source string) {
 }
 
 func (s *Stream) AddConsumer(cons streamer.Consumer) (err error) {
+	// support for multiple simultaneous requests from different consumers
+	atomic.AddInt32(&s.requests, 1)
+
 	ic := len(s.consumers)
 
 	consumer := &Consumer{element: cons}
@@ -60,9 +59,6 @@ func (s *Stream) AddConsumer(cons streamer.Consumer) (err error) {
 
 	var codecs string
 
-	// support for multiple simultaneous requests from different consumers
-	s.wg.Add(1)
-
 	// Step 1. Get consumer medias
 	for icc, consMedia := range cons.GetMedias() {
 		log.Trace().Stringer("media", consMedia).
@@ -86,7 +82,7 @@ func (s *Stream) AddConsumer(cons streamer.Consumer) (err error) {
 					// Step 4. Get producer track
 					prodTrack := prod.GetTrack(prodMedia, prodCodec)
 					if prodTrack == nil {
-						log.Warn().Str("url", prod.url).Msg("[stream] can't get track")
+						log.Warn().Str("url", prod.url).Msg("[streams] can't get track")
 						continue
 					}
 
@@ -101,12 +97,11 @@ func (s *Stream) AddConsumer(cons streamer.Consumer) (err error) {
 		}
 	}
 
-	s.wg.Done()
+	if atomic.AddInt32(&s.requests, -1) == 0 {
-	s.wg.Wait()
+		s.stopProducers()
+	}
 
 	if len(producers) == 0 {
-		s.stopProducers()
-
 		if len(codecs) > 0 {
 			return errors.New("codecs not match: " + codecs)
 		}
@@ -197,22 +192,21 @@ producers:
 //}
 
 func (s *Stream) MarshalJSON() ([]byte, error) {
-	var v []interface{}
+	if !s.mu.TryLock() {
-	s.mu.Lock()
+		log.Warn().Msgf("[streams] json locked")
-	for _, prod := range s.producers {
+		return json.Marshal(nil)
-		if prod.element != nil {
-			v = append(v, prod.element)
-		}
 	}
-	for _, cons := range s.consumers {
+
-		// cons.element always not nil
+	var info struct {
-		v = append(v, cons.element)
+		Producers []*Producer `json:"producers"`
+		Consumers []*Consumer `json:"consumers"`
 	}
+	info.Producers = s.producers
+	info.Consumers = s.consumers
+
 	s.mu.Unlock()
-	if len(v) == 0 {
+
-		v = nil
+	return json.Marshal(info)
-	}
-	return json.Marshal(v)
 }
 
 func (s *Stream) removeConsumer(i int) {
@@ -242,6 +236,10 @@ func (s *Stream) removeProducer(i int) {
 }
 
 func collectCodecs(media *streamer.Media, codecs *string) {
+	if media.Direction == streamer.DirectionRecvonly {
+		return
+	}
+
 	for _, codec := range media.Codecs {
 		name := codec.Name
 		if name == streamer.CodecAAC {

cmd/streams/streams.go

@@ -1,9 +1,12 @@
 package streams
 
 import (
+	"encoding/json"
+	"github.com/AlexxIT/go2rtc/cmd/api"
 	"github.com/AlexxIT/go2rtc/cmd/app"
 	"github.com/AlexxIT/go2rtc/cmd/app/store"
 	"github.com/rs/zerolog"
+	"net/http"
 )
 
 func Init() {
@@ -22,6 +25,8 @@ func Init() {
 	for name, item := range store.GetDict("streams") {
 		streams[name] = NewStream(item)
 	}
+
+	api.HandleFunc("api/streams", streamsHandler)
 }
 
 func Get(name string) *Stream {
@@ -48,19 +53,29 @@ func GetOrNew(src string) *Stream {
 	return New(src, src)
 }
 
-func Delete(name string) {
+func streamsHandler(w http.ResponseWriter, r *http.Request) {
-	delete(streams, name)
+	src := r.URL.Query().Get("src")
-}
 
-func All() map[string]interface{} {
+	switch r.Method {
-	all := map[string]interface{}{}
+	case "PUT":
-	for name, stream := range streams {
+		name := r.URL.Query().Get("name")
-		all[name] = stream
+		if name == "" {
-		//if stream.Active() {
+			name = src
-		//	all[name] = stream
+		}
-		//}
+		New(name, src)
+		return
+	case "DELETE":
+		delete(streams, src)
+		return
+	}
+
+	if src != "" {
+		e := json.NewEncoder(w)
+		e.SetIndent("", "  ")
+		_ = e.Encode(streams[src])
+	} else {
+		_ = json.NewEncoder(w).Encode(streams)
 	}
-	return all
 }
 
 var log zerolog.Logger

cmd/webrtc/candidates.go

@@ -7,6 +7,7 @@ import (
 )
 
 var candidates []string
+var networks = []string{"udp", "tcp"}
 
 func AddCandidate(address string) {
 	candidates = append(candidates, address)
@@ -20,15 +21,17 @@ func asyncCandidates(tr *api.Transport) {
 			continue
 		}
 
-		cand, err := webrtc.NewCandidate(address)
+		for _, network := range networks {
-		if err != nil {
+			cand, err := webrtc.NewCandidate(network, address)
-			log.Warn().Err(err).Caller().Send()
+			if err != nil {
-			continue
+				log.Warn().Err(err).Caller().Send()
+				continue
+			}
+
+			log.Trace().Str("candidate", cand).Msg("[webrtc] config")
+
+			tr.Write(&api.Message{Type: "webrtc/candidate", Value: cand})
 		}
-
-		log.Trace().Str("candidate", cand).Msg("[webrtc] config")
-
-		tr.Write(&api.Message{Type: "webrtc/candidate", Value: cand})
 	}
 }
 
@@ -57,13 +60,15 @@ func syncCanditates(answer string) (string, error) {
 			continue
 		}
 
-		cand, err := webrtc.NewCandidate(address)
+		for _, network := range networks {
-		if err != nil {
+			cand, err := webrtc.NewCandidate(network, address)
-			log.Warn().Err(err).Msg("[webrtc] candidate")
+			if err != nil {
-			continue
+				log.Warn().Err(err).Msg("[webrtc] candidate")
-		}
+				continue
+			}
 
-		md.WithPropertyAttribute(cand)
+			md.WithPropertyAttribute(cand)
+		}
 	}
 
 	if end {

cmd/webrtc/webrtc.go

@@ -22,6 +22,7 @@ func Init() {
 		} `yaml:"webrtc"`
 	}
 
+	cfg.Mod.Listen = ":8555"
 	cfg.Mod.IceServers = []pion.ICEServer{
 		{URLs: []string{"stun:stun.l.google.com:19302"}},
 	}
@@ -112,7 +113,7 @@ func asyncHandler(tr *api.Transport, msg *api.Message) error {
 
 	// 2. AddConsumer, so we get new tracks
 	if err = stream.AddConsumer(conn); err != nil {
-		log.Warn().Err(err).Caller().Send()
+		log.Debug().Err(err).Msg("[webrtc] add consumer")
 		_ = conn.Conn.Close()
 		return err
 	}

pkg/h264/rtp.go

@@ -1,6 +1,7 @@
 package h264
 
 import (
+	"bytes"
 	"encoding/binary"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/pion/rtp"
@@ -27,7 +28,8 @@ func RTPDepay(track *streamer.Track) streamer.WrapperFunc {
 			}
 
 			// Fix TP-Link Tapo TC70: sends SPS and PPS with packet.Marker = true
-			if packet.Marker {
+			// Reolink Duo 2: sends SPS with Marker and PPS without
+			if packet.Marker && len(payload) < 128 {
 				switch NALUType(payload) {
 				case NALUTypeSPS, NALUTypePPS:
 					buf = append(buf, payload...)
@@ -68,9 +70,30 @@ func RTPDepay(track *streamer.Track) streamer.WrapperFunc {
 			if len(buf) > 0 {
 				payload = append(buf, payload...)
 				buf = buf[:0]
+			} else {
+				// some Chinese buggy cameras has single packet with SPS+PPS+IFrame separated by 00 00 00 01
+				// https://github.com/AlexxIT/WebRTC/issues/391
+				// https://github.com/AlexxIT/WebRTC/issues/392
+				for i := 0; i < len(payload); {
+					if i+4 >= len(payload) {
+						break
+					}
+
+					size := bytes.Index(payload[i+4:], []byte{0, 0, 0, 1})
+					if size < 0 {
+						if i == 0 {
+							break
+						}
+						size = len(payload) - (i + 4)
+					}
+
+					binary.BigEndian.PutUint32(payload[i:], uint32(size))
+
+					i += size + 4
+				}
 			}
 
-			//log.Printf("[AVC] %v, len: %d", Types(payload), len(payload))
+			//log.Printf("[AVC] %v, len: %d, ts: %10d, seq: %d", Types(payload), len(payload), packet.Timestamp, packet.SequenceNumber)
 
 			clone := *packet
 			clone.Version = RTPPacketVersionAVC

pkg/homekit/client.go

@@ -1,6 +1,7 @@
 package homekit
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"github.com/AlexxIT/go2rtc/pkg/hap"
@@ -11,6 +12,7 @@ import (
 	"github.com/brutella/hap/rtp"
 	"net"
 	"net/url"
+	"sync/atomic"
 )
 
 type Client struct {
@@ -263,3 +265,19 @@ func (c *Client) getMedias() []*streamer.Media {
 
 	return medias
 }
+
+func (c *Client) MarshalJSON() ([]byte, error) {
+	var recv uint32
+	for _, session := range c.sessions {
+		recv += atomic.LoadUint32(&session.Recv)
+	}
+
+	info := &streamer.Info{
+		Type:   "HomeKit source",
+		URL:    c.conn.URL(),
+		Medias: c.medias,
+		Tracks: c.tracks,
+		Recv:   recv,
+	}
+	return json.Marshal(info)
+}

pkg/httpflv/amf0.go

@@ -0,0 +1,165 @@
+package httpflv
+
+import (
+	"encoding/binary"
+	"errors"
+	"math"
+)
+
+const (
+	TypeNumber byte = iota
+	TypeBoolean
+	TypeString
+	TypeObject
+	TypeEcmaArray = 8
+	TypeObjectEnd = 9
+)
+
+var Err = errors.New("amf0 read error")
+
+// AMF0 spec: http://download.macromedia.com/pub/labs/amf/amf0_spec_121207.pdf
+type AMF0 struct {
+	buf []byte
+	pos int
+}
+
+func NewReader(b []byte) *AMF0 {
+	return &AMF0{buf: b}
+}
+
+func (a *AMF0) ReadMetaData() map[string]interface{} {
+	if b, _ := a.ReadByte(); b != TypeString {
+		return nil
+	}
+	if s, _ := a.ReadString(); s != "onMetaData" {
+		return nil
+	}
+
+	b, _ := a.ReadByte()
+	switch b {
+	case TypeObject:
+		v, _ := a.ReadObject()
+		return v
+	case TypeEcmaArray:
+		v, _ := a.ReadEcmaArray()
+		return v
+	}
+
+	return nil
+}
+
+func (a *AMF0) ReadMap() (map[interface{}]interface{}, error) {
+	dict := make(map[interface{}]interface{})
+
+	for a.pos < len(a.buf) {
+		k, err := a.ReadItem()
+		if err != nil {
+			return nil, err
+		}
+		v, err := a.ReadItem()
+		if err != nil {
+			return nil, err
+		}
+		dict[k] = v
+	}
+
+	return dict, nil
+}
+
+func (a *AMF0) ReadItem() (interface{}, error) {
+	dataType, err := a.ReadByte()
+	if err != nil {
+		return nil, err
+	}
+
+	switch dataType {
+	case TypeNumber:
+		return a.ReadNumber()
+
+	case TypeBoolean:
+		v, err := a.ReadByte()
+		return v != 0, err
+
+	case TypeString:
+		return a.ReadString()
+
+	case TypeObject:
+		return a.ReadObject()
+
+	case TypeObjectEnd:
+		return nil, nil
+	}
+
+	return nil, Err
+}
+
+func (a *AMF0) ReadByte() (byte, error) {
+	if a.pos >= len(a.buf) {
+		return 0, Err
+	}
+
+	v := a.buf[a.pos]
+	a.pos++
+	return v, nil
+}
+
+func (a *AMF0) ReadNumber() (float64, error) {
+	if a.pos+8 >= len(a.buf) {
+		return 0, Err
+	}
+
+	v := binary.BigEndian.Uint64(a.buf[a.pos : a.pos+8])
+	a.pos += 8
+	return math.Float64frombits(v), nil
+}
+
+func (a *AMF0) ReadString() (string, error) {
+	if a.pos+2 >= len(a.buf) {
+		return "", Err
+	}
+
+	size := int(binary.BigEndian.Uint16(a.buf[a.pos:]))
+	a.pos += 2
+
+	if a.pos+size >= len(a.buf) {
+		return "", Err
+	}
+
+	s := string(a.buf[a.pos : a.pos+size])
+	a.pos += size
+
+	return s, nil
+}
+
+func (a *AMF0) ReadObject() (map[string]interface{}, error) {
+	obj := make(map[string]interface{})
+
+	for {
+		k, err := a.ReadString()
+		if err != nil {
+			return nil, err
+		}
+
+		v, err := a.ReadItem()
+		if err != nil {
+			return nil, err
+		}
+
+		if k == "" {
+			break
+		}
+
+		obj[k] = v
+	}
+
+	return obj, nil
+}
+
+func (a *AMF0) ReadEcmaArray() (map[string]interface{}, error) {
+	if a.pos+4 >= len(a.buf) {
+		return nil, Err
+	}
+	a.pos += 4 // skip size
+
+	return a.ReadObject()
+}

pkg/httpflv/flvio.go

@@ -0,0 +1,97 @@
+package httpflv
+
+import (
+	"fmt"
+	"github.com/deepch/vdk/format/flv/flvio"
+	"github.com/deepch/vdk/utils/bits/pio"
+	"io"
+)
+
+// TODO: rewrite all of this someday
+
+func ReadTag(r io.Reader, b []byte) (tag flvio.Tag, ts int32, err error) {
+	if _, err = io.ReadFull(r, b[:flvio.TagHeaderLength]); err != nil {
+		return
+	}
+	var datalen int
+	if tag, ts, datalen, err = flvio.ParseTagHeader(b); err != nil {
+		return
+	}
+
+	data := make([]byte, datalen)
+	if _, err = io.ReadFull(r, data); err != nil {
+		return
+	}
+
+	n, err := ParseHeader(&tag, data)
+	if err != nil {
+		return
+	}
+	tag.Data = data[n:]
+
+	if _, err = io.ReadFull(r, b[:4]); err != nil {
+		return
+	}
+	return
+}
+
+func ParseHeader(self *flvio.Tag, b []byte) (n int, err error) {
+	switch self.Type {
+	case flvio.TAG_AUDIO:
+		return audioParseHeader(self, b)
+
+	case flvio.TAG_VIDEO:
+		return videoParseHeader(self, b)
+	}
+
+	return
+}
+
+func audioParseHeader(tag *flvio.Tag, b []byte) (n int, err error) {
+	if len(b) < n+1 {
+		err = fmt.Errorf("audiodata: parse invalid")
+		return
+	}
+
+	flags := b[n]
+	n++
+	tag.SoundFormat = flags >> 4
+	tag.SoundRate = (flags >> 2) & 0x3
+	tag.SoundSize = (flags >> 1) & 0x1
+	tag.SoundType = flags & 0x1
+
+	switch tag.SoundFormat {
+	case flvio.SOUND_AAC:
+		if len(b) < n+1 {
+			err = fmt.Errorf("audiodata: parse invalid")
+			return
+		}
+		tag.AACPacketType = b[n]
+		n++
+	}
+
+	return
+}
+
+func videoParseHeader(tag *flvio.Tag, b []byte) (n int, err error) {
+	if len(b) < n+1 {
+		err = fmt.Errorf("videodata: parse invalid")
+		return
+	}
+	flags := b[n]
+	tag.FrameType = flags >> 4
+	tag.CodecID = flags & 0xf
+	n++
+
+	if len(b) < n+4 {
+		err = fmt.Errorf("videodata: parse invalid")
+		return
+	}
+	tag.AVCPacketType = b[n]
+	n++
+
+	tag.CompositionTime = pio.I24BE(b[n:])
+	n += 3
+
+	return
+}

pkg/httpflv/httpflv.go

@@ -2,8 +2,9 @@ package httpflv
 
 import (
 	"bufio"
-	"errors"
+	"bytes"
 	"github.com/deepch/vdk/av"
+	"github.com/deepch/vdk/codec/aacparser"
 	"github.com/deepch/vdk/codec/h264parser"
 	"github.com/deepch/vdk/format/flv/flvio"
 	"github.com/deepch/vdk/utils/bits/pio"
@@ -41,8 +42,12 @@ func Accept(res *http.Response) (*Conn, error) {
 		return nil, err
 	}
 
-	if flags&flvio.FILE_HAS_VIDEO == 0 {
+	if flags&flvio.FILE_HAS_VIDEO != 0 {
-		return nil, errors.New("not supported")
+		c.videoIdx = -1
+	}
+
+	if flags&flvio.FILE_HAS_AUDIO != 0 {
+		c.audioIdx = -1
 	}
 
 	if _, err = c.reader.Discard(n); err != nil {
@@ -56,49 +61,154 @@ type Conn struct {
 	conn   io.ReadCloser
 	reader *bufio.Reader
 	buf    []byte
+
+	videoIdx int8
+	audioIdx int8
 }
 
 func (c *Conn) Streams() ([]av.CodecData, error) {
-	for {
+	var video, audio av.CodecData
+
+	// Normal software sends:
+	// 1. Video/audio flag in header
+	// 2. MetaData as first tag (with video/audio codec info)
+	// 3. Video/audio headers in 2nd and 3rd tag
+
+	// Reolink camera sends:
+	// 1. Empty video/audio flag
+	// 2. MedaData without stereo key for AAC
+	// 3. Audio header after Video keyframe tag
+
+	waitVideo := c.videoIdx != 0
+	waitAudio := c.audioIdx != 0
+
+	for i := 0; i < 20; i++ {
 		tag, _, err := flvio.ReadTag(c.reader, c.buf)
 		if err != nil {
 			return nil, err
 		}
 
-		if tag.Type != flvio.TAG_VIDEO || tag.AVCPacketType != flvio.AAC_SEQHDR {
+		//log.Printf("[FLV] type=%d avc=%d aac=%d video=%t audio=%t", tag.Type, tag.AVCPacketType, tag.AACPacketType, video != nil, audio != nil)
-			continue
+
+		switch tag.Type {
+		case flvio.TAG_SCRIPTDATA:
+			if meta := NewReader(tag.Data).ReadMetaData(); meta != nil {
+				waitVideo = meta["videocodecid"] != nil
+
+				// don't wait audio tag because parse all info from MetaData
+				waitAudio = false
+
+				audio = parseAudioConfig(meta)
+			} else {
+				waitVideo = bytes.Contains(tag.Data, []byte("videocodecid"))
+				waitAudio = bytes.Contains(tag.Data, []byte("audiocodecid"))
+			}
+
+		case flvio.TAG_VIDEO:
+			if tag.AVCPacketType == flvio.AVC_SEQHDR {
+				video, _ = h264parser.NewCodecDataFromAVCDecoderConfRecord(tag.Data)
+			}
+			waitVideo = false
+
+		case flvio.TAG_AUDIO:
+			if tag.SoundFormat == flvio.SOUND_AAC && tag.AACPacketType == flvio.AAC_SEQHDR {
+				audio, _ = aacparser.NewCodecDataFromMPEG4AudioConfigBytes(tag.Data)
+			}
+			waitAudio = false
 		}
 
-		stream, err := h264parser.NewCodecDataFromAVCDecoderConfRecord(tag.Data)
+		if !waitVideo && !waitAudio {
-		if err != nil {
+			break
-			return nil, err
 		}
-
-		return []av.CodecData{stream}, nil
 	}
+
+	if video != nil && audio != nil {
+		c.videoIdx = 0
+		c.audioIdx = 1
+		return []av.CodecData{video, audio}, nil
+	} else if video != nil {
+		c.videoIdx = 0
+		c.audioIdx = -1
+		return []av.CodecData{video}, nil
+	} else if audio != nil {
+		c.videoIdx = -1
+		c.audioIdx = 0
+		return []av.CodecData{audio}, nil
+	}
+
+	return nil, nil
 }
 
 func (c *Conn) ReadPacket() (av.Packet, error) {
 	for {
-		tag, ts, err := flvio.ReadTag(c.reader, c.buf)
+		tag, ts, err := ReadTag(c.reader, c.buf)
 		if err != nil {
 			return av.Packet{}, err
 		}
 
-		if tag.Type != flvio.TAG_VIDEO || tag.AVCPacketType != flvio.AVC_NALU {
+		switch tag.Type {
-			continue
+		case flvio.TAG_VIDEO:
-		}
+			if c.videoIdx < 0 || tag.AVCPacketType != flvio.AVC_NALU {
+				continue
+			}
 
-		return av.Packet{
+			//log.Printf("[FLV] %v, len: %d, ts: %10d", h264.Types(tag.Data), len(tag.Data), flvio.TsToTime(ts))
-			Idx:             0,
+
-			Data:            tag.Data,
+			return av.Packet{
-			CompositionTime: flvio.TsToTime(tag.CompositionTime),
+				Idx:             c.videoIdx,
-			IsKeyFrame:      tag.FrameType == flvio.FRAME_KEY,
+				Data:            tag.Data,
-			Time:            flvio.TsToTime(ts),
+				CompositionTime: flvio.TsToTime(tag.CompositionTime),
-		}, nil
+				IsKeyFrame:      tag.FrameType == flvio.FRAME_KEY,
+				Time:            flvio.TsToTime(ts),
+			}, nil
+
+		case flvio.TAG_AUDIO:
+			if c.audioIdx < 0 || tag.SoundFormat != flvio.SOUND_AAC || tag.AACPacketType != flvio.AAC_RAW {
+				continue
+			}
+
+			return av.Packet{Idx: c.audioIdx, Data: tag.Data, Time: flvio.TsToTime(ts)}, nil
+		}
 	}
 }
 
 func (c *Conn) Close() (err error) {
 	return c.conn.Close()
 }
+
+func parseAudioConfig(meta map[string]interface{}) av.CodecData {
+	if meta["audiocodecid"] != float64(10) {
+		return nil
+	}
+
+	config := aacparser.MPEG4AudioConfig{
+		ObjectType: aacparser.AOT_AAC_LC,
+	}
+
+	switch v := meta["audiosamplerate"].(type) {
+	case float64:
+		config.SampleRate = int(v)
+	default:
+		return nil
+	}
+
+	switch meta["stereo"] {
+	case true:
+		config.ChannelConfig = 2
+		config.ChannelLayout = av.CH_STEREO
+	default:
+		// Reolink doesn't have this setting
+		config.ChannelConfig = 1
+		config.ChannelLayout = av.CH_MONO
+	}
+
+	buf := &bytes.Buffer{}
+	if err := aacparser.WriteMPEG4AudioConfig(buf, config); err != nil {
+		return nil
+	}
+
+	return aacparser.CodecData{
+		Config:      config,
+		ConfigBytes: buf.Bytes(),
+	}
+}

pkg/ivideon/client.go

@@ -14,9 +14,19 @@ import (
 	"io"
 	"net/http"
 	"strings"
+	"sync"
+	"sync/atomic"
 	"time"
 )
 
+type State byte
+
+const (
+	StateNone State = iota
+	StateConn
+	StateHandle
+)
+
 type Client struct {
 	streamer.Element
 
@@ -26,12 +36,14 @@ type Client struct {
 	medias []*streamer.Media
 	tracks map[byte]*streamer.Track
 
-	closed bool
-
 	msg *message
 	t0  time.Time
 
 	buffer chan []byte
+	state  State
+	mu     sync.Mutex
+
+	recv uint32
 }
 
 func NewClient(id string) *Client {
@@ -69,16 +81,26 @@ func (c *Client) Dial() (err error) {
 		return err
 	}
 
+	c.state = StateConn
+
 	return nil
 }
 
 func (c *Client) Handle() error {
-	c.buffer = make(chan []byte, 5)
 	// add delay to the stream for smooth playing (not a best solution)
 	c.t0 = time.Now().Add(time.Second)
 
-	// processing stream in separate thread for lower delay between packets
+	c.mu.Lock()
-	go c.worker()
+
+	if c.state == StateConn {
+		c.buffer = make(chan []byte, 5)
+		c.state = StateHandle
+
+		// processing stream in separate thread for lower delay between packets
+		go c.worker(c.buffer)
+	}
+
+	c.mu.Unlock()
 
 	_, data, err := c.conn.ReadMessage()
 	if err != nil {
@@ -87,7 +109,12 @@ func (c *Client) Handle() error {
 
 	track := c.tracks[c.msg.Track]
 	if track != nil {
-		c.buffer <- data
+		c.mu.Lock()
+		if c.state == StateHandle {
+			c.buffer <- data
+			atomic.AddUint32(&c.recv, uint32(len(data)))
+		}
+		c.mu.Unlock()
 	}
 
 	// we have one unprocessed msg after getTracks
@@ -114,7 +141,12 @@ func (c *Client) Handle() error {
 
 			track = c.tracks[msg.Track]
 			if track != nil {
-				c.buffer <- data
+				c.mu.Lock()
+				if c.state == StateHandle {
+					c.buffer <- data
+					atomic.AddUint32(&c.recv, uint32(len(data)))
+				}
+				c.mu.Unlock()
 			}
 
 		default:
@@ -124,13 +156,19 @@ func (c *Client) Handle() error {
 }
 
 func (c *Client) Close() error {
-	if c.conn == nil {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	switch c.state {
+	case StateNone:
 		return nil
-	}
+	case StateConn:
-	if c.buffer != nil {
+	case StateHandle:
 		close(c.buffer)
 	}
-	c.closed = true
+
+	c.state = StateNone
+
 	return c.conn.Close()
 }
 
@@ -210,13 +248,13 @@ func (c *Client) getTracks() error {
 	}
 }
 
-func (c *Client) worker() {
+func (c *Client) worker(buffer chan []byte) {
 	var track *streamer.Track
 	for _, track = range c.tracks {
 		break
 	}
 
-	for data := range c.buffer {
+	for data := range buffer {
 		moof := &fmp4io.MovieFrag{}
 		if _, err := moof.Unmarshal(data, 0); err != nil {
 			continue

pkg/ivideon/streamer.go

@@ -1,8 +1,10 @@
 package ivideon
 
 import (
+	"encoding/json"
 	"fmt"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"sync/atomic"
 )
 
 func (c *Client) GetMedias() []*streamer.Media {
@@ -20,7 +22,7 @@ func (c *Client) GetTrack(media *streamer.Media, codec *streamer.Codec) *streame
 
 func (c *Client) Start() error {
 	err := c.Handle()
-	if c.closed {
+	if c.buffer == nil {
 		return nil
 	}
 	return err
@@ -29,3 +31,19 @@ func (c *Client) Start() error {
 func (c *Client) Stop() error {
 	return c.Close()
 }
+
+func (c *Client) MarshalJSON() ([]byte, error) {
+	var tracks []*streamer.Track
+	for _, track := range c.tracks {
+		tracks = append(tracks, track)
+	}
+
+	info := &streamer.Info{
+		Type:   "Ivideon source",
+		URL:    c.ID,
+		Medias: c.medias,
+		Tracks: tracks,
+		Recv:   atomic.LoadUint32(&c.recv),
+	}
+	return json.Marshal(info)
+}

pkg/mjpeg/client.go

@@ -2,6 +2,7 @@ package mjpeg
 
 import (
 	"bufio"
+	"encoding/json"
 	"errors"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/AlexxIT/go2rtc/pkg/tcp"
@@ -11,6 +12,7 @@ import (
 	"net/textproto"
 	"strconv"
 	"strings"
+	"sync/atomic"
 	"time"
 )
 
@@ -24,6 +26,7 @@ type Client struct {
 	res    *http.Response
 
 	track *streamer.Track
+	recv  uint32
 }
 
 func NewClient(res *http.Response) *Client {
@@ -64,10 +67,23 @@ func (c *Client) Start() error {
 }
 
 func (c *Client) Stop() error {
+	// important for close reader/writer gorutines
+	_ = c.res.Body.Close()
 	c.closed = true
 	return nil
 }
 
+func (c *Client) MarshalJSON() ([]byte, error) {
+	info := &streamer.Info{
+		Type:       "MJPEG source",
+		URL:        c.res.Request.URL.String(),
+		RemoteAddr: c.RemoteAddr,
+		UserAgent:  c.UserAgent,
+		Recv:       atomic.LoadUint32(&c.recv),
+	}
+	return json.Marshal(info)
+}
+
 func (c *Client) startJPEG() error {
 	buf, err := io.ReadAll(c.res.Body)
 	if err != nil {
@@ -77,6 +93,8 @@ func (c *Client) startJPEG() error {
 	packet := &rtp.Packet{Header: rtp.Header{Timestamp: now()}, Payload: buf}
 	_ = c.track.WriteRTP(packet)
 
+	atomic.AddUint32(&c.recv, uint32(len(buf)))
+
 	req := c.res.Request
 
 	for !c.closed {
@@ -96,6 +114,8 @@ func (c *Client) startJPEG() error {
 
 		packet = &rtp.Packet{Header: rtp.Header{Timestamp: now()}, Payload: buf}
 		_ = c.track.WriteRTP(packet)
+
+		atomic.AddUint32(&c.recv, uint32(len(buf)))
 	}
 
 	return nil
@@ -139,6 +159,8 @@ func (c *Client) startMJPEG(boundary string) error {
 		packet := &rtp.Packet{Header: rtp.Header{Timestamp: now()}, Payload: buf}
 		_ = c.track.WriteRTP(packet)
 
+		atomic.AddUint32(&c.recv, uint32(len(buf)))
+
 		if _, err = r.Discard(2); err != nil {
 			return err
 		}

pkg/mjpeg/consumer.go

@@ -1,8 +1,10 @@
 package mjpeg
 
 import (
+	"encoding/json"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/pion/rtp"
+	"sync/atomic"
 )
 
 type Consumer struct {
@@ -14,7 +16,7 @@ type Consumer struct {
 	codecs []*streamer.Codec
 	start  bool
 
-	send int
+	send uint32
 }
 
 func (c *Consumer) GetMedias() []*streamer.Media {
@@ -28,6 +30,7 @@ func (c *Consumer) GetMedias() []*streamer.Media {
 func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *streamer.Track {
 	push := func(packet *rtp.Packet) error {
 		c.Fire(packet.Payload)
+		atomic.AddUint32(&c.send, uint32(len(packet.Payload)))
 		return nil
 	}
 
@@ -38,3 +41,13 @@ func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 
 	return track.Bind(push)
 }
+
+func (c *Consumer) MarshalJSON() ([]byte, error) {
+	info := &streamer.Info{
+		Type:       "MJPEG client",
+		RemoteAddr: c.RemoteAddr,
+		UserAgent:  c.UserAgent,
+		Send:       atomic.LoadUint32(&c.send),
+	}
+	return json.Marshal(info)
+}

pkg/mp4/consumer.go

@@ -7,6 +7,7 @@ import (
 	"github.com/AlexxIT/go2rtc/pkg/h265"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/pion/rtp"
+	"sync/atomic"
 )
 
 type Consumer struct {
@@ -20,7 +21,7 @@ type Consumer struct {
 	codecs []*streamer.Codec
 	wait   byte
 
-	send int
+	send uint32
 }
 
 const (
@@ -76,7 +77,7 @@ func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 			}
 
 			buf := c.muxer.Marshal(trackID, packet)
-			c.send += len(buf)
+			atomic.AddUint32(&c.send, uint32(len(buf)))
 			c.Fire(buf)
 
 			return nil
@@ -108,7 +109,7 @@ func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 			}
 
 			buf := c.muxer.Marshal(trackID, packet)
-			c.send += len(buf)
+			atomic.AddUint32(&c.send, uint32(len(buf)))
 			c.Fire(buf)
 
 			return nil
@@ -128,7 +129,7 @@ func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 			}
 
 			buf := c.muxer.Marshal(trackID, packet)
-			c.send += len(buf)
+			atomic.AddUint32(&c.send, uint32(len(buf)))
 			c.Fire(buf)
 
 			return nil
@@ -163,12 +164,11 @@ func (c *Consumer) Start() {
 //
 
 func (c *Consumer) MarshalJSON() ([]byte, error) {
-	v := map[string]interface{}{
+	info := &streamer.Info{
-		"type":        "MP4 server consumer",
+		Type:       "MP4 client",
-		"send":        c.send,
+		RemoteAddr: c.RemoteAddr,
-		"remote_addr": c.RemoteAddr,
+		UserAgent:  c.UserAgent,
-		"user_agent":  c.UserAgent,
+		Send:       atomic.LoadUint32(&c.send),
 	}
-
+	return json.Marshal(info)
-	return json.Marshal(v)
 }

pkg/mp4/segment.go

@@ -1,18 +1,25 @@
 package mp4
 
 import (
+	"encoding/json"
 	"github.com/AlexxIT/go2rtc/pkg/h264"
 	"github.com/AlexxIT/go2rtc/pkg/h265"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/pion/rtp"
+	"sync/atomic"
 )
 
 type Segment struct {
 	streamer.Element
 
-	Medias       []*streamer.Media
+	Medias     []*streamer.Media
+	UserAgent  string
+	RemoteAddr string
+
 	MimeType     string
 	OnlyKeyframe bool
+
+	send uint32
 }
 
 func (c *Segment) GetMedias() []*streamer.Media {
@@ -56,6 +63,7 @@ func (c *Segment) AddTrack(media *streamer.Media, track *streamer.Track) *stream
 				}
 
 				buf := muxer.Marshal(0, packet)
+				atomic.AddUint32(&c.send, uint32(len(buf)))
 				c.Fire(append(init, buf...))
 
 				return nil
@@ -73,6 +81,7 @@ func (c *Segment) AddTrack(media *streamer.Media, track *streamer.Track) *stream
 						buf = append(buf, b...)
 					}
 
+					atomic.AddUint32(&c.send, uint32(len(buf)))
 					c.Fire(buf)
 
 					buf = buf[:0]
@@ -106,6 +115,7 @@ func (c *Segment) AddTrack(media *streamer.Media, track *streamer.Track) *stream
 			}
 
 			buf := muxer.Marshal(0, packet)
+			atomic.AddUint32(&c.send, uint32(len(buf)))
 			c.Fire(append(init, buf...))
 
 			return nil
@@ -121,3 +131,13 @@ func (c *Segment) AddTrack(media *streamer.Media, track *streamer.Track) *stream
 
 	panic("unsupported codec")
 }
+
+func (c *Segment) MarshalJSON() ([]byte, error) {
+	info := &streamer.Info{
+		Type:       "WS/MP4 client",
+		RemoteAddr: c.RemoteAddr,
+		UserAgent:  c.UserAgent,
+		Send:       atomic.LoadUint32(&c.send),
+	}
+	return json.Marshal(info)
+}

pkg/mp4f/consumer.go

@@ -1,7 +1,6 @@
 package mp4f
 
 import (
-	"encoding/json"
 	"github.com/AlexxIT/go2rtc/pkg/h264"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/deepch/vdk/av"
@@ -15,6 +14,7 @@ import (
 type Consumer struct {
 	streamer.Element
 
+	Medias     []*streamer.Media
 	UserAgent  string
 	RemoteAddr string
 
@@ -27,6 +27,10 @@ type Consumer struct {
 }
 
 func (c *Consumer) GetMedias() []*streamer.Media {
+	if c.Medias != nil {
+		return c.Medias
+	}
+
 	return []*streamer.Media{
 		{
 			Kind:      streamer.KindVideo,
@@ -89,7 +93,7 @@ func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 			return nil
 		}
 
-		if !codec.IsRAW() {
+		if codec.IsRTP() {
 			wrapper := h264.RTPDepay(track)
 			push = wrapper(push)
 		}
@@ -149,16 +153,3 @@ func (c *Consumer) Init() ([]byte, error) {
 func (c *Consumer) Start() {
 	c.start = true
 }
-
-//
-
-func (c *Consumer) MarshalJSON() ([]byte, error) {
-	v := map[string]interface{}{
-		"type":        "MSE server consumer",
-		"send":        c.send,
-		"remote_addr": c.RemoteAddr,
-		"user_agent":  c.UserAgent,
-	}
-
-	return json.Marshal(v)
-}

pkg/rtmp/client.go

@@ -12,6 +12,7 @@ import (
 	"github.com/deepch/vdk/format/rtmp"
 	"github.com/pion/rtp"
 	"net/http"
+	"sync/atomic"
 	"time"
 )
 
@@ -33,7 +34,7 @@ type Client struct {
 	conn   Conn
 	closed bool
 
-	receive int
+	recv uint32
 }
 
 func NewClient(uri string) *Client {
@@ -138,7 +139,7 @@ func (c *Client) Handle() (err error) {
 			return
 		}
 
-		c.receive += len(pkt.Data)
+		atomic.AddUint32(&c.recv, uint32(len(pkt.Data)))
 
 		track := c.tracks[int(pkt.Idx)]
 

pkg/rtmp/streamer.go

@@ -4,7 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
-	"strconv"
+	"sync/atomic"
 )
 
 func (c *Client) GetMedias() []*streamer.Media {
@@ -29,19 +29,12 @@ func (c *Client) Stop() error {
 }
 
 func (c *Client) MarshalJSON() ([]byte, error) {
-	v := map[string]interface{}{
+	info := &streamer.Info{
-		streamer.JSONReceive:    c.receive,
+		Type:   "RTMP source",
-		streamer.JSONType:       "RTMP client producer",
+		URL:    c.URI,
-		//streamer.JSONRemoteAddr: c.conn.NetConn().RemoteAddr().String(),
+		Medias: c.medias,
-		"url":                   c.URI,
+		Tracks: c.tracks,
+		Recv:   atomic.LoadUint32(&c.recv),
 	}
-	for i, media := range c.medias {
+	return json.Marshal(info)
-		k := "media:" + strconv.Itoa(i)
-		v[k] = media.String()
-	}
-	for i, track := range c.tracks {
-		k := "track:" + strconv.Itoa(i)
-		v[k] = track.String()
-	}
-	return json.Marshal(v)
 }

pkg/rtsp/conn.go

@@ -2,7 +2,6 @@ package rtsp
 
 import (
 	"bufio"
-	"bytes"
 	"crypto/tls"
 	"encoding/binary"
 	"errors"
@@ -48,6 +47,22 @@ const (
 
 type State byte
 
+func (s State) String() string {
+	switch s {
+	case StateNone:
+		return "NONE"
+	case StateConn:
+		return "CONN"
+	case StateSetup:
+		return "SETUP"
+	case StatePlay:
+		return "PLAY"
+	case StateHandle:
+		return "HANDLE"
+	}
+	return strconv.Itoa(int(s))
+}
+
 const (
 	StateNone State = iota
 	StateConn
@@ -62,6 +77,7 @@ type Conn struct {
 	// public
 
 	Backchannel bool
+	SessionName string
 
 	Medias    []*streamer.Media
 	Session   string
@@ -264,7 +280,7 @@ func (c *Conn) Options() error {
 	}
 
 	if val := res.Header.Get("Content-Base"); val != "" {
-		c.URL, err = url.Parse(val)
+		c.URL, err = urlParse(val)
 		if err != nil {
 			return err
 		}
@@ -294,7 +310,7 @@ func (c *Conn) Describe() error {
 	}
 
 	if val := res.Header.Get("Content-Base"); val != "" {
-		c.URL, err = url.Parse(val)
+		c.URL, err = urlParse(val)
 		if err != nil {
 			return err
 		}
@@ -346,6 +362,10 @@ func (c *Conn) SetupMedia(
 	c.stateMu.Lock()
 	defer c.stateMu.Unlock()
 
+	if c.state != StateConn && c.state != StateSetup {
+		return nil, fmt.Errorf("RTSP SETUP from wrong state: %s", c.state)
+	}
+
 	ch := c.GetChannel(media)
 	if ch < 0 {
 		return nil, fmt.Errorf("wrong media: %v", media)
@@ -359,7 +379,7 @@ func (c *Conn) SetupMedia(
 		}
 		rawURL += media.Control
 	}
-	trackURL, err := url.Parse(rawURL)
+	trackURL, err := urlParse(rawURL)
 	if err != nil {
 		return nil, err
 	}
@@ -598,7 +618,7 @@ func (c *Conn) Accept() error {
 				medias = append(medias, media)
 			}
 
-			res.Body, err = streamer.MarshalSDP(medias)
+			res.Body, err = streamer.MarshalSDP(c.SessionName, medias)
 			if err != nil {
 				return err
 			}
@@ -634,6 +654,12 @@ func (c *Conn) Accept() error {
 			}
 			return err
 
+		case MethodTeardown:
+			res := &tcp.Response{Request: req}
+			_ = c.Response(res)
+			c.state = StateNone
+			return c.conn.Close()
+
 		default:
 			return fmt.Errorf("unsupported method: %s", req.Method)
 		}
@@ -648,15 +674,17 @@ func (c *Conn) Handle() (err error) {
 	case StatePlay:
 		c.state = StateHandle
 	default:
-		err = fmt.Errorf("RTSP Handle from wrong state: %d", c.state)
+		err = fmt.Errorf("RTSP HANDLE from wrong state: %s", c.state)
 
 		c.state = StateNone
 		_ = c.conn.Close()
 	}
 
+	ok := c.state == StateHandle
+
 	c.stateMu.Unlock()
 
-	if c.state != StateHandle {
+	if !ok {
 		return
 	}
 
@@ -770,12 +798,12 @@ func (c *Conn) Handle() (err error) {
 			msg := &RTCP{Channel: channelID}
 
 			if err = msg.Header.Unmarshal(buf); err != nil {
-				return
+				continue
 			}
 
 			msg.Packets, err = rtcp.Unmarshal(buf)
 			if err != nil {
-				return
+				continue
 			}
 
 			c.Fire(msg)
@@ -853,42 +881,3 @@ func (c *Conn) bindTrack(
 
 	return track.Bind(push)
 }
-
-type RTCP struct {
-	Channel byte
-	Header  rtcp.Header
-	Packets []rtcp.Packet
-}
-
-const sdpHeader = `v=0
-o=- 0 0 IN IP4 0.0.0.0
-s=-
-t=0 0`
-
-func UnmarshalSDP(rawSDP []byte) ([]*streamer.Media, error) {
-	medias, err := streamer.UnmarshalSDP(rawSDP)
-	if err != nil {
-		// fix SDP header for some cameras
-		i := bytes.Index(rawSDP, []byte("\nm="))
-		if i > 0 {
-			rawSDP = append([]byte(sdpHeader), rawSDP[i:]...)
-			medias, err = streamer.UnmarshalSDP(rawSDP)
-		}
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	// fix bug in ONVIF spec
-	// https://www.onvif.org/specs/stream/ONVIF-Streaming-Spec-v241.pdf
-	for _, media := range medias {
-		switch media.Direction {
-		case streamer.DirectionRecvonly, "":
-			media.Direction = streamer.DirectionSendonly
-		case streamer.DirectionSendonly:
-			media.Direction = streamer.DirectionRecvonly
-		}
-	}
-
-	return medias, nil
-}

pkg/rtsp/helpers.go

@@ -0,0 +1,63 @@
+package rtsp
+
+import (
+	"bytes"
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/pion/rtcp"
+	"net/url"
+	"strings"
+)
+
+type RTCP struct {
+	Channel byte
+	Header  rtcp.Header
+	Packets []rtcp.Packet
+}
+
+const sdpHeader = `v=0
+o=- 0 0 IN IP4 0.0.0.0
+s=-
+t=0 0`
+
+func UnmarshalSDP(rawSDP []byte) ([]*streamer.Media, error) {
+	medias, err := streamer.UnmarshalSDP(rawSDP)
+	if err != nil {
+		// fix SDP header for some cameras
+		i := bytes.Index(rawSDP, []byte("\nm="))
+		if i > 0 {
+			rawSDP = append([]byte(sdpHeader), rawSDP[i:]...)
+			medias, err = streamer.UnmarshalSDP(rawSDP)
+		}
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// fix bug in ONVIF spec
+	// https://www.onvif.org/specs/stream/ONVIF-Streaming-Spec-v241.pdf
+	for _, media := range medias {
+		switch media.Direction {
+		case streamer.DirectionRecvonly, "":
+			media.Direction = streamer.DirectionSendonly
+		case streamer.DirectionSendonly:
+			media.Direction = streamer.DirectionRecvonly
+		}
+	}
+
+	return medias, nil
+}
+
+// urlParse fix bug in URL from D-Link camera:
+// Content-Base: rtsp://::ffff:192.168.1.123/onvif/profile.1/
+func urlParse(rawURL string) (*url.URL, error) {
+	u, err := url.Parse(rawURL)
+	if err != nil && strings.HasSuffix(err.Error(), "after host") {
+		if i1 := strings.Index(rawURL, "://"); i1 > 0 {
+			if i2 := strings.IndexByte(rawURL[i1+3:], '/'); i2 > 0 {
+				return urlParse(rawURL[:i1+3+i2] + ":" + rawURL[i1+3+i2:])
+			}
+		}
+	}
+
+	return u, err
+}

pkg/rtsp/rtsp_test.go

@@ -0,0 +1,12 @@
+package rtsp
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestURLParse(t *testing.T) {
+	base := "rtsp://::ffff:192.168.1.123/onvif/profile.1/"
+	_, err := urlParse(base)
+	assert.Empty(t, err)
+}

pkg/rtsp/streamer.go

@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
-	"strconv"
 )
 
 // Element Producer
@@ -88,40 +87,30 @@ func (c *Conn) AddTrack(media *streamer.Media, track *streamer.Track) *streamer.
 //
 
 func (c *Conn) MarshalJSON() ([]byte, error) {
-	v := map[string]interface{}{
+	info := &streamer.Info{
-		streamer.JSONReceive: c.receive,
+		UserAgent: c.UserAgent,
-		streamer.JSONSend:    c.send,
+		Medias:    c.Medias,
+		Tracks:    c.tracks,
+		Recv:      uint32(c.receive),
+		Send:      uint32(c.send),
 	}
+
 	switch c.mode {
 	case ModeUnknown:
-		v[streamer.JSONType] = "RTSP unknown"
+		info.Type = "RTSP unknown"
-	case ModeClientProducer:
+	case ModeClientProducer, ModeServerProducer:
-		v[streamer.JSONType] = "RTSP client producer"
+		info.Type = "RTSP source"
-	case ModeServerProducer:
-		v[streamer.JSONType] = "RTSP server producer"
 	case ModeServerConsumer:
-		v[streamer.JSONType] = "RTSP server consumer"
+		info.Type = "RTSP client"
 	}
-	//if c.URI != "" {
+
-	//	v["uri"] = c.URI
-	//}
 	if c.URL != nil {
-		v["url"] = c.URL.String()
+		info.URL = c.URL.String()
 	}
 	if c.conn != nil {
-		v[streamer.JSONRemoteAddr] = c.conn.RemoteAddr().String()
+		info.RemoteAddr = c.conn.RemoteAddr().String()
-	}
-	if c.UserAgent != "" {
-		v[streamer.JSONUserAgent] = c.UserAgent
-	}
-	for i, media := range c.Medias {
-		k := "media:" + strconv.Itoa(i)
-		v[k] = media.String()
-	}
-	for i, track := range c.tracks {
-		k := "track:" + strconv.Itoa(int(i>>1))
-		v[k] = track.String()
 	}
+
 	//for i, track := range c.tracks {
 	//	k := "track:" + strconv.Itoa(i+1)
 	//	if track.MimeType() == streamer.MimeTypeH264 {
@@ -130,5 +119,6 @@ func (c *Conn) MarshalJSON() ([]byte, error) {
 	//		v[k] = track.MimeType()
 	//	}
 	//}
-	return json.Marshal(v)
+
+	return json.Marshal(info)
 }

pkg/shell/env.go

@@ -0,0 +1,32 @@
+package shell
+
+import (
+	"os"
+	"regexp"
+	"strings"
+)
+
+func ReplaceEnvVars(text string) string {
+	re := regexp.MustCompile(`\${([^}{]+)}`)
+	return re.ReplaceAllStringFunc(text, func(match string) string {
+		key := match[2 : len(match)-1]
+
+		var def string
+		var dok bool
+
+		if i := strings.IndexByte(key, ':'); i > 0 {
+			key, def = key[:i], key[i+1:]
+			dok = true
+		}
+
+		if value, vok := os.LookupEnv(key); vok {
+			return value
+		}
+
+		if dok {
+			return def
+		}
+
+		return match
+	})
+}

pkg/srtp/server.go

@@ -3,6 +3,7 @@ package srtp
 import (
 	"encoding/binary"
 	"net"
+	"sync/atomic"
 )
 
 // Server using same UDP port for SRTP and for SRTCP as the iPhone does
@@ -55,6 +56,8 @@ func (s *Server) Serve(conn net.PacketConn) error {
 				}
 			}
 
+			atomic.AddUint32(&session.Recv, uint32(n))
+
 			if err = session.HandleRTP(buf[:n]); err != nil {
 				return err
 			}

pkg/srtp/session.go

@@ -17,6 +17,7 @@ type Session struct {
 
 	Write func(b []byte) (int, error)
 	Track *streamer.Track
+	Recv  uint32
 
 	lastSequence  uint32
 	lastTimestamp uint32

pkg/streamer/helpers.go

@@ -4,13 +4,16 @@ import (
 	"strings"
 )
 
-const (
+type Info struct {
-	JSONType       = "type"
+	Type       string   `json:"type,omitempty"`
-	JSONRemoteAddr = "remote_addr"
+	URL        string   `json:"url,omitempty"`
-	JSONUserAgent  = "user_agent"
+	RemoteAddr string   `json:"remote_addr,omitempty"`
-	JSONReceive    = "receive"
+	UserAgent  string   `json:"user_agent,omitempty"`
-	JSONSend       = "send"
+	Medias     []*Media `json:"medias,omitempty"`
-)
+	Tracks     []*Track `json:"tracks,omitempty"`
+	Recv       uint32   `json:"recv,omitempty"`
+	Send       uint32   `json:"send,omitempty"`
+}
 
 func Between(s, sub1, sub2 string) string {
 	i := strings.Index(s, sub1)

pkg/streamer/media.go

@@ -1,6 +1,7 @@
 package streamer
 
 import (
+	"encoding/json"
 	"fmt"
 	"github.com/pion/sdp/v3"
 	"strconv"
@@ -70,6 +71,10 @@ func (m *Media) String() string {
 	return s
 }
 
+func (m *Media) MarshalJSON() ([]byte, error) {
+	return json.Marshal(m.String())
+}
+
 func (m *Media) Clone() *Media {
 	clone := *m
 	return &clone
@@ -178,8 +183,22 @@ func UnmarshalSDP(rawSDP []byte) ([]*Media, error) {
 	return medias, nil
 }
 
-func MarshalSDP(medias []*Media) ([]byte, error) {
+func MarshalSDP(name string, medias []*Media) ([]byte, error) {
-	sd := &sdp.SessionDescription{}
+	sd := &sdp.SessionDescription{
+		Origin: sdp.Origin{
+			Username: "-", SessionID: 1, SessionVersion: 1,
+			NetworkType: "IN", AddressType: "IP4", UnicastAddress: "0.0.0.0",
+		},
+		SessionName: sdp.SessionName(name),
+		ConnectionInformation: &sdp.ConnectionInformation{
+			NetworkType: "IN", AddressType: "IP4", Address: &sdp.Address{
+				Address: "0.0.0.0",
+			},
+		},
+		TimeDescriptions: []sdp.TimeDescription{
+			{Timing: sdp.Timing{}},
+		},
+	}
 
 	payloadType := uint8(96)
 

pkg/streamer/media_test.go

@@ -0,0 +1,23 @@
+package streamer
+
+import (
+	"github.com/pion/sdp/v3"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestSDP(t *testing.T) {
+	medias := []*Media{{
+		Kind: KindAudio, Direction: DirectionSendonly,
+		Codecs: []*Codec{
+			{Name: CodecPCMU, ClockRate: 8000},
+		},
+	}}
+
+	data, err := MarshalSDP("go2rtc/1.0.0", medias)
+	assert.Empty(t, err)
+
+	sd := &sdp.SessionDescription{}
+	err = sd.Unmarshal(data)
+	assert.Empty(t, err)
+}

pkg/streamer/track.go

@@ -1,6 +1,7 @@
 package streamer
 
 import (
+	"encoding/json"
 	"fmt"
 	"github.com/pion/rtp"
 	"sync"
@@ -22,12 +23,19 @@ func NewTrack(codec *Codec, direction string) *Track {
 
 func (t *Track) String() string {
 	s := t.Codec.String()
-	t.sinkMu.RLock()
+	if t.sinkMu.TryRLock() {
-	s += fmt.Sprintf(", sinks=%d", len(t.sink))
+		s += fmt.Sprintf(", sinks=%d", len(t.sink))
-	t.sinkMu.RUnlock()
+		t.sinkMu.RUnlock()
+	} else {
+		s += fmt.Sprintf(", sinks=?")
+	}
 	return s
 }
 
+func (t *Track) MarshalJSON() ([]byte, error) {
+	return json.Marshal(t.String())
+}
+
 func (t *Track) WriteRTP(p *rtp.Packet) error {
 	t.sinkMu.RLock()
 	for _, f := range t.sink {

pkg/webrtc/api.go

@@ -35,13 +35,17 @@ func NewAPI(address string) (*webrtc.API, error) {
 	s.SetICEMulticastDNSMode(ice.MulticastDNSModeDisabled)
 
 	if address != "" {
-		ln, err := net.Listen("tcp", address)
+		s.SetNetworkTypes([]webrtc.NetworkType{
-		if err == nil {
+			webrtc.NetworkTypeUDP4, webrtc.NetworkTypeUDP6,
-			s.SetNetworkTypes([]webrtc.NetworkType{
+			webrtc.NetworkTypeTCP4, webrtc.NetworkTypeTCP6,
-				webrtc.NetworkTypeUDP4, webrtc.NetworkTypeUDP6,
+		})
-				webrtc.NetworkTypeTCP4, webrtc.NetworkTypeTCP6,
-			})
 
+		if ln, err := net.ListenPacket("udp", address); err == nil {
+			udpMux := webrtc.NewICEUDPMux(nil, ln)
+			s.SetICEUDPMux(udpMux)
+		}
+
+		if ln, err := net.Listen("tcp", address); err == nil {
 			tcpMux := webrtc.NewICETCPMux(nil, ln, 8)
 			s.SetICETCPMux(tcpMux)
 		}

pkg/webrtc/consumer.go

@@ -113,20 +113,12 @@ func (c *Conn) AddCandidate(candidate string) {
 }
 
 func (c *Conn) MarshalJSON() ([]byte, error) {
-	v := map[string]interface{}{
+	info := &streamer.Info{
-		streamer.JSONType:       "WebRTC server consumer",
+		Type:       "WebRTC client",
-		streamer.JSONRemoteAddr: c.remote(),
+		RemoteAddr: c.remote(),
+		UserAgent:  c.UserAgent,
+		Recv:       uint32(c.receive),
+		Send:       uint32(c.send),
 	}
-
+	return json.Marshal(info)
-	if c.receive > 0 {
-		v[streamer.JSONReceive] = c.receive
-	}
-	if c.send > 0 {
-		v[streamer.JSONSend] = c.send
-	}
-	if c.UserAgent != "" {
-		v[streamer.JSONUserAgent] = c.UserAgent
-	}
-
-	return json.Marshal(v)
 }

pkg/webrtc/helper.go

@@ -13,7 +13,7 @@ import (
 	"time"
 )
 
-func NewCandidate(address string) (string, error) {
+func NewCandidate(network, address string) (string, error) {
 	i := strings.LastIndexByte(address, ':')
 	if i < 0 {
 		return "", errors.New("wrong candidate: " + address)
@@ -25,13 +25,18 @@ func NewCandidate(address string) (string, error) {
 		return "", err
 	}
 
-	cand, err := ice.NewCandidateHost(&ice.CandidateHostConfig{
+	config := &ice.CandidateHostConfig{
-		Network:   "tcp",
+		Network:   network,
 		Address:   host,
 		Port:      i,
 		Component: ice.ComponentRTP,
-		TCPType:   ice.TCPTypePassive,
+	}
-	})
+
+	if network == "tcp" {
+		config.TCPType = ice.TCPTypePassive
+	}
+
+	cand, err := ice.NewCandidateHost(config)
 	if err != nil {
 		return "", err
 	}

www/devices.html

@@ -58,7 +58,7 @@
         0, location.pathname.lastIndexOf("/")
     );
 
-    fetch(`${baseUrl}/api/devices`)
+    fetch(`${baseUrl}/api/devices`, {cache: 'no-cache'})
         .then(r => r.json())
         .then(data => {
             document.querySelector("body > table > tbody").innerHTML =

www/editor.html

@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>File Editor</title>
+    <meta name="viewport" content="width=device-width, user-scalable=yes, initial-scale=1, maximum-scale=1">
+    <meta http-equiv="X-UA-Compatible" content="ie=edge">
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/ace/1.14.0/ace.min.js"></script>
+    <style>
+        body {
+            font-family: Arial, Helvetica, sans-serif;
+        }
+
+        body {
+            margin: 0;
+            padding: 0;
+            display: flex;
+            flex-direction: column;
+        }
+
+        html, body, #config {
+            width: 100%;
+            height: 100%;
+        }
+    </style>
+</head>
+<body>
+<script src="main.js"></script>
+<div>
+    <button id="save">Save & Restart</button>
+</div>
+<br>
+<div id="config"></div>
+<script>
+    ace.config.set('basePath', 'https://cdnjs.cloudflare.com/ajax/libs/ace/1.14.0/');
+    const editor = ace.edit("config", {
+        mode: "ace/mode/yaml",
+    });
+
+    document.getElementById('save').addEventListener('click', () => {
+        fetch('api/config', {
+            method: 'POST', body: editor.getValue()
+        }).then(r => {
+            if (r.ok) {
+                alert('OK');
+                fetch('api/exit', {method: 'POST'});
+            } else {
+                r.text().then(alert);
+            }
+        });
+    });
+
+    window.addEventListener('load', () => {
+        fetch('api/config', {cache: 'no-cache'}).then(r => {
+            if (r.status === 410) {
+                alert('Config file is not set');
+            } else if (r.status === 404) {
+                editor.setValue(''); // config file not exist
+            } else if (r.ok) {
+                r.text().then(data => {
+                    editor.setValue(data);
+                });
+            } else {
+                alert(`Unknown error: ${r.statusText} (${r.status})`);
+            }
+        });
+    })
+</script>
+</body>
+</html>

www/homekit.html

@@ -65,7 +65,7 @@
         0, location.pathname.lastIndexOf("/")
     );
 
-    fetch(`${baseUrl}/api/homekit`)
+    fetch(`${baseUrl}/api/homekit`, {cache: 'no-cache'})
         .then(r => r.json())
         .then(data => {
             document.querySelector("body > table > tbody").innerHTML =

www/index.html

@@ -10,6 +10,7 @@
     <style>
         body {
             font-family: Arial, Helvetica, sans-serif;
+            background-color: white;
         }
 
         table {
@@ -61,6 +62,7 @@
 </head>
 <body>
 <script src="main.js"></script>
+<div class="info"></div>
 <div class="header">
     <input id="src" type="text" placeholder="url">
     <a id="add" href="#">add</a>
@@ -89,7 +91,6 @@
         '<a href="webrtc.html?src={name}">2-way-aud</a>',
         '<a href="api/stream.mp4?src={name}">mp4</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>',
     ];
@@ -132,11 +133,11 @@
 
     function reload() {
         const url = new URL("api/streams", location.href);
-        fetch(url).then(r => r.json()).then(data => {
+        fetch(url, {cache: 'no-cache'}).then(r => r.json()).then(data => {
             tbody.innerHTML = "";
 
             for (const [name, value] of Object.entries(data)) {
-                const online = value ? value.length : 0;
+                const online = value && value.consumers ? value.consumers.length : 0;
                 const links = templates.map(link => {
                     return link.replace("{name}", encodeURIComponent(name));
                 }).join(" ");
@@ -151,7 +152,21 @@
         });
     }
 
-    reload();
+    const url = new URL("api", location.href);
+    fetch(url, {cache: 'no-cache'}).then(r => r.json()).then(data => {
+        const info = document.querySelector(".info");
+        info.innerText = `Version: ${data.version}, Config: ${data.config_path}`;
+
+        try {
+            const host = data.host.match(/^[^:]+/)[0];
+            const port = data.rtsp.listen.match(/[0-9]+$/)[0];
+            templates.splice(4, 0, `<a href="rtsp://${host}:${port}/{name}">rtsp</a>`);
+        } catch (e) {
+            templates.splice(4, 0, `<a href="rtsp://${location.host}:8554/{name}">rtsp</a>`);
+        }
+
+        reload();
+    });
 </script>
 </body>
 </html>

www/main.js

@@ -47,6 +47,7 @@ nav li {
         <li><a href="index.html">Streams</a></li>
         <li><a href="devices.html">Devices</a></li>
         <li><a href="homekit.html">HomeKit</a></li>
+        <li><a href="editor.html">Config</a></li>
     </ul>
 </nav>
 ` + document.body.innerHTML;

www/video-rtc.js

@@ -228,16 +228,12 @@ export class VideoRTC extends HTMLElement {
         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%"
 
+        this.appendChild(this.video);
+
         if (this.background) return;
 
         if ("hidden" in document && this.visibilityCheck) {
@@ -392,21 +388,23 @@ export class VideoRTC extends HTMLElement {
             sb.mode = "segments"; // segments or sequence
             sb.addEventListener("updateend", () => {
                 if (sb.updating) return;
-                if (bufLen > 0) {
+
-                    try {
+                try {
-                        sb.appendBuffer(buf.slice(0, bufLen));
+                    if (bufLen > 0) {
-                    } catch (e) {
+                        const data = buf.slice(0, bufLen);
-                        // console.debug(e);
+                        bufLen = 0;
+                        sb.appendBuffer(data);
+                    } else if (sb.buffered && sb.buffered.length) {
+                        const end = sb.buffered.end(sb.buffered.length - 1) - 15;
+                        const start = sb.buffered.start(0);
+                        if (end > start) {
+                            sb.remove(start, end);
+                            ms.setLiveSeekableRange(end, end + 15);
+                        }
+                        // console.debug("VideoRTC.buffered", start, end);
                     }
-                    bufLen = 0;
+                } catch (e) {
-                } else if (sb.buffered && sb.buffered.length) {
+                    // console.debug(e);
-                    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);
                 }
             });
 
@@ -504,6 +502,8 @@ export class VideoRTC extends HTMLElement {
      * @param ev {Event}
      */
     onpcvideo(ev) {
+        if (!this.pc) return;
+
         /** @type {HTMLVideoElement} */
         const video2 = ev.target;
         const state = this.pc.connectionState;
@@ -543,46 +543,42 @@ export class VideoRTC extends HTMLElement {
 
     onmjpeg() {
         this.ondata = data => {
+            this.video.controls = false;
             this.video.poster = "data:image/jpeg;base64," + VideoRTC.btoa(data);
         };
 
         this.send({type: "mjpeg"});
-        this.video.controls = false;
     }
 
     onmp4() {
-        /** @type {HTMLVideoElement} */
+        /** @type {HTMLCanvasElement} **/
-        let video2;
+        const canvas = document.createElement("canvas");
+        /** @type {CanvasRenderingContext2D} */
+        let context;
 
-        this.ondata = data => {
+        /** @type {HTMLVideoElement} */
-            // first video with default position (set container size)
+        const video2 = document.createElement("video");
-            // second video with position=absolute and top=0px
+        video2.autoplay = true;
-            if (video2) {
+        video2.muted = true;
-                this.removeChild(this.video);
+
-                this.video.src = "";
+        video2.addEventListener("loadeddata", ev => {
-                this.video = video2;
+            if (!context) {
-                video2.style.position = "";
+                canvas.width = video2.videoWidth;
-                video2.style.top = "";
+                canvas.height = video2.videoHeight;
+                context = canvas.getContext('2d');
             }
 
-            video2 = this.video.cloneNode();
+            context.drawImage(video2, 0, 0, canvas.width, canvas.height);
-            video2.style.position = "absolute";
-            video2.style.top = "0px";
-            this.appendChild(video2);
 
-            video2.src = "data:video/mp4;base64," + VideoRTC.btoa(data);
+            this.video.controls = false;
-            video2.play().catch(() => console.log);
+            this.video.poster = canvas.toDataURL("image/jpeg");
-        };
-
-        this.ws.addEventListener("close", () => {
-            if (!video2) return;
-
-            this.removeChild(video2);
-            video2.src = "";
         });
 
+        this.ondata = data => {
+            video2.src = "data:video/mp4;base64," + VideoRTC.btoa(data);
+        };
+
         this.send({type: "mp4", value: this.codecs("mp4")});
-        this.video.controls = false;
     }
 
     static btoa(buffer) {

www/video-stream.js

@@ -22,6 +22,9 @@ class VideoStream extends VideoRTC {
 
         this.innerHTML = `
         <style>
+        video-stream {
+            position: relative;
+        }
         .info {
             position: absolute;
             top: 0;