Merge pull request #1716 from gudaja/fix/getScreenshotFromNonconfigurreCamera

Fix: Handle RTSP cameras requiring fragment-implied config in dynamic snapshot API

.github/workflows/build.yml

@@ -0,0 +1,280 @@
+name: Build and Push
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - 'master'
+    tags:
+      - 'v*'
+
+jobs:
+  build-binaries:
+    name: Build binaries
+    runs-on: ubuntu-latest
+    env: { CGO_ENABLED: 0 }
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with: { go-version: '1.24' }
+
+      - name: Build go2rtc_win64
+        env: { GOOS: windows, GOARCH: amd64 }
+        run: go build -ldflags "-s -w" -trimpath
+      - name: Upload go2rtc_win64
+        uses: actions/upload-artifact@v4
+        with: { name: go2rtc_win64, path: go2rtc.exe }
+
+      - name: Build go2rtc_win32
+        env: { GOOS: windows, GOARCH: 386, GOTOOLCHAIN: go1.20.14 }
+        run: go build -ldflags "-s -w" -trimpath
+      - name: Upload go2rtc_win32
+        uses: actions/upload-artifact@v4
+        with: { name: go2rtc_win32, path: go2rtc.exe }
+
+      - name: Build go2rtc_win_arm64
+        env: { GOOS: windows, GOARCH: arm64 }
+        run: go build -ldflags "-s -w" -trimpath
+      - name: Upload go2rtc_win_arm64
+        uses: actions/upload-artifact@v4
+        with: { name: go2rtc_win_arm64, path: go2rtc.exe }
+
+      - name: Build go2rtc_linux_amd64
+        env: { GOOS: linux, GOARCH: amd64 }
+        run: go build -ldflags "-s -w" -trimpath
+      - name: Upload go2rtc_linux_amd64
+        uses: actions/upload-artifact@v4
+        with: { name: go2rtc_linux_amd64, path: go2rtc }
+
+      - name: Build go2rtc_linux_i386
+        env: { GOOS: linux, GOARCH: 386 }
+        run: go build -ldflags "-s -w" -trimpath
+      - name: Upload go2rtc_linux_i386
+        uses: actions/upload-artifact@v4
+        with: { name: go2rtc_linux_i386, path: go2rtc }
+
+      - name: Build go2rtc_linux_arm64
+        env: { GOOS: linux, GOARCH: arm64 }
+        run: go build -ldflags "-s -w" -trimpath
+      - name: Upload go2rtc_linux_arm64
+        uses: actions/upload-artifact@v4
+        with: { name: go2rtc_linux_arm64, path: go2rtc }
+
+      - name: Build go2rtc_linux_arm
+        env: { GOOS: linux, GOARCH: arm, GOARM: 7 }
+        run: go build -ldflags "-s -w" -trimpath
+      - name: Upload go2rtc_linux_arm
+        uses: actions/upload-artifact@v4
+        with: { name: go2rtc_linux_arm, path: go2rtc }
+
+      - name: Build go2rtc_linux_armv6
+        env: { GOOS: linux, GOARCH: arm, GOARM: 6 }
+        run: go build -ldflags "-s -w" -trimpath
+      - name: Upload go2rtc_linux_armv6
+        uses: actions/upload-artifact@v4
+        with: { name: go2rtc_linux_armv6, path: go2rtc }
+
+      - name: Build go2rtc_linux_mipsel
+        env: { GOOS: linux, GOARCH: mipsle }
+        run: go build -ldflags "-s -w" -trimpath
+      - name: Upload go2rtc_linux_mipsel
+        uses: actions/upload-artifact@v4
+        with: { name: go2rtc_linux_mipsel, path: go2rtc }
+
+      - name: Build go2rtc_mac_amd64
+        env: { GOOS: darwin, GOARCH: amd64, GOTOOLCHAIN: go1.20.14 }
+        run: go build -ldflags "-s -w" -trimpath
+      - name: Upload go2rtc_mac_amd64
+        uses: actions/upload-artifact@v4
+        with: { name: go2rtc_mac_amd64, path: go2rtc }
+
+      - name: Build go2rtc_mac_arm64
+        env: { GOOS: darwin, GOARCH: arm64 }
+        run: go build -ldflags "-s -w" -trimpath
+      - name: Upload go2rtc_mac_arm64
+        uses: actions/upload-artifact@v4
+        with: { name: go2rtc_mac_arm64, path: go2rtc }
+
+      - name: Build go2rtc_freebsd_amd64
+        env: { GOOS: freebsd, GOARCH: amd64 }
+        run: go build -ldflags "-s -w" -trimpath
+      - name: Upload go2rtc_freebsd_amd64
+        uses: actions/upload-artifact@v4
+        with: { name: go2rtc_freebsd_amd64, path: go2rtc }
+
+      - name: Build go2rtc_freebsd_arm64
+        env: { GOOS: freebsd, GOARCH: arm64 }
+        run: go build -ldflags "-s -w" -trimpath
+      - name: Upload go2rtc_freebsd_arm64
+        uses: actions/upload-artifact@v4
+        with: { name: go2rtc_freebsd_arm64, path: go2rtc }
+
+  docker-master:
+    name: Build docker master
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: |
+            ${{ github.repository }}
+            ghcr.io/${{ github.repository }}
+          tags: |
+            type=ref,event=branch
+            type=semver,pattern={{version}},enable=false
+            type=match,pattern=v(.*),group=1
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to DockerHub
+        if: github.event_name != 'pull_request'
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Login to GitHub Container Registry
+        if: github.event_name != 'pull_request'
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: docker/Dockerfile
+          platforms: |
+            linux/amd64
+            linux/386
+            linux/arm/v6
+            linux/arm/v7
+            linux/arm64/v8
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+  docker-hardware:
+    name: Build docker hardware
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Docker meta
+        id: meta-hw
+        uses: docker/metadata-action@v5
+        with:
+          images: |
+            ${{ github.repository }}
+            ghcr.io/${{ github.repository }}
+          flavor: |
+            suffix=-hardware,onlatest=true
+            latest=auto
+          tags: |
+            type=ref,event=branch
+            type=semver,pattern={{version}},enable=false
+            type=match,pattern=v(.*),group=1
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to DockerHub
+        if: github.event_name != 'pull_request'
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      
+      - name: Login to GitHub Container Registry
+        if: github.event_name != 'pull_request'
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: docker/hardware.Dockerfile
+          platforms: linux/amd64
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.meta-hw.outputs.tags }}
+          labels: ${{ steps.meta-hw.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+  docker-rockchip:
+    name: Build docker rockchip
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Docker meta
+        id: meta-rk
+        uses: docker/metadata-action@v5
+        with:
+          images: |
+            ${{ github.repository }}
+            ghcr.io/${{ github.repository }}
+          flavor: |
+            suffix=-rockchip,onlatest=true
+            latest=auto
+          tags: |
+            type=ref,event=branch
+            type=semver,pattern={{version}},enable=false
+            type=match,pattern=v(.*),group=1
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to DockerHub
+        if: github.event_name != 'pull_request'
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Login to GitHub Container Registry
+        if: github.event_name != 'pull_request'
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: docker/rockchip.Dockerfile
+          platforms: linux/arm64
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.meta-rk.outputs.tags }}
+          labels: ${{ steps.meta-rk.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

.github/workflows/docker.yml

@@ -1,78 +0,0 @@
-name: docker
-
-on:
-  workflow_dispatch:
-  push:
-    branches:
-      - 'master'
-    tags:
-      - 'v*'
-
-jobs:
-  build-and-push:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Docker meta
-        id: meta
-        uses: docker/metadata-action@v4
-        with:
-          images: ${{ github.repository }}
-          tags: |
-            type=ref,event=branch
-            type=semver,pattern={{version}},enable=false
-            type=match,pattern=v(.*),group=1
-
-      - name: Docker meta Hardware
-        id: meta-hw
-        uses: docker/metadata-action@v4
-        with:
-          images: ${{ github.repository }}
-          flavor: |
-            suffix=-hardware
-            latest=false
-          tags: |
-            type=ref,event=branch
-            type=semver,pattern={{version}},enable=false
-            type=match,pattern=v(.*),group=1
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-
-      - name: Login to DockerHub
-        if: github.event_name != 'pull_request'
-        uses: docker/login-action@v2
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Build and push
-        uses: docker/build-push-action@v4
-        with:
-          context: .
-          platforms: |
-            linux/amd64
-            linux/386
-            linux/arm/v7
-            linux/arm64/v8
-          push: ${{ github.event_name != 'pull_request' }}
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
-      - name: Build and push Hardware
-        uses: docker/build-push-action@v4
-        with:
-          context: .
-          file: hardware.Dockerfile
-          platforms: linux/amd64
-          push: ${{ github.event_name != 'pull_request' }}
-          tags: ${{ steps.meta-hw.outputs.tags }}
-          labels: ${{ steps.meta-hw.outputs.labels }}
-          cache-from: type=gha
-          cache-to: type=gha,mode=max

.github/workflows/gh-pages.yml

@@ -25,13 +25,13 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Setup Pages
-        uses: actions/configure-pages@v3
+        uses: actions/configure-pages@v4
       - name: Upload artifact
-        uses: actions/upload-pages-artifact@v1
+        uses: actions/upload-pages-artifact@v3
         with:
           path: './website'
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@v2
+        uses: actions/deploy-pages@v4

.github/workflows/release.yml

@@ -1,99 +0,0 @@
-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: install lipo
-        run: |
-          curl -L -o /tmp/lipo https://github.com/konoui/lipo/releases/latest/download/lipo_Linux_amd64
-          chmod +x /tmp/lipo
-          mv /tmp/lipo /usr/local/bin
-      - name: Build Go binaries
-        run: |
-          #!/bin/bash
-          
-          export CGO_ENABLED=0
-          
-          mkdir -p 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
-          go build -ldflags "-s -w" -trimpath -o go2rtc.amd64
-          
-          export GOOS=darwin
-          export GOARCH=arm64
-          go build -ldflags "-s -w" -trimpath -o go2rtc.arm64
-
-          export FILENAME=artifacts/go2rtc_mac_universal.zip
-          lipo -output go2rtc -create go2rtc.arm64 go2rtc.amd64 && 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

.github/workflows/test.yml

@@ -1,11 +1,11 @@
 name: Test Build and Run
 
 on:
-  push:
-    branches:
-      - '*'
-  pull_request:
-  merge_group:
+#  push:
+#    branches:
+#      - '*'
+#  pull_request:
+#  merge_group:
   workflow_dispatch:
 
 jobs:
@@ -21,12 +21,12 @@ jobs:
       GOARCH: ${{ matrix.arch }}
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       - name: Setup Go
-        uses: actions/setup-go@v2
+        uses: actions/setup-go@v5
         with:
-          go-version: '1.20'
+          go-version: '1.24'
 
       - name: Build Go binary
         run: go build -ldflags "-s -w" -trimpath -o ./go2rtc
@@ -70,15 +70,16 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
+        uses: docker/setup-qemu-action@v3
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
+        uses: docker/setup-buildx-action@v3
       - name: Build and push
-        uses: docker/build-push-action@v4
+        uses: docker/build-push-action@v5
         with:
           context: .
+          file: docker/Dockerfile
           platforms: linux/${{ matrix.platform }}
           push: false
           load: true
@@ -89,10 +90,10 @@ jobs:
 
       - name: Build and push Hardware
         if: matrix.platform == 'amd64'
-        uses: docker/build-push-action@v4
+        uses: docker/build-push-action@v5
         with:
           context: .
-          file: hardware.Dockerfile
+          file: docker/hardware.Dockerfile
           platforms: linux/amd64
           push: false
           load: true

.gitignore

@@ -1,8 +1,14 @@
-
 .idea/
-
 .tmp/
 
 go2rtc.yaml
-
 go2rtc.json
+
+go2rtc_freebsd*
+go2rtc_linux*
+go2rtc_mac*
+go2rtc_win*
+
+0_test.go
+
+.DS_Store

README.md

@@ -1,8 +1,12 @@
-# go2rtc
+<h1 align="center">
 
-[![](https://img.shields.io/github/stars/AlexxIT/go2rtc?style=flat-square&logo=github)](https://github.com/AlexxIT/go2rtc/stargazers) 
-[![](https://img.shields.io/docker/pulls/alexxit/go2rtc?style=flat-square&logo=docker&logoColor=white&label=pulls)](https://hub.docker.com/r/alexxit/go2rtc) 
-[![](https://img.shields.io/github/downloads/AlexxIT/go2rtc/total?color=blue&style=flat-square&logo=github)](https://github.com/AlexxIT/go2rtc/releases)
+  ![go2rtc](assets/logo.gif)
+  <br>
+  [![stars](https://img.shields.io/github/stars/AlexxIT/go2rtc?style=flat-square&logo=github)](https://github.com/AlexxIT/go2rtc/stargazers) 
+  [![docker pulls](https://img.shields.io/docker/pulls/alexxit/go2rtc?style=flat-square&logo=docker&logoColor=white&label=pulls)](https://hub.docker.com/r/alexxit/go2rtc) 
+  [![releases](https://img.shields.io/github/downloads/AlexxIT/go2rtc/total?color=blue&style=flat-square&logo=github)](https://github.com/AlexxIT/go2rtc/releases)
+  [![goreport](https://goreportcard.com/badge/github.com/AlexxIT/go2rtc)](https://goreportcard.com/report/github.com/AlexxIT/go2rtc)
+</h1>
 
 Ultimate camera streaming application with support RTSP, WebRTC, HomeKit, FFmpeg, RTMP, etc.
 
@@ -12,16 +16,17 @@ Ultimate camera streaming application with support RTSP, WebRTC, HomeKit, FFmpeg
 - zero-delay for many supported protocols (lowest possible streaming latency)
 - streaming from [RTSP](#source-rtsp), [RTMP](#source-rtmp), [DVRIP](#source-dvrip), [HTTP](#source-http) (FLV/MJPEG/JPEG/TS), [USB Cameras](#source-ffmpeg-device) and [other sources](#module-streams)
 - streaming from any sources, supported by [FFmpeg](#source-ffmpeg)
-- streaming to [RTSP](#module-rtsp), [WebRTC](#module-webrtc), [MSE/MP4](#module-mp4), [HLS](#module-hls) or [MJPEG](#module-mjpeg)
+- streaming to [RTSP](#module-rtsp), [WebRTC](#module-webrtc), [MSE/MP4](#module-mp4), [HomeKit](#module-homekit) [HLS](#module-hls) or [MJPEG](#module-mjpeg)
+- [publish](#publish-stream) any source to popular streaming services (YouTube, Telegram, etc.)
 - 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 (Safari only, [read more](https://github.com/AlexxIT/Blog/issues/5))
+- 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)
 - play audio files and live streams on some cameras with [speaker](#stream-to-camera)
 - multi-source 2-way [codecs negotiation](#codecs-negotiation)
    - mixing tracks from different sources to single stream
    - auto match client supported codecs
    - [2-way audio](#two-way-audio) for some cameras
-- streaming from private networks via [Ngrok](#module-ngrok)
+- streaming from private networks via [ngrok](#module-ngrok)
 - can be [integrated to](#module-api) any smart home platform or be used as [standalone app](#go2rtc-binary)
 
 **Inspired by:**
@@ -32,6 +37,7 @@ Ultimate camera streaming application with support RTSP, WebRTC, HomeKit, FFmpeg
 - [GStreamer](https://gstreamer.freedesktop.org/) framework pipeline idea
 - [MediaSoup](https://mediasoup.org/) framework routing idea
 - HomeKit Accessory Protocol from [@brutella](https://github.com/brutella/hap)
+- creator of the project's logo [@v_novoseltsev](https://www.instagram.com/v_novoseltsev) 
 
 ---
 
@@ -40,6 +46,7 @@ Ultimate camera streaming application with support RTSP, WebRTC, HomeKit, FFmpeg
   * [go2rtc: Docker](#go2rtc-docker)
   * [go2rtc: Home Assistant Add-on](#go2rtc-home-assistant-add-on)
   * [go2rtc: Home Assistant Integration](#go2rtc-home-assistant-integration)
+  * [go2rtc: Dev version](#go2rtc-dev-version)
 * [Configuration](#configuration)
   * [Module: Streams](#module-streams)
     * [Two way audio](#two-way-audio)
@@ -51,10 +58,13 @@ Ultimate camera streaming application with support RTSP, WebRTC, HomeKit, FFmpeg
     * [Source: FFmpeg Device](#source-ffmpeg-device)
     * [Source: Exec](#source-exec)
     * [Source: Echo](#source-echo)
+    * [Source: Expr](#source-expr)
     * [Source: HomeKit](#source-homekit)
     * [Source: Bubble](#source-bubble)
     * [Source: DVRIP](#source-dvrip)
     * [Source: Tapo](#source-tapo)
+    * [Source: Kasa](#source-kasa)
+    * [Source: GoPro](#source-gopro)
     * [Source: Ivideon](#source-ivideon)
     * [Source: Hass](#source-hass)
     * [Source: ISAPI](#source-isapi)
@@ -64,11 +74,14 @@ Ultimate camera streaming application with support RTSP, WebRTC, HomeKit, FFmpeg
     * [Source: WebTorrent](#source-webtorrent)
     * [Incoming sources](#incoming-sources)
     * [Stream to camera](#stream-to-camera)
+    * [Publish stream](#publish-stream)
   * [Module: API](#module-api)
   * [Module: RTSP](#module-rtsp)
+  * [Module: RTMP](#module-rtmp)
   * [Module: WebRTC](#module-webrtc)
+  * [Module: HomeKit](#module-homekit)
   * [Module: WebTorrent](#module-webtorrent)
-  * [Module: Ngrok](#module-ngrok)
+  * [Module: ngrok](#module-ngrok)
   * [Module: Hass](#module-hass)
   * [Module: MP4](#module-mp4)
   * [Module: HLS](#module-hls)
@@ -102,23 +115,25 @@ Ultimate camera streaming application with support RTSP, WebRTC, HomeKit, FFmpeg
 
 Download binary for your OS from [latest release](https://github.com/AlexxIT/go2rtc/releases/):
 
-- `go2rtc_win64.zip` - Windows 64-bit
-- `go2rtc_win32.zip` - Windows 32-bit
+- `go2rtc_win64.zip` - Windows 10+ 64-bit
+- `go2rtc_win32.zip` - Windows 7+ 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)
 - `go2rtc_linux_arm` - Linux ARM 32-bit (ex. Raspberry 32-bit OS)
 - `go2rtc_linux_armv6` - Linux ARMv6 (for old Raspberry 1 and Zero)
-- `go2rtc_linux_mipsel` - Linux MIPS (ex. [Xiaomi Gateway 3](https://github.com/AlexxIT/XiaomiGateway3))
-- `go2rtc_mac_amd64.zip` - Mac Intel 64-bit
-- `go2rtc_mac_arm64.zip` - Mac ARM 64-bit
+- `go2rtc_linux_mipsel` - Linux MIPS (ex. [Xiaomi Gateway 3](https://github.com/AlexxIT/XiaomiGateway3), [Wyze cameras](https://github.com/gtxaspec/wz_mini_hacks))
+- `go2rtc_mac_amd64.zip` - macOS 10.13+ Intel 64-bit
+- `go2rtc_mac_arm64.zip` - macOS ARM 64-bit
+- `go2rtc_freebsd_amd64.zip` - FreeBSD 64-bit
+- `go2rtc_freebsd_arm64.zip` - FreeBSD ARM 64-bit
 
 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 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).
+The Docker container [`alexxit/go2rtc`](https://hub.docker.com/r/alexxit/go2rtc) supports multiple architectures including `amd64`, `386`, `arm64`, and `arm`. This container offers the same functionality as the [Home Assistant Add-on](#go2rtc-home-assistant-add-on) but is designed to operate independently of Home Assistant. It comes preinstalled with [FFmpeg](#source-ffmpeg), [ngrok](#module-ngrok), and [Python](#source-echo).
 
 ### go2rtc: Home Assistant Add-on
 
@@ -133,9 +148,17 @@ Container [alexxit/go2rtc](https://hub.docker.com/r/alexxit/go2rtc) with support
 
 [WebRTC Camera](https://github.com/AlexxIT/WebRTC) custom component can be used on any [Home Assistant installation](https://www.home-assistant.io/installation/), including [HassWP](https://github.com/AlexxIT/HassWP) on Windows. It can automatically download and use the latest version of go2rtc. Or it can connect to an existing version of go2rtc. Addon installation in this case is optional.
 
+### go2rtc: Dev version
+
+Latest, but maybe unstable version:
+
+- Binary: [latest nightly release](https://nightly.link/AlexxIT/go2rtc/workflows/build/master)
+- Docker: `alexxit/go2rtc:master` or `alexxit/go2rtc:master-hardware` versions
+- Hass Add-on: `go2rtc master` or `go2rtc master hardware` versions
+
 ## Configuration
 
-- by default go2rtc will search `go2rtc.yaml` in the current work dirrectory
+- by default go2rtc will search `go2rtc.yaml` in the current work directory
 - `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
@@ -149,11 +172,11 @@ 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 Server
+- [mp4](#module-mp4) - MSE, MP4 stream and MP4 snapshot Server
 - [hls](#module-hls) - HLS TS or fMP4 stream Server
 - [mjpeg](#module-mjpeg) - MJPEG Server
 - [ffmpeg](#source-ffmpeg) - FFmpeg integration
-- [ngrok](#module-ngrok) - Ngrok integration (external access for private network)
+- [ngrok](#module-ngrok) - ngrok integration (external access for private network)
 - [hass](#module-hass) - Home Assistant integration
 - [log](#module-log) - logs config
 
@@ -171,10 +194,13 @@ Available source types:
 - [ffmpeg:device](#source-ffmpeg-device) - local USB Camera or Webcam
 - [exec](#source-exec) - get media from external app output
 - [echo](#source-echo) - get stream link from bash or python
+- [expr](#source-expr) - get stream link via built-in expression language
 - [homekit](#source-homekit) - streaming from HomeKit Camera
 - [bubble](#source-bubble) - streaming from ESeeCloud/dvr163 NVR
 - [dvrip](#source-dvrip) - streaming from DVR-IP NVR
 - [tapo](#source-tapo) - TP-Link Tapo cameras with [two way audio](#two-way-audio) support
+- [kasa](#source-tapo) - TP-Link Kasa cameras
+- [gopro](#source-gopro) - GoPro cameras
 - [ivideon](#source-ivideon) - public cameras from [Ivideon](https://tv.ivideon.com/) service
 - [hass](#source-hass) - Home Assistant integration
 - [isapi](#source-isapi) - two way audio for Hikvision (ISAPI) cameras
@@ -189,9 +215,11 @@ Read more about [incoming sources](#incoming-sources)
 Supported for sources:
 
 - [RTSP cameras](#source-rtsp) with [ONVIF Profile T](https://www.onvif.org/specs/stream/ONVIF-Streaming-Spec.pdf) (back channel connection)
+- [DVRIP](#source-dvrip) cameras
 - [TP-Link Tapo](#source-tapo) cameras
 - [Hikvision ISAPI](#source-isapi) cameras
 - [Roborock vacuums](#source-roborock) models with cameras
+- [Exec](#source-exec) audio on server
 - [Any Browser](#incoming-browser) as IP-camera
 
 Two way audio can be used in browser with [WebRTC](#module-webrtc) technology. The browser will give access to the microphone only for HTTPS sites ([read more](https://stackoverflow.com/questions/52759992/how-to-access-camera-and-microphone-in-chrome-without-https)).
@@ -205,23 +233,33 @@ streams:
   sonoff_camera: rtsp://rtsp:12345678@192.168.1.123/av_stream/ch0
   dahua_camera:
     - rtsp://admin:password@192.168.1.123/cam/realmonitor?channel=1&subtype=0&unicast=true&proto=Onvif
-    - rtsp://admin:password@192.168.1.123/cam/realmonitor?channel=1&subtype=1
+    - rtsp://admin:password@192.168.1.123/cam/realmonitor?channel=1&subtype=1#backchannel=0
   amcrest_doorbell:
     - rtsp://username:password@192.168.1.123:554/cam/realmonitor?channel=1&subtype=0#backchannel=0
   unifi_camera: rtspx://192.168.1.123:7441/fD6ouM72bWoFijxK
-  glichy_camera: ffmpeg:rstp://username:password@192.168.1.123/live/ch00_1 
+  glichy_camera: ffmpeg:rtsp://username:password@192.168.1.123/live/ch00_1 
 ```
 
 **Recommendations**
 
 - **Amcrest Doorbell** users may want to disable two way audio, because with an active stream you won't have a call button working. You need to add `#backchannel=0` to the end of your RTSP link in YAML config file
-- **Dahua Doorbell** users may want to change backchannel [audio codec](https://github.com/AlexxIT/go2rtc/issues/52)
+- **Dahua Doorbell** users may want to change [audio codec](https://github.com/AlexxIT/go2rtc/issues/49#issuecomment-2127107379) for proper 2-way audio. Make sure not to request backchannel multiple times by adding `#backchannel=0` to other stream sources of the same doorbell. The `unicast=true&proto=Onvif` is preferred for 2-way audio as this makes the doorbell accept multiple codecs for the incoming audio
+- **Reolink** users may want NOT to use RTSP protocol at all, some camera models have a very awful unusable stream implementation
 - **Ubiquiti UniFi** users may want to disable HTTPS verification. Use `rtspx://` prefix instead of `rtsps://`. And don't use `?enableSrtp` [suffix](https://github.com/AlexxIT/go2rtc/issues/81)
 - **TP-Link Tapo** users may skip login and password, because go2rtc support login [without them](https://drmnsamoliu.github.io/video.html)
 - If your camera has two RTSP links - you can add both of them as sources. This is useful when streams has different codecs, as example AAC audio with main stream and PCMU/PCMA audio with second stream
 - If the stream from your camera is glitchy, try using [ffmpeg source](#source-ffmpeg). It will not add CPU load if you won't use transcoding
 - If the stream from your camera is very glitchy, try to use transcoding with [ffmpeg source](#source-ffmpeg)
 
+**Other options**
+
+Format: `rtsp...#{param1}#{param2}#{param3}`
+
+- Add custom timeout `#timeout=30` (in seconds)
+- Ignore audio - `#media=video` or ignore video - `#media=audio` 
+- Ignore two way audio API `#backchannel=0` - important for some glitchy cameras
+- Use WebSocket transport `#transport=ws...`
+
 **RTSP over WebSocket**
 
 ```yaml
@@ -234,7 +272,7 @@ streams:
 
 #### Source: RTMP
 
-You can get stream from RTMP server, for example [Frigate](https://docs.frigate.video/configuration/rtmp).
+You can get stream from RTMP server, for example [Nginx with nginx-rtmp-module](https://github.com/arut/nginx-rtmp-module).
 
 ```yaml
 streams:
@@ -265,12 +303,17 @@ streams:
 
   # [MJPEG or H.264/H.265 bitstream or MPEG-TS]
   tcp_magic: tcp://192.168.1.123:12345
+
+  # Add custom header
+  custom_header: "https://mjpeg.sanford.io/count.mjpeg#header=Authorization: Bearer XXX"
 ```
 
 **PS.** Dahua camera has bug: if you select MJPEG codec for RTSP second stream - snapshot won't work.
 
 #### Source: ONVIF
 
+*[New in v1.5.0](https://github.com/AlexxIT/go2rtc/releases/tag/v1.5.0)*
+
 The source is not very useful if you already know RTSP and snapshot links for your camera. But it can be useful if you don't.
 
 **WebUI > Add** webpage support ONVIF autodiscovery. Your server must be on the same subnet as the camera. If you use docker, you must use "network host".
@@ -309,7 +352,7 @@ streams:
   mjpeg: ffmpeg:http://185.97.122.128/cgi-bin/faststream.jpg#video=h264
 
   # [RTSP] video with rotation, should be transcoded, so select H264
-  rotate: ffmpeg:rtsp://rtsp:12345678@192.168.1.123/av_stream/ch0#video=h264#rotate=90
+  rotate: ffmpeg:rtsp://12345678@192.168.1.123/av_stream/ch0#video=h264#rotate=90
 ```
 
 All trascoding formats has [built-in templates](https://github.com/AlexxIT/go2rtc/blob/master/internal/ffmpeg/ffmpeg.go): `h264`, `h265`, `opus`, `pcmu`, `pcmu/16000`, `pcmu/48000`, `pcma`, `pcma/16000`, `pcma/48000`, `aac`, `aac/16000`.
@@ -363,24 +406,35 @@ streams:
 
 #### Source: Exec
 
-Exec source can run any external application and expect data from it. Two transports are supported - **pipe** and **RTSP**.
+Exec source can run any external application and expect data from it. Two transports are supported - **pipe** (*from [v1.5.0](https://github.com/AlexxIT/go2rtc/releases/tag/v1.5.0)*) and **RTSP**.
 
 If you want to use **RTSP** transport - the command must contain the `{output}` argument in any place. On launch, it will be replaced by the local address of the RTSP server.
 
-**pipe** reads data from app stdout in different formats: **MJPEG**, **H.264/H.265 bitstream**, **MPEG-TS**.
+**pipe** reads data from app stdout in different formats: **MJPEG**, **H.264/H.265 bitstream**, **MPEG-TS**. Also pipe can write data to app stdin in two formats: **PCMA** and **PCM/48000**.
 
 The source can be used with:
 
 - [FFmpeg](https://ffmpeg.org/) - go2rtc ffmpeg source just a shortcut to exec source
+- [FFplay](https://ffmpeg.org/ffplay.html) - play audio on your server
 - [GStreamer](https://gstreamer.freedesktop.org/)
 - [Raspberry Pi Cameras](https://www.raspberrypi.com/documentation/computers/camera_software.html)
 - any your own software
 
+Pipe commands support parameters (format: `exec:{command}#{param1}#{param2}`):
+
+- `killsignal` - signal which will be send to stop the process (numeric form)
+- `killtimeout` - time in seconds for forced termination with sigkill
+- `backchannel` - enable backchannel for two-way audio
+
 ```yaml
 streams:
   stream: exec:ffmpeg -re -i /media/BigBuckBunny.mp4 -c copy -rtsp_transport tcp -f rtsp {output}
   picam_h264: exec:libcamera-vid -t 0 --inline -o -
   picam_mjpeg: exec:libcamera-vid -t 0 --codec mjpeg -o -
+  pi5cam_h264: exec:libcamera-vid -t 0 --libav-format h264 -o -
+  canon: exec:gphoto2 --capture-movie --stdout#killsignal=2#killtimeout=5
+  play_pcma: exec:ffplay -fflags nobuffer -f alaw -ar 8000 -i -#backchannel=1
+  play_pcm48k: exec:ffplay -fflags nobuffer -f s16be -ar 48000 -i -#backchannel=1
 ```
 
 #### Source: Echo
@@ -396,6 +450,12 @@ streams:
   apple_hls: echo:python3 hls.py https://developer.apple.com/streaming/examples/basic-stream-osx-ios5.html
 ```
 
+#### Source: Expr
+
+*[New in v1.8.2](https://github.com/AlexxIT/go2rtc/releases/tag/v1.8.2)*
+
+Like `echo` source, but uses the built-in [expr](https://github.com/antonmedv/expr) expression language ([read more](https://github.com/AlexxIT/go2rtc/blob/master/internal/expr/README.md)).
+
 #### Source: HomeKit
 
 **Important:**
@@ -413,9 +473,8 @@ If you see a device but it does not have a pair button - it is paired to some ec
 **Important:**
 
 - HomeKit audio uses very non-standard **AAC-ELD** codec with very non-standard params and specification violation
-- Audio can be transcoded by [ffmpeg](#source-ffmpeg) source with `#async` option
-- Audio can be played by `ffplay` with `-use_wallclock_as_timestamps 1 -async 1` options
 - Audio can't be played in `VLC` and probably any other player
+- Audio should be transcoded for using with MSE, WebRTC, etc.
 
 Recommended settings for using HomeKit Camera with WebRTC, MSE, MP4, RTSP:
 
@@ -423,7 +482,7 @@ Recommended settings for using HomeKit Camera with WebRTC, MSE, MP4, RTSP:
 streams:
   aqara_g3:
     - hass:Camera-Hub-G3-AB12
-    - ffmpeg:aqara_g3#audio=aac#audio=opus#async
+    - ffmpeg:aqara_g3#audio=aac#audio=opus
 ```
 
 RTSP link with "normal" audio for any player: `rtsp://192.168.1.123:8554/aqara_g3?video&audio=aac`
@@ -432,6 +491,8 @@ RTSP link with "normal" audio for any player: `rtsp://192.168.1.123:8554/aqara_g
 
 #### Source: Bubble
 
+*[New in v1.6.1](https://github.com/AlexxIT/go2rtc/releases/tag/v1.6.1)*
+
 Other names: [ESeeCloud](http://www.eseecloud.com/), [dvr163](http://help.dvr163.com/).
 
 - you can skip `username`, `password`, `port`, `ch` and `stream` if they are default
@@ -444,6 +505,8 @@ streams:
 
 #### Source: DVRIP
 
+*[New in v1.2.0](https://github.com/AlexxIT/go2rtc/releases/tag/v1.2.0)*
+
 Other names: DVR-IP, NetSurveillance, Sofia protocol (NETsurveillance ActiveX plugin XMeye SDK).
 
 - you can skip `username`, `password`, `port`, `channel` and `subtype` if they are default
@@ -453,25 +516,61 @@ Other names: DVR-IP, NetSurveillance, Sofia protocol (NETsurveillance ActiveX pl
 
 ```yaml
 streams:
-  camera1: dvrip://username:password@192.168.1.123:34567?channel=0&subtype=0
+  only_stream: dvrip://username:password@192.168.1.123:34567?channel=0&subtype=0
+  only_tts: dvrip://username:password@192.168.1.123:34567?backchannel=1
+  two_way_audio:
+    - dvrip://username:password@192.168.1.123:34567?channel=0&subtype=0
+    - dvrip://username:password@192.168.1.123:34567?backchannel=1
 ```
 
 #### Source: Tapo
 
+*[New in v1.2.0](https://github.com/AlexxIT/go2rtc/releases/tag/v1.2.0)*
+
 [TP-Link Tapo](https://www.tapo.com/) proprietary camera protocol with **two way audio** support.
 
 - stream quality is the same as [RTSP protocol](https://www.tapo.com/en/faq/34/)
 - use the **cloud password**, this is not the RTSP password! you do not need to add a login!
 - you can also use UPPERCASE MD5 hash from your cloud password with `admin` username
+- some new camera firmwares requires SHA256 instead of MD5
 
 ```yaml
 streams:
   # cloud password without username
   camera1: tapo://cloud-password@192.168.1.123
   # admin username and UPPERCASE MD5 cloud-password hash
-  camera2: tapo://admin:MD5-PASSWORD-HASH@192.168.1.123
+  camera2: tapo://admin:UPPERCASE-MD5@192.168.1.123
+  # admin username and UPPERCASE SHA256 cloud-password hash
+  camera3: tapo://admin:UPPERCASE-SHA256@192.168.1.123
 ```
 
+```bash
+echo -n "cloud password" | md5 | awk '{print toupper($0)}'
+echo -n "cloud password" | shasum -a 256 | awk '{print toupper($0)}'
+```
+
+#### Source: Kasa
+
+*[New in v1.7.0](https://github.com/AlexxIT/go2rtc/releases/tag/v1.7.0)*
+
+[TP-Link Kasa](https://www.kasasmart.com/) non-standard protocol [more info](https://medium.com/@hu3vjeen/reverse-engineering-tp-link-kc100-bac4641bf1cd).
+
+- `username` - urlsafe email, `alex@gmail.com` -> `alex%40gmail.com`
+- `password` - base64password, `secret1` -> `c2VjcmV0MQ==`
+
+```yaml
+streams:
+  kc401: kasa://username:password@192.168.1.123:19443/https/stream/mixed
+```
+
+Tested: KD110, KC200, KC401, KC420WS, EC71.
+
+#### Source: GoPro
+
+*[New in v1.8.3](https://github.com/AlexxIT/go2rtc/releases/tag/v1.8.3)*
+
+Support streaming from [GoPro](https://gopro.com/) cameras, connected via USB or Wi-Fi to Linux, Mac, Windows. [Read more](https://github.com/AlexxIT/go2rtc/tree/master/internal/gopro).
+
 #### Source: Ivideon
 
 Support public cameras from service [Ivideon](https://tv.ivideon.com/).
@@ -499,11 +598,11 @@ streams:
   aqara_g3: hass:Camera-Hub-G3-AB12
 ```
 
-**WebRTC Cameras**
+**WebRTC Cameras** (*from [v1.6.0](https://github.com/AlexxIT/go2rtc/releases/tag/v1.6.0)*)
 
 Any cameras in WebRTC format are supported. But at the moment Home Assistant only supports some [Nest](https://www.home-assistant.io/integrations/nest/) cameras in this fomat.
 
-The Nest API only allows you to get a link to a stream for 5 minutes. So every 5 minutes the stream will be reconnected.
+**Important.** The Nest API only allows you to get a link to a stream for 5 minutes. Do not use this with Frigate! If the stream expires, Frigate will consume all available ram on your machine within seconds. It's recommended to use [Nest source](#source-nest) - it supports extending the stream.
 
 ```yaml
 streams:
@@ -519,6 +618,8 @@ By default, the Home Assistant API does not allow you to get dynamic RTSP link t
 
 #### Source: ISAPI
 
+*[New in v1.3.0](https://github.com/AlexxIT/go2rtc/releases/tag/v1.3.0)*
+
 This source type support only backchannel audio for Hikvision ISAPI protocol. So it should be used as second source in addition to the RTSP protocol.
 
 ```yaml
@@ -530,7 +631,9 @@ streams:
 
 #### Source: Nest
 
-Currently only WebRTC cameras are supported. Stream reconnects every 5 minutes.
+*[New in v1.6.0](https://github.com/AlexxIT/go2rtc/releases/tag/v1.6.0)*
+
+Currently only WebRTC cameras are supported.
 
 For simplicity, it is recommended to connect the Nest/WebRTC camera to the [Home Assistant](#source-hass). But if you can somehow get the below parameters - Nest/WebRTC source will work without Hass.
 
@@ -541,47 +644,64 @@ streams:
 
 #### Source: Roborock
 
+*[New in v1.3.0](https://github.com/AlexxIT/go2rtc/releases/tag/v1.3.0)*
+
 This source type support Roborock vacuums with cameras. Known working models:
 
 - Roborock S6 MaxV - only video (the vacuum has no microphone)
 - Roborock S7 MaxV - video and two way audio
+- Roborock Qrevo MaxV - video and two way audio
 
-Source support load Roborock credentials from Home Assistant [custom integration](https://github.com/humbertogontijo/homeassistant-roborock). Otherwise, you need to log in to your Roborock account (MiHome account is not supported). Go to: go2rtc WebUI > Add webpage. Copy `roborock://...` source for your vacuum and paste it to `go2rtc.yaml` config.
+Source support load Roborock credentials from Home Assistant [custom integration](https://github.com/humbertogontijo/homeassistant-roborock) or the [core integration](https://www.home-assistant.io/integrations/roborock). Otherwise, you need to log in to your Roborock account (MiHome account is not supported). Go to: go2rtc WebUI > Add webpage. Copy `roborock://...` source for your vacuum and paste it to `go2rtc.yaml` config.
 
-If you have graphic pin for your vacuum - add it as numeric pin (lines: 123, 456, 678) to the end of the roborock-link.
+If you have graphic pin for your vacuum - add it as numeric pin (lines: 123, 456, 789) to the end of the roborock-link.
 
 #### Source: WebRTC
 
+*[New in v1.3.0](https://github.com/AlexxIT/go2rtc/releases/tag/v1.3.0)*
+
 This source type support four connection formats.
 
 **whep**
 
-[WebRTC/WHEP](https://www.ietf.org/id/draft-murillo-whep-01.html) - is an unapproved standard for WebRTC video/audio viewers. But it may already be supported in some third-party software. It is supported in go2rtc.
+[WebRTC/WHEP](https://datatracker.ietf.org/doc/draft-murillo-whep/) - is replaced by [WebRTC/WISH](https://datatracker.ietf.org/doc/charter-ietf-wish/02/) standard for WebRTC video/audio viewers. But it may already be supported in some third-party software. It is supported in go2rtc.
 
 **go2rtc**
 
 This format is only supported in go2rtc. Unlike WHEP it supports asynchronous WebRTC connection and two way audio.
 
-**wyze**
+**openipc** (*from [v1.7.0](https://github.com/AlexxIT/go2rtc/releases/tag/v1.7.0)*)
+
+Support connection to [OpenIPC](https://openipc.org/) cameras.
+
+**wyze** (*from [v1.6.1](https://github.com/AlexxIT/go2rtc/releases/tag/v1.6.1)*)
 
 Supports connection to [Wyze](https://www.wyze.com/) cameras, using WebRTC protocol. You can use [docker-wyze-bridge](https://github.com/mrlt8/docker-wyze-bridge) project to get connection credentials.
 
-**kinesis**
+**kinesis** (*from [v1.6.1](https://github.com/AlexxIT/go2rtc/releases/tag/v1.6.1)*)
 
 Supports [Amazon Kinesis Video Streams](https://aws.amazon.com/kinesis/video-streams/), using WebRTC protocol. You need to specify signalling WebSocket URL with all credentials in query params, `client_id` and `ice_servers` list in [JSON format](https://developer.mozilla.org/en-US/docs/Web/API/RTCIceServer).
 
+**switchbot**
+
+Support connection to [SwitchBot](https://us.switch-bot.com/) cameras that are based on Kinesis Video Streams. Specifically, this includes [Pan/Tilt Cam Plus 2K](https://us.switch-bot.com/pages/switchbot-pan-tilt-cam-plus-2k) and [Pan/Tilt Cam Plus 3K](https://us.switch-bot.com/pages/switchbot-pan-tilt-cam-plus-3k). `Outdoor Spotlight Cam 1080P`, `Outdoor Spotlight Cam 2K`, `Pan/Tilt Cam`, `Pan/Tilt Cam 2K`, `Indoor Cam` are based on Tuya, so this feature is not available.
+
 ```yaml
 streams:
-  webrtc-whep:    webrtc:http://192.168.1.123:1984/api/webrtc?src=camera1
-  webrtc-go2rtc:  webrtc:ws://192.168.1.123:1984/api/ws?src=camera1
-  webrtc-wyze:    webrtc:http://192.168.1.123:5000/signaling/camera1?kvs#format=wyze
-  webrtc-kinesis: webrtc:wss://...amazonaws.com/?...#format=kinesis#client_id=...#ice_servers=[{...},{...}]
+  webrtc-whep:      webrtc:http://192.168.1.123:1984/api/webrtc?src=camera1
+  webrtc-go2rtc:    webrtc:ws://192.168.1.123:1984/api/ws?src=camera1
+  webrtc-openipc:   webrtc:ws://192.168.1.123/webrtc_ws#format=openipc#ice_servers=[{"urls":"stun:stun.kinesisvideo.eu-north-1.amazonaws.com:443"}]
+  webrtc-wyze:      webrtc:http://192.168.1.123:5000/signaling/camera1?kvs#format=wyze
+  webrtc-kinesis:   webrtc:wss://...amazonaws.com/?...#format=kinesis#client_id=...#ice_servers=[{...},{...}]
+  webrtc-switchbot: webrtc:wss://...amazonaws.com/?...#format=switchbot#resolution=hd#client_id=...#ice_servers=[{...},{...}]
 ```
 
-**PS.** For `wyze` and `kinesis` sources you can use [echo](#source-echo) to get connection params using `bash`/`python` or any other script language.
+**PS.** For `kinesis` sources you can use [echo](#source-echo) to get connection params using `bash`/`python` or any other script language.
 
 #### Source: WebTorrent
 
+*[New in v1.3.0](https://github.com/AlexxIT/go2rtc/releases/tag/v1.3.0)*
+
 This source can get a stream from another go2rtc via [WebTorrent](#module-webtorrent) protocol.
 
 ```yaml
@@ -593,7 +713,7 @@ streams:
 
 By default, go2rtc establishes a connection to the source when any client requests it. Go2rtc drops the connection to the source when it has no clients left.
 
-- Go2rtc also can accepts incoming sources in [RTSP](#source-rtsp), [HTTP](#source-http) and **WebRTC/WHIP** formats
+- Go2rtc also can accepts incoming sources in [RTSP](#module-rtsp), [RTMP](#module-rtmp), [HTTP](#source-http) and **WebRTC/WHIP** formats
 - Go2rtc won't stop such a source if it has no clients
 - You can push data only to existing stream (create stream with empty source in config)
 - You can push multiple incoming sources to same stream
@@ -620,6 +740,8 @@ By default, go2rtc establishes a connection to the source when any client reques
 
 #### Incoming: Browser
 
+*[New in v1.3.0](https://github.com/AlexxIT/go2rtc/releases/tag/v1.3.0)*
+
 You can turn the browser of any PC or mobile into an IP-camera with support video and two way audio. Or even broadcast your PC screen:
 
 1. Create empty stream in the `go2rtc.yaml`
@@ -630,12 +752,16 @@ You can turn the browser of any PC or mobile into an IP-camera with support vide
 
 #### Incoming: WebRTC/WHIP
 
+*[New in v1.3.0](https://github.com/AlexxIT/go2rtc/releases/tag/v1.3.0)*
+
 You can use **OBS Studio** or any other broadcast software with [WHIP](https://www.ietf.org/archive/id/draft-ietf-wish-whip-01.html) protocol support. This standard has not yet been approved. But you can download OBS Studio [dev version](https://github.com/obsproject/obs-studio/actions/runs/3969201209):
 
 - Settings > Stream > Service: WHIP > http://192.168.1.123:1984/api/webrtc?dst=camera1
 
 #### Stream to camera
 
+*[New in v1.3.0](https://github.com/AlexxIT/go2rtc/releases/tag/v1.3.0)*
+
 go2rtc support play audio files (ex. music or [TTS](https://www.home-assistant.io/integrations/#text-to-speech)) and live streams (ex. radio) on cameras with [two way audio](#two-way-audio) support (RTSP/ONVIF cameras, TP-Link Tapo, Hikvision ISAPI, Roborock vacuums, any Browser).
 
 API example:
@@ -654,10 +780,50 @@ POST http://localhost:1984/api/streams?dst=camera1&src=ffmpeg:http://example.com
 - you can stop active playback by calling the API with the empty `src` parameter
 - you will see one active producer and one active consumer in go2rtc WebUI info page during streaming
 
+### Publish stream
+
+*[New in v1.8.0](https://github.com/AlexxIT/go2rtc/releases/tag/v1.8.0)*
+
+You can publish any stream to streaming services (YouTube, Telegram, etc.) via RTMP/RTMPS. Important:
+
+- Supported codecs: H264 for video and AAC for audio
+- AAC audio is required for YouTube, videos without audio will not work
+- You don't need to enable [RTMP module](#module-rtmp) listening for this task
+
+You can use API:
+
+```
+POST http://localhost:1984/api/streams?src=camera1&dst=rtmps://...
+```
+
+Or config file:
+
+```yaml
+publish:
+  # publish stream "video_audio_transcode" to Telegram
+  video_audio_transcode:
+    - rtmps://xxx-x.rtmp.t.me/s/xxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxx
+  # publish stream "audio_transcode" to Telegram and YouTube
+  audio_transcode:
+    - rtmps://xxx-x.rtmp.t.me/s/xxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxx
+    - rtmp://xxx.rtmp.youtube.com/live2/xxxx-xxxx-xxxx-xxxx-xxxx
+
+streams:
+  video_audio_transcode:
+    - ffmpeg:rtsp://user:pass@192.168.1.123/stream1#video=h264#hardware#audio=aac
+  audio_transcode:
+    - ffmpeg:rtsp://user:pass@192.168.1.123/stream1#video=copy#audio=aac
+```
+
+- **Telegram Desktop App** > Any public or private channel or group (where you admin) > Live stream > Start with... > Start streaming.
+- **YouTube** > Create > Go live > Stream latency: Ultra low-latency > Copy: Stream URL + Stream key.
+
 ### Module: API
 
 The HTTP API is the main part for interacting with the application. Default address: `http://localhost:1984/`.
 
+**Important!** go2rtc passes requests from localhost and from unix socket without HTTP authorisation, even if you have it configured! It is your responsibility to set up secure external access to API. If not properly configured, an attacker can gain access to your cameras and even your server.
+
 [API description](https://github.com/AlexxIT/go2rtc/tree/master/api).
 
 **Module config**
@@ -666,6 +832,7 @@ The HTTP API is the main part for interacting with the application. Default addr
 - you can enable HTTP API only on localhost with `listen: "127.0.0.1:1984"` setting
 - you can change API `base_path` and host go2rtc on your main app webserver suburl
 - all files from `static_dir` hosted on root path: `/`
+- you can use raw TLS cert/key content or path to files
 
 ```yaml
 api:
@@ -684,6 +851,7 @@ api:
     -----BEGIN PRIVATE KEY-----
     ...
     -----END PRIVATE KEY-----
+  unix_listen: "/tmp/go2rtc.sock"  # default "", unix socket listener for API
 ```
 
 **PS:**
@@ -714,6 +882,19 @@ By default go2rtc provide RTSP-stream with only one first video and only one fir
 
 Read more about [codecs filters](#codecs-filters).
 
+### Module: RTMP
+
+*[New in v1.8.0](https://github.com/AlexxIT/go2rtc/releases/tag/v1.8.0)*
+
+You can get any stream as RTMP-stream: `rtmp://192.168.1.123/{stream_name}`. Only H264/AAC codecs supported right now.
+
+[Incoming stream](#incoming-sources) in RTMP-format tested only with [OBS Studio](https://obsproject.com/) and Dahua camera. Different FFmpeg versions has different problems with this format. 
+
+```yaml
+rtmp:
+  listen: ":1935"  # by default - disabled!
+```
+
 ### Module: WebRTC
 
 In most cases [WebRTC](https://en.wikipedia.org/wiki/WebRTC) uses direct peer-to-peer connection from your browser to go2rtc and sends media data via UDP.
@@ -757,7 +938,7 @@ webrtc:
 
 **Private IP**
 
-- setup integration with [Ngrok service](#module-ngrok)
+- setup integration with [ngrok service](#module-ngrok)
 
 ```yaml
 ngrok:
@@ -781,8 +962,64 @@ webrtc:
       credential: your_pass
 ```
 
+### Module: HomeKit
+
+*[New in v1.7.0](https://github.com/AlexxIT/go2rtc/releases/tag/v1.7.0)*
+
+HomeKit module can work in two modes:
+
+- export any H264 camera to Apple HomeKit
+- transparent proxy any Apple HomeKit camera (Aqara, Eve, Eufy, etc.) back to Apple HomeKit, so you will have all camera features in Apple Home and also will have RTSP/WebRTC/MP4/etc. from your HomeKit camera
+
+**Important**
+
+- HomeKit cameras supports only H264 video and OPUS audio
+
+**Minimal config**
+
+```yaml
+streams:
+  dahua1: rtsp://admin:password@192.168.1.123/cam/realmonitor?channel=1&subtype=0
+homekit:
+  dahua1:  # same stream ID from streams list, default PIN - 19550224
+```
+
+**Full config**
+
+```yaml
+streams:
+  dahua1:
+    - rtsp://admin:password@192.168.1.123/cam/realmonitor?channel=1&subtype=0
+    - ffmpeg:dahua1#video=h264#hardware  # if your camera doesn't support H264, important for HomeKit
+    - ffmpeg:dahua1#audio=opus           # only OPUS audio supported by HomeKit
+
+homekit:
+  dahua1:                   # same stream ID from streams list
+    pin: 12345678           # custom PIN, default: 19550224
+    name: Dahua camera      # custom camera name, default: generated from stream ID
+    device_id: dahua1       # custom ID, default: generated from stream ID
+    device_private: dahua1  # custom key, default: generated from stream ID
+```
+
+**Proxy HomeKit camera**
+
+- Video stream from HomeKit camera to Apple device (iPhone, AppleTV) will be transmitted directly
+- Video stream from HomeKit camera to RTSP/WebRTC/MP4/etc. will be transmitted via go2rtc
+
+```yaml
+streams:
+  aqara1:
+    - homekit://...
+    - ffmpeg:aqara1#audio=aac#audio=opus  # optional audio transcoding
+
+homekit:
+  aqara1:  # same stream ID from streams list
+```
+
 ### Module: WebTorrent
 
+*[New in v1.3.0](https://github.com/AlexxIT/go2rtc/releases/tag/v1.3.0)*
+
 This module support:
 
 - Share any local stream via [WebTorrent](https://webtorrent.io/) technology
@@ -807,29 +1044,29 @@ Link example: https://alexxit.github.io/go2rtc/#share=02SNtgjKXY&pwd=wznEQqznxW&
 
 TODO: article how it works...
 
-### Module: Ngrok
+### Module: ngrok
 
-With Ngrok integration you can get external access to your streams in situation when you have Internet with private IP-address.
+With ngrok integration you can get external access to your streams in situations when you have Internet with private IP-address.
 
-- Ngrok preistalled for **Docker** and **Hass Add-on** users
+- ngrok is pre-installed for **Docker** and **Hass Add-on** users
 - you may need external access for two different things:
   - WebRTC stream, so you need tunnel WebRTC TCP port (ex. 8555)
   - go2rtc web interface, so you need tunnel API HTTP port (ex. 1984)
-- Ngrok support authorization for your web interface
-- Ngrok automatically adds HTTPS to your web interface
+- ngrok support authorization for your web interface
+- ngrok automatically adds HTTPS to your web interface
 
-Ngrok free subscription limitations:
+The ngrok free subscription has the following limitations:
 
-- you will always get random external address (not a problem for webrtc stream)
-- you can forward multiple ports but use only one Ngrok app
+- You can reserve a free domain for serving the web interface, but the TCP address you get will always be random and change with each restart of the ngrok agent (not a problem for webrtc stream)
+- You can forward multiple ports from a single agent, but you can only run one ngrok agent on the free plan
 
 go2rtc will automatically get your external TCP address (if you enable it in ngrok config) and use it with WebRTC connection (if you enable it in webrtc config).
 
-You need manually download [Ngrok agent app](https://ngrok.com/download) for your OS and register in [Ngrok service](https://ngrok.com/).
+You need to manually download the [ngrok agent app](https://ngrok.com/download) for your OS and register with the [ngrok service](https://ngrok.com/signup).
 
 **Tunnel for only WebRTC Stream**
 
-You need to add your [Ngrok token](https://dashboard.ngrok.com/get-started/your-authtoken) and WebRTC TCP port to YAML:
+You need to add your [ngrok authtoken](https://dashboard.ngrok.com/get-started/your-authtoken) and WebRTC TCP port to YAML:
 
 ```yaml
 ngrok:
@@ -845,7 +1082,7 @@ ngrok:
   command: ngrok start --all --config ngrok.yaml
 ```
 
-Ngrok config example:
+ngrok config example:
 
 ```yaml
 version: "2"
@@ -861,6 +1098,8 @@ tunnels:
     proto: tcp
 ```
 
+See the [ngrok agent documentation](https://ngrok.com/docs/agent/config/) for more details on the ngrok configuration file.
+
 ### Module: Hass
 
 The best and easiest way to use go2rtc inside the Home Assistant is to install the custom integration [WebRTC Camera](#go2rtc-home-assistant-integration) and custom lovelace card.
@@ -874,7 +1113,7 @@ You have several options on how to add a camera to Home Assistant:
    - Install any [go2rtc](#fast-start)
    - Add your stream to [go2rtc config](#configuration)
    - Hass > Settings > Integrations > Add Integration > [ONVIF](https://my.home-assistant.io/redirect/config_flow_start/?domain=onvif) > Host: `127.0.0.1`, Port: `1984`
-   - Hass > Settings > Integrations > Add Integration > [Generic Camera](https://my.home-assistant.io/redirect/config_flow_start/?domain=generic) > `rtsp://127.0.0.1:8554/camera1` (change to your stream name)
+   - Hass > Settings > Integrations > Add Integration > [Generic Camera](https://my.home-assistant.io/redirect/config_flow_start/?domain=generic) > Stream Source URL: `rtsp://127.0.0.1:8554/camera1` (change to your stream name, leave everything else as is)
 
 You have several options on how to watch the stream from the cameras in Home Assistant:
 
@@ -924,6 +1163,8 @@ Read more about [codecs filters](#codecs-filters).
 
 ### Module: HLS
 
+*[New in v1.1.0](https://github.com/AlexxIT/go2rtc/releases/tag/v1.1.0)*
+
 [HLS](https://en.wikipedia.org/wiki/HTTP_Live_Streaming) is the worst technology for real-time streaming. It can only be useful on devices that do not support more modern technology, like [WebRTC](#module-webrtc), [MSE/MP4](#module-mp4).
 
 The go2rtc implementation differs from the standards and may not work with all players.
@@ -963,6 +1204,10 @@ API examples:
   - You can use `rotate` param with `90`, `180`, `270` or `-90` values
   - You can use `hardware`/`hw` param [read more](https://github.com/AlexxIT/go2rtc/wiki/Hardware-acceleration)
 
+**PS.** This module also supports streaming to the server console (terminal) in the **animated ASCII art** format ([read more](https://github.com/AlexxIT/go2rtc/blob/master/internal/mjpeg/README.md)):
+
+[![](https://img.youtube.com/vi/sHj_3h_sX7M/mqdefault.jpg)](https://www.youtube.com/watch?v=sHj_3h_sX7M)
+
 ### Module: Log
 
 You can set different log levels for different modules.
@@ -1000,7 +1245,7 @@ webrtc:
 - external access to WebRTC TCP port is not a problem, because it used only for transmit encrypted media data
   - anyway you need to open this port to your local network and to the Internet in order for WebRTC to work
 
-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.
+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 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.
 
@@ -1031,17 +1276,14 @@ Some examples:
 
 `AVC/H.264` video 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                           | HTTP                               | HLS                    |
-|---------------------|-------------------------------|-------------------------------|------------------------------------|------------------------|
-| *latency*           | best                          | medium                        | bad                                | bad                    |
-| Desktop Chrome 107+ | H264, OPUS, PCMU, PCMA        | H264, H265*, AAC, FLAC*, OPUS | H264, H265*, AAC, FLAC*, OPUS, MP3 | no                     |
-| Desktop Edge        | H264, OPUS, PCMU, PCMA        | H264, H265*, AAC, FLAC*, OPUS | H264, H265*, AAC, FLAC*, OPUS, MP3 | no                     |
-| Android Chrome 107+ | H264, OPUS, PCMU, PCMA        | H264, H265*, AAC, FLAC*, OPUS | H264, H265*, AAC, FLAC*, OPUS, MP3 | no                     |
-| Desktop Firefox     | H264, OPUS, PCMU, PCMA        | H264, AAC, FLAC*, OPUS        | H264, AAC, FLAC*, OPUS             | no                     |
-| Desktop Safari 14+  | H264, H265*, OPUS, PCMU, PCMA | H264, H265, AAC, FLAC*        | **no!**                            | H264, H265, AAC, FLAC* |
-| iPad Safari 14+     | H264, H265*, OPUS, PCMU, PCMA | H264, H265, AAC, FLAC*        | **no!**                            | H264, H265, AAC, FLAC* |
-| iPhone Safari 14+   | H264, H265*, OPUS, PCMU, PCMA | **no!**                       | **no!**                            | H264, H265, AAC, FLAC* |
-| macOS [Hass App][1] | no                            | no                            | no                                 | H264, H265, AAC, FLAC* |
+| Device                                                                   | WebRTC                                  | MSE                                     | HTTP*                                        | HLS                         |
+|--------------------------------------------------------------------------|-----------------------------------------|-----------------------------------------|----------------------------------------------|-----------------------------|
+| *latency*                                                                | best                                    | medium                                  | bad                                          | bad                         |
+| - Desktop Chrome 107+ <br/> - Desktop Edge <br/> - Android Chrome 107+   | H264 <br/> PCMU, PCMA <br/> OPUS        | H264, H265* <br/> AAC, FLAC* <br/> OPUS | H264, H265* <br/> AAC, FLAC* <br/> OPUS, MP3 | no                          |
+| Desktop Firefox                                                          | H264 <br/> PCMU, PCMA <br/> OPUS        | H264 <br/> AAC, FLAC* <br/> OPUS        | H264 <br/> AAC, FLAC* <br/> OPUS             | no                          |
+| - Desktop Safari 14+ <br/> - iPad Safari 14+ <br/> - iPhone Safari 17.1+ | H264, H265* <br/> PCMU, PCMA <br/> OPUS | H264, H265 <br/> AAC, FLAC*             | **no!**                                      | H264, H265 <br/> AAC, FLAC* |
+| iPhone Safari 14+                                                        | H264, H265* <br/> PCMU, PCMA <br/> OPUS | **no!**                                 | **no!**                                      | H264, H265 <br/> AAC, FLAC* |
+| macOS [Hass App][1]                                                      | no                                      | no                                      | no                                           | H264, H265 <br/> AAC, FLAC* |
 
 [1]: https://apps.apple.com/app/home-assistant/id1099568401
 
@@ -1068,8 +1310,8 @@ Some examples:
 
 - H264 = H.264 = AVC (Advanced Video Coding)
 - H265 = H.265 = HEVC (High Efficiency Video Coding)
-- PCMU = G.711 PCM (A-law) = PCM A-law (`alaw`)
-- PCMA = G.711 PCM (µ-law) = PCM mu-law (`mulaw`)
+- PCMA = G.711 PCM (A-law) = PCM A-law (`alaw`)
+- PCMU = G.711 PCM (µ-law) = PCM mu-law (`mulaw`)
 - PCM = L16 = PCM signed 16-bit big-endian (`s16be`)
 - AAC = MPEG4-GENERIC
 - MP3 = MPEG-1 Audio Layer III or MPEG-2 Audio Layer III
@@ -1136,14 +1378,22 @@ streams:
 
 - [Frigate 12+](https://frigate.video/) - open source NVR built around real-time AI object detection
 - [Frigate Lovelace Card](https://github.com/dermotduffy/frigate-hass-card) - custom card for Home Assistant
-- [ring-mqtt](https://github.com/tsightler/ring-mqtt) - Ring devices to MQTT Bridge
+- [OpenIPC](https://github.com/OpenIPC/firmware/tree/master/general/package/go2rtc) - Alternative IP Camera firmware from an open community
+- [wz_mini_hacks](https://github.com/gtxaspec/wz_mini_hacks) - Custom firmware for Wyze cameras
 - [EufyP2PStream](https://github.com/oischinger/eufyp2pstream) - A small project that provides a Video/Audio Stream from Eufy cameras that don't directly support RTSP
 - [ioBroker.euSec](https://github.com/bropat/ioBroker.eusec) - [ioBroker](https://www.iobroker.net/) adapter for control Eufy security devices
-- [wz_mini_hacks](https://github.com/gtxaspec/wz_mini_hacks) - Custom firmware for Wyze cameras
 - [MMM-go2rtc](https://github.com/Anonym-tsk/MMM-go2rtc) - MagicMirror² Module
+- [ring-mqtt](https://github.com/tsightler/ring-mqtt) - Ring devices to MQTT Bridge
+
+**Distributions**
+
 - [Alpine Linux](https://pkgs.alpinelinux.org/packages?name=go2rtc)
+- [Arch User Repository](https://linux-packages.com/aur/package/go2rtc)
+- [Gentoo](https://github.com/inode64/inode64-overlay/tree/main/media-video/go2rtc)
 - [NixOS](https://search.nixos.org/packages?query=go2rtc)
 - [Proxmox Helper Scripts](https://tteck.github.io/Proxmox/)
+- [QNAP](https://www.myqnap.org/product/go2rtc/)
+- [Synology NAS](https://synocommunity.com/package/go2rtc)
 - [Unraid](https://unraid.net/community/apps?q=go2rtc)
 
 ## Cameras experience
@@ -1151,7 +1401,7 @@ streams:
 - [Dahua](https://www.dahuasecurity.com/) - reference implementation streaming protocols, a lot of settings, high stream quality, multiple streaming clients
 - [EZVIZ](https://www.ezviz.com/) - awful RTSP protocol realisation, many bugs in SDP
 - [Hikvision](https://www.hikvision.com/) - a lot of proprietary streaming technologies
-- [Reolink](https://reolink.com/) - some models has awful unusable RTSP realisation and not best HTTP-FLV alternative (I recommend that you contact Reolink support for new firmware), few settings
+- [Reolink](https://reolink.com/) - some models has awful unusable RTSP realisation and not best RTMP alternative (I recommend that you contact Reolink support for new firmware), few settings
 - [Sonoff](https://sonoff.tech/) - very low stream quality, no settings, not best protocol implementation
 - [TP-Link](https://www.tp-link.com/) - few streaming clients, packet loss?
 - Chinese cheap noname cameras, Wyze Cams, Xiaomi cameras with hacks (usual has `/live/ch00_1` in RTSP URL) - awful but usable RTSP protocol realisation, low stream quality, few settings, packet loss?

api/openapi.yaml

@@ -1,4 +1,4 @@
-openapi: 3.0.0
+openapi: 3.1.0
 
 info:
   title: go2rtc
@@ -111,9 +111,18 @@ paths:
           required: false
           schema: { type: integer }
           example: 100
-      responses: { }
-
+      responses:
+            default:
+              description: Default response
 
+  /api/restart:
+    post:
+      summary: Restart Daemon
+      description: Restarts the daemon.
+      tags: [ Application ]
+      responses:
+            default:
+              description: Default response
 
   /api/config:
     get:
@@ -130,14 +139,18 @@ paths:
       requestBody:
         content:
           "*/*": { example: "streams:..." }
-      responses: { }
+      responses:
+            default:
+              description: Default response
     patch:
       summary: Merge changes to main config file
       tags: [ Config ]
       requestBody:
         content:
           "*/*": { example: "streams:..." }
-      responses: { }
+      responses:
+            default:
+              description: Default response
 
 
 
@@ -166,7 +179,9 @@ paths:
           required: false
           schema: { type: string }
           example: camera1
-      responses: { }
+      responses:
+            default:
+              description: Default response
     patch:
       summary: Update stream source
       tags: [ Streams list ]
@@ -183,7 +198,9 @@ paths:
           required: true
           schema: { type: string }
           example: camera1
-      responses: { }
+      responses:
+            default:
+              description: Default response
     delete:
       summary: Delete stream
       tags: [ Streams list ]
@@ -194,7 +211,9 @@ paths:
           required: true
           schema: { type: string }
           example: camera1
-      responses: { }
+      responses:
+            default:
+              description: Default response
     post:
       summary: Send stream from source to destination
       description: "[Stream to camera](https://github.com/AlexxIT/go2rtc#stream-to-camera)"
@@ -212,7 +231,9 @@ paths:
           required: true
           schema: { type: string }
           example: camera1
-      responses: { }
+      responses:
+            default:
+              description: Default response
 
 
 
@@ -347,7 +368,9 @@ paths:
       tags: [ Produce stream ]
       parameters:
         - $ref: "#/components/parameters/stream_dst_path"
-      responses: { }
+      responses:
+            default:
+              description: Default response
   /api/stream.flv?dst={dst}:
     post:
       summary: Post stream in FLV format
@@ -355,7 +378,9 @@ paths:
       tags: [ Produce stream ]
       parameters:
         - $ref: "#/components/parameters/stream_dst_path"
-      responses: { }
+      responses:
+            default:
+              description: Default response
   /api/stream.ts?dst={dst}:
     post:
       summary: Post stream in MPEG-TS format
@@ -363,7 +388,9 @@ paths:
       tags: [ Produce stream ]
       parameters:
         - $ref: "#/components/parameters/stream_dst_path"
-      responses: { }
+      responses:
+            default:
+              description: Default response
   /api/stream.mjpeg?dst={dst}:
     post:
       summary: Post stream in MJPEG format
@@ -371,7 +398,9 @@ paths:
       tags: [ Produce stream ]
       parameters:
         - $ref: "#/components/parameters/stream_dst_path"
-      responses: { }
+      responses:
+            default:
+              description: Default response
 
 
 
@@ -380,49 +409,65 @@ paths:
       summary: DVRIP cameras discovery
       description: "[Source: DVRIP](https://github.com/AlexxIT/go2rtc#source-dvrip)"
       tags: [ Discovery ]
-      responses: { }
+      responses:
+            default:
+              description: Default response
 
   /api/ffmpeg/devices:
     get:
       summary: FFmpeg USB devices discovery
       description: "[Source: FFmpeg Device](https://github.com/AlexxIT/go2rtc#source-ffmpeg-device)"
       tags: [ Discovery ]
-      responses: { }
+      responses:
+            default:
+              description: Default response
   /api/ffmpeg/hardware:
     get:
       summary: FFmpeg hardware transcoding discovery
       description: "[Hardware acceleration](https://github.com/AlexxIT/go2rtc/wiki/Hardware-acceleration)"
       tags: [ Discovery ]
-      responses: { }
+      responses:
+            default:
+              description: Default response
   /api/hass:
     get:
       summary: Home Assistant cameras discovery
       description: "[Source: Hass](https://github.com/AlexxIT/go2rtc#source-hass)"
       tags: [ Discovery ]
-      responses: { }
+      responses:
+            default:
+              description: Default response
   /api/homekit:
     get:
       summary: HomeKit cameras discovery
       description: "[Source: HomeKit](https://github.com/AlexxIT/go2rtc#source-homekit)"
       tags: [ Discovery ]
-      responses: { }
+      responses:
+            default:
+              description: Default response
   /api/nest:
     get:
       summary: Nest cameras discovery
       tags: [ Discovery ]
-      responses: { }
+      responses:
+            default:
+              description: Default response
   /api/onvif:
     get:
       summary: ONVIF cameras discovery
       description: "[Source: ONVIF](https://github.com/AlexxIT/go2rtc#source-onvif)"
       tags: [ Discovery ]
-      responses: { }
+      responses:
+            default:
+              description: Default response
   /api/roborock:
     get:
       summary: Roborock vacuums discovery
       description: "[Source: Roborock](https://github.com/AlexxIT/go2rtc#source-roborock)"
       tags: [ Discovery ]
-      responses: { }
+      responses:
+            default:
+              description: Default response
 
 
 
@@ -431,7 +476,9 @@ paths:
       summary: ONVIF server implementation
       description: Simple realisation of the ONVIF protocol. Accepts any suburl requests
       tags: [ ONVIF ]
-      responses: { }
+      responses:
+            default:
+              description: Default response
 
 
 
@@ -440,7 +487,9 @@ paths:
       summary: RTSPtoWebRTC server implementation
       description: Simple API for support [RTSPtoWebRTC](https://www.home-assistant.io/integrations/rtsp_to_webrtc/) integration
       tags: [ RTSPtoWebRTC ]
-      responses: { }
+      responses:
+            default:
+              description: Default response
 
 
 
@@ -465,7 +514,9 @@ paths:
       tags: [ WebTorrent ]
       parameters:
         - $ref: "#/components/parameters/stream_src_path"
-      responses: { }
+      responses:
+            default:
+              description: Default response
 
   /api/webtorrent:
     get:

docker/Dockerfile

@@ -2,11 +2,7 @@
 
 # 0. Prepare images
 ARG PYTHON_VERSION="3.11"
-ARG GO_VERSION="1.20"
-ARG NGROK_VERSION="3"
-
-FROM python:${PYTHON_VERSION}-alpine AS base
-FROM ngrok/ngrok:${NGROK_VERSION}-alpine AS ngrok
+ARG GO_VERSION="1.24"
 
 
 # 1. Build go2rtc binary
@@ -20,6 +16,8 @@ ENV GOARCH=${TARGETARCH}
 
 WORKDIR /build
 
+RUN apk add git
+
 # Cache dependencies
 COPY go.mod go.sum ./
 RUN --mount=type=cache,target=/root/.cache/go-build go mod download
@@ -28,21 +26,14 @@ COPY . .
 RUN --mount=type=cache,target=/root/.cache/go-build CGO_ENABLED=0 go build -ldflags "-s -w" -trimpath
 
 
-# 2. Collect all files
-FROM scratch AS rootfs
-
-COPY --from=build /build/go2rtc /usr/local/bin/
-COPY --from=ngrok /bin/ngrok /usr/local/bin/
-
-
-# 3. Final image
-FROM base
+# 2. Final image
+FROM python:${PYTHON_VERSION}-alpine AS base
 
 # Install ffmpeg, tini (for signal handling),
 # and other common tools for the echo source.
 # alsa-plugins-pulse for ALSA support (+0MB)
 # font-droid for FFmpeg drawtext filter (+2MB)
-RUN apk add --no-cache tini ffmpeg bash curl jq alsa-plugins-pulse font-droid
+RUN apk add --no-cache tini ffmpeg ffplay bash curl jq alsa-plugins-pulse font-droid
 
 # Hardware Acceleration for Intel CPU (+50MB)
 ARG TARGETARCH
@@ -54,7 +45,7 @@ RUN if [ "${TARGETARCH}" = "amd64" ]; then apk add --no-cache libva-intel-driver
 # Hardware: AMD and NVidia VDPAU (not sure about this)
 # RUN libva-vdpau-driver mesa-vdpau-gallium (+150MB total)
 
-COPY --from=rootfs / /
+COPY --from=build /build/go2rtc /usr/local/bin/
 
 ENTRYPOINT ["/sbin/tini", "--"]
 VOLUME /config

docker/README.md

@@ -0,0 +1,50 @@
+## Versions
+
+- `alexxit/go2rtc:latest` - latest release based on `alpine` (`amd64`, `386`, `arm/v6`, `arm/v7`, `arm64`) with support hardware transcoding for Intel iGPU and Raspberry
+- `alexxit/go2rtc:latest-hardware` - latest release based on `debian 13` (`amd64`) with support hardware transcoding for Intel iGPU, AMD GPU and NVidia GPU
+- `alexxit/go2rtc:latest-rockchip` - latest release based on `debian 12` (`arm64`) with support hardware transcoding for Rockchip RK35xx
+- `alexxit/go2rtc:master` - latest unstable version based on `alpine`
+- `alexxit/go2rtc:master-hardware` - latest unstable version based on `debian 13` (`amd64`)
+- `alexxit/go2rtc:master-rockchip` - latest unstable version based on `debian 12` (`arm64`)
+
+## Docker compose
+
+```yaml
+services:
+  go2rtc:
+    image: alexxit/go2rtc
+    network_mode: host       # important for WebRTC, HomeKit, UDP cameras
+    privileged: true         # only for FFmpeg hardware transcoding
+    restart: unless-stopped  # autorestart on fail or config change from WebUI
+    environment:
+      - TZ=Atlantic/Bermuda  # timezone in logs
+    volumes:
+      - "~/go2rtc:/config"   # folder for go2rtc.yaml file (edit from WebUI)
+```
+
+## Basic Deployment
+
+```bash
+docker run -d \
+  --name go2rtc \
+  --network host \
+  --privileged \
+  --restart unless-stopped \
+  -e TZ=Atlantic/Bermuda \
+  -v ~/go2rtc:/config \
+  alexxit/go2rtc
+```
+
+## Deployment with GPU Acceleration
+
+```bash
+docker run -d \
+  --name go2rtc \
+  --network host \
+  --privileged \
+  --restart unless-stopped \
+  -e TZ=Atlantic/Bermuda \
+  --gpus all \
+  -v ~/go2rtc:/config \
+  alexxit/go2rtc:latest-hardware
+```

docker/hardware.Dockerfile

@@ -1,18 +1,14 @@
 # syntax=docker/dockerfile:labs
 
 # 0. Prepare images
-# only debian 12 (bookworm) has latest ffmpeg
-ARG DEBIAN_VERSION="bookworm-slim"
-ARG GO_VERSION="1.20-buster"
-ARG NGROK_VERSION="3"
-
-FROM debian:${DEBIAN_VERSION} AS base
-FROM golang:${GO_VERSION} AS go
-FROM ngrok/ngrok:${NGROK_VERSION} AS ngrok
+# only debian 13 (trixie) has latest ffmpeg
+# https://packages.debian.org/trixie/ffmpeg
+ARG DEBIAN_VERSION="trixie-slim"
+ARG GO_VERSION="1.24-bookworm"
 
 
 # 1. Build go2rtc binary
-FROM --platform=$BUILDPLATFORM go AS build
+FROM --platform=$BUILDPLATFORM golang:${GO_VERSION} AS build
 ARG TARGETPLATFORM
 ARG TARGETOS
 ARG TARGETARCH
@@ -30,31 +26,28 @@ COPY . .
 RUN --mount=type=cache,target=/root/.cache/go-build CGO_ENABLED=0 go build -ldflags "-s -w" -trimpath
 
 
-# 2. Collect all files
-FROM scratch AS rootfs
+# 2. Final image
+FROM debian:${DEBIAN_VERSION}
 
-COPY --link --from=build /build/go2rtc /usr/local/bin/
-COPY --link --from=ngrok /bin/ngrok /usr/local/bin/
-
-# 3. Final image
-FROM base
 # Prepare apt for buildkit cache
 RUN rm -f /etc/apt/apt.conf.d/docker-clean \
   && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' >/etc/apt/apt.conf.d/keep-cache
-# Install ffmpeg, bash (for run.sh), tini (for signal handling),
+
+# Install ffmpeg, tini (for signal handling),
 # and other common tools for the echo source.
 # non-free for Intel QSV support (not used by go2rtc, just for tests)
+# mesa-va-drivers for AMD APU
 # libasound2-plugins for ALSA support
 RUN --mount=type=cache,target=/var/cache/apt,sharing=locked --mount=type=cache,target=/var/lib/apt,sharing=locked \
-    echo 'deb http://deb.debian.org/debian bookworm non-free' > /etc/apt/sources.list.d/debian-non-free.list && \
-    apt-get -y update && apt-get -y install tini ffmpeg \
+    echo 'deb http://deb.debian.org/debian trixie non-free' > /etc/apt/sources.list.d/debian-non-free.list && \
+    apt-get -y update && apt-get -y install ffmpeg tini \
         python3 curl jq \
         intel-media-va-driver-non-free \
-        libasound2-plugins
-
-COPY --link --from=rootfs / /
-
+        mesa-va-drivers \
+        libasound2-plugins && \
+    apt-get clean && rm -rf /var/lib/apt/lists/*
 
+COPY --from=build /build/go2rtc /usr/local/bin/
 
 ENTRYPOINT ["/usr/bin/tini", "--"]
 VOLUME /config

docker/rockchip.Dockerfile

@@ -0,0 +1,50 @@
+# syntax=docker/dockerfile:labs
+
+# 0. Prepare images
+ARG PYTHON_VERSION="3.13-slim-bookworm"
+ARG GO_VERSION="1.24-bookworm"
+
+
+# 1. Build go2rtc binary
+FROM --platform=$BUILDPLATFORM golang:${GO_VERSION} AS build
+ARG TARGETPLATFORM
+ARG TARGETOS
+ARG TARGETARCH
+
+ENV GOOS=${TARGETOS}
+ENV GOARCH=${TARGETARCH}
+
+WORKDIR /build
+
+# Cache dependencies
+COPY go.mod go.sum ./
+RUN --mount=type=cache,target=/root/.cache/go-build go mod download
+
+COPY . .
+RUN --mount=type=cache,target=/root/.cache/go-build CGO_ENABLED=0 go build -ldflags "-s -w" -trimpath
+
+
+# 2. Final image
+FROM python:${PYTHON_VERSION}
+
+# Prepare apt for buildkit cache
+RUN rm -f /etc/apt/apt.conf.d/docker-clean \
+  && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' >/etc/apt/apt.conf.d/keep-cache
+
+# Install ffmpeg, tini (for signal handling),
+# and other common tools for the echo source.
+# libasound2-plugins for ALSA support
+RUN --mount=type=cache,target=/var/cache/apt,sharing=locked --mount=type=cache,target=/var/lib/apt,sharing=locked \
+    apt-get -y update && apt-get -y install tini \
+        curl jq \
+        libasound2-plugins && \
+    apt-get clean && rm -rf /var/lib/apt/lists/*
+
+COPY --from=build /build/go2rtc /usr/local/bin/
+ADD --chmod=755 https://github.com/MarcA711/Rockchip-FFmpeg-Builds/releases/download/6.1-8-no_extra_dump/ffmpeg /usr/local/bin
+
+ENTRYPOINT ["/usr/bin/tini", "--"]
+VOLUME /config
+WORKDIR /config
+
+CMD ["go2rtc", "-config", "/config/go2rtc.yaml"]

examples/go2rtc_mjpeg/main.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/api/ws"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/ffmpeg"
+	"github.com/AlexxIT/go2rtc/internal/mjpeg"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/internal/v4l2"
+	"github.com/AlexxIT/go2rtc/pkg/shell"
+)
+
+func main() {
+	app.Init()
+	streams.Init()
+
+	api.Init()
+	ws.Init()
+
+	ffmpeg.Init()
+	mjpeg.Init()
+	v4l2.Init()
+
+	shell.RunUntilSignal()
+}

examples/homekit_info/main.go

@@ -0,0 +1,123 @@
+package main
+
+import (
+	"encoding/json"
+	"os"
+
+	"github.com/AlexxIT/go2rtc/pkg/hap"
+)
+
+var servs = map[string]string{
+	"3E":  "Accessory Information",
+	"7E":  "Security System",
+	"85":  "Motion Sensor",
+	"96":  "Battery",
+	"A2":  "Protocol Information",
+	"110": "Camera RTP Stream Management",
+	"112": "Microphone",
+	"113": "Speaker",
+	"121": "Doorbell",
+	"129": "Data Stream Transport Management",
+	"204": "Camera Recording Management",
+	"21A": "Camera Operating Mode",
+	"22A": "Wi-Fi Transport",
+	"239": "Accessory Runtime Information",
+}
+
+var chars = map[string]string{
+	"14":  "Identify",
+	"20":  "Manufacturer",
+	"21":  "Model",
+	"23":  "Name",
+	"30":  "Serial Number",
+	"52":  "Firmware Revision",
+	"53":  "Hardware Revision",
+	"220": "Product Data",
+	"A6":  "Accessory Flags",
+
+	"22": "Motion Detected",
+	"75": "Status Active",
+
+	"11A": "Mute",
+	"119": "Volume",
+
+	"B0":  "Active",
+	"209": "Selected Camera Recording Configuration",
+	"207": "Supported Audio Recording Configuration",
+	"205": "Supported Camera Recording Configuration",
+	"206": "Supported Video Recording Configuration",
+	"226": "Recording Audio Active",
+
+	"223": "Event Snapshots Active",
+	"225": "Periodic Snapshots Active",
+	"21B": "HomeKit Camera Active",
+	"21C": "Third Party Camera Active",
+	"21D": "Camera Operating Mode Indicator",
+	"11B": "Night Vision",
+	//"129": "Supported Data Stream Transport Configuration",
+	"37":  "Version",
+	"131": "Setup Data Stream Transport",
+	"130": "Supported Data Stream Transport Configuration",
+
+	"120": "Streaming Status",
+	"115": "Supported Audio Stream Configuration",
+	"116": "Supported RTP Configuration",
+	"114": "Supported Video Stream Configuration",
+	"117": "Selected RTP Stream Configuration",
+	"118": "Setup Endpoints",
+
+	"22B": "Current Transport",
+	"22C": "Wi-Fi Capabilities",
+	"22D": "Wi-Fi Configuration Control",
+
+	"23C": "Ping",
+
+	"68": "Battery Level",
+	"79": "Status Low Battery",
+	"8F": "Charging State",
+
+	"73":  "Programmable Switch Event",
+	"232": "Operating State Response",
+
+	"66": "Security System Current State",
+	"67": "Security System Target State",
+}
+
+func main() {
+	src := os.Args[1]
+	dst := os.Args[2]
+
+	f, err := os.Open(src)
+	if err != nil {
+		panic(err)
+	}
+
+	var v hap.JSONAccessories
+	if err = json.NewDecoder(f).Decode(&v); err != nil {
+		panic(err)
+	}
+
+	for _, acc := range v.Value {
+		for _, srv := range acc.Services {
+			if srv.Desc == "" {
+				srv.Desc = servs[srv.Type]
+			}
+			for _, chr := range srv.Characters {
+				if chr.Desc == "" {
+					chr.Desc = chars[chr.Type]
+				}
+			}
+		}
+	}
+
+	f, err = os.Create(dst)
+	if err != nil {
+		panic(err)
+	}
+
+	enc := json.NewEncoder(f)
+	enc.SetIndent("", "  ")
+	if err = enc.Encode(v); err != nil {
+		panic(err)
+	}
+}

examples/onvif_client/README.md

@@ -0,0 +1,5 @@
+## Example
+
+```shell
+go run examples/onvif_client/main.go http://admin:password@192.168.10.90 GetAudioEncoderConfigurations
+```

examples/onvif_client/main.go

@@ -0,0 +1,75 @@
+package main
+
+import (
+	"log"
+	"net/url"
+	"os"
+
+	"github.com/AlexxIT/go2rtc/pkg/onvif"
+)
+
+func main() {
+	var rawURL = os.Args[1]
+	var operation = os.Args[2]
+	var token string
+	if len(os.Args) > 3 {
+		token = os.Args[3]
+	}
+
+	client, err := onvif.NewClient(rawURL)
+	if err != nil {
+		log.Panic(err)
+	}
+
+	var b []byte
+
+	switch operation {
+	case onvif.ServiceGetServiceCapabilities:
+		b, err = client.MediaRequest(operation)
+	case onvif.DeviceGetCapabilities,
+		onvif.DeviceGetDeviceInformation,
+		onvif.DeviceGetDiscoveryMode,
+		onvif.DeviceGetDNS,
+		onvif.DeviceGetHostname,
+		onvif.DeviceGetNetworkDefaultGateway,
+		onvif.DeviceGetNetworkInterfaces,
+		onvif.DeviceGetNetworkProtocols,
+		onvif.DeviceGetNTP,
+		onvif.DeviceGetScopes,
+		onvif.DeviceGetServices,
+		onvif.DeviceGetSystemDateAndTime,
+		onvif.DeviceSystemReboot:
+		b, err = client.DeviceRequest(operation)
+	case onvif.MediaGetProfiles,
+		onvif.MediaGetVideoEncoderConfigurations,
+		onvif.MediaGetVideoSources,
+		onvif.MediaGetVideoSourceConfigurations,
+		onvif.MediaGetAudioEncoderConfigurations,
+		onvif.MediaGetAudioSources,
+		onvif.MediaGetAudioSourceConfigurations:
+		b, err = client.MediaRequest(operation)
+	case onvif.MediaGetProfile:
+		b, err = client.GetProfile(token)
+	case onvif.MediaGetVideoSourceConfiguration:
+		b, err = client.GetVideoSourceConfiguration(token)
+	case onvif.MediaGetStreamUri:
+		b, err = client.GetStreamUri(token)
+	case onvif.MediaGetSnapshotUri:
+		b, err = client.GetSnapshotUri(token)
+	default:
+		log.Printf("unknown action\n")
+	}
+
+	if err != nil {
+		log.Printf("%s\n", err)
+	}
+
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if err = os.WriteFile(u.Hostname()+"_"+operation+".xml", b, 0644); err != nil {
+		log.Printf("%s\n", err)
+	}
+}

examples/rtsp_client/main.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"log"
+	"os"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/rtsp"
+	"github.com/AlexxIT/go2rtc/pkg/shell"
+)
+
+func main() {
+	client := rtsp.NewClient(os.Args[1])
+	if err := client.Dial(); err != nil {
+		log.Panic(err)
+	}
+
+	client.Medias = []*core.Media{
+		{
+			Kind:      core.KindAudio,
+			Direction: core.DirectionRecvonly,
+			Codecs: []*core.Codec{
+				{Name: core.CodecPCMU, ClockRate: 8000},
+			},
+			ID: "streamid=0",
+		},
+	}
+	if err := client.Announce(); err != nil {
+		log.Panic(err)
+	}
+	if _, err := client.SetupMedia(client.Medias[0]); err != nil {
+		log.Panic(err)
+	}
+	if err := client.Record(); err != nil {
+		log.Panic(err)
+	}
+
+	shell.RunUntilSignal()
+}

go.mod

@@ -3,55 +3,47 @@ module github.com/AlexxIT/go2rtc
 go 1.20
 
 require (
-	github.com/brutella/hap v0.0.17
-	github.com/deepch/vdk v0.0.19
-	github.com/gorilla/websocket v1.5.0
-	github.com/miekg/dns v1.1.55
-	github.com/pion/ice/v2 v2.3.9
-	github.com/pion/interceptor v0.1.17
-	github.com/pion/rtcp v1.2.10
-	github.com/pion/rtp v1.7.13
-	github.com/pion/sdp/v3 v3.0.6
-	github.com/pion/srtp/v2 v2.0.15
-	github.com/pion/stun v0.6.1
-	github.com/pion/webrtc/v3 v3.2.12
-	github.com/rs/zerolog v1.29.1
-	github.com/sigurn/crc16 v0.0.0-20211026045750-20ab5afb07e3
+	github.com/asticode/go-astits v1.13.0
+	github.com/expr-lang/expr v1.17.2
+	github.com/google/uuid v1.6.0
+	github.com/gorilla/websocket v1.5.3
+	github.com/mattn/go-isatty v0.0.20
+	github.com/miekg/dns v1.1.63
+	github.com/pion/ice/v4 v4.0.9
+	github.com/pion/interceptor v0.1.37
+	github.com/pion/rtcp v1.2.15
+	github.com/pion/rtp v1.8.13
+	github.com/pion/sdp/v3 v3.0.11
+	github.com/pion/srtp/v3 v3.0.4
+	github.com/pion/stun/v3 v3.0.0
+	github.com/pion/webrtc/v4 v4.0.14
+	github.com/rs/zerolog v1.34.0
+	github.com/sigurn/crc16 v0.0.0-20240131213347-83fcde1e29d1
 	github.com/sigurn/crc8 v0.0.0-20220107193325-2243fe600f9f
-	github.com/stretchr/testify v1.8.4
+	github.com/stretchr/testify v1.10.0
 	github.com/tadglines/go-pkgs v0.0.0-20210623144937-b983b20f54f9
+	golang.org/x/crypto v0.33.0
 	gopkg.in/yaml.v3 v3.0.1
 )
 
 require (
-	github.com/brutella/dnssd v1.2.9 // indirect
+	github.com/asticode/go-astikit v0.54.0 // indirect
 	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.13 // indirect
-	github.com/mattn/go-isatty v0.0.19 // indirect
-	github.com/pion/datachannel v1.5.5 // indirect
-	github.com/pion/dtls/v2 v2.2.7 // indirect
-	github.com/pion/logging v0.2.2 // indirect
-	github.com/pion/mdns v0.0.7 // indirect
+	github.com/kr/pretty v0.3.1 // indirect
+	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/pion/datachannel v1.5.10 // indirect
+	github.com/pion/dtls/v3 v3.0.6 // indirect
+	github.com/pion/logging v0.2.3 // indirect
+	github.com/pion/mdns/v2 v2.0.7 // indirect
 	github.com/pion/randutil v0.1.0 // indirect
-	github.com/pion/sctp v1.8.7 // indirect
-	github.com/pion/transport/v2 v2.2.1 // indirect
-	github.com/pion/turn/v2 v2.1.2 // indirect
+	github.com/pion/sctp v1.8.37 // indirect
+	github.com/pion/transport/v3 v3.0.7 // indirect
+	github.com/pion/turn/v4 v4.0.0 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/xiam/to v0.0.0-20200126224905-d60d31e03561 // indirect
-	golang.org/x/crypto v0.11.0 // indirect
-	golang.org/x/mod v0.12.0 // indirect
-	golang.org/x/net v0.12.0 // indirect
-	golang.org/x/sys v0.10.0 // indirect
-	golang.org/x/text v0.11.0 // indirect
-	golang.org/x/tools v0.11.0 // indirect
-)
-
-replace (
-	// RTP tlv8 fix
-	github.com/brutella/hap v0.0.17 => github.com/AlexxIT/hap v0.0.15-0.20221108133010-d8a45b7a7045
-	// fix reading AAC config bytes
-	github.com/deepch/vdk v0.0.19 => github.com/AlexxIT/vdk v0.0.18-0.20221108193131-6168555b4f92
+	github.com/wlynxg/anet v0.0.5 // indirect
+	golang.org/x/mod v0.20.0 // indirect
+	golang.org/x/net v0.35.0 // indirect
+	golang.org/x/sync v0.11.0 // indirect
+	golang.org/x/sys v0.30.0 // indirect
+	golang.org/x/tools v0.24.0 // indirect
 )

go.sum

@@ -1,253 +1,104 @@
-github.com/AlexxIT/hap v0.0.15-0.20221108133010-d8a45b7a7045 h1:xJf3FxQJReJSDyYXJfI1NUWv8tUEAGNV9xigLqNtmrI=
-github.com/AlexxIT/hap v0.0.15-0.20221108133010-d8a45b7a7045/go.mod h1:QNA3sm16zE5uUyC8+E/gNkMvQWjqQLuxQKkU5PMi8N4=
-github.com/AlexxIT/vdk v0.0.18-0.20221108193131-6168555b4f92 h1:cIeYMGaAirSZnrKRDTb5VgZDDYqPLhYiczElMg4sQW0=
-github.com/AlexxIT/vdk v0.0.18-0.20221108193131-6168555b4f92/go.mod h1:7ydHfSkflMZxBXfWR79dMjrT54xzvLxnPaByOa9Jpzg=
-github.com/brutella/dnssd v1.2.3/go.mod h1:JoW2sJUrmVIef25G6lrLj7HS6Xdwh6q8WUIvMkkBYXs=
-github.com/brutella/dnssd v1.2.9 h1:eUqO0qXZAMaFN4W4Ms1AAO/OtAbNoh9U87GAlN+1FCs=
-github.com/brutella/dnssd v1.2.9/go.mod h1:yZ+GHHbGhtp5yJeKTnppdFGiy6OhiPoxs0WHW1KUcFA=
+github.com/asticode/go-astikit v0.30.0/go.mod h1:h4ly7idim1tNhaVkdVBeXQZEE3L0xblP7fCWbgwipF0=
+github.com/asticode/go-astikit v0.54.0 h1:uq9eurgisdkYwJU9vSWIQaPH4MH0cac82sQH00kmSNQ=
+github.com/asticode/go-astikit v0.54.0/go.mod h1:fV43j20UZYfXzP9oBn33udkvCvDvCDhzjVqoLFuuYZE=
+github.com/asticode/go-astits v1.13.0 h1:XOgkaadfZODnyZRR5Y0/DWkA9vrkLLPLeeOvDwfKZ1c=
+github.com/asticode/go-astits v1.13.0/go.mod h1:QSHmknZ51pf6KJdHKZHJTLlMegIrhega3LPWz3ND/iI=
 github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 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=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
-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/expr-lang/expr v1.17.2 h1:o0A99O/Px+/DTjEnQiodAgOIK9PPxL8DtXhBRKC+Iso=
+github.com/expr-lang/expr v1.17.2/go.mod h1:8/vRC7+7HBzESEqt5kKpYXxrxkr31SaO8r40VO/1IT4=
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
-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=
-github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
-github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
-github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
-github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
-github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-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.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=
-github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
-github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
-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/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
-github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
-github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
+github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
+github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/miekg/dns v1.1.50/go.mod h1:e3IlAVfNqAllflbibAZEWOXOQ+Ynzk/dDozDxY7XnME=
-github.com/miekg/dns v1.1.55 h1:GoQ4hpsj0nFLYe+bWiCToyrBEJXkQfOOIvFGFy0lEgo=
-github.com/miekg/dns v1.1.55/go.mod h1:uInx36IzPl7FYnDcMeVWxj9byh7DutNykX4G9Sj60FY=
-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.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.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.5.5 h1:10ef4kwdjije+M9d7Xm9im2Y3O6A6ccQb0zcqZcJew8=
-github.com/pion/datachannel v1.5.5/go.mod h1:iMz+lECmfdCMqFRhXhcA/219B0SQlbpoR2V118yimL0=
-github.com/pion/dtls/v2 v2.2.7 h1:cSUBsETxepsCSFSxC3mc/aDo14qQLMSL+O6IjG28yV8=
-github.com/pion/dtls/v2 v2.2.7/go.mod h1:8WiMkebSHFD0T+dIU+UeBaoV7kDhOW5oDCzZ7WZ/F9s=
-github.com/pion/ice/v2 v2.3.9 h1:7yZpHf3PhPxJGT4JkMj1Y8Rl5cQ6fB709iz99aeMd/U=
-github.com/pion/ice/v2 v2.3.9/go.mod h1:lT3kv5uUIlHfXHU/ZRD7uKD/ufM202+eTa3C/umgGf4=
-github.com/pion/interceptor v0.1.17 h1:prJtgwFh/gB8zMqGZoOgJPHivOwVAp61i2aG61Du/1w=
-github.com/pion/interceptor v0.1.17/go.mod h1:SY8kpmfVBvrbUzvj2bsXz7OJt5JvmVNZ+4Kjq7FcwrI=
-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.7 h1:P0UB4Sr6xDWEox0kTVxF0LmQihtCbSAdW0H2nEgkA3U=
-github.com/pion/mdns v0.0.7/go.mod h1:4iP2UbeFhLI/vWju/bw6ZfwjJzk0z8DNValjGxR/dD8=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/miekg/dns v1.1.63 h1:8M5aAw6OMZfFXTT7K5V0Eu5YiiL8l7nUAkyN6C9YwaY=
+github.com/miekg/dns v1.1.63/go.mod h1:6NGHfjhpmr5lt3XPLuyfDJi5AXbNIPM9PY6H6sF1Nfs=
+github.com/pion/datachannel v1.5.10 h1:ly0Q26K1i6ZkGf42W7D4hQYR90pZwzFOjTq5AuCKk4o=
+github.com/pion/datachannel v1.5.10/go.mod h1:p/jJfC9arb29W7WrxyKbepTU20CFgyx5oLo8Rs4Py/M=
+github.com/pion/dtls/v3 v3.0.6 h1:7Hkd8WhAJNbRgq9RgdNh1aaWlZlGpYTzdqjy9x9sK2E=
+github.com/pion/dtls/v3 v3.0.6/go.mod h1:iJxNQ3Uhn1NZWOMWlLxEEHAN5yX7GyPvvKw04v9bzYU=
+github.com/pion/ice/v4 v4.0.9 h1:VKgU4MwA2LUDVLq+WBkpEHTcAb8c5iCvFMECeuPOZNk=
+github.com/pion/ice/v4 v4.0.9/go.mod h1:y3M18aPhIxLlcO/4dn9X8LzLLSma84cx6emMSu14FGw=
+github.com/pion/interceptor v0.1.37 h1:aRA8Zpab/wE7/c0O3fh1PqY0AJI3fCSEM5lRWJVorwI=
+github.com/pion/interceptor v0.1.37/go.mod h1:JzxbJ4umVTlZAf+/utHzNesY8tmRkM2lVmkS82TTj8Y=
+github.com/pion/logging v0.2.3 h1:gHuf0zpoh1GW67Nr6Gj4cv5Z9ZscU7g/EaoC/Ke/igI=
+github.com/pion/logging v0.2.3/go.mod h1:z8YfknkquMe1csOrxK5kc+5/ZPAzMxbKLX5aXpbpC90=
+github.com/pion/mdns/v2 v2.0.7 h1:c9kM8ewCgjslaAmicYMFQIde2H9/lrZpjBkN8VwoVtM=
+github.com/pion/mdns/v2 v2.0.7/go.mod h1:vAdSYNAT0Jy3Ru0zl2YiW3Rm/fJCwIeM0nToenfOJKA=
 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.10 h1:nkr3uj+8Sp97zyItdN60tE/S6vk4al5CPRR6Gejsdjc=
-github.com/pion/rtcp v1.2.10/go.mod h1:ztfEwXZNLGyF1oQDttz/ZKIBaeeg/oWbRYqzBM9TL1I=
-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.8.5/go.mod h1:SUFFfDpViyKejTAdwD1d/HQsCu+V/40cCs2nZIvC3s0=
-github.com/pion/sctp v1.8.7 h1:JnABvFakZueGAn4KU/4PSKg+GWbF6QWbKTWZOSGJjXw=
-github.com/pion/sctp v1.8.7/go.mod h1:g1Ul+ARqZq5JEmoFy87Q/4CePtKnTJ1QCL9dBBdN6AU=
-github.com/pion/sdp/v3 v3.0.6 h1:WuDLhtuFUUVpTfus9ILC4HRyHsW6TdugjEX/QY9OiUw=
-github.com/pion/sdp/v3 v3.0.6/go.mod h1:iiFWFpQO8Fy3S5ldclBkpXqmWy02ns78NOKoLLL0YQw=
-github.com/pion/srtp/v2 v2.0.15 h1:+tqRtXGsGwHC0G0IUIAzRmdkHvriF79IHVfZGfHrQoA=
-github.com/pion/srtp/v2 v2.0.15/go.mod h1:b/pQOlDrbB0HEH5EUAQXzSYxikFbNcNuKmF8tM0hCtw=
-github.com/pion/stun v0.6.1 h1:8lp6YejULeHBF8NmV8e2787BogQhduZugh5PdhDyyN4=
-github.com/pion/stun v0.6.1/go.mod h1:/hO7APkX4hZKu/D0f2lHzNyvdkTGtIy3NDmLR7kSz/8=
-github.com/pion/transport v0.14.1 h1:XSM6olwW+o8J4SCmOBb/BpwZypkHeyM0PGFCxNQBr40=
-github.com/pion/transport v0.14.1/go.mod h1:4tGmbk00NeYA3rUa9+n+dzCCoKkcy3YlYb99Jn2fNnI=
-github.com/pion/transport/v2 v2.0.0/go.mod h1:HS2MEBJTwD+1ZI2eSXSvHJx/HnzQqRy2/LXxt6eVMHc=
-github.com/pion/transport/v2 v2.1.0/go.mod h1:AdSw4YBZVDkZm8fpoz+fclXyQwANWmZAlDuQdctTThQ=
-github.com/pion/transport/v2 v2.2.0/go.mod h1:AdSw4YBZVDkZm8fpoz+fclXyQwANWmZAlDuQdctTThQ=
-github.com/pion/transport/v2 v2.2.1 h1:7qYnCBlpgSJNYMbLCKuSY9KbQdBFoETvPNETv0y4N7c=
-github.com/pion/transport/v2 v2.2.1/go.mod h1:cXXWavvCnFF6McHTft3DWS9iic2Mftcz1Aq29pGcU5g=
-github.com/pion/turn/v2 v2.1.2 h1:wj0cAoGKltaZ790XEGW9HwoUewqjliwmhtxCuB2ApyM=
-github.com/pion/turn/v2 v2.1.2/go.mod h1:1kjnPkBcex3dhCU2Am+AAmxDcGhLX3WnMfmkNpvSTQU=
-github.com/pion/webrtc/v3 v3.2.12 h1:pVqz5NdtTqyhKIhMcXR8bPp709kCf9blyAhDjoVRLvA=
-github.com/pion/webrtc/v3 v3.2.12/go.mod h1:/Oz6K95CGWaN+3No+Z0NYvgOPOr3aY8UyTlMm/dec3A=
+github.com/pion/rtcp v1.2.15 h1:LZQi2JbdipLOj4eBjK4wlVoQWfrZbh3Q6eHtWtJBZBo=
+github.com/pion/rtcp v1.2.15/go.mod h1:jlGuAjHMEXwMUHK78RgX0UmEJFV4zUKOFHR7OP+D3D0=
+github.com/pion/rtp v1.8.13 h1:8uSUPpjSL4OlwZI8Ygqu7+h2p9NPFB+yAZ461Xn5sNg=
+github.com/pion/rtp v1.8.13/go.mod h1:8uMBJj32Pa1wwx8Fuv/AsFhn8jsgw+3rUC2PfoBZ8p4=
+github.com/pion/sctp v1.8.37 h1:ZDmGPtRPX9mKCiVXtMbTWybFw3z/hVKAZgU81wcOrqs=
+github.com/pion/sctp v1.8.37/go.mod h1:cNiLdchXra8fHQwmIoqw0MbLLMs+f7uQ+dGMG2gWebE=
+github.com/pion/sdp/v3 v3.0.11 h1:VhgVSopdsBKwhCFoyyPmT1fKMeV9nLMrEKxNOdy3IVI=
+github.com/pion/sdp/v3 v3.0.11/go.mod h1:88GMahN5xnScv1hIMTqLdu/cOcUkj6a9ytbncwMCq2E=
+github.com/pion/srtp/v3 v3.0.4 h1:2Z6vDVxzrX3UHEgrUyIGM4rRouoC7v+NiF1IHtp9B5M=
+github.com/pion/srtp/v3 v3.0.4/go.mod h1:1Jx3FwDoxpRaTh1oRV8A/6G1BnFL+QI82eK4ms8EEJQ=
+github.com/pion/stun/v3 v3.0.0 h1:4h1gwhWLWuZWOJIJR9s2ferRO+W3zA/b6ijOI6mKzUw=
+github.com/pion/stun/v3 v3.0.0/go.mod h1:HvCN8txt8mwi4FBvS3EmDghW6aQJ24T+y+1TKjB5jyU=
+github.com/pion/transport/v3 v3.0.7 h1:iRbMH05BzSNwhILHoBoAPxoB9xQgOaJk+591KC9P1o0=
+github.com/pion/transport/v3 v3.0.7/go.mod h1:YleKiTZ4vqNxVwh77Z0zytYi7rXHl7j6uPLGhhz9rwo=
+github.com/pion/turn/v4 v4.0.0 h1:qxplo3Rxa9Yg1xXDxxH8xaqcyGUtbHYw4QSCvmFWvhM=
+github.com/pion/turn/v4 v4.0.0/go.mod h1:MuPDkm15nYSklKpN8vWJ9W2M0PlyQZqYt1McGuxG7mA=
+github.com/pion/webrtc/v4 v4.0.14 h1:nyds/sFRR+HvmWoBa6wrL46sSfpArE0qR883MBW96lg=
+github.com/pion/webrtc/v4 v4.0.14/go.mod h1:R3+qTnQTS03UzwDarYecgioNf7DYgTsldxnCXB821Kk=
+github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/profile v1.4.0/go.mod h1:NWz/XGvpEW1FyYQ7fCx4dqYBLlfTcE+A9FLAkNKqjFE=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rs/xid v1.4.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
-github.com/rs/zerolog v1.29.1 h1:cO+d60CHkknCbvzEWxP0S9K6KqyTjrCNUy1LdQLCGPc=
-github.com/rs/zerolog v1.29.1/go.mod h1:Le6ESbR7hc+DP6Lt1THiV8CQSdkkNrd3R0XbEgp3ZBU=
-github.com/sclevine/agouti v3.0.0+incompatible/go.mod h1:b4WX9W9L1sfQKXeJf1mUTLZKJ48R1S7H23Ji7oFO5Bw=
-github.com/sigurn/crc16 v0.0.0-20211026045750-20ab5afb07e3 h1:aQKxg3+2p+IFXXg97McgDGT5zcMrQoi0EICZs8Pgchs=
-github.com/sigurn/crc16 v0.0.0-20211026045750-20ab5afb07e3/go.mod h1:9/etS5gpQq9BJsJMWg1wpLbfuSnkm8dPF6FdW2JXVhA=
+github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
+github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
+github.com/rs/zerolog v1.34.0 h1:k43nTLIwcTVQAncfCw4KZ2VY6ukYoZaBPNOE8txlOeY=
+github.com/rs/zerolog v1.34.0/go.mod h1:bJsvje4Z08ROH4Nhs5iH600c3IkWhwp44iRc54W6wYQ=
+github.com/sigurn/crc16 v0.0.0-20240131213347-83fcde1e29d1 h1:NVK+OqnavpyFmUiKfUMHrpvbCi2VFoWTrcpI7aDaJ2I=
+github.com/sigurn/crc16 v0.0.0-20240131213347-83fcde1e29d1/go.mod h1:9/etS5gpQq9BJsJMWg1wpLbfuSnkm8dPF6FdW2JXVhA=
 github.com/sigurn/crc8 v0.0.0-20220107193325-2243fe600f9f h1:1R9KdKjCNSd7F8iGTxIpoID9prlYH8nuNYKt0XvweHA=
 github.com/sigurn/crc8 v0.0.0-20220107193325-2243fe600f9f/go.mod h1:vQhwQ4meQEDfahT5kd61wLAF5AAeh5ZPLVI4JJ/tYo8=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
 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.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/tadglines/go-pkgs v0.0.0-20210623144937-b983b20f54f9 h1:aeN+ghOV0b2VCmKKO3gqnDQ8mLbpABZgRR2FVYx4ouI=
 github.com/tadglines/go-pkgs v0.0.0-20210623144937-b983b20f54f9/go.mod h1:roo6cZ/uqpwKMuvPG0YmzI5+AmUiMWfjCBZpGXqbTxE=
-github.com/xiam/to v0.0.0-20200126224905-d60d31e03561 h1:SVoNK97S6JlaYlHcaC+79tg3JUlQABcc0dH2VQ4Y+9s=
-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=
-github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
-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-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.0.0-20220131195533-30dcbda58838/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/crypto v0.8.0/go.mod h1:mRqEX+O9/h5TFCrQhkgjo2yKi0yYA+9ecGkdQoHrywE=
-golang.org/x/crypto v0.10.0/go.mod h1:o4eNf7Ede1fv+hwOwZsTHl9EsPFO6q6ZvYR8vYfY45I=
-golang.org/x/crypto v0.11.0 h1:6Ewdq3tDic1mg5xRO4milcWCfMVQhI4NkqWWvqejpuA=
-golang.org/x/crypto v0.11.0/go.mod h1:xgJhtzW8F9jGdVFWZESrid1U1bjeNy4zgy5cRr/CIio=
-golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/mod v0.12.0 h1:rmsUpXtvNzj340zd98LZ4KntptpfRHwpFOHG188oHXc=
-golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-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-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
-golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
-golang.org/x/net v0.0.0-20210726213435-c6fcb2dbf985/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco=
-golang.org/x/net v0.5.0/go.mod h1:DivGGAXEgPSlEBzxGzZI+ZLohi+xUj054jfeKui00ws=
-golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
-golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
-golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
-golang.org/x/net v0.11.0/go.mod h1:2L/ixqYpgIVXmeoSA/4Lu7BzTG4KIyPIryS4IsOd1oQ=
-golang.org/x/net v0.12.0 h1:cfawfvKITfUsFCeJIHJrbSxpeu/E81khclypR0GVT50=
-golang.org/x/net v0.12.0/go.mod h1:zEVYFnQC7m/vmpQFELhcD1EWkZlX69l4oqgmer6hfKA=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E=
-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-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-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=
-golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/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-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+github.com/wlynxg/anet v0.0.5 h1:J3VJGi1gvo0JwZ/P1/Yc/8p63SoW98B5dHkYDmpgvvU=
+github.com/wlynxg/anet v0.0.5/go.mod h1:eay5PRQr7fIVAMbTbchTnO9gG65Hg/uYGdc7mguHxoA=
+golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus=
+golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M=
+golang.org/x/mod v0.20.0 h1:utOm6MM3R3dnawAiJgn0y+xvuYRsm1RKM/4giyfDgV0=
+golang.org/x/mod v0.20.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/net v0.35.0 h1:T5GQRQb2y08kTAByq9L4/bz8cipCdA8FbRTXewonqY8=
+golang.org/x/net v0.35.0/go.mod h1:EglIi67kWsHKlRzzVMUD93VMSWGFOMSZgxFjparz1Qk=
+golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
+golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.9.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.10.0 h1:SqMFp9UcQJZa+pmYuAKjd9xq1f0j5rLcDIk0mj4qAsA=
-golang.org/x/sys v0.10.0/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/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/term v0.4.0/go.mod h1:9P2UbLfCdcvo3p/nzKvsmas4TnlujnuoV9hGgYzW1lQ=
-golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
-golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U=
-golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
-golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
-golang.org/x/term v0.9.0/go.mod h1:M6DEAAIenWoTxdKrOltXcmDY3rSplQUkrvaDU5FcQyo=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.6.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/text v0.10.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
-golang.org/x/text v0.11.0 h1:LAntKIrcmeSKERyiOh0XMV39LXS8IE9UL2yP7+f5ij4=
-golang.org/x/text v0.11.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
-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/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
-golang.org/x/tools v0.11.0 h1:EMCa6U9S2LtZXLAMoWiR/R8dAQFRqbAitmbJ2UKhoi8=
-golang.org/x/tools v0.11.0/go.mod h1:anzJrxPjNtfgiYQYirP2CPGzGLxrH2u2QBhn6Bf3qY8=
-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/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=
-google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
-google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
-google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
-google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
-google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
+golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/tools v0.24.0 h1:J1shsA93PJUEVaUSaay7UXAyE8aimq3GW0pjlolpa24=
+golang.org/x/tools v0.24.0/go.mod h1:YhNqVBIfWHdzvTLs0d8LCuMhkKUgSUKldakyV7W/WDQ=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
-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.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=
-gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/alsa/alsa.go

@@ -0,0 +1,7 @@
+//go:build !(linux && (386 || amd64 || arm || arm64 || mipsle))
+
+package alsa
+
+func Init() {
+	// not supported
+}

internal/alsa/alsa_linux.go

@@ -0,0 +1,83 @@
+//go:build linux && (386 || amd64 || arm || arm64 || mipsle)
+
+package alsa
+
+import (
+	"fmt"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/alsa"
+	"github.com/AlexxIT/go2rtc/pkg/alsa/device"
+)
+
+func Init() {
+	streams.HandleFunc("alsa", alsa.Open)
+
+	api.HandleFunc("api/alsa", apiAlsa)
+}
+
+func apiAlsa(w http.ResponseWriter, r *http.Request) {
+	files, err := os.ReadDir("/dev/snd/")
+	if err != nil {
+		return
+	}
+
+	var sources []*api.Source
+
+	for _, file := range files {
+		if !strings.HasPrefix(file.Name(), "pcm") {
+			continue
+		}
+
+		path := "/dev/snd/" + file.Name()
+
+		dev, err := device.Open(path)
+		if err != nil {
+			continue
+		}
+
+		info, err := dev.Info()
+		if err == nil {
+			formats := formatsToString(dev.ListFormats())
+			r1, r2 := dev.RangeRates()
+			c1, c2 := dev.RangeChannels()
+			source := &api.Source{
+				Name: info.ID,
+				Info: fmt.Sprintf("Formats: %s, Rates: %d-%d, Channels: %d-%d", formats, r1, r2, c1, c2),
+				URL:  "alsa:device?audio=" + path,
+			}
+			if !strings.Contains(source.Name, info.Name) {
+				source.Name += ", " + info.Name
+			}
+			sources = append(sources, source)
+		}
+
+		_ = dev.Close()
+	}
+
+	api.ResponseSources(w, sources)
+}
+
+func formatsToString(formats []byte) string {
+	var s string
+	for i, format := range formats {
+		if i > 0 {
+			s += " "
+		}
+		switch format {
+		case 2:
+			s += "s16le"
+		case 10:
+			s += "s32le"
+		default:
+			s += strconv.Itoa(int(format))
+		}
+
+	}
+	return s
+}

internal/api/api.go

@@ -10,6 +10,8 @@ import (
 	"strconv"
 	"strings"
 	"sync"
+	"syscall"
+	"time"
 
 	"github.com/AlexxIT/go2rtc/internal/app"
 	"github.com/rs/zerolog"
@@ -18,25 +20,26 @@ import (
 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"`
-			TLSListen string `yaml:"tls_listen"`
-			TLSCert   string `yaml:"tls_cert"`
-			TLSKey    string `yaml:"tls_key"`
+			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"`
+			TLSListen  string `yaml:"tls_listen"`
+			TLSCert    string `yaml:"tls_cert"`
+			TLSKey     string `yaml:"tls_key"`
+			UnixListen string `yaml:"unix_listen"`
 		} `yaml:"api"`
 	}
 
 	// default config
-	cfg.Mod.Listen = "0.0.0.0:1984"
+	cfg.Mod.Listen = ":1984"
 
 	// load config from YAML
 	app.LoadConfig(&cfg)
 
-	if cfg.Mod.Listen == "" {
+	if cfg.Mod.Listen == "" && cfg.Mod.UnixListen == "" && cfg.Mod.TLSListen == "" {
 		return
 	}
 
@@ -48,15 +51,8 @@ func Init() {
 	HandleFunc("api", apiHandler)
 	HandleFunc("api/config", configHandler)
 	HandleFunc("api/exit", exitHandler)
-
-	// ensure we can listen without errors
-	listener, err := net.Listen("tcp", cfg.Mod.Listen)
-	if err != nil {
-		log.Fatal().Err(err).Msg("[api] listen")
-		return
-	}
-
-	log.Info().Str("addr", cfg.Mod.Listen).Msg("[api] listen")
+	HandleFunc("api/restart", restartHandler)
+	HandleFunc("api/log", logHandler)
 
 	Handler = http.DefaultServeMux // 4th
 
@@ -72,45 +68,76 @@ func Init() {
 		Handler = middlewareLog(Handler) // 1st
 	}
 
-	go func() {
-		s := http.Server{}
-		s.Handler = Handler
-		if err = s.Serve(listener); err != nil {
-			log.Fatal().Err(err).Msg("[api] serve")
-		}
-	}()
+	if cfg.Mod.Listen != "" {
+		_, port, _ := net.SplitHostPort(cfg.Mod.Listen)
+		Port, _ = strconv.Atoi(port)
+		go listen("tcp", cfg.Mod.Listen)
+	}
+
+	if cfg.Mod.UnixListen != "" {
+		_ = syscall.Unlink(cfg.Mod.UnixListen)
+		go listen("unix", cfg.Mod.UnixListen)
+	}
 
 	// Initialize the HTTPS server
 	if cfg.Mod.TLSListen != "" && cfg.Mod.TLSCert != "" && cfg.Mod.TLSKey != "" {
-		cert, err := tls.X509KeyPair([]byte(cfg.Mod.TLSCert), []byte(cfg.Mod.TLSKey))
-		if err != nil {
-			log.Error().Err(err).Caller().Send()
-			return
-		}
-
-		tlsListener, err := net.Listen("tcp", cfg.Mod.TLSListen)
-		if err != nil {
-			log.Fatal().Err(err).Caller().Send()
-			return
-		}
-
-		log.Info().Str("addr", cfg.Mod.TLSListen).Msg("[api] tls listen")
-
-		tlsServer := &http.Server{
-			Handler: Handler,
-			TLSConfig: &tls.Config{
-				Certificates: []tls.Certificate{cert},
-			},
-		}
-
-		go func() {
-			if err := tlsServer.ServeTLS(tlsListener, "", ""); err != nil {
-				log.Fatal().Err(err).Msg("[api] tls serve")
-			}
-		}()
+		go tlsListen("tcp", cfg.Mod.TLSListen, cfg.Mod.TLSCert, cfg.Mod.TLSKey)
 	}
 }
 
+func listen(network, address string) {
+	ln, err := net.Listen(network, address)
+	if err != nil {
+		log.Error().Err(err).Msg("[api] listen")
+		return
+	}
+
+	log.Info().Str("addr", address).Msg("[api] listen")
+
+	server := http.Server{
+		Handler:           Handler,
+		ReadHeaderTimeout: 5 * time.Second, // Example: Set to 5 seconds
+	}
+	if err = server.Serve(ln); err != nil {
+		log.Fatal().Err(err).Msg("[api] serve")
+	}
+}
+
+func tlsListen(network, address, certFile, keyFile string) {
+	var cert tls.Certificate
+	var err error
+	if strings.IndexByte(certFile, '\n') < 0 && strings.IndexByte(keyFile, '\n') < 0 {
+		// check if file path
+		cert, err = tls.LoadX509KeyPair(certFile, keyFile)
+	} else {
+		// if text file content
+		cert, err = tls.X509KeyPair([]byte(certFile), []byte(keyFile))
+	}
+	if err != nil {
+		log.Error().Err(err).Caller().Send()
+		return
+	}
+
+	ln, err := net.Listen(network, address)
+	if err != nil {
+		log.Error().Err(err).Msg("[api] tls listen")
+		return
+	}
+
+	log.Info().Str("addr", address).Msg("[api] tls listen")
+
+	server := &http.Server{
+		Handler:           Handler,
+		TLSConfig:         &tls.Config{Certificates: []tls.Certificate{cert}},
+		ReadHeaderTimeout: 5 * time.Second,
+	}
+	if err = server.ServeTLS(ln, "", ""); err != nil {
+		log.Fatal().Err(err).Msg("[api] tls serve")
+	}
+}
+
+var Port int
+
 const (
 	MimeJSON = "application/json"
 	MimeText = "text/plain"
@@ -170,7 +197,7 @@ func middlewareLog(next http.Handler) http.Handler {
 
 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]") {
+		if !strings.HasPrefix(r.RemoteAddr, "127.") && !strings.HasPrefix(r.RemoteAddr, "[::1]") && r.RemoteAddr != "@" {
 			user, pass, ok := r.BasicAuth()
 			if !ok || user != username || pass != password {
 				w.Header().Set("Www-Authenticate", `Basic realm="go2rtc"`)
@@ -187,7 +214,7 @@ func middlewareCORS(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Access-Control-Allow-Origin", "*")
 		w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
-		w.Header().Set("Access-Control-Allow-Headers", "Authorization")
+		w.Header().Set("Access-Control-Allow-Headers", "Authorization, Content-Type")
 		next.ServeHTTP(w, r)
 	})
 }
@@ -209,25 +236,72 @@ func exitHandler(w http.ResponseWriter, r *http.Request) {
 	}
 
 	s := r.URL.Query().Get("code")
-	code, _ := strconv.Atoi(s)
+	code, err := strconv.Atoi(s)
+
+	// https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_08_02
+	if err != nil || code < 0 || code > 125 {
+		http.Error(w, "Code must be in the range [0, 125]", http.StatusBadRequest)
+		return
+	}
+
 	os.Exit(code)
 }
 
-type Stream struct {
-	Name string `json:"name"`
-	URL  string `json:"url"`
+func restartHandler(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		http.Error(w, "", http.StatusBadRequest)
+		return
+	}
+
+	path, err := os.Executable()
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	log.Debug().Msgf("[api] restart %s", path)
+
+	go syscall.Exec(path, os.Args, os.Environ())
 }
 
-func ResponseStreams(w http.ResponseWriter, streams []Stream) {
-	if len(streams) == 0 {
-		http.Error(w, "no streams", http.StatusNotFound)
+func logHandler(w http.ResponseWriter, r *http.Request) {
+	switch r.Method {
+	case "GET":
+		// Send current state of the log file immediately
+		w.Header().Set("Content-Type", "application/jsonlines")
+		_, _ = app.MemoryLog.WriteTo(w)
+	case "DELETE":
+		app.MemoryLog.Reset()
+		Response(w, "OK", "text/plain")
+	default:
+		http.Error(w, "Method not allowed", http.StatusBadRequest)
+	}
+}
+
+type Source struct {
+	ID       string `json:"id,omitempty"`
+	Name     string `json:"name,omitempty"`
+	Info     string `json:"info,omitempty"`
+	URL      string `json:"url,omitempty"`
+	Location string `json:"location,omitempty"`
+}
+
+func ResponseSources(w http.ResponseWriter, sources []*Source) {
+	if len(sources) == 0 {
+		http.Error(w, "no sources", http.StatusNotFound)
 		return
 	}
 
 	var response = struct {
-		Streams []Stream `json:"streams"`
+		Sources []*Source `json:"sources"`
 	}{
-		Streams: streams,
+		Sources: sources,
 	}
 	ResponseJSON(w, response)
 }
+
+func Error(w http.ResponseWriter, err error) {
+	log.Error().Err(err).Caller(1).Send()
+
+	http.Error(w, err.Error(), http.StatusInsufficientStorage)
+}

internal/api/config.go

@@ -1,11 +1,12 @@
 package api
 
 import (
-	"github.com/AlexxIT/go2rtc/internal/app"
-	"gopkg.in/yaml.v3"
 	"io"
 	"net/http"
 	"os"
+
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"gopkg.in/yaml.v3"
 )
 
 func configHandler(w http.ResponseWriter, r *http.Request) {
@@ -40,8 +41,7 @@ func configHandler(w http.ResponseWriter, r *http.Request) {
 			}
 		} else {
 			// validate config
-			var tmp struct{}
-			if err = yaml.Unmarshal(data, &tmp); err != nil {
+			if err = yaml.Unmarshal(data, map[string]any{}); err != nil {
 				http.Error(w, err.Error(), http.StatusInternalServerError)
 				return
 			}

internal/api/static.go

@@ -1,8 +1,9 @@
 package api
 
 import (
-	"github.com/AlexxIT/go2rtc/www"
 	"net/http"
+
+	"github.com/AlexxIT/go2rtc/www"
 )
 
 func initStatic(staticDir string) {

internal/api/ws/ws.go

@@ -1,15 +1,18 @@
 package ws
 
 import (
-	"github.com/AlexxIT/go2rtc/internal/api"
-	"github.com/AlexxIT/go2rtc/internal/app"
-	"github.com/gorilla/websocket"
-	"github.com/rs/zerolog/log"
+	"encoding/json"
+	"io"
 	"net/http"
 	"net/url"
 	"strings"
 	"sync"
 	"time"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/gorilla/websocket"
+	"github.com/rs/zerolog"
 )
 
 func Init() {
@@ -21,31 +24,34 @@ func Init() {
 
 	app.LoadConfig(&cfg)
 
+	log = app.GetLogger("api")
+
 	initWS(cfg.Mod.Origin)
 
 	api.HandleFunc("api/ws", apiWS)
 }
 
+var log zerolog.Logger
+
 // Message - struct for data exchange in Web API
 type Message struct {
 	Type  string `json:"type"`
 	Value any    `json:"value,omitempty"`
 }
 
-func (m *Message) String() string {
+func (m *Message) String() (value string) {
 	if s, ok := m.Value.(string); ok {
 		return s
 	}
-	return ""
+	return
 }
 
-func (m *Message) GetString(key string) string {
-	if v, ok := m.Value.(map[string]any); ok {
-		if s, ok := v[key].(string); ok {
-			return s
-		}
+func (m *Message) Unmarshal(v any) error {
+	b, err := json.Marshal(m.Value)
+	if err != nil {
+		return err
 	}
-	return ""
+	return json.Unmarshal(b, v)
 }
 
 type WSHandler func(tr *Transport, msg *Message) error
@@ -77,7 +83,7 @@ func initWS(origin string) {
 			if o.Host == r.Host {
 				return true
 			}
-			log.Trace().Msgf("[api.ws] origin=%s, host=%s", o.Host, r.Host)
+			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
@@ -101,13 +107,13 @@ func apiWS(w http.ResponseWriter, r *http.Request) {
 	}
 
 	tr := &Transport{Request: r}
-	tr.OnWrite(func(msg any) {
+	tr.OnWrite(func(msg any) error {
 		_ = ws.SetWriteDeadline(time.Now().Add(time.Second * 5))
 
 		if data, ok := msg.([]byte); ok {
-			_ = ws.WriteMessage(websocket.BinaryMessage, data)
+			return ws.WriteMessage(websocket.BinaryMessage, data)
 		} else {
-			_ = ws.WriteJSON(msg)
+			return ws.WriteJSON(msg)
 		}
 	})
 
@@ -121,7 +127,7 @@ func apiWS(w http.ResponseWriter, r *http.Request) {
 			break
 		}
 
-		log.Trace().Str("type", msg.Type).Msg("[api.ws] msg")
+		log.Trace().Str("type", msg.Type).Msg("[api] ws msg")
 
 		if handler := wsHandlers[msg.Type]; handler != nil {
 			go func() {
@@ -147,11 +153,11 @@ type Transport struct {
 	wrmx   sync.Mutex
 
 	onChange func()
-	onWrite  func(msg any)
+	onWrite  func(msg any) error
 	onClose  []func()
 }
 
-func (t *Transport) OnWrite(f func(msg any)) {
+func (t *Transport) OnWrite(f func(msg any) error) {
 	t.mx.Lock()
 	if t.onChange != nil {
 		t.onChange()
@@ -162,7 +168,7 @@ func (t *Transport) OnWrite(f func(msg any)) {
 
 func (t *Transport) Write(msg any) {
 	t.wrmx.Lock()
-	t.onWrite(msg)
+	_ = t.onWrite(msg)
 	t.wrmx.Unlock()
 }
 
@@ -200,3 +206,20 @@ func (t *Transport) WithContext(f func(ctx map[any]any)) {
 	f(t.ctx)
 	t.mx.Unlock()
 }
+
+func (t *Transport) Writer() io.Writer {
+	return &writer{t: t}
+}
+
+type writer struct {
+	t *Transport
+}
+
+func (w *writer) Write(p []byte) (n int, err error) {
+	w.t.wrmx.Lock()
+	if err = w.t.onWrite(p); err == nil {
+		n = len(p)
+	}
+	w.t.wrmx.Unlock()
+	return
+}

internal/app/README.md

@@ -0,0 +1,70 @@
+- By default go2rtc will search config file `go2rtc.yaml` in current work directory
+- go2rtc support multiple config files:
+  - `go2rtc -c config1.yaml -c config2.yaml -c config3.yaml` 
+- go2rtc support inline config as multiple formats from command line:
+  - **YAML**: `go2rtc -c '{log: {format: text}}'`
+  - **JSON**: `go2rtc -c '{"log":{"format":"text"}}'`
+  - **key=value**: `go2rtc -c log.format=text`
+- Every next config will overwrite previous (but only defined params)
+
+```
+go2rtc -config "{log: {format: text}}" -config /config/go2rtc.yaml -config "{rtsp: {listen: ''}}" -config /usr/local/go2rtc/go2rtc.yaml
+```
+
+or simple version
+
+```
+go2rtc -c log.format=text -c /config/go2rtc.yaml -c rtsp.listen='' -c /usr/local/go2rtc/go2rtc.yaml
+```
+
+## Environment variables
+
+There is support for loading external variables into the config. First, they will be attempted to be loaded from [credential files](https://systemd.io/CREDENTIALS). If `CREDENTIALS_DIRECTORY` is not set, then the key will be loaded from an environment variable. If no environment variable is set, then the string will be left as-is.
+
+```yaml
+streams:
+  camera1: rtsp://rtsp:${CAMERA_PASSWORD}@192.168.1.123/av_stream/ch0
+
+rtsp:
+  username: ${RTSP_USER:admin}   # "admin" if "RTSP_USER" not set
+  password: ${RTSP_PASS:secret}  # "secret" if "RTSP_PASS" not set
+```
+
+## JSON Schema
+
+Editors like [GoLand](https://www.jetbrains.com/go/) and [VS Code](https://code.visualstudio.com/) supports autocomplete and syntax validation.
+
+```yaml
+# yaml-language-server: $schema=https://raw.githubusercontent.com/AlexxIT/go2rtc/master/website/schema.json
+```
+
+## Defaults
+
+- Default values may change in updates
+- FFmpeg module has many presets, they are not listed here because they may also change in updates
+
+```yaml
+api:
+  listen: ":1984"
+
+ffmpeg:
+  bin: "ffmpeg"
+
+log:
+  format: "color"
+  level: "info"
+  output: "stdout"
+  time: "UNIXMS"
+
+rtsp:
+  listen: ":8554"
+  default_query: "video&audio"
+
+srtp:
+  listen: ":8443"
+
+webrtc:
+  listen: ":8555/tcp"
+  ice_servers:
+    - urls: [ "stun:stun.l.google.com:19302" ]
+```

internal/app/app.go

@@ -3,140 +3,99 @@ package app
 import (
 	"flag"
 	"fmt"
-	"io"
 	"os"
-	"path/filepath"
+	"os/exec"
 	"runtime"
-	"strings"
-	"time"
-
-	"github.com/AlexxIT/go2rtc/pkg/shell"
-	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/log"
-	"gopkg.in/yaml.v3"
+	"runtime/debug"
 )
 
-var Version = "1.6.2"
-var UserAgent = "go2rtc/" + Version
+var (
+	Version    string
+	UserAgent  string
+	ConfigPath string
+	Info       = make(map[string]any)
+)
 
-var ConfigPath string
-var Info = map[string]any{
-	"version": Version,
-}
+const usage = `Usage of go2rtc:
+
+  -c, --config   Path to config file or config string as YAML or JSON, support multiple
+  -d, --daemon   Run in background
+  -v, --version  Print version and exit
+`
 
 func Init() {
-	var confs Config
+	var config flagConfig
+	var daemon bool
 	var version bool
 
-	flag.Var(&confs, "config", "go2rtc config (path to file or raw text), support multiple")
-	flag.BoolVar(&version, "version", false, "Print the version of the application and exit")
+	flag.Var(&config, "config", "")
+	flag.Var(&config, "c", "")
+	flag.BoolVar(&daemon, "daemon", false, "")
+	flag.BoolVar(&daemon, "d", false, "")
+	flag.BoolVar(&version, "version", false, "")
+	flag.BoolVar(&version, "v", false, "")
+
+	flag.Usage = func() { fmt.Print(usage) }
 	flag.Parse()
 
+	revision, vcsTime := readRevisionTime()
+
 	if version {
-		fmt.Println("Current version: ", Version)
+		fmt.Printf("go2rtc version %s (%s) %s/%s\n", Version, revision, runtime.GOOS, runtime.GOARCH)
 		os.Exit(0)
 	}
 
-	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 daemon && os.Getppid() != 1 {
+		if runtime.GOOS == "windows" {
+			fmt.Println("Daemon mode is not supported on Windows")
+			os.Exit(1)
 		}
+
+		// Re-run the program in background and exit
+		cmd := exec.Command(os.Args[0], os.Args[1:]...)
+		if err := cmd.Start(); err != nil {
+			fmt.Println("Failed to start daemon:", err)
+			os.Exit(1)
+		}
+		fmt.Println("Running in daemon mode with PID:", cmd.Process.Pid)
+		os.Exit(0)
 	}
 
+	UserAgent = "go2rtc/" + Version
+
+	Info["version"] = Version
+	Info["revision"] = revision
+
+	initConfig(config)
+	initLogger()
+
+	platform := fmt.Sprintf("%s/%s", runtime.GOOS, runtime.GOARCH)
+	Logger.Info().Str("version", Version).Str("platform", platform).Str("revision", revision).Msg("go2rtc")
+	Logger.Debug().Str("version", runtime.Version()).Str("vcs.time", vcsTime).Msg("build")
+
 	if ConfigPath != "" {
-		if !filepath.IsAbs(ConfigPath) {
-			if cwd, err := os.Getwd(); err == nil {
-				ConfigPath = filepath.Join(cwd, ConfigPath)
+		Logger.Info().Str("path", ConfigPath).Msg("config")
+	}
+}
+
+func readRevisionTime() (revision, vcsTime string) {
+	if info, ok := debug.ReadBuildInfo(); ok {
+		for _, setting := range info.Settings {
+			switch setting.Key {
+			case "vcs.revision":
+				if len(setting.Value) > 7 {
+					revision = setting.Value[:7]
+				} else {
+					revision = setting.Value
+				}
+			case "vcs.time":
+				vcsTime = setting.Value
+			case "vcs.modified":
+				if setting.Value == "true" {
+					revision = "mod." + revision
+				}
 			}
 		}
-		Info["config_path"] = ConfigPath
 	}
-
-	var cfg struct {
-		Mod map[string]string `yaml:"log"`
-	}
-
-	LoadConfig(&cfg)
-
-	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)
+	return
 }
-
-func NewLogger(format string, level string) zerolog.Logger {
-	var writer io.Writer = os.Stdout
-
-	if format != "json" {
-		writer = zerolog.ConsoleWriter{
-			Out: writer, TimeFormat: "15:04:05.000",
-			NoColor: writer != os.Stdout || format == "text",
-		}
-	}
-
-	zerolog.TimeFieldFormat = time.RFC3339Nano
-
-	lvl, err := zerolog.ParseLevel(level)
-	if err != nil || lvl == zerolog.NoLevel {
-		lvl = zerolog.InfoLevel
-	}
-
-	return zerolog.New(writer).With().Timestamp().Logger().Level(lvl)
-}
-
-func LoadConfig(v any) {
-	for _, data := range configs {
-		if err := yaml.Unmarshal(data, v); err != nil {
-			log.Warn().Err(err).Msg("[app] read config")
-		}
-	}
-}
-
-func GetLogger(module string) zerolog.Logger {
-	if s, ok := modules[module]; ok {
-		lvl, err := zerolog.ParseLevel(s)
-		if err == nil {
-			return log.Level(lvl)
-		}
-		log.Warn().Err(err).Caller().Send()
-	}
-
-	return log.Logger
-}
-
-// internal
-
-type Config []string
-
-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

internal/app/config.go

@@ -0,0 +1,109 @@
+package app
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/pkg/shell"
+	"github.com/AlexxIT/go2rtc/pkg/yaml"
+)
+
+func LoadConfig(v any) {
+	for _, data := range configs {
+		if err := yaml.Unmarshal(data, v); err != nil {
+			Logger.Warn().Err(err).Send()
+		}
+	}
+}
+
+func PatchConfig(path []string, value any) error {
+	if ConfigPath == "" {
+		return errors.New("config file disabled")
+	}
+
+	// empty config is OK
+	b, _ := os.ReadFile(ConfigPath)
+
+	b, err := yaml.Patch(b, path, value)
+	if err != nil {
+		return err
+	}
+
+	return os.WriteFile(ConfigPath, b, 0644)
+}
+
+type flagConfig []string
+
+func (c *flagConfig) String() string {
+	return strings.Join(*c, " ")
+}
+
+func (c *flagConfig) Set(value string) error {
+	*c = append(*c, value)
+	return nil
+}
+
+var configs [][]byte
+
+func initConfig(confs flagConfig) {
+	if confs == nil {
+		confs = []string{"go2rtc.yaml"}
+	}
+
+	for _, conf := range confs {
+		if len(conf) == 0 {
+			continue
+		}
+		if conf[0] == '{' {
+			// config as raw YAML or JSON
+			configs = append(configs, []byte(conf))
+		} else if data := parseConfString(conf); data != nil {
+			configs = append(configs, data)
+		} else {
+			// config as file
+			if ConfigPath == "" {
+				ConfigPath = conf
+			}
+
+			if data, _ = os.ReadFile(conf); data == nil {
+				continue
+			}
+
+			data = []byte(shell.ReplaceEnvVars(string(data)))
+			configs = append(configs, data)
+		}
+	}
+
+	if ConfigPath != "" {
+		if !filepath.IsAbs(ConfigPath) {
+			if cwd, err := os.Getwd(); err == nil {
+				ConfigPath = filepath.Join(cwd, ConfigPath)
+			}
+		}
+		Info["config_path"] = ConfigPath
+	}
+}
+
+func parseConfString(s string) []byte {
+	i := strings.IndexByte(s, '=')
+	if i < 0 {
+		return nil
+	}
+
+	items := strings.Split(s[:i], ".")
+	if len(items) < 2 {
+		return nil
+	}
+
+	// `log.level=trace` => `{log: {level: trace}}`
+	var pre string
+	var suf = s[i+1:]
+	for _, item := range items {
+		pre += "{" + item + ": "
+		suf += "}"
+	}
+
+	return []byte(pre + suf)
+}

internal/app/log.go

@@ -0,0 +1,186 @@
+package app
+
+import (
+	"io"
+	"os"
+	"strings"
+	"sync"
+
+	"github.com/mattn/go-isatty"
+	"github.com/rs/zerolog"
+)
+
+var MemoryLog = newBuffer()
+
+func GetLogger(module string) zerolog.Logger {
+	if s, ok := modules[module]; ok {
+		lvl, err := zerolog.ParseLevel(s)
+		if err == nil {
+			return Logger.Level(lvl)
+		}
+		Logger.Warn().Err(err).Caller().Send()
+	}
+
+	return Logger
+}
+
+// initLogger support:
+// - output: empty (only to memory), stderr, stdout
+// - format: empty (autodetect color support), color, json, text
+// - time:   empty (disable timestamp), UNIXMS, UNIXMICRO, UNIXNANO
+// - level:  disabled, trace, debug, info, warn, error...
+func initLogger() {
+	var cfg struct {
+		Mod map[string]string `yaml:"log"`
+	}
+
+	cfg.Mod = modules // defaults
+
+	LoadConfig(&cfg)
+
+	var writer io.Writer
+
+	switch output, path, _ := strings.Cut(modules["output"], ":"); output {
+	case "stderr":
+		writer = os.Stderr
+	case "stdout":
+		writer = os.Stdout
+	case "file":
+		if path == "" {
+			path = "go2rtc.log"
+		}
+		// if fail - only MemoryLog will be available
+		writer, _ = os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	}
+
+	timeFormat := modules["time"]
+
+	if writer != nil {
+		if format := modules["format"]; format != "json" {
+			console := &zerolog.ConsoleWriter{Out: writer}
+
+			switch format {
+			case "text":
+				console.NoColor = true
+			case "color":
+				console.NoColor = false // useless, but anyway
+			default:
+				// autodetection if output support color
+				// go-isatty - dependency for go-colorable - dependency for ConsoleWriter
+				console.NoColor = !isatty.IsTerminal(writer.(*os.File).Fd())
+			}
+
+			if timeFormat != "" {
+				console.TimeFormat = "15:04:05.000"
+			} else {
+				console.PartsOrder = []string{
+					zerolog.LevelFieldName,
+					zerolog.CallerFieldName,
+					zerolog.MessageFieldName,
+				}
+			}
+
+			writer = console
+		}
+
+		writer = zerolog.MultiLevelWriter(writer, MemoryLog)
+	} else {
+		writer = MemoryLog
+	}
+
+	lvl, _ := zerolog.ParseLevel(modules["level"])
+	Logger = zerolog.New(writer).Level(lvl)
+
+	if timeFormat != "" {
+		zerolog.TimeFieldFormat = timeFormat
+		Logger = Logger.With().Timestamp().Logger()
+	}
+}
+
+var Logger zerolog.Logger
+
+// modules log levels
+var modules = map[string]string{
+	"format": "", // useless, but anyway
+	"level":  "info",
+	"output": "stdout", // TODO: change to stderr someday
+	"time":   zerolog.TimeFormatUnixMs,
+}
+
+const (
+	chunkCount = 16
+	chunkSize  = 1 << 16
+)
+
+type circularBuffer struct {
+	chunks [][]byte
+	r, w   int
+	mu     sync.Mutex
+}
+
+func newBuffer() *circularBuffer {
+	b := &circularBuffer{chunks: make([][]byte, 0, chunkCount)}
+	// create first chunk
+	b.chunks = append(b.chunks, make([]byte, 0, chunkSize))
+	return b
+}
+
+func (b *circularBuffer) Write(p []byte) (n int, err error) {
+	n = len(p)
+
+	b.mu.Lock()
+	// check if chunk has size
+	if len(b.chunks[b.w])+n > chunkSize {
+		// increase write chunk index
+		if b.w++; b.w == chunkCount {
+			b.w = 0
+		}
+		// check overflow
+		if b.r == b.w {
+			// increase read chunk index
+			if b.r++; b.r == chunkCount {
+				b.r = 0
+			}
+		}
+		// check if current chunk exists
+		if b.w == len(b.chunks) {
+			// allocate new chunk
+			b.chunks = append(b.chunks, make([]byte, 0, chunkSize))
+		} else {
+			// reset len of current chunk
+			b.chunks[b.w] = b.chunks[b.w][:0]
+		}
+	}
+
+	b.chunks[b.w] = append(b.chunks[b.w], p...)
+	b.mu.Unlock()
+	return
+}
+
+func (b *circularBuffer) WriteTo(w io.Writer) (n int64, err error) {
+	buf := make([]byte, 0, chunkCount*chunkSize)
+
+	// use temp buffer inside mutex because w.Write can take some time
+	b.mu.Lock()
+	for i := b.r; ; {
+		buf = append(buf, b.chunks[i]...)
+		if i == b.w {
+			break
+		}
+		if i++; i == chunkCount {
+			i = 0
+		}
+	}
+	b.mu.Unlock()
+
+	nn, err := w.Write(buf)
+	return int64(nn), err
+}
+
+func (b *circularBuffer) Reset() {
+	b.mu.Lock()
+	b.chunks[0] = b.chunks[0][:0]
+	b.r = 0
+	b.w = 0
+	b.mu.Unlock()
+}

internal/app/store/store.go

@@ -1,61 +0,0 @@
-package store
-
-import (
-	"encoding/json"
-	"github.com/rs/zerolog/log"
-	"os"
-)
-
-const name = "go2rtc.json"
-
-var store map[string]any
-
-func load() {
-	data, _ := os.ReadFile(name)
-	if data != nil {
-		if err := json.Unmarshal(data, &store); err != nil {
-			// TODO: log
-			log.Warn().Err(err).Msg("[app] read storage")
-		}
-	}
-
-	if store == nil {
-		store = make(map[string]any)
-	}
-}
-
-func save() error {
-	data, err := json.Marshal(store)
-	if err != nil {
-		return err
-	}
-
-	return os.WriteFile(name, data, 0644)
-}
-
-func GetRaw(key string) any {
-	if store == nil {
-		load()
-	}
-
-	return store[key]
-}
-
-func GetDict(key string) map[string]any {
-	raw := GetRaw(key)
-	if raw != nil {
-		return raw.(map[string]any)
-	}
-
-	return make(map[string]any)
-}
-
-func Set(key string, v any) error {
-	if store == nil {
-		load()
-	}
-
-	store[key] = v
-
-	return save()
-}

internal/bubble/bubble.go

@@ -7,13 +7,7 @@ import (
 )
 
 func Init() {
-	streams.HandleFunc("bubble", handle)
-}
-
-func handle(url string) (core.Producer, error) {
-	conn := bubble.NewClient(url)
-	if err := conn.Dial(); err != nil {
-		return nil, err
-	}
-	return conn, nil
+	streams.HandleFunc("bubble", func(source string) (core.Producer, error) {
+		return bubble.Dial(source)
+	})
 }

internal/debug/debug.go

@@ -2,16 +2,8 @@ package debug
 
 import (
 	"github.com/AlexxIT/go2rtc/internal/api"
-	"github.com/AlexxIT/go2rtc/internal/streams"
-	"github.com/AlexxIT/go2rtc/pkg/core"
 )
 
 func Init() {
 	api.HandleFunc("api/stack", stackHandler)
-
-	streams.HandleFunc("null", nullHandler)
-}
-
-func nullHandler(string) (core.Producer, error) {
-	return nil, nil
 }

internal/debug/stack.go

@@ -3,9 +3,10 @@ package debug
 import (
 	"bytes"
 	"fmt"
-	"github.com/AlexxIT/go2rtc/internal/api"
 	"net/http"
 	"runtime"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
 )
 
 var stackSkip = [][]byte{
@@ -24,6 +25,9 @@ var stackSkip = [][]byte{
 	[]byte("created by github.com/AlexxIT/go2rtc/internal/rtsp.Init"),
 	[]byte("created by github.com/AlexxIT/go2rtc/internal/srtp.Init"),
 
+	// homekit
+	[]byte("created by github.com/AlexxIT/go2rtc/internal/homekit.Init"),
+
 	// webrtc/api.go
 	[]byte("created by github.com/pion/ice/v2.NewTCPMuxDefault"),
 	[]byte("created by github.com/pion/ice/v2.NewUDPMuxDefault"),

internal/doorbird/doorbird.go

@@ -0,0 +1,36 @@
+package doorbird
+
+import (
+	"net/url"
+
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/doorbird"
+)
+
+func Init() {
+	streams.RedirectFunc("doorbird", func(rawURL string) (string, error) {
+		u, err := url.Parse(rawURL)
+		if err != nil {
+			return "", err
+		}
+
+		// https://www.doorbird.com/downloads/api_lan.pdf
+		switch u.Query().Get("media") {
+		case "video":
+			u.Path = "/bha-api/video.cgi"
+		case "audio":
+			u.Path = "/bha-api/audio-receive.cgi"
+		default:
+			return "", nil
+		}
+
+		u.Scheme = "http"
+
+		return u.String(), nil
+	})
+
+	streams.HandleFunc("doorbird", func(source string) (core.Producer, error) {
+		return doorbird.Dial(source)
+	})
+}

internal/dvrip/dvrip.go

@@ -10,32 +10,16 @@ import (
 
 	"github.com/AlexxIT/go2rtc/internal/api"
 	"github.com/AlexxIT/go2rtc/internal/streams"
-	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/AlexxIT/go2rtc/pkg/dvrip"
-	"github.com/rs/zerolog/log"
 )
 
 func Init() {
-	streams.HandleFunc("dvrip", handle)
+	streams.HandleFunc("dvrip", dvrip.Dial)
 
 	// DVRIP client autodiscovery
 	api.HandleFunc("api/dvrip", apiDvrip)
 }
 
-func handle(url string) (core.Producer, error) {
-	conn := dvrip.NewClient(url)
-	if err := conn.Dial(); err != nil {
-		return nil, err
-	}
-	if err := conn.Play(); err != nil {
-		return nil, err
-	}
-	if err := conn.Handle(); err != nil {
-		return nil, err
-	}
-	return conn, nil
-}
-
 const Port = 34569 // UDP port number for dvrip discovery
 
 func apiDvrip(w http.ResponseWriter, r *http.Request) {
@@ -45,10 +29,10 @@ func apiDvrip(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	api.ResponseStreams(w, items)
+	api.ResponseSources(w, items)
 }
 
-func discover() ([]api.Stream, error) {
+func discover() ([]*api.Source, error) {
 	addr := &net.UDPAddr{
 		Port: Port,
 		IP:   net.IP{239, 255, 255, 250},
@@ -63,7 +47,7 @@ func discover() ([]api.Stream, error) {
 
 	go sendBroadcasts(conn)
 
-	var items []api.Stream
+	var items []*api.Source
 
 	for _, info := range getResponses(conn) {
 		if info.HostIP == "" || info.HostName == "" {
@@ -75,7 +59,7 @@ func discover() ([]api.Stream, error) {
 			continue
 		}
 
-		items = append(items, api.Stream{
+		items = append(items, &api.Source{
 			Name: info.HostName,
 			URL:  "dvrip://user:pass@" + host + "?channel=0&subtype=0",
 		})
@@ -98,10 +82,7 @@ func sendBroadcasts(conn *net.UDPConn) {
 
 	for i := 0; i < 3; i++ {
 		time.Sleep(100 * time.Millisecond)
-
-		if _, err = conn.WriteToUDP(data, addr); err != nil {
-			log.Err(err).Caller().Send()
-		}
+		_, _ = conn.WriteToUDP(data, addr)
 	}
 }
 

internal/echo/echo.go

@@ -2,28 +2,28 @@ package echo
 
 import (
 	"bytes"
+	"os/exec"
+
 	"github.com/AlexxIT/go2rtc/internal/app"
 	"github.com/AlexxIT/go2rtc/internal/streams"
-	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/AlexxIT/go2rtc/pkg/shell"
-	"os/exec"
 )
 
 func Init() {
 	log := app.GetLogger("echo")
 
-	streams.HandleFunc("echo", func(url string) (core.Producer, error) {
+	streams.RedirectFunc("echo", func(url string) (string, error) {
 		args := shell.QuoteSplit(url[5:])
 
 		b, err := exec.Command(args[0], args[1:]...).Output()
 		if err != nil {
-			return nil, err
+			return "", err
 		}
 
 		b = bytes.TrimSpace(b)
 
 		log.Debug().Str("url", url).Msgf("[echo] %s", b)
 
-		return streams.GetProducer(string(b))
+		return string(b), nil
 	})
 }

internal/eseecloud/eseecloud.go

@@ -0,0 +1,10 @@
+package eseecloud
+
+import (
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/eseecloud"
+)
+
+func Init() {
+	streams.HandleFunc("eseecloud", eseecloud.Dial)
+}

internal/exec/README.md

@@ -0,0 +1,12 @@
+## Backchannel
+
+- You can check audio card names in the **Go2rtc > WebUI > Add**
+- You can specify multiple backchannel lines with different codecs
+
+```yaml
+sources:
+  two_way_audio_win:
+    - exec:ffmpeg -hide_banner -f dshow -i "audio=Microphone (High Definition Audio Device)" -c pcm_s16le -ar 16000 -ac 1 -f wav -
+    - exec:ffplay -nodisp -probesize 32 -f s16le -ar 16000 -#backchannel=1#audio=s16le/16000
+    - exec:ffplay -nodisp -probesize 32 -f alaw -ar 8000 -#backchannel=1#audio=alaw/8000
+```

internal/exec/exec.go

@@ -1,22 +1,28 @@
 package exec
 
 import (
+	"bufio"
 	"crypto/md5"
 	"encoding/hex"
 	"errors"
 	"fmt"
+	"io"
+	"net/url"
+	"os"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+
 	"github.com/AlexxIT/go2rtc/internal/app"
 	"github.com/AlexxIT/go2rtc/internal/rtsp"
 	"github.com/AlexxIT/go2rtc/internal/streams"
 	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/AlexxIT/go2rtc/pkg/magic"
+	"github.com/AlexxIT/go2rtc/pkg/pcm"
 	pkg "github.com/AlexxIT/go2rtc/pkg/rtsp"
 	"github.com/AlexxIT/go2rtc/pkg/shell"
 	"github.com/rs/zerolog"
-	"os"
-	"os/exec"
-	"sync"
-	"time"
 )
 
 func Init() {
@@ -43,65 +49,107 @@ func Init() {
 	log = app.GetLogger("exec")
 }
 
-func execHandle(url string) (core.Producer, error) {
+func execHandle(rawURL string) (prod core.Producer, err error) {
+	rawURL, rawQuery, _ := strings.Cut(rawURL, "#")
+	query := streams.ParseQuery(rawQuery)
+
 	var path string
 
-	args := shell.QuoteSplit(url[5:]) // remove `exec:`
-	for i, arg := range args {
-		if arg == "{output}" {
-			if rtsp.Port == "" {
-				return nil, errors.New("rtsp module disabled")
-			}
+	// RTSP flow should have `{output}` inside URL
+	// pipe flow may have `#{params}` inside URL
+	if i := strings.Index(rawURL, "{output}"); i > 0 {
+		if rtsp.Port == "" {
+			return nil, errors.New("exec: rtsp module disabled")
+		}
 
-			sum := md5.Sum([]byte(url))
-			path = "/" + hex.EncodeToString(sum[:])
-			args[i] = "rtsp://127.0.0.1:" + rtsp.Port + path
-			break
+		sum := md5.Sum([]byte(rawURL))
+		path = "/" + hex.EncodeToString(sum[:])
+		rawURL = rawURL[:i] + "rtsp://127.0.0.1:" + rtsp.Port + path + rawURL[i+8:]
+	}
+
+	cmd := shell.NewCommand(rawURL[5:]) // remove `exec:`
+	cmd.Stderr = &logWriter{
+		buf:   make([]byte, 512),
+		debug: log.Debug().Enabled(),
+	}
+
+	if s := query.Get("killsignal"); s != "" {
+		sig := syscall.Signal(core.Atoi(s))
+		cmd.Cancel = func() error {
+			log.Debug().Msgf("[exec] kill with signal=%d", sig)
+			return cmd.Process.Signal(sig)
 		}
 	}
 
-	cmd := exec.Command(args[0], args[1:]...)
-	if log.Debug().Enabled() {
-		cmd.Stderr = os.Stderr
+	if s := query.Get("killtimeout"); s != "" {
+		cmd.WaitDelay = time.Duration(core.Atoi(s)) * time.Second
+	}
+
+	if query.Get("backchannel") == "1" {
+		return pcm.NewBackchannel(cmd, query.Get("audio"))
 	}
 
 	if path == "" {
-		return handlePipe(url, cmd)
+		prod, err = handlePipe(rawURL, cmd)
+	} else {
+		prod, err = handleRTSP(rawURL, cmd, path)
 	}
 
-	return handleRTSP(url, path, cmd)
+	if err != nil {
+		_ = cmd.Close()
+	}
+
+	return
 }
 
-func handlePipe(url string, cmd *exec.Cmd) (core.Producer, error) {
-	r, err := PipeCloser(cmd)
+func handlePipe(source string, cmd *shell.Command) (core.Producer, error) {
+	stdout, err := cmd.StdoutPipe()
 	if err != nil {
 		return nil, err
 	}
 
+	rd := struct {
+		io.Reader
+		io.Closer
+	}{
+		// add buffer for pipe reader to reduce syscall
+		bufio.NewReaderSize(stdout, core.BufferSize),
+		// stop cmd on close pipe call
+		cmd,
+	}
+
+	log.Debug().Strs("args", cmd.Args).Msg("[exec] run pipe")
+
+	ts := time.Now()
+
 	if err = cmd.Start(); err != nil {
 		return nil, err
 	}
 
-	client := magic.NewClient(r)
-	if err = client.Probe(); err != nil {
-		return nil, err
+	prod, err := magic.Open(rd)
+	if err != nil {
+		return nil, fmt.Errorf("exec/pipe: %w\n%s", err, cmd.Stderr)
 	}
 
-	client.Desc = "exec active producer"
-	client.URL = url
+	if info, ok := prod.(core.Info); ok {
+		info.SetProtocol("pipe")
+		setRemoteInfo(info, source, cmd.Args)
+	}
 
-	return client, nil
+	log.Debug().Stringer("launch", time.Since(ts)).Msg("[exec] run pipe")
+
+	return prod, nil
 }
 
-func handleRTSP(url, path string, cmd *exec.Cmd) (core.Producer, error) {
+func handleRTSP(source string, cmd *shell.Command, path string) (core.Producer, error) {
 	if log.Trace().Enabled() {
 		cmd.Stdout = os.Stdout
 	}
 
-	ch := make(chan core.Producer)
+	waiter := make(chan *pkg.Conn, 1)
 
 	waitersMu.Lock()
-	waiters[path] = ch
+	waiters[path] = waiter
 	waitersMu.Unlock()
 
 	defer func() {
@@ -110,42 +158,96 @@ func handleRTSP(url, path string, cmd *exec.Cmd) (core.Producer, error) {
 		waitersMu.Unlock()
 	}()
 
-	log.Debug().Str("url", url).Msg("[exec] run")
+	log.Debug().Strs("args", cmd.Args).Msg("[exec] run rtsp")
 
 	ts := time.Now()
 
 	if err := cmd.Start(); err != nil {
-		log.Error().Err(err).Str("url", url).Msg("[exec]")
+		log.Error().Err(err).Str("source", source).Msg("[exec]")
 		return nil, err
 	}
 
-	chErr := make(chan error)
-
-	go func() {
-		err := cmd.Wait()
-		// unblocking write to channel
-		select {
-		case chErr <- err:
-		default:
-			log.Trace().Str("url", url).Msg("[exec] close")
-		}
-	}()
+	timeout := time.NewTimer(30 * time.Second)
+	defer timeout.Stop()
 
 	select {
-	case <-time.After(time.Second * 60):
-		_ = cmd.Process.Kill()
-		log.Error().Str("url", url).Msg("[exec] timeout")
-		return nil, errors.New("timeout")
-	case err := <-chErr:
-		return nil, fmt.Errorf("exec: %s", err)
-	case prod := <-ch:
-		log.Debug().Stringer("launch", time.Since(ts)).Msg("[exec] run")
+	case <-timeout.C:
+		// haven't received data from app in timeout
+		log.Error().Str("source", source).Msg("[exec] timeout")
+		return nil, errors.New("exec: timeout")
+	case <-cmd.Done():
+		// app fail before we receive any data
+		return nil, fmt.Errorf("exec/rtsp\n%s", cmd.Stderr)
+	case prod := <-waiter:
+		// app started successfully
+		log.Debug().Stringer("launch", time.Since(ts)).Msg("[exec] run rtsp")
+		setRemoteInfo(prod, source, cmd.Args)
+		prod.OnClose = cmd.Close
 		return prod, nil
 	}
 }
 
 // internal
 
-var log zerolog.Logger
-var waiters = map[string]chan core.Producer{}
-var waitersMu sync.Mutex
+var (
+	log       zerolog.Logger
+	waiters   = make(map[string]chan *pkg.Conn)
+	waitersMu sync.Mutex
+)
+
+type logWriter struct {
+	buf   []byte
+	debug bool
+	n     int
+}
+
+func (l *logWriter) String() string {
+	if l.n == len(l.buf) {
+		return string(l.buf) + "..."
+	}
+	return string(l.buf[:l.n])
+}
+
+func (l *logWriter) Write(p []byte) (n int, err error) {
+	if l.n < cap(l.buf) {
+		l.n += copy(l.buf[l.n:], p)
+	}
+	n = len(p)
+	if l.debug {
+		if p = trimSpace(p); p != nil {
+			log.Debug().Msgf("[exec] %s", p)
+		}
+	}
+	return
+}
+
+func trimSpace(b []byte) []byte {
+	start := 0
+	stop := len(b)
+	for ; start < stop; start++ {
+		if b[start] >= ' ' {
+			break // trim all ASCII before 0x20
+		}
+	}
+	for ; ; stop-- {
+		if stop == start {
+			return nil // skip empty output
+		}
+		if b[stop-1] > ' ' {
+			break // trim all ASCII before 0x21
+		}
+	}
+	return b[start:stop]
+}
+
+func setRemoteInfo(info core.Info, source string, args []string) {
+	info.SetSource(source)
+
+	if i := core.Index(args, "-i"); i > 0 && i < len(args)-1 {
+		rawURL := args[i+1]
+		if u, err := url.Parse(rawURL); err == nil && u.Host != "" {
+			info.SetRemoteAddr(u.Host)
+			info.SetURL(rawURL)
+		}
+	}
+}

internal/exec/pipe.go

@@ -1,26 +0,0 @@
-package exec
-
-import (
-	"github.com/AlexxIT/go2rtc/pkg/core"
-	"io"
-	"os/exec"
-)
-
-// PipeCloser - return StdoutPipe that Kill cmd on Close call
-func PipeCloser(cmd *exec.Cmd) (io.ReadCloser, error) {
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		return nil, err
-	}
-
-	return pipeCloser{stdout, cmd}, nil
-}
-
-type pipeCloser struct {
-	io.ReadCloser
-	cmd *exec.Cmd
-}
-
-func (p pipeCloser) Close() error {
-	return core.Any(p.ReadCloser.Close(), p.cmd.Process.Kill(), p.cmd.Wait())
-}

internal/expr/README.md

@@ -0,0 +1,91 @@
+# Expr
+
+[Expr](https://github.com/antonmedv/expr) - expression language and expression evaluation for Go.
+
+- [language definition](https://expr.medv.io/docs/Language-Definition) - takes best from JS, Python, Jinja2 syntax
+- your expression should return a link of any supported source
+- expression supports multiple operation, but:
+  - all operations must be separated by a semicolon
+  - all operations, except the last one, must declare a new variable (`let s = "abc";`)
+  - the last operation should return a string
+- go2rtc supports additional functions:
+  - `fetch` - JS-like HTTP requests
+  - `match` - JS-like RegExp queries
+
+## Examples
+
+**Two way audio for Dahua VTO**
+
+```yaml
+streams:
+  dahua_vto: |
+    expr: let host = "admin:password@192.168.1.123";
+    fetch("http://"+host+"/cgi-bin/configManager.cgi?action=setConfig&Encode[0].MainFormat[0].Audio.Compression=G.711A&Encode[0].MainFormat[0].Audio.Frequency=8000").ok
+        ? "rtsp://"+host+"/cam/realmonitor?channel=1&subtype=0&unicast=true&proto=Onvif" : ""
+```
+
+**dom.ru**
+
+You can get credentials via:
+
+- https://github.com/alexmorbo/domru (file `/share/domru/accounts`)
+- https://github.com/ad/domru
+
+```yaml
+streams:
+  dom_ru: |
+    expr: let camera = "99999999"; let token = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"; let operator = 99;
+    fetch("https://myhome.novotelecom.ru/rest/v1/forpost/cameras/"+camera+"/video", {
+      headers: {Authorization: "Bearer "+token, Operator: operator}
+    }).json().data.URL
+```
+
+**Parse HLS files from Apple**
+
+Same example in two languages - python and expr.
+
+```yaml
+streams:
+  example_python: |
+    echo:python -c 'from urllib.request import urlopen; import re
+
+    # url1 = "https://devstreaming-cdn.apple.com/videos/streaming/examples/bipbop_16x9/bipbop_16x9_variant.m3u8"
+    html1 = urlopen("https://developer.apple.com/streaming/examples/basic-stream-osx-ios5.html").read().decode("utf-8")
+    url1 = re.search(r"https.+?m3u8", html1)[0]
+
+    # url2 = "gear1/prog_index.m3u8"
+    html2 = urlopen(url1).read().decode("utf-8")
+    url2 = re.search(r"^[a-z0-1/_]+\.m3u8$", html2, flags=re.MULTILINE)[0]
+
+    # url3 = "https://devstreaming-cdn.apple.com/videos/streaming/examples/bipbop_16x9/gear1/prog_index.m3u8"
+    url3 = url1[:url1.rindex("/")+1] + url2
+
+    print("ffmpeg:" + url3 + "#video=copy")'
+
+  example_expr: |
+    expr:
+
+    let html1 = fetch("https://developer.apple.com/streaming/examples/basic-stream-osx-ios5.html").text;
+    let url1 = match(html1, "https.+?m3u8")[0];
+
+    let html2 = fetch(url1).text;
+    let url2 = match(html2, "^[a-z0-1/_]+\\.m3u8$", "m")[0];
+
+    let url3 = url1[:lastIndexOf(url1, "/")+1] + url2;
+
+    "ffmpeg:" + url3 + "#video=copy"
+```
+
+## Comparsion
+
+| expr                         | python                     | js                             |
+|------------------------------|----------------------------|--------------------------------|
+| let x = 1;                   | x = 1                      | let x = 1                      |
+| {a: 1, b: 2}                 | {"a": 1, "b": 2}           | {a: 1, b: 2}                   |
+| let r = fetch(url, {method}) | r = request(method, url)   | r = await fetch(url, {method}) |
+| r.ok                         | r.ok                       | r.ok                           |
+| r.status                     | r.status_code              | r.status                       |
+| r.text                       | r.text                     | await r.text()                 |
+| r.json()                     | r.json()                   | await r.json()                 |
+| r.headers                    | r.headers                  | r.headers                      |
+| let m = match(text, "abc")   | m = re.search("abc", text) | let m = text.match(/abc/)      |

internal/expr/expr.go

@@ -0,0 +1,28 @@
+package expr
+
+import (
+	"errors"
+
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/expr"
+)
+
+func Init() {
+	log := app.GetLogger("expr")
+
+	streams.RedirectFunc("expr", func(url string) (string, error) {
+		v, err := expr.Eval(url[5:], nil)
+		if err != nil {
+			return "", err
+		}
+
+		log.Debug().Msgf("[expr] url=%s", url)
+
+		if url = v.(string); url == "" {
+			return "", errors.New("expr: result is empty")
+		}
+
+		return url, nil
+	})
+}

internal/ffmpeg/README.md

@@ -45,6 +45,13 @@
 [video4linux2,v4l2 @ 0x7f7de7c58bc0] Compressed:       mjpeg :          Motion-JPEG : 640x480 160x120 176x144 320x176 320x240 352x288 432x240 544x288 640x360 752x416 800x448 800x600 864x480 960x544 960x720 1024x576 1184x656 1280x720 1280x960
 ```
 
+## TTS
+
+```yaml
+streams:
+  tts: ffmpeg:#input=-readrate 1 -readrate_initial_burst 0.001 -f lavfi -i "flite=text='1 2 3 4 5 6 7 8 9 0'"#audio=pcma
+```
+
 ## Useful links
 
 - https://superuser.com/questions/564402/explanation-of-x264-tune

internal/ffmpeg/api.go

@@ -0,0 +1,51 @@
+package ffmpeg
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/streams"
+)
+
+func apiFFmpeg(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		http.Error(w, "", http.StatusMethodNotAllowed)
+		return
+	}
+
+	query := r.URL.Query()
+	dst := query.Get("dst")
+	stream := streams.Get(dst)
+	if stream == nil {
+		http.Error(w, "", http.StatusNotFound)
+		return
+	}
+
+	var src string
+	if s := query.Get("file"); s != "" {
+		if streams.Validate(s) == nil {
+			src = "ffmpeg:" + s + "#audio=auto#input=file"
+		}
+	} else if s = query.Get("live"); s != "" {
+		if streams.Validate(s) == nil {
+			src = "ffmpeg:" + s + "#audio=auto"
+		}
+	} else if s = query.Get("text"); s != "" {
+		if strings.IndexAny(s, `'"&%$`) < 0 {
+			src = "ffmpeg:tts?text=" + s
+			if s = query.Get("voice"); s != "" {
+				src += "&voice=" + s
+			}
+			src += "#audio=auto"
+		}
+	}
+
+	if src == "" {
+		http.Error(w, "", http.StatusBadRequest)
+		return
+	}
+
+	if err := stream.Play(src); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+}

internal/ffmpeg/device/device_bsd.go

@@ -0,0 +1,99 @@
+//go:build freebsd || netbsd || openbsd || dragonfly
+
+package device
+
+import (
+	"net/url"
+	"os"
+	"os/exec"
+	"regexp"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func queryToInput(query url.Values) string {
+	if video := query.Get("video"); video != "" {
+		// https://ffmpeg.org/ffmpeg-devices.html#video4linux2_002c-v4l2
+		input := "-f v4l2"
+
+		for key, value := range query {
+			switch key {
+			case "resolution":
+				input += " -video_size " + value[0]
+			case "video_size", "pixel_format", "input_format", "framerate", "use_libv4l2":
+				input += " -" + key + " " + value[0]
+			}
+		}
+
+		return input + " -i " + indexToItem(videos, video)
+	}
+
+	if audio := query.Get("audio"); audio != "" {
+		input := "-f oss"
+
+		for key, value := range query {
+			switch key {
+			case "channels", "sample_rate":
+				input += " -" + key + " " + value[0]
+			}
+		}
+
+		return input + " -i " + indexToItem(audios, audio)
+	}
+
+	return ""
+}
+
+func initDevices() {
+	files, err := os.ReadDir("/dev")
+	if err != nil {
+		return
+	}
+
+	for _, file := range files {
+		if !strings.HasPrefix(file.Name(), core.KindVideo) {
+			continue
+		}
+
+		name := "/dev/" + file.Name()
+
+		cmd := exec.Command(
+			Bin, "-hide_banner", "-f", "v4l2", "-list_formats", "all", "-i", name,
+		)
+		b, _ := cmd.CombinedOutput()
+
+		// [video4linux2,v4l2 @ 0x860b92280] Raw       :     yuyv422 :           YUYV 4:2:2 : 640x480 160x120 176x144 320x176 320x240 352x288 432x240 544x288 640x360 752x416 800x448 800x600 864x480 960x544 960x720 1024x576 1184x656 1280x720 1280x960
+		// [video4linux2,v4l2 @ 0x860b92280] Compressed:       mjpeg :          Motion-JPEG : 640x480 160x120 176x144 320x176 320x240 352x288 432x240 544x288 640x360 752x416 800x448 800x600 864x480 960x544 960x720 1024x576 1184x656 1280x720 1280x960
+		re := regexp.MustCompile("(Raw *|Compressed): +(.+?) : +(.+?) : (.+)")
+		m := re.FindAllStringSubmatch(string(b), -1)
+		for _, i := range m {
+			size, _, _ := strings.Cut(i[4], " ")
+			stream := &api.Source{
+				Name: i[3],
+				Info: i[4],
+				URL:  "ffmpeg:device?video=" + name + "&input_format=" + i[2] + "&video_size=" + size,
+			}
+
+			if i[1] != "Compressed" {
+				stream.URL += "#video=h264#hardware"
+			}
+
+			videos = append(videos, name)
+			streams = append(streams, stream)
+		}
+	}
+
+	err = exec.Command(Bin, "-f", "oss", "-i", "/dev/dsp", "-t", "1", "-f", "null", "-").Run()
+	if err == nil {
+		stream := &api.Source{
+			Name: "OSS default",
+			Info: " ",
+			URL:  "ffmpeg:device?audio=default&channels=1&sample_rate=16000&#audio=opus",
+		}
+
+		audios = append(audios, "default")
+		streams = append(streams, stream)
+	}
+}

internal/ffmpeg/device/device_darwin.go

@@ -1,12 +1,15 @@
+//go:build darwin || ios
+
 package device
 
 import (
-	"github.com/AlexxIT/go2rtc/internal/api"
-	"github.com/AlexxIT/go2rtc/pkg/core"
 	"net/url"
 	"os/exec"
 	"regexp"
 	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 )
 
 func queryToInput(query url.Values) string {
@@ -78,7 +81,7 @@ func initDevices() {
 			audios = append(audios, name)
 		}
 
-		streams = append(streams, api.Stream{
+		streams = append(streams, &api.Source{
 			Name: name, URL: "ffmpeg:device?" + kind + "=" + name,
 		})
 	}

internal/ffmpeg/device/device_unix.go

@@ -1,3 +1,5 @@
+//go:build unix && !darwin && !freebsd && !netbsd && !openbsd && !dragonfly
+
 package device
 
 import (
@@ -70,8 +72,9 @@ func initDevices() {
 		m := re.FindAllStringSubmatch(string(b), -1)
 		for _, i := range m {
 			size, _, _ := strings.Cut(i[4], " ")
-			stream := api.Stream{
-				Name: i[3] + " | " + i[4],
+			stream := &api.Source{
+				Name: i[3],
+				Info: i[4],
 				URL:  "ffmpeg:device?video=" + name + "&input_format=" + i[2] + "&video_size=" + size,
 			}
 
@@ -86,8 +89,9 @@ func initDevices() {
 
 	err = exec.Command(Bin, "-f", "alsa", "-i", "default", "-t", "1", "-f", "null", "-").Run()
 	if err == nil {
-		stream := api.Stream{
+		stream := &api.Source{
 			Name: "ALSA default",
+			Info: " ",
 			URL:  "ffmpeg:device?audio=default&channels=1&sample_rate=16000&#audio=opus",
 		}
 

internal/ffmpeg/device/device_windows.go

@@ -1,11 +1,14 @@
+//go:build windows
+
 package device
 
 import (
-	"github.com/AlexxIT/go2rtc/internal/api"
-	"github.com/AlexxIT/go2rtc/pkg/core"
 	"net/url"
 	"os/exec"
 	"regexp"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 )
 
 func queryToInput(query url.Values) string {
@@ -44,30 +47,20 @@ func queryToInput(query url.Values) string {
 	}
 
 	if video != "" {
-		input += ` -i video="` + video + `"`
+		input += ` -i "video=` + video
 
 		if audio != "" {
-			input += `:audio="` + audio + `"`
+			input += `:audio=` + audio
 		}
+
+		input += `"`
 	} else {
-		input += ` -i audio="` + audio + `"`
+		input += ` -i "audio=` + audio + `"`
 	}
 
 	return input
 }
 
-func deviceInputSuffix(video, audio string) string {
-	switch {
-	case video != "" && audio != "":
-		return `video="` + video + `":audio=` + audio + `"`
-	case video != "":
-		return `video="` + video + `"`
-	case audio != "":
-		return `audio="` + audio + `"`
-	}
-	return ""
-}
-
 func initDevices() {
 	cmd := exec.Command(
 		Bin, "-hide_banner", "-list_devices", "true", "-f", "dshow", "-i", "",
@@ -79,7 +72,7 @@ func initDevices() {
 		name := m[1]
 		kind := m[2]
 
-		stream := api.Stream{
+		stream := &api.Source{
 			Name: name, URL: "ffmpeg:device?" + kind + "=" + name,
 		}
 

internal/ffmpeg/device/devices.go

@@ -1,13 +1,12 @@
 package device
 
 import (
-	"errors"
-	"github.com/AlexxIT/go2rtc/internal/api"
 	"net/http"
 	"net/url"
 	"strconv"
-	"strings"
 	"sync"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
 )
 
 func Init(bin string) {
@@ -16,36 +15,27 @@ func Init(bin string) {
 	api.HandleFunc("api/ffmpeg/devices", apiDevices)
 }
 
-func GetInput(src string) (string, error) {
-	i := strings.IndexByte(src, '?')
-	if i < 0 {
-		return "", errors.New("empty query: " + src)
-	}
-
-	query, err := url.ParseQuery(src[i+1:])
+func GetInput(src string) string {
+	query, err := url.ParseQuery(src)
 	if err != nil {
-		return "", err
+		return ""
 	}
 
 	runonce.Do(initDevices)
 
-	if input := queryToInput(query); input != "" {
-		return input, nil
-	}
-
-	return "", errors.New("wrong query: " + src)
+	return queryToInput(query)
 }
 
 var Bin string
 
 var videos, audios []string
-var streams []api.Stream
+var streams []*api.Source
 var runonce sync.Once
 
 func apiDevices(w http.ResponseWriter, r *http.Request) {
 	runonce.Do(initDevices)
 
-	api.ResponseStreams(w, streams)
+	api.ResponseSources(w, streams)
 }
 
 func indexToItem(items []string, index string) string {

internal/ffmpeg/ffmpeg.go

@@ -1,40 +1,58 @@
 package ffmpeg
 
 import (
-	"errors"
 	"net/url"
 	"strings"
 
+	"github.com/AlexxIT/go2rtc/internal/api"
 	"github.com/AlexxIT/go2rtc/internal/app"
 	"github.com/AlexxIT/go2rtc/internal/ffmpeg/device"
 	"github.com/AlexxIT/go2rtc/internal/ffmpeg/hardware"
+	"github.com/AlexxIT/go2rtc/internal/ffmpeg/virtual"
 	"github.com/AlexxIT/go2rtc/internal/rtsp"
 	"github.com/AlexxIT/go2rtc/internal/streams"
 	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/AlexxIT/go2rtc/pkg/ffmpeg"
+	"github.com/rs/zerolog"
 )
 
 func Init() {
 	var cfg struct {
 		Mod map[string]string `yaml:"ffmpeg"`
+		Log struct {
+			Level string `yaml:"ffmpeg"`
+		} `yaml:"log"`
 	}
 
 	cfg.Mod = defaults // will be overriden from yaml
+	cfg.Log.Level = "error"
 
 	app.LoadConfig(&cfg)
 
-	if app.GetLogger("exec").GetLevel() >= 0 {
-		defaults["global"] += " -v error"
-	}
+	log = app.GetLogger("ffmpeg")
 
-	streams.HandleFunc("ffmpeg", func(url string) (core.Producer, error) {
-		args := parseArgs(url[7:]) // remove `ffmpeg:`
-		if args == nil {
-			return nil, errors.New("can't generate ffmpeg command")
+	// zerolog levels: trace debug         info warn    error fatal panic disabled
+	// FFmpeg  levels: trace debug verbose info warning error fatal panic quiet
+	if cfg.Log.Level == "warn" {
+		cfg.Log.Level = "warning"
+	}
+	defaults["global"] += " -v " + cfg.Log.Level
+
+	streams.RedirectFunc("ffmpeg", func(url string) (string, error) {
+		if _, err := Version(); err != nil {
+			return "", err
 		}
-		return streams.GetProducer("exec:" + args.String())
+		args := parseArgs(url[7:])
+		if core.Contains(args.Codecs, "auto") {
+			return "", nil // force call streams.HandleFunc("ffmpeg")
+		}
+		return "exec:" + args.String(), nil
 	})
 
+	streams.HandleFunc("ffmpeg", NewProducer)
+
+	api.HandleFunc("api/ffmpeg", apiFFmpeg)
+
 	device.Init(defaults["bin"])
 	hardware.Init(defaults["bin"])
 }
@@ -53,61 +71,86 @@ var defaults = map[string]string{
 	// output
 	"output":       "-user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}",
 	"output/mjpeg": "-f mjpeg -",
+	"output/raw":   "-f yuv4mpegpipe -",
+	"output/aac":   "-f adts -",
+	"output/wav":   "-f wav -",
 
 	// `-preset superfast` - we can't use ultrafast because it doesn't support `-profile main -level 4.1`
 	// `-tune zerolatency` - for minimal latency
 	// `-profile high -level 4.1` - most used streaming profile
-	"h264":  "-c:v libx264 -g 50 -profile:v high -level:v 4.1 -preset:v superfast -tune:v zerolatency -pix_fmt:v yuvj420p",
-	"h265":  "-c:v libx265 -g 50 -profile:v main -level:v 5.1 -preset:v superfast -tune:v zerolatency",
+	// `-pix_fmt:v yuv420p` - important for Telegram
+	"h264":  "-c:v libx264 -g 50 -profile:v high -level:v 4.1 -preset:v superfast -tune:v zerolatency -pix_fmt:v yuv420p",
+	"h265":  "-c:v libx265 -g 50 -profile:v main -level:v 5.1 -preset:v superfast -tune:v zerolatency -pix_fmt:v yuv420p",
 	"mjpeg": "-c:v mjpeg",
 	//"mjpeg": "-c:v mjpeg -force_duplicated_matrix:v 1 -huffman:v 0 -pix_fmt:v yuvj420p",
 
+	"raw":         "-c:v rawvideo",
+	"raw/gray8":   "-c:v rawvideo -pix_fmt:v gray8",
+	"raw/yuv420p": "-c:v rawvideo -pix_fmt:v yuv420p",
+	"raw/yuv422p": "-c:v rawvideo -pix_fmt:v yuv422p",
+	"raw/yuv444p": "-c:v rawvideo -pix_fmt:v yuv444p",
+
 	// https://ffmpeg.org/ffmpeg-codecs.html#libopus-1
 	// https://github.com/pion/webrtc/issues/1514
 	// https://ffmpeg.org/ffmpeg-resampler.html
-	// `-async 1` or `-min_comp 0` - force frame_size=960, important for WebRTC audio quality
-	"opus":       "-c:a libopus -ar:a 48000 -ac:a 2 -application:a voip -min_comp 0",
+	// `-async 1` or `-min_comp 0` - force resampling for static timestamp inc, important for WebRTC audio quality
+	"opus":       "-c:a libopus -application:a lowdelay -min_comp 0",
+	"opus/16000": "-c:a libopus -application:a lowdelay -min_comp 0 -ar:a 16000 -ac:a 1",
 	"pcmu":       "-c:a pcm_mulaw -ar:a 8000 -ac:a 1",
+	"pcmu/8000":  "-c:a pcm_mulaw -ar:a 8000 -ac:a 1",
 	"pcmu/16000": "-c:a pcm_mulaw -ar:a 16000 -ac:a 1",
 	"pcmu/48000": "-c:a pcm_mulaw -ar:a 48000 -ac:a 1",
 	"pcma":       "-c:a pcm_alaw -ar:a 8000 -ac:a 1",
+	"pcma/8000":  "-c:a pcm_alaw -ar:a 8000 -ac:a 1",
 	"pcma/16000": "-c:a pcm_alaw -ar:a 16000 -ac:a 1",
 	"pcma/48000": "-c:a pcm_alaw -ar:a 48000 -ac:a 1",
 	"aac":        "-c:a aac", // keep sample rate and channels
 	"aac/16000":  "-c:a aac -ar:a 16000 -ac:a 1",
 	"mp3":        "-c:a libmp3lame -q:a 8",
 	"pcm":        "-c:a pcm_s16be -ar:a 8000 -ac:a 1",
+	"pcm/8000":   "-c:a pcm_s16be -ar:a 8000 -ac:a 1",
 	"pcm/16000":  "-c:a pcm_s16be -ar:a 16000 -ac:a 1",
 	"pcm/48000":  "-c:a pcm_s16be -ar:a 48000 -ac:a 1",
 	"pcml":       "-c:a pcm_s16le -ar:a 8000 -ac:a 1",
+	"pcml/8000":  "-c:a pcm_s16le -ar:a 8000 -ac:a 1",
+	"pcml/16000": "-c:a pcm_s16le -ar:a 16000 -ac:a 1",
 	"pcml/44100": "-c:a pcm_s16le -ar:a 44100 -ac:a 1",
 
 	// hardware Intel and AMD on Linux
 	// better not to set `-async_depth:v 1` like for QSV, because framedrops
 	// `-bf 0` - disable B-frames is very important
 	"h264/vaapi":  "-c:v h264_vaapi -g 50 -bf 0 -profile:v high -level:v 4.1 -sei:v 0",
-	"h265/vaapi":  "-c:v hevc_vaapi -g 50 -bf 0 -profile:v high -level:v 5.1 -sei:v 0",
+	"h265/vaapi":  "-c:v hevc_vaapi -g 50 -bf 0 -profile:v main -level:v 5.1 -sei:v 0",
 	"mjpeg/vaapi": "-c:v mjpeg_vaapi",
 
 	// hardware Raspberry
 	"h264/v4l2m2m": "-c:v h264_v4l2m2m -g 50 -bf 0",
 	"h265/v4l2m2m": "-c:v hevc_v4l2m2m -g 50 -bf 0",
 
+	// hardware Rockchip
+	// important to use custom ffmpeg https://github.com/AlexxIT/go2rtc/issues/768
+	// hevc - doesn't have a profile setting
+	"h264/rkmpp":  "-c:v h264_rkmpp -g 50 -bf 0 -profile:v high -level:v 4.1",
+	"h265/rkmpp":  "-c:v hevc_rkmpp -g 50 -bf 0 -profile:v main -level:v 5.1",
+	"mjpeg/rkmpp": "-c:v mjpeg_rkmpp",
+
 	// hardware NVidia on Linux and Windows
 	// preset=p2 - faster, tune=ll - low latency
 	"h264/cuda": "-c:v h264_nvenc -g 50 -bf 0 -profile:v high -level:v auto -preset:v p2 -tune:v ll",
-	"h265/cuda": "-c:v hevc_nvenc -g 50 -bf 0 -profile:v high -level:v auto",
+	"h265/cuda": "-c:v hevc_nvenc -g 50 -bf 0 -profile:v main -level:v auto",
 
 	// hardware Intel on Windows
 	"h264/dxva2":  "-c:v h264_qsv -g 50 -bf 0 -profile:v high -level:v 4.1 -async_depth:v 1",
-	"h265/dxva2":  "-c:v hevc_qsv -g 50 -bf 0 -profile:v high -level:v 5.1 -async_depth:v 1",
-	"mjpeg/dxva2": "-c:v mjpeg_qsv -profile:v high -level:v 5.1",
+	"h265/dxva2":  "-c:v hevc_qsv -g 50 -bf 0 -profile:v main -level:v 5.1 -async_depth:v 1",
+	"mjpeg/dxva2": "-c:v mjpeg_qsv",
 
 	// hardware macOS
 	"h264/videotoolbox": "-c:v h264_videotoolbox -g 50 -bf 0 -profile:v high -level:v 4.1",
-	"h265/videotoolbox": "-c:v hevc_videotoolbox -g 50 -bf 0 -profile:v high -level:v 5.1",
+	"h265/videotoolbox": "-c:v hevc_videotoolbox -g 50 -bf 0 -profile:v main -level:v 5.1",
 }
 
+var log zerolog.Logger
+
 // configTemplate - return template from config (defaults) if exist or return raw template
 func configTemplate(template string) string {
 	if s := defaults[template]; s != "" {
@@ -132,13 +175,15 @@ func inputTemplate(name, s string, query url.Values) string {
 func parseArgs(s string) *ffmpeg.Args {
 	// init FFmpeg arguments
 	args := &ffmpeg.Args{
-		Bin:    defaults["bin"],
-		Global: defaults["global"],
-		Output: defaults["output"],
+		Bin:     defaults["bin"],
+		Global:  defaults["global"],
+		Output:  defaults["output"],
+		Version: verAV,
 	}
 
+	var source = s
 	var query url.Values
-	if i := strings.IndexByte(s, '#'); i > 0 {
+	if i := strings.IndexByte(s, '#'); i >= 0 {
 		query = streams.ParseQuery(s[i+1:])
 		args.Video = len(query["video"])
 		args.Audio = len(query["audio"])
@@ -179,12 +224,19 @@ func parseArgs(s string) *ffmpeg.Args {
 		default:
 			s += "?video&audio"
 		}
+		s += "&source=ffmpeg:" + url.QueryEscape(source)
+		for _, v := range query["query"] {
+			s += "&" + v
+		}
 		args.Input = inputTemplate("rtsp", s, query)
-	} else if strings.HasPrefix(s, "device?") {
-		var err error
-		args.Input, err = device.GetInput(s)
-		if err != nil {
-			return nil
+	} else if i = strings.Index(s, "?"); i > 0 {
+		switch s[:i] {
+		case "device":
+			args.Input = device.GetInput(s[i+1:])
+		case "virtual":
+			args.Input = virtual.GetInput(s[i+1:])
+		case "tts":
+			args.Input = virtual.GetInputTTS(s[i+1:])
 		}
 	} else {
 		args.Input = inputTemplate("file", s, query)
@@ -267,6 +319,12 @@ func parseArgs(s string) *ffmpeg.Args {
 			}
 		}
 
+		if query["bitrate"] != nil {
+			// https://trac.ffmpeg.org/wiki/Limiting%20the%20output%20bitrate
+			b := query["bitrate"][0]
+			args.AddCodec("-b:v " + b + " -maxrate " + b + " -bufsize " + b)
+		}
+
 		// 4. Process audio codecs
 		if args.Audio > 0 {
 			for _, audio := range query["audio"] {
@@ -296,11 +354,27 @@ func parseArgs(s string) *ffmpeg.Args {
 		args.AddCodec("-an")
 	}
 
-	// transcoding to only mjpeg
-	if (args.Video == 1 && args.Audio == 0 && query.Get("video") == "mjpeg") ||
-		// no transcoding from mjpeg input
-		(args.Video == 0 && args.Audio == 0 && strings.Contains(args.Input, " mjpeg ")) {
-		args.Output = defaults["output/mjpeg"]
+	// change otput from RTSP to some other pipe format
+	switch {
+	case args.Video == 0 && args.Audio == 0:
+		// no transcoding from mjpeg input (ffmpeg device with support output as raw MJPEG)
+		if strings.Contains(args.Input, " mjpeg ") {
+			args.Output = defaults["output/mjpeg"]
+		}
+	case args.Video == 1 && args.Audio == 0:
+		switch core.Before(query.Get("video"), "/") {
+		case "mjpeg":
+			args.Output = defaults["output/mjpeg"]
+		case "raw":
+			args.Output = defaults["output/raw"]
+		}
+	case args.Video == 0 && args.Audio == 1:
+		switch core.Before(query.Get("audio"), "/") {
+		case "aac":
+			args.Output = defaults["output/aac"]
+		case "pcma", "pcmu", "pcml":
+			args.Output = defaults["output/wav"]
+		}
 	}
 
 	return args

internal/ffmpeg/ffmpeg_test.go

@@ -3,136 +3,236 @@ package ffmpeg
 import (
 	"testing"
 
+	"github.com/AlexxIT/go2rtc/pkg/ffmpeg"
 	"github.com/stretchr/testify/require"
 )
 
 func TestParseArgsFile(t *testing.T) {
-	// [FILE] all tracks will be copied without transcoding codecs
-	args := parseArgs("/media/bbb.mp4")
-	require.Equal(t, `ffmpeg -hide_banner -re -i /media/bbb.mp4 -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
-
-	// [FILE] video will be transcoded to H264, audio will be skipped
-	args = parseArgs("/media/bbb.mp4#video=h264")
-	require.Equal(t, `ffmpeg -hide_banner -re -i /media/bbb.mp4 -c:v libx264 -g 50 -profile:v high -level:v 4.1 -preset:v superfast -tune:v zerolatency -pix_fmt:v yuvj420p -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
-
-	// [FILE] video will be copied, audio will be transcoded to pcmu
-	args = parseArgs("/media/bbb.mp4#video=copy#audio=pcmu")
-	require.Equal(t, `ffmpeg -hide_banner -re -i /media/bbb.mp4 -c:v copy -c:a pcm_mulaw -ar:a 8000 -ac:a 1 -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
-
-	// [FILE] video will be transcoded to H265 and rotate 270º, audio will be skipped
-	args = parseArgs("/media/bbb.mp4#video=h265#rotate=-90")
-	require.Equal(t, `ffmpeg -hide_banner -re -i /media/bbb.mp4 -c:v libx265 -g 50 -profile:v main -level:v 5.1 -preset:v superfast -tune:v zerolatency -an -vf "transpose=2" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
-
-	// [FILE] video will be output for MJPEG to pipe, audio will be skipped
-	args = parseArgs("/media/bbb.mp4#video=mjpeg")
-	require.Equal(t, `ffmpeg -hide_banner -re -i /media/bbb.mp4 -c:v mjpeg -an -f mjpeg -`, args.String())
-
-	// https://github.com/AlexxIT/go2rtc/issues/509
-	args = parseArgs("ffmpeg:test.mp4#raw=-ss 00:00:20")
-	require.Equal(t, `ffmpeg -hide_banner -re -i ffmpeg:test.mp4 -ss 00:00:20 -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
+	tests := []struct {
+		name   string
+		source string
+		expect string
+	}{
+		{
+			name:   "[FILE] all tracks will be copied without transcoding codecs",
+			source: "/media/bbb.mp4",
+			expect: `ffmpeg -hide_banner -re -i /media/bbb.mp4 -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[FILE] video will be transcoded to H264, audio will be skipped",
+			source: "/media/bbb.mp4#video=h264",
+			expect: `ffmpeg -hide_banner -re -i /media/bbb.mp4 -c:v libx264 -g 50 -profile:v high -level:v 4.1 -preset:v superfast -tune:v zerolatency -pix_fmt:v yuv420p -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[FILE] video will be copied, audio will be transcoded to pcmu",
+			source: "/media/bbb.mp4#video=copy#audio=pcmu",
+			expect: `ffmpeg -hide_banner -re -i /media/bbb.mp4 -c:v copy -c:a pcm_mulaw -ar:a 8000 -ac:a 1 -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[FILE] video will be transcoded to H265 and rotate 270º, audio will be skipped",
+			source: "/media/bbb.mp4#video=h265#rotate=-90",
+			expect: `ffmpeg -hide_banner -re -i /media/bbb.mp4 -c:v libx265 -g 50 -profile:v main -level:v 5.1 -preset:v superfast -tune:v zerolatency -pix_fmt:v yuv420p -an -vf "transpose=2" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[FILE] video will be output for MJPEG to pipe, audio will be skipped",
+			source: "/media/bbb.mp4#video=mjpeg",
+			expect: `ffmpeg -hide_banner -re -i /media/bbb.mp4 -c:v mjpeg -an -f mjpeg -`,
+		},
+		{
+			name:   "https://github.com/AlexxIT/go2rtc/issues/509",
+			source: "ffmpeg:test.mp4#raw=-ss 00:00:20",
+			expect: `ffmpeg -hide_banner -re -i ffmpeg:test.mp4 -ss 00:00:20 -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			args := parseArgs(test.source)
+			require.Equal(t, test.expect, args.String())
+		})
+	}
 }
 
 func TestParseArgsDevice(t *testing.T) {
-	// [DEVICE] video will be output for MJPEG to pipe, with size 1920x1080
-	args := parseArgs("device?video=0&video_size=1920x1080")
-	require.Equal(t, `ffmpeg -hide_banner -f dshow -video_size 1920x1080 -i video="0" -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
-
-	// [DEVICE] video will be transcoded to H265 with framerate 20, audio will be skipped
-	args = parseArgs("device?video=0&video_size=1280x720&framerate=20#video=h265#audio=pcma")
-	require.Equal(t, `ffmpeg -hide_banner -f dshow -video_size 1280x720 -framerate 20 -i video="0" -c:v libx265 -g 50 -profile:v main -level:v 5.1 -preset:v superfast -tune:v zerolatency -c:a pcm_alaw -ar:a 8000 -ac:a 1 -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
+	tests := []struct {
+		name   string
+		source string
+		expect string
+	}{
+		{
+			name:   "[DEVICE] video will be output for MJPEG to pipe, with size 1920x1080",
+			source: "device?video=0&video_size=1920x1080",
+			expect: `ffmpeg -hide_banner -f dshow -video_size 1920x1080 -i "video=0" -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[DEVICE] video will be transcoded to H265 with framerate 20, audio will be skipped",
+			source: "device?video=0&framerate=20#video=h265",
+			expect: `ffmpeg -hide_banner -f dshow -framerate 20 -i "video=0" -c:v libx265 -g 50 -profile:v main -level:v 5.1 -preset:v superfast -tune:v zerolatency -pix_fmt:v yuv420p -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[DEVICE] video/audio",
+			source: "device?video=FaceTime HD Camera&audio=Microphone (High Definition Audio Device)",
+			expect: `ffmpeg -hide_banner -f dshow -i "video=FaceTime HD Camera:audio=Microphone (High Definition Audio Device)" -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			args := parseArgs(test.source)
+			require.Equal(t, test.expect, args.String())
+		})
+	}
 }
 
 func TestParseArgsIpCam(t *testing.T) {
-	// [HTTP] video will be copied
-	args := parseArgs("http://example.com")
-	require.Equal(t, `ffmpeg -hide_banner -fflags nobuffer -flags low_delay -i http://example.com -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
-
-	// [HTTP-MJPEG] video will be transcoded to H264
-	args = parseArgs("http://example.com#video=h264")
-	require.Equal(t, `ffmpeg -hide_banner -fflags nobuffer -flags low_delay -i http://example.com -c:v libx264 -g 50 -profile:v high -level:v 4.1 -preset:v superfast -tune:v zerolatency -pix_fmt:v yuvj420p -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
-
-	// [HLS] video will be copied, audio will be skipped
-	args = parseArgs("https://example.com#video=copy")
-	require.Equal(t, `ffmpeg -hide_banner -fflags nobuffer -flags low_delay -i https://example.com -c:v copy -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
-
-	// [RTSP] video will be copied without transcoding codecs
-	args = parseArgs("rtsp://example.com")
-	require.Equal(t, `ffmpeg -hide_banner -allowed_media_types video+audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
-
-	// [RTSP] video with resize to 1280x720, should be transcoded, so select H265
-	args = parseArgs("rtsp://example.com#video=h265#width=1280#height=720")
-	require.Equal(t, `ffmpeg -hide_banner -allowed_media_types video -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:v libx265 -g 50 -profile:v main -level:v 5.1 -preset:v superfast -tune:v zerolatency -an -vf "scale=1280:720" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
-
-	// [RTSP] video will be copied, changing RTSP transport from TCP to UDP+TCP
-	args = parseArgs("rtsp://example.com#input=rtsp/udp")
-	require.Equal(t, `ffmpeg -hide_banner -allowed_media_types video+audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -i rtsp://example.com -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
-
-	// [RTMP] video will be copied, changing RTSP transport from TCP to UDP+TCP
-	args = parseArgs("rtmp://example.com#input=rtsp/udp")
-	require.Equal(t, `ffmpeg -hide_banner -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -i rtmp://example.com -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
+	tests := []struct {
+		name   string
+		source string
+		expect string
+	}{
+		{
+			name:   "[HTTP] video will be copied",
+			source: "http://example.com",
+			expect: `ffmpeg -hide_banner -fflags nobuffer -flags low_delay -i http://example.com -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[HTTP-MJPEG] video will be transcoded to H264",
+			source: "http://example.com#video=h264",
+			expect: `ffmpeg -hide_banner -fflags nobuffer -flags low_delay -i http://example.com -c:v libx264 -g 50 -profile:v high -level:v 4.1 -preset:v superfast -tune:v zerolatency -pix_fmt:v yuv420p -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[HLS] video will be copied, audio will be skipped",
+			source: "https://example.com#video=copy",
+			expect: `ffmpeg -hide_banner -fflags nobuffer -flags low_delay -i https://example.com -c:v copy -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[RTSP] video will be copied without transcoding codecs",
+			source: "rtsp://example.com",
+			expect: `ffmpeg -hide_banner -allowed_media_types video+audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[RTSP] video with resize to 1280x720, should be transcoded, so select H265",
+			source: "rtsp://example.com#video=h265#width=1280#height=720",
+			expect: `ffmpeg -hide_banner -allowed_media_types video -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:v libx265 -g 50 -profile:v main -level:v 5.1 -preset:v superfast -tune:v zerolatency -pix_fmt:v yuv420p -an -vf "scale=1280:720" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[RTSP] video will be copied, changing RTSP transport from TCP to UDP+TCP",
+			source: "rtsp://example.com#input=rtsp/udp",
+			expect: `ffmpeg -hide_banner -allowed_media_types video+audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -i rtsp://example.com -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[RTMP] video will be copied, changing RTSP transport from TCP to UDP+TCP",
+			source: "rtmp://example.com#input=rtsp/udp",
+			expect: `ffmpeg -hide_banner -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -i rtmp://example.com -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			args := parseArgs(test.source)
+			require.Equal(t, test.expect, args.String())
+		})
+	}
 }
 
 func TestParseArgsAudio(t *testing.T) {
-	// [AUDIO] audio will be transcoded to AAC, video will be skipped
-	args := parseArgs("rtsp:///example.com#audio=aac")
-	require.Equal(t, `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp:///example.com -c:a aac -vn -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
-
-	// [AUDIO] audio will be transcoded to AAC/16000, video will be skipped
-	args = parseArgs("rtsp:///example.com#audio=aac/16000")
-	require.Equal(t, `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp:///example.com -c:a aac -ar:a 16000 -ac:a 1 -vn -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
-
-	// [AUDIO] audio will be transcoded to OPUS, video will be skipped
-	args = parseArgs("rtsp:///example.com#audio=opus")
-	require.Equal(t, `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp:///example.com -c:a libopus -ar:a 48000 -ac:a 2 -application:a voip -min_comp 0 -vn -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
-
-	// [AUDIO] audio will be transcoded to PCMU, video will be skipped
-	args = parseArgs("rtsp:///example.com#audio=pcmu")
-	require.Equal(t, `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp:///example.com -c:a pcm_mulaw -ar:a 8000 -ac:a 1 -vn -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
-
-	// [AUDIO] audio will be transcoded to PCMU/16000, video will be skipped
-	args = parseArgs("rtsp:///example.com#audio=pcmu/16000")
-	require.Equal(t, `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp:///example.com -c:a pcm_mulaw -ar:a 16000 -ac:a 1 -vn -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
-
-	// [AUDIO] audio will be transcoded to PCMU/48000, video will be skipped
-	args = parseArgs("rtsp:///example.com#audio=pcmu/48000")
-	require.Equal(t, `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp:///example.com -c:a pcm_mulaw -ar:a 48000 -ac:a 1 -vn -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
-
-	// [AUDIO] audio will be transcoded to PCMA, video will be skipped
-	args = parseArgs("rtsp:///example.com#audio=pcma")
-	require.Equal(t, `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp:///example.com -c:a pcm_alaw -ar:a 8000 -ac:a 1 -vn -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
-
-	// [AUDIO] audio will be transcoded to PCMA/16000, video will be skipped
-	args = parseArgs("rtsp:///example.com#audio=pcma/16000")
-	require.Equal(t, `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp:///example.com -c:a pcm_alaw -ar:a 16000 -ac:a 1 -vn -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
-
-	// [AUDIO] audio will be transcoded to PCMA/48000, video will be skipped
-	args = parseArgs("rtsp:///example.com#audio=pcma/48000")
-	require.Equal(t, `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp:///example.com -c:a pcm_alaw -ar:a 48000 -ac:a 1 -vn -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
+	tests := []struct {
+		name   string
+		source string
+		expect string
+	}{
+		{
+			name:   "[AUDIO] audio will be transcoded to AAC, video will be skipped",
+			source: "rtsp://example.com#audio=aac",
+			expect: `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:a aac -vn -f adts -`,
+		},
+		{
+			name:   "[AUDIO] audio will be transcoded to AAC/16000, video will be skipped",
+			source: "rtsp://example.com#audio=aac/16000",
+			expect: `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:a aac -ar:a 16000 -ac:a 1 -vn -f adts -`,
+		},
+		{
+			name:   "[AUDIO] audio will be transcoded to OPUS, video will be skipped",
+			source: "rtsp://example.com#audio=opus",
+			expect: `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:a libopus -application:a lowdelay -min_comp 0 -vn -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[AUDIO] audio will be transcoded to PCMU, video will be skipped",
+			source: "rtsp://example.com#audio=pcmu",
+			expect: `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:a pcm_mulaw -ar:a 8000 -ac:a 1 -vn -f wav -`,
+		},
+		{
+			name:   "[AUDIO] audio will be transcoded to PCMU/16000, video will be skipped",
+			source: "rtsp://example.com#audio=pcmu/16000",
+			expect: `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:a pcm_mulaw -ar:a 16000 -ac:a 1 -vn -f wav -`,
+		},
+		{
+			name:   "[AUDIO] audio will be transcoded to PCMU/48000, video will be skipped",
+			source: "rtsp://example.com#audio=pcmu/48000",
+			expect: `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:a pcm_mulaw -ar:a 48000 -ac:a 1 -vn -f wav -`,
+		},
+		{
+			name:   "[AUDIO] audio will be transcoded to PCMA, video will be skipped",
+			source: "rtsp://example.com#audio=pcma",
+			expect: `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:a pcm_alaw -ar:a 8000 -ac:a 1 -vn -f wav -`,
+		},
+		{
+			name:   "[AUDIO] audio will be transcoded to PCMA/16000, video will be skipped",
+			source: "rtsp://example.com#audio=pcma/16000",
+			expect: `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:a pcm_alaw -ar:a 16000 -ac:a 1 -vn -f wav -`,
+		},
+		{
+			name:   "[AUDIO] audio will be transcoded to PCMA/48000, video will be skipped",
+			source: "rtsp://example.com#audio=pcma/48000",
+			expect: `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:a pcm_alaw -ar:a 48000 -ac:a 1 -vn -f wav -`,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			args := parseArgs(test.source)
+			require.Equal(t, test.expect, args.String())
+		})
+	}
 }
 
 func TestParseArgsHwVaapi(t *testing.T) {
-	// [HTTP-MJPEG] video will be transcoded to H264
-	args := parseArgs("http:///example.com#video=h264#hardware=vaapi")
-	require.Equal(t, `ffmpeg -hide_banner -hwaccel vaapi -hwaccel_output_format vaapi -fflags nobuffer -flags low_delay -i http:///example.com -c:v h264_vaapi -g 50 -bf 0 -profile:v high -level:v 4.1 -sei:v 0 -an -vf "format=vaapi|nv12,hwupload" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
-
-	// [RTSP] video with rotation, should be transcoded, so select H264
-	args = parseArgs("rtsp://example.com#video=h264#rotate=180#hardware=vaapi")
-	require.Equal(t, `ffmpeg -hide_banner -hwaccel vaapi -hwaccel_output_format vaapi -allowed_media_types video -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:v h264_vaapi -g 50 -bf 0 -profile:v high -level:v 4.1 -sei:v 0 -an -vf "format=vaapi|nv12,hwupload,transpose_vaapi=4" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
-
-	// [RTSP] video with resize to 1280x720, should be transcoded, so select H265
-	args = parseArgs("rtsp://example.com#video=h265#width=1280#height=720#hardware=vaapi")
-	require.Equal(t, `ffmpeg -hide_banner -hwaccel vaapi -hwaccel_output_format vaapi -allowed_media_types video -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:v hevc_vaapi -g 50 -bf 0 -profile:v high -level:v 5.1 -sei:v 0 -an -vf "format=vaapi|nv12,hwupload,scale_vaapi=1280:720" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
-
-	// [FILE] video will be output for MJPEG to pipe, audio will be skipped
-	args = parseArgs("/media/bbb.mp4#video=mjpeg#hardware=vaapi")
-	require.Equal(t, `ffmpeg -hide_banner -hwaccel vaapi -hwaccel_output_format vaapi -re -i /media/bbb.mp4 -c:v mjpeg_vaapi -an -vf "format=vaapi|nv12,hwupload" -f mjpeg -`, args.String())
-
-	// [DEVICE] MJPEG video with size 1920x1080 will be transcoded to H265
-	args = parseArgs("device?video=0&video_size=1920x1080#video=h265#hardware=vaapi")
-	require.Equal(t, `ffmpeg -hide_banner -hwaccel vaapi -hwaccel_output_format vaapi -f dshow -video_size 1920x1080 -i video="0" -c:v hevc_vaapi -g 50 -bf 0 -profile:v high -level:v 5.1 -sei:v 0 -an -vf "format=vaapi|nv12,hwupload" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
+	tests := []struct {
+		name   string
+		source string
+		expect string
+	}{
+		{
+			name:   "[HTTP-MJPEG] video will be transcoded to H264",
+			source: "http:///example.com#video=h264#hardware=vaapi",
+			expect: `ffmpeg -hide_banner -hwaccel vaapi -hwaccel_output_format vaapi -hwaccel_flags allow_profile_mismatch -fflags nobuffer -flags low_delay -i http:///example.com -c:v h264_vaapi -g 50 -bf 0 -profile:v high -level:v 4.1 -sei:v 0 -an -vf "format=vaapi|nv12,hwupload,scale_vaapi=out_color_matrix=bt709:out_range=tv:format=nv12" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[RTSP] video with rotation, should be transcoded, so select H264",
+			source: "rtsp://example.com#video=h264#rotate=180#hardware=vaapi",
+			expect: `ffmpeg -hide_banner -hwaccel vaapi -hwaccel_output_format vaapi -hwaccel_flags allow_profile_mismatch -allowed_media_types video -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:v h264_vaapi -g 50 -bf 0 -profile:v high -level:v 4.1 -sei:v 0 -an -vf "format=vaapi|nv12,hwupload,transpose_vaapi=4,scale_vaapi=out_color_matrix=bt709:out_range=tv:format=nv12" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[RTSP] video with resize to 1280x720, should be transcoded, so select H265",
+			source: "rtsp://example.com#video=h265#width=1280#height=720#hardware=vaapi",
+			expect: `ffmpeg -hide_banner -hwaccel vaapi -hwaccel_output_format vaapi -hwaccel_flags allow_profile_mismatch -allowed_media_types video -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:v hevc_vaapi -g 50 -bf 0 -profile:v main -level:v 5.1 -sei:v 0 -an -vf "format=vaapi|nv12,hwupload,scale_vaapi=1280:720" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[FILE] video will be output for MJPEG to pipe, audio will be skipped",
+			source: "/media/bbb.mp4#video=mjpeg#hardware=vaapi",
+			expect: `ffmpeg -hide_banner -hwaccel vaapi -hwaccel_output_format vaapi -hwaccel_flags allow_profile_mismatch -re -i /media/bbb.mp4 -c:v mjpeg_vaapi -an -vf "format=vaapi|nv12,hwupload" -f mjpeg -`,
+		},
+		{
+			name:   "[DEVICE] MJPEG video with size 1920x1080 will be transcoded to H265",
+			source: "device?video=0&video_size=1920x1080#video=h265#hardware=vaapi",
+			expect: `ffmpeg -hide_banner -hwaccel vaapi -hwaccel_output_format vaapi -hwaccel_flags allow_profile_mismatch -f dshow -video_size 1920x1080 -i "video=0" -c:v hevc_vaapi -g 50 -bf 0 -profile:v main -level:v 5.1 -sei:v 0 -an -vf "format=vaapi|nv12,hwupload" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			args := parseArgs(test.source)
+			require.Equal(t, test.expect, args.String())
+		})
+	}
 }
 
-func TestParseArgsHwV4l2m2m(t *testing.T) {
+func _TestParseArgsHwV4l2m2m(t *testing.T) {
 	// [HTTP-MJPEG] video will be transcoded to H264
 	args := parseArgs("http:///example.com#video=h264#hardware=v4l2m2m")
 	require.Equal(t, `ffmpeg -hide_banner -fflags nobuffer -flags low_delay -i http:///example.com -c:v h264_v4l2m2m -g 50 -bf 0 -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
@@ -150,7 +250,37 @@ func TestParseArgsHwV4l2m2m(t *testing.T) {
 	require.Equal(t, `ffmpeg -hide_banner -f dshow -video_size 1920x1080 -i video="0" -c:v hevc_v4l2m2m -g 50 -bf 0 -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
 }
 
-func TestParseArgsHwCuda(t *testing.T) {
+func TestParseArgsHwRKMPP(t *testing.T) {
+	tests := []struct {
+		name   string
+		source string
+		expect string
+	}{
+		{
+			name:   "[FILE] transcoding to H264",
+			source: "bbb.mp4#video=h264#hardware=rkmpp",
+			expect: `ffmpeg -hide_banner -hwaccel rkmpp -hwaccel_output_format drm_prime -afbc rga -re -i bbb.mp4 -c:v h264_rkmpp -g 50 -bf 0 -profile:v high -level:v 4.1 -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[FILE] transcoding with rotation",
+			source: "bbb.mp4#video=h264#rotate=180#hardware=rkmpp",
+			expect: `ffmpeg -hide_banner -hwaccel rkmpp -hwaccel_output_format drm_prime -afbc rga -re -i bbb.mp4 -c:v h264_rkmpp -g 50 -bf 0 -profile:v high -level:v 4.1 -an -vf "format=drm_prime|nv12,hwupload,vpp_rkrga=transpose=4" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[FILE] transcoding with scaling",
+			source: "bbb.mp4#video=h264#height=320#hardware=rkmpp",
+			expect: `ffmpeg -hide_banner -hwaccel rkmpp -hwaccel_output_format drm_prime -afbc rga -re -i bbb.mp4 -c:v h264_rkmpp -g 50 -bf 0 -profile:v high -level:v 4.1 -an -vf "format=drm_prime|nv12,hwupload,scale_rkrga=-1:320:force_original_aspect_ratio=0" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			args := parseArgs(test.source)
+			require.Equal(t, test.expect, args.String())
+		})
+	}
+}
+
+func _TestParseArgsHwCuda(t *testing.T) {
 	// [HTTP-MJPEG] video will be transcoded to H264
 	args := parseArgs("http:///example.com#video=h264#hardware=cuda")
 	require.Equal(t, `ffmpeg -hide_banner -hwaccel cuda -hwaccel_output_format cuda -fflags nobuffer -flags low_delay -i http:///example.com -c:v h264_nvenc -g 50 -bf 0 -profile:v high -level:v auto -preset:v p2 -tune:v ll -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
@@ -168,7 +298,7 @@ func TestParseArgsHwCuda(t *testing.T) {
 	require.Equal(t, `ffmpeg -hide_banner -hwaccel cuda -hwaccel_output_format cuda -f dshow -video_size 1920x1080 -i video="0" -c:v hevc_nvenc -g 50 -bf 0 -profile:v high -level:v auto -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
 }
 
-func TestParseArgsHwDxva2(t *testing.T) {
+func _TestParseArgsHwDxva2(t *testing.T) {
 	// [HTTP-MJPEG] video will be transcoded to H264
 	args := parseArgs("http:///example.com#video=h264#hardware=dxva2")
 	require.Equal(t, `ffmpeg -hide_banner -hwaccel dxva2 -hwaccel_output_format dxva2_vld -fflags nobuffer -flags low_delay -i http:///example.com -c:v h264_qsv -g 50 -bf 0 -profile:v high -level:v 4.1 -async_depth:v 1 -an -vf "hwmap=derive_device=qsv,format=qsv" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
@@ -190,7 +320,7 @@ func TestParseArgsHwDxva2(t *testing.T) {
 	require.Equal(t, `ffmpeg -hide_banner -hwaccel dxva2 -hwaccel_output_format dxva2_vld -f dshow -video_size 1920x1080 -i video="0" -c:v hevc_qsv -g 50 -bf 0 -profile:v high -level:v 5.1 -async_depth:v 1 -an -vf "hwmap=derive_device=qsv,format=qsv" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
 }
 
-func TestParseArgsHwVideotoolbox(t *testing.T) {
+func _TestParseArgsHwVideotoolbox(t *testing.T) {
 	// [HTTP-MJPEG] video will be transcoded to H264
 	args := parseArgs("http:///example.com#video=h264#hardware=videotoolbox")
 	require.Equal(t, `ffmpeg -hide_banner -hwaccel videotoolbox -hwaccel_output_format videotoolbox_vld -fflags nobuffer -flags low_delay -i http:///example.com -c:v h264_videotoolbox -g 50 -bf 0 -profile:v high -level:v 4.1 -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
@@ -207,3 +337,55 @@ func TestParseArgsHwVideotoolbox(t *testing.T) {
 	args = parseArgs("device?video=0&video_size=1920x1080#video=h265#hardware=videotoolbox")
 	require.Equal(t, `ffmpeg -hide_banner -hwaccel videotoolbox -hwaccel_output_format videotoolbox_vld -f dshow -video_size 1920x1080 -i video="0" -c:v hevc_videotoolbox -g 50 -bf 0 -profile:v high -level:v 5.1 -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
 }
+
+func TestDeckLink(t *testing.T) {
+	args := parseArgs(`DeckLink SDI (2)#video=h264#hardware=vaapi#input=-format_code Hp29 -f decklink -i "{input}"`)
+	require.Equal(t, `ffmpeg -hide_banner -hwaccel vaapi -hwaccel_output_format vaapi -hwaccel_flags allow_profile_mismatch -format_code Hp29 -f decklink -i "DeckLink SDI (2)" -c:v h264_vaapi -g 50 -bf 0 -profile:v high -level:v 4.1 -sei:v 0 -an -vf "format=vaapi|nv12,hwupload,scale_vaapi=out_color_matrix=bt709:out_range=tv:format=nv12" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
+}
+
+func TestDrawText(t *testing.T) {
+	tests := []struct {
+		name   string
+		source string
+		expect string
+	}{
+		{
+			source: "http:///example.com#video=h264#drawtext=fontsize=12",
+			expect: `ffmpeg -hide_banner -fflags nobuffer -flags low_delay -i http:///example.com -c:v libx264 -g 50 -profile:v high -level:v 4.1 -preset:v superfast -tune:v zerolatency -pix_fmt:v yuv420p -an -vf "drawtext=fontsize=12:text='%{localtime\:%Y-%m-%d %X}'" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			source: "http:///example.com#video=h264#width=640#drawtext=fontsize=12",
+			expect: `ffmpeg -hide_banner -fflags nobuffer -flags low_delay -i http:///example.com -c:v libx264 -g 50 -profile:v high -level:v 4.1 -preset:v superfast -tune:v zerolatency -pix_fmt:v yuv420p -an -vf "scale=640:-1,drawtext=fontsize=12:text='%{localtime\:%Y-%m-%d %X}'" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			source: "http:///example.com#video=h264#width=640#drawtext=fontsize=12#hardware=vaapi",
+			expect: `ffmpeg -hide_banner -hwaccel vaapi -hwaccel_output_format nv12 -hwaccel_flags allow_profile_mismatch -fflags nobuffer -flags low_delay -i http:///example.com -c:v h264_vaapi -g 50 -bf 0 -profile:v high -level:v 4.1 -sei:v 0 -an -vf "scale=640:-1,drawtext=fontsize=12:text='%{localtime\:%Y-%m-%d %X}',hwupload" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			args := parseArgs(test.source)
+			require.Equal(t, test.expect, args.String())
+		})
+	}
+}
+
+func TestVersion(t *testing.T) {
+	verAV = ffmpeg.Version61
+	tests := []struct {
+		name   string
+		source string
+		expect string
+	}{
+		{
+			source: "/media/bbb.mp4",
+			expect: `ffmpeg -hide_banner -readrate_initial_burst 0.001 -re -i /media/bbb.mp4 -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			args := parseArgs(test.source)
+			require.Equal(t, test.expect, args.String())
+		})
+	}
+}

internal/ffmpeg/hardware/README.md

@@ -0,0 +1,106 @@
+# Hardware
+
+You **DON'T** need hardware acceleration if:
+
+- you not using [FFmpeg source](https://github.com/AlexxIT/go2rtc#source-ffmpeg)
+- you using only `#video=copy` for FFmpeg source
+- you using only `#audio=...` (any audio) transcoding for FFmpeg source
+
+You **NEED** hardware acceleration if you using `#video=h264`, `#video=h265`, `#video=mjpeg` (video) transcoding.
+
+## Important
+
+- Acceleration is disabled by default because it can be unstable (it can be changed in future)
+- go2rtc can automatically detect supported hardware acceleration if enabled
+- go2rtc will enable hardware decoding only if hardware encoding supported
+- go2rtc will use the same GPU for decoder and encoder
+- Intel and AMD will switch to software decoder if input codec is not supported with hardware decoder
+- NVidia will fail if input codec is not supported with hardware decoder
+- Raspberry always uses software decoder
+
+```yaml
+streams:
+  # auto select hardware encoder
+  camera1_hw: ffmpeg:rtsp://rtsp:12345678@192.168.1.123/av_stream/ch0#video=h264#hardware
+  
+  # manual select hardware encoder (vaapi, cuda, v4l2m2m, dxva2, videotoolbox)
+  camera1_vaapi: ffmpeg:rtsp://rtsp:12345678@192.168.1.123/av_stream/ch0#video=h264#hardware=vaapi
+```
+
+## Docker and Hass Addon
+
+There are two versions of the Docker container and Hass Add-on:
+
+- Latest (alpine) support hardware acceleration for Intel iGPU (CPU with Graphics) and Raspberry.
+- Hardware (debian 12) support Intel iGPU, AMD GPU, NVidia GPU.
+
+## Intel iGPU
+
+**Supported on:** Windows binary, Linux binary, Docker, Hass Addon.
+
+If you have Intel CPU Sandy Bridge (2011) with Graphics, you already have support hardware decoding/encoding for `AVC/H.264`.
+
+If you have Intel CPU Skylake (2015) with Graphics, you already have support hardware decoding/encoding for `AVC/H.264`, `HEVC/H.265` and `MJPEG`.
+
+Read more [here](https://en.wikipedia.org/wiki/Intel_Quick_Sync_Video#Hardware_decoding_and_encoding) and [here](https://en.wikipedia.org/wiki/Intel_Graphics_Technology#Capabilities_(GPU_video_acceleration)).
+
+Linux and Docker:
+
+- It may be important to have the latest version of the OS with the latest version of the Linux kernel. For example, on my **Debian 10 (kernel 4.19)** it did not work, but after update to **Debian 11 (kernel 5.10)** all was fine.
+- In case of troube check you have `/dev/dri/` folder on your host.
+
+Docker users should add `--privileged` option to container for access to Hardware.
+
+**PS.** Supported via [VAAPI](https://trac.ffmpeg.org/wiki/Hardware/VAAPI) engine on Linux and [DXVA2+QSV](https://trac.ffmpeg.org/wiki/Hardware/QuickSync) engine on Windows.
+
+## AMD GPU
+
+*I don't have the hardware for test support!!!*
+
+**Supported on:** Linux binary, Docker, Hass Addon.
+
+Docker users should install: `alexxit/go2rtc:master-hardware`. Docker users should add `--privileged` option to container for access to Hardware.
+
+Hass Addon users should install **go2rtc master hardware** version.
+
+**PS.** Supported via [VAAPI](https://trac.ffmpeg.org/wiki/Hardware/VAAPI) engine.
+
+## NVidia GPU
+
+**Supported on:** Windows binary, Linux binary, Docker.
+
+Docker users should install: `alexxit/go2rtc:master-hardware`.
+
+Read more [here](https://docs.frigate.video/configuration/hardware_acceleration) and [here](https://jellyfin.org/docs/general/administration/hardware-acceleration/#nvidia-hardware-acceleration-on-docker-linux).
+
+**PS.** Supported via [CUDA](https://trac.ffmpeg.org/wiki/HWAccelIntro#CUDANVENCNVDEC) engine.
+
+## Raspberry Pi 3
+
+**Supported on:** Linux binary, Docker, Hass Addon.
+
+I don't recommend using transcoding on the Raspberry Pi 3. It's extreamly slow, even with hardware acceleration. Also it may fail when transcoding 2K+ stream.
+
+## Raspberry Pi 4
+
+*I don't have the hardware for test support!!!*
+
+**Supported on:** Linux binary, Docker, Hass Addon.
+
+**PS.** Supported via [v4l2m2m](https://lalitm.com/hw-encoding-raspi/) engine.
+
+## macOS
+
+In my tests, transcoding is faster on the M1 CPU than on the M1 GPU. Transcoding time on M1 CPU better than any Intel iGPU and comparable to NVidia RTX 2070.
+
+**PS.** Supported via [videotoolbox](https://trac.ffmpeg.org/wiki/HWAccelIntro#VideoToolbox) engine.
+
+## Rockchip
+
+- Important to use custom FFmpeg with Rockchip support from [@nyanmisaka](https://github.com/nyanmisaka/ffmpeg-rockchip)
+  - Static binaries from [@MarcA711](https://github.com/MarcA711/Rockchip-FFmpeg-Builds/releases/)
+- Important to have Linux kernel 5.10 or 6.1
+
+**Tested**
+
+- [Orange Pi 3B](https://www.armbian.com/orangepi3b/) with Armbian 6.1, support transcoding H264, H265, MJPEG

internal/ffmpeg/hardware/hardware.go

@@ -1,13 +1,12 @@
 package hardware
 
 import (
-	"github.com/AlexxIT/go2rtc/internal/api"
-	"github.com/AlexxIT/go2rtc/pkg/ffmpeg"
 	"net/http"
 	"os/exec"
 	"strings"
 
-	"github.com/rs/zerolog/log"
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/pkg/ffmpeg"
 )
 
 const (
@@ -17,11 +16,12 @@ const (
 	EngineCUDA         = "cuda"         // NVidia on Windows and Linux
 	EngineDXVA2        = "dxva2"        // Intel on Windows
 	EngineVideoToolbox = "videotoolbox" // macOS
+	EngineRKMPP        = "rkmpp"        // Rockchip
 )
 
 func Init(bin string) {
 	api.HandleFunc("api/ffmpeg/hardware", func(w http.ResponseWriter, r *http.Request) {
-		api.ResponseStreams(w, ProbeAll(bin))
+		api.ResponseSources(w, ProbeAll(bin))
 	})
 }
 
@@ -58,7 +58,11 @@ func MakeHardware(args *ffmpeg.Args, engine string, defaults map[string]string)
 			args.Codecs[i] = defaults[name+"/"+engine]
 
 			if !args.HasFilters("drawtext=") {
-				args.Input = "-hwaccel vaapi -hwaccel_output_format vaapi " + args.Input
+				args.Input = "-hwaccel vaapi -hwaccel_output_format vaapi -hwaccel_flags allow_profile_mismatch " + args.Input
+
+				if name == "h264" {
+					fixPixelFormat(args)
+				}
 
 				for i, filter := range args.Filters {
 					if strings.HasPrefix(filter, "scale=") {
@@ -78,7 +82,7 @@ func MakeHardware(args *ffmpeg.Args, engine string, defaults map[string]string)
 				args.InsertFilter("format=vaapi|nv12,hwupload")
 			} else {
 				// enable software pixel for drawtext, scale and transpose
-				args.Input = "-hwaccel vaapi -hwaccel_output_format nv12 " + args.Input
+				args.Input = "-hwaccel vaapi -hwaccel_output_format nv12 -hwaccel_flags allow_profile_mismatch " + args.Input
 
 				args.AddFilter("hwupload")
 			}
@@ -120,6 +124,37 @@ func MakeHardware(args *ffmpeg.Args, engine string, defaults map[string]string)
 
 		case EngineV4L2M2M:
 			args.Codecs[i] = defaults[name+"/"+engine]
+
+		case EngineRKMPP:
+			args.Codecs[i] = defaults[name+"/"+engine]
+
+			if !args.HasFilters("drawtext=") {
+				args.Input = "-hwaccel rkmpp -hwaccel_output_format drm_prime -afbc rga " + args.Input
+
+				for i, filter := range args.Filters {
+					if strings.HasPrefix(filter, "scale=") {
+						args.Filters[i] = "scale_rkrga=" + filter[6:] + ":force_original_aspect_ratio=0"
+					}
+					if strings.HasPrefix(filter, "transpose=") {
+						if filter == "transpose=1,transpose=1" { // 180 degrees half-turn
+							args.Filters[i] = "vpp_rkrga=transpose=4" // reversal
+						} else {
+							args.Filters[i] = "vpp_rkrga=transpose=" + filter[10:]
+						}
+					}
+				}
+
+				if len(args.Filters) > 0 {
+					// fix if input doesn't support hwaccel, do nothing when support
+					// insert as first filter before hardware scale and transpose
+					args.InsertFilter("format=drm_prime|nv12,hwupload")
+				}
+			} else {
+				// enable software pixel for drawtext, scale and transpose
+				args.Input = "-hwaccel rkmpp -hwaccel_output_format nv12 -afbc rga " + args.Input
+
+				args.AddFilter("hwupload")
+			}
 		}
 	}
 }
@@ -128,7 +163,6 @@ var cache = map[string]string{}
 
 func run(bin string, args string) bool {
 	err := exec.Command(bin, strings.Split(args, " ")...).Run()
-	log.Printf("%v %v", args, err)
 	return err == nil
 }
 
@@ -153,3 +187,24 @@ func cut(s string, sep byte, pos int) string {
 	}
 	return s
 }
+
+// fixPixelFormat:
+//   - good h264 pixel: yuv420p(tv, bt709) == yuv420p (mpeg/limited/tv)
+//   - bad h264 pixel: yuvj420p(pc, bt709) == yuvj420p (jpeg/full/pc)
+//   - bad jpeg pixel: yuvj422p(pc, bt470bg)
+func fixPixelFormat(args *ffmpeg.Args) {
+	// in my tests this filters has same CPU/GPU load:
+	//   - "hwupload"
+	//   - "hwupload,scale_vaapi=out_color_matrix=bt709:out_range=tv"
+	//   - "hwupload,scale_vaapi=out_color_matrix=bt709:out_range=tv:format=nv12"
+	const fixPixFmt = "out_color_matrix=bt709:out_range=tv:format=nv12"
+
+	for i, filter := range args.Filters {
+		if strings.HasPrefix(filter, "scale=") {
+			args.Filters[i] = filter + ":" + fixPixFmt
+			return
+		}
+	}
+
+	args.Filters = append(args.Filters, "scale="+fixPixFmt)
+}

internal/ffmpeg/hardware/hardware_bsd.go

@@ -0,0 +1,62 @@
+//go:build freebsd || netbsd || openbsd || dragonfly
+
+package hardware
+
+import (
+	"runtime"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+)
+
+const (
+	ProbeV4L2M2MH264 = "-f lavfi -i testsrc2 -t 1 -c h264_v4l2m2m -f null -"
+	ProbeV4L2M2MH265 = "-f lavfi -i testsrc2 -t 1 -c hevc_v4l2m2m -f null -"
+	ProbeRKMPPH264   = "-f lavfi -i testsrc2 -t 1 -c h264_rkmpp_encoder -f null -"
+	ProbeRKMPPH265   = "-f lavfi -i testsrc2 -t 1 -c hevc_rkmpp_encoder -f null -"
+)
+
+func ProbeAll(bin string) []*api.Source {
+	return []*api.Source{
+		{
+			Name: runToString(bin, ProbeV4L2M2MH264),
+			URL:  "ffmpeg:...#video=h264#hardware=" + EngineV4L2M2M,
+		},
+		{
+			Name: runToString(bin, ProbeV4L2M2MH265),
+			URL:  "ffmpeg:...#video=h265#hardware=" + EngineV4L2M2M,
+		},
+		{
+			Name: runToString(bin, ProbeRKMPPH264),
+			URL:  "ffmpeg:...#video=h264#hardware=" + EngineRKMPP,
+		},
+		{
+			Name: runToString(bin, ProbeRKMPPH265),
+			URL:  "ffmpeg:...#video=h265#hardware=" + EngineRKMPP,
+		},
+	}
+}
+
+func ProbeHardware(bin, name string) string {
+	if runtime.GOARCH == "arm64" || runtime.GOARCH == "arm" {
+		switch name {
+		case "h264":
+			if run(bin, ProbeV4L2M2MH264) {
+				return EngineV4L2M2M
+			}
+			if run(bin, ProbeRKMPPH264) {
+				return EngineRKMPP
+			}
+		case "h265":
+			if run(bin, ProbeV4L2M2MH265) {
+				return EngineV4L2M2M
+			}
+			if run(bin, ProbeRKMPPH265) {
+				return EngineRKMPP
+			}
+		}
+
+		return EngineSoftware
+	}
+
+	return EngineSoftware
+}

internal/ffmpeg/hardware/hardware_darwin.go

@@ -1,3 +1,5 @@
+//go:build darwin || ios
+
 package hardware
 
 import (
@@ -7,8 +9,8 @@ import (
 const ProbeVideoToolboxH264 = "-f lavfi -i testsrc2=size=svga -t 1 -c h264_videotoolbox -f null -"
 const ProbeVideoToolboxH265 = "-f lavfi -i testsrc2=size=svga -t 1 -c hevc_videotoolbox -f null -"
 
-func ProbeAll(bin string) []api.Stream {
-	return []api.Stream{
+func ProbeAll(bin string) []*api.Source {
+	return []*api.Source{
 		{
 			Name: runToString(bin, ProbeVideoToolboxH264),
 			URL:  "ffmpeg:...#video=h264#hardware=" + EngineVideoToolbox,

internal/ffmpeg/hardware/hardware_unix.go

@@ -1,21 +1,29 @@
+//go:build unix && !darwin && !freebsd && !netbsd && !openbsd && !dragonfly
+
 package hardware
 
 import (
-	"github.com/AlexxIT/go2rtc/internal/api"
 	"runtime"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
 )
 
-const ProbeV4L2M2MH264 = "-f lavfi -i testsrc2 -t 1 -c h264_v4l2m2m -f null -"
-const ProbeV4L2M2MH265 = "-f lavfi -i testsrc2 -t 1 -c hevc_v4l2m2m -f null -"
-const ProbeVAAPIH264 = "-init_hw_device vaapi -f lavfi -i testsrc2 -t 1 -vf format=nv12,hwupload -c h264_vaapi -f null -"
-const ProbeVAAPIH265 = "-init_hw_device vaapi -f lavfi -i testsrc2 -t 1 -vf format=nv12,hwupload -c hevc_vaapi -f null -"
-const ProbeVAAPIJPEG = "-init_hw_device vaapi -f lavfi -i testsrc2 -t 1 -vf format=nv12,hwupload -c mjpeg_vaapi -f null -"
-const ProbeCUDAH264 = "-init_hw_device cuda -f lavfi -i testsrc2 -t 1 -c h264_nvenc -f null -"
-const ProbeCUDAH265 = "-init_hw_device cuda -f lavfi -i testsrc2 -t 1 -c hevc_nvenc -f null -"
+const (
+	ProbeV4L2M2MH264 = "-f lavfi -i testsrc2 -t 1 -c h264_v4l2m2m -f null -"
+	ProbeV4L2M2MH265 = "-f lavfi -i testsrc2 -t 1 -c hevc_v4l2m2m -f null -"
+	ProbeRKMPPH264   = "-f lavfi -i testsrc2 -t 1 -c h264_rkmpp -f null -"
+	ProbeRKMPPH265   = "-f lavfi -i testsrc2 -t 1 -c hevc_rkmpp -f null -"
+	ProbeRKMPPJPEG   = "-f lavfi -i testsrc2 -t 1 -c mjpeg_rkmpp -f null -"
+	ProbeVAAPIH264   = "-init_hw_device vaapi -f lavfi -i testsrc2 -t 1 -vf format=nv12,hwupload -c h264_vaapi -f null -"
+	ProbeVAAPIH265   = "-init_hw_device vaapi -f lavfi -i testsrc2 -t 1 -vf format=nv12,hwupload -c hevc_vaapi -f null -"
+	ProbeVAAPIJPEG   = "-init_hw_device vaapi -f lavfi -i testsrc2 -t 1 -vf format=nv12,hwupload -c mjpeg_vaapi -f null -"
+	ProbeCUDAH264    = "-init_hw_device cuda -f lavfi -i testsrc2 -t 1 -c h264_nvenc -f null -"
+	ProbeCUDAH265    = "-init_hw_device cuda -f lavfi -i testsrc2 -t 1 -c hevc_nvenc -f null -"
+)
 
-func ProbeAll(bin string) []api.Stream {
+func ProbeAll(bin string) []*api.Source {
 	if runtime.GOARCH == "arm64" || runtime.GOARCH == "arm" {
-		return []api.Stream{
+		return []*api.Source{
 			{
 				Name: runToString(bin, ProbeV4L2M2MH264),
 				URL:  "ffmpeg:...#video=h264#hardware=" + EngineV4L2M2M,
@@ -24,10 +32,22 @@ func ProbeAll(bin string) []api.Stream {
 				Name: runToString(bin, ProbeV4L2M2MH265),
 				URL:  "ffmpeg:...#video=h265#hardware=" + EngineV4L2M2M,
 			},
+			{
+				Name: runToString(bin, ProbeRKMPPH264),
+				URL:  "ffmpeg:...#video=h264#hardware=" + EngineRKMPP,
+			},
+			{
+				Name: runToString(bin, ProbeRKMPPH265),
+				URL:  "ffmpeg:...#video=h265#hardware=" + EngineRKMPP,
+			},
+			{
+				Name: runToString(bin, ProbeRKMPPJPEG),
+				URL:  "ffmpeg:...#video=mjpeg#hardware=" + EngineRKMPP,
+			},
 		}
 	}
 
-	return []api.Stream{
+	return []*api.Source{
 		{
 			Name: runToString(bin, ProbeVAAPIH264),
 			URL:  "ffmpeg:...#video=h264#hardware=" + EngineVAAPI,
@@ -58,10 +78,20 @@ func ProbeHardware(bin, name string) string {
 			if run(bin, ProbeV4L2M2MH264) {
 				return EngineV4L2M2M
 			}
+			if run(bin, ProbeRKMPPH264) {
+				return EngineRKMPP
+			}
 		case "h265":
 			if run(bin, ProbeV4L2M2MH265) {
 				return EngineV4L2M2M
 			}
+			if run(bin, ProbeRKMPPH265) {
+				return EngineRKMPP
+			}
+		case "mjpeg":
+			if run(bin, ProbeRKMPPJPEG) {
+				return EngineRKMPP
+			}
 		}
 
 		return EngineSoftware

internal/ffmpeg/hardware/hardware_windows.go

@@ -1,3 +1,5 @@
+//go:build windows
+
 package hardware
 
 import "github.com/AlexxIT/go2rtc/internal/api"
@@ -8,8 +10,8 @@ const ProbeDXVA2JPEG = "-init_hw_device dxva2 -f lavfi -i testsrc2 -t 1 -c mjpeg
 const ProbeCUDAH264 = "-init_hw_device cuda -f lavfi -i testsrc2 -t 1 -c h264_nvenc -f null -"
 const ProbeCUDAH265 = "-init_hw_device cuda -f lavfi -i testsrc2 -t 1 -c hevc_nvenc -f null -"
 
-func ProbeAll(bin string) []api.Stream {
-	return []api.Stream{
+func ProbeAll(bin string) []*api.Source {
+	return []*api.Source{
 		{
 			Name: runToString(bin, ProbeDXVA2H264),
 			URL:  "ffmpeg:...#video=h264#hardware=" + EngineDXVA2,

internal/ffmpeg/jpeg.go

@@ -12,22 +12,36 @@ import (
 	"github.com/AlexxIT/go2rtc/pkg/shell"
 )
 
-func TranscodeToJPEG(b []byte, query url.Values) ([]byte, error) {
-	ffmpegArgs := parseQuery(query)
-	cmdArgs := shell.QuoteSplit(ffmpegArgs.String())
+func JPEGWithQuery(b []byte, query url.Values) ([]byte, error) {
+	args := parseQuery(query)
+	return transcode(b, args.String())
+}
+
+func JPEGWithScale(b []byte, width, height int) ([]byte, error) {
+	args := defaultArgs()
+	args.AddFilter(fmt.Sprintf("scale=%d:%d", width, height))
+	return transcode(b, args.String())
+}
+
+func transcode(b []byte, args string) ([]byte, error) {
+	cmdArgs := shell.QuoteSplit(args)
 	cmd := exec.Command(cmdArgs[0], cmdArgs[1:]...)
 	cmd.Stdin = bytes.NewBuffer(b)
 	return cmd.Output()
 }
 
-func parseQuery(query url.Values) *ffmpeg.Args {
-	args := &ffmpeg.Args{
+func defaultArgs() *ffmpeg.Args {
+	return &ffmpeg.Args{
 		Bin:    defaults["bin"],
 		Global: defaults["global"],
 		Input:  "-i -",
 		Codecs: []string{defaults["mjpeg"]},
 		Output: defaults["output/mjpeg"],
 	}
+}
+
+func parseQuery(query url.Values) *ffmpeg.Args {
+	args := defaultArgs()
 
 	var width = -1
 	var height = -1

internal/ffmpeg/jpeg_test.go

@@ -19,5 +19,5 @@ func TestParseQuery(t *testing.T) {
 	query, err = url.ParseQuery("hw=vaapi")
 	require.Nil(t, err)
 	args = parseQuery(query)
-	require.Equal(t, `ffmpeg -hide_banner -hwaccel vaapi -hwaccel_output_format vaapi -i - -c:v mjpeg_vaapi -vf "format=vaapi|nv12,hwupload" -f mjpeg -`, args.String())
+	require.Equal(t, `ffmpeg -hide_banner -hwaccel vaapi -hwaccel_output_format vaapi -hwaccel_flags allow_profile_mismatch -i - -c:v mjpeg_vaapi -vf "format=vaapi|nv12,hwupload" -f mjpeg -`, args.String())
 }

internal/ffmpeg/producer.go

@@ -0,0 +1,121 @@
+package ffmpeg
+
+import (
+	"encoding/json"
+	"errors"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/aac"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+type Producer struct {
+	core.Connection
+	url    string
+	query  url.Values
+	ffmpeg core.Producer
+}
+
+// NewProducer - FFmpeg producer with auto selection video/audio codec based on client capabilities
+func NewProducer(url string) (core.Producer, error) {
+	p := &Producer{}
+
+	i := strings.IndexByte(url, '#')
+	p.url, p.query = url[:i], streams.ParseQuery(url[i+1:])
+
+	// ffmpeg.NewProducer support only one audio
+	if len(p.query["video"]) != 0 || len(p.query["audio"]) != 1 {
+		return nil, errors.New("ffmpeg: unsupported params: " + url[i:])
+	}
+
+	p.ID = core.NewID()
+	p.FormatName = "ffmpeg"
+	p.Medias = []*core.Media{
+		{
+			// we can support only audio, because don't know FmtpLine for H264 and PayloadType for MJPEG
+			Kind:      core.KindAudio,
+			Direction: core.DirectionRecvonly,
+			// codecs in order from best to worst
+			Codecs: []*core.Codec{
+				// OPUS will always marked as OPUS/48000/2
+				{Name: core.CodecOpus, ClockRate: 48000, Channels: 2},
+				{Name: core.CodecPCML, ClockRate: 16000},
+				{Name: core.CodecPCM, ClockRate: 16000},
+				{Name: core.CodecPCMA, ClockRate: 16000},
+				{Name: core.CodecPCMU, ClockRate: 16000},
+				{Name: core.CodecPCM, ClockRate: 8000},
+				{Name: core.CodecPCMA, ClockRate: 8000},
+				{Name: core.CodecPCMU, ClockRate: 8000},
+				// AAC has unknown problems on Dahua two way
+				{Name: core.CodecAAC, ClockRate: 16000, FmtpLine: aac.FMTP + "1408"},
+			},
+		},
+	}
+	return p, nil
+}
+
+func (p *Producer) Start() error {
+	var err error
+	if p.ffmpeg, err = streams.GetProducer(p.newURL()); err != nil {
+		return err
+	}
+
+	for i, media := range p.ffmpeg.GetMedias() {
+		track, err := p.ffmpeg.GetTrack(media, media.Codecs[0])
+		if err != nil {
+			return err
+		}
+		p.Receivers[i].Replace(track)
+	}
+
+	return p.ffmpeg.Start()
+}
+
+func (p *Producer) Stop() error {
+	if p.ffmpeg == nil {
+		return nil
+	}
+	return p.ffmpeg.Stop()
+}
+
+func (p *Producer) MarshalJSON() ([]byte, error) {
+	if p.ffmpeg == nil {
+		return json.Marshal(p.Connection)
+	}
+	return json.Marshal(p.ffmpeg)
+}
+
+func (p *Producer) newURL() string {
+	s := p.url
+	// rewrite codecs in url from auto to known presets from defaults
+	for _, receiver := range p.Receivers {
+		codec := receiver.Codec
+		switch codec.Name {
+		case core.CodecOpus:
+			s += "#audio=opus"
+		case core.CodecAAC:
+			s += "#audio=aac/16000"
+		case core.CodecPCML:
+			s += "#audio=pcml/16000"
+		case core.CodecPCM:
+			s += "#audio=pcm/" + strconv.Itoa(int(codec.ClockRate))
+		case core.CodecPCMA:
+			s += "#audio=pcma/" + strconv.Itoa(int(codec.ClockRate))
+		case core.CodecPCMU:
+			s += "#audio=pcmu/" + strconv.Itoa(int(codec.ClockRate))
+		}
+	}
+	// add other params
+	for key, values := range p.query {
+		if key != "audio" {
+			for _, value := range values {
+				s += "#" + key + "=" + value
+			}
+		}
+	}
+
+	return s
+}

internal/ffmpeg/version.go

@@ -0,0 +1,46 @@
+package ffmpeg
+
+import (
+	"errors"
+	"os/exec"
+	"sync"
+
+	"github.com/AlexxIT/go2rtc/pkg/ffmpeg"
+)
+
+var verMu sync.Mutex
+var verErr error
+var verFF string
+var verAV string
+
+func Version() (string, error) {
+	verMu.Lock()
+	defer verMu.Unlock()
+
+	if verFF != "" {
+		return verFF, verErr
+	}
+
+	cmd := exec.Command(defaults["bin"], "-version")
+	b, err := cmd.Output()
+	if err != nil {
+		verFF = "-"
+		verErr = err
+		return verFF, verErr
+	}
+
+	verFF, verAV = ffmpeg.ParseVersion(b)
+
+	if verFF == "" {
+		verFF = "?"
+	}
+
+	// better to compare libavformat, because nightly/master builds
+	if verAV != "" && verAV < ffmpeg.Version50 {
+		verErr = errors.New("ffmpeg: unsupported version: " + verFF)
+	}
+
+	log.Debug().Str("version", verFF).Str("libavformat", verAV).Msgf("[ffmpeg] bin")
+
+	return verFF, verErr
+}

internal/ffmpeg/virtual/virtual.go

@@ -0,0 +1,79 @@
+package virtual
+
+import (
+	"net/url"
+)
+
+func GetInput(src string) string {
+	query, err := url.ParseQuery(src)
+	if err != nil {
+		return ""
+	}
+
+	input := "-re"
+
+	for _, video := range query["video"] {
+		// https://ffmpeg.org/ffmpeg-filters.html
+		sep := "=" // first separator
+
+		if video == "" {
+			video = "testsrc=decimals=2" // default video
+			sep = ":"
+		}
+
+		input += " -f lavfi -i " + video
+
+		// set defaults (using Add instead of Set)
+		query.Add("size", "1920x1080")
+
+		for key, values := range query {
+			value := values[0]
+
+			// https://ffmpeg.org/ffmpeg-utils.html#video-size-syntax
+			switch key {
+			case "color", "rate", "duration", "sar", "decimals":
+			case "size":
+				switch value {
+				case "720":
+					value = "1280x720" // crf=1 -> 12 Mbps
+				case "1080":
+					value = "1920x1080" // crf=1 -> 25 Mbps
+				case "2K":
+					value = "2560x1440" // crf=1 -> 43 Mbps
+				case "4K":
+					value = "3840x2160" // crf=1 -> 103 Mbps
+				case "8K":
+					value = "7680x4230" // https://reolink.com/blog/8k-resolution/
+				}
+			default:
+				continue
+			}
+
+			input += sep + key + "=" + value
+			sep = ":" // next separator
+		}
+
+		if s := query.Get("format"); s != "" {
+			input += ",format=" + s
+		}
+	}
+
+	return input
+}
+
+func GetInputTTS(src string) string {
+	query, err := url.ParseQuery(src)
+	if err != nil {
+		return ""
+	}
+
+	input := `-re -f lavfi -i "flite=text='` + query.Get("text") + `'`
+
+	// ffmpeg -f lavfi -i flite=list_voices=1
+	// awb, kal, kal16, rms, slt
+	if voice := query.Get("voice"); voice != "" {
+		input += ":voice" + voice
+	}
+
+	return input + `"`
+}

internal/ffmpeg/virtual/virtual_test.go

@@ -0,0 +1,20 @@
+package virtual
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestGetInput(t *testing.T) {
+	s := GetInput("video")
+	require.Equal(t, "-re -f lavfi -i testsrc=decimals=2:size=1920x1080", s)
+
+	s = GetInput("video=testsrc2&size=4K")
+	require.Equal(t, "-re -f lavfi -i testsrc2=size=3840x2160", s)
+}
+
+func TestGetInputTTS(t *testing.T) {
+	s := GetInputTTS("text=hello world&voice=slt")
+	require.Equal(t, `-re -f lavfi -i "flite=text='hello world':voiceslt"`, s)
+}

internal/flussonic/flussonic.go

@@ -0,0 +1,10 @@
+package flussonic
+
+import (
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/flussonic"
+)
+
+func Init() {
+	streams.HandleFunc("flussonic", flussonic.Dial)
+}

internal/gopro/README.md

@@ -0,0 +1,25 @@
+# GoPro
+
+Supported models: HERO9, HERO10, HERO11, HERO12.  
+Supported OS: Linux, Mac, Windows, [HassOS](https://www.home-assistant.io/installation/)
+
+The other camera models have different APIs. I will try to add them in the next versions.
+
+## Config
+
+- USB-connected cameras create a new network interface in the system
+- Linux users do not need to install anything
+- Windows users should install the [network driver](https://community.gopro.com/s/article/GoPro-Webcam)
+- if the camera is detected but the stream does not start - you need to disable firewall
+
+1. Discover camera address: WebUI > Add > GoPro
+2. Add camera to config
+
+```yaml
+streams:
+  hero12: gopro://172.20.100.51
+```
+
+## Useful links
+
+- https://gopro.github.io/OpenGoPro/

internal/gopro/gopro.go

@@ -0,0 +1,28 @@
+package gopro
+
+import (
+	"net/http"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/gopro"
+)
+
+func Init() {
+	streams.HandleFunc("gopro", func(source string) (core.Producer, error) {
+		return gopro.Dial(source)
+	})
+
+	api.HandleFunc("api/gopro", apiGoPro)
+}
+
+func apiGoPro(w http.ResponseWriter, r *http.Request) {
+	var items []*api.Source
+
+	for _, host := range gopro.Discovery() {
+		items = append(items, &api.Source{Name: host, URL: "gopro://" + host})
+	}
+
+	api.ResponseSources(w, items)
+}

internal/hass/api.go

@@ -63,7 +63,7 @@ func apiStream(w http.ResponseWriter, r *http.Request) {
 			return
 		}
 
-		s, err = webrtc.ExchangeSDP(stream, string(offer), "WebRTC/Hass sync", r.UserAgent())
+		s, err = webrtc.ExchangeSDP(stream, string(offer), "hass/webrtc", r.UserAgent())
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return

internal/hass/hass.go

@@ -4,6 +4,11 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"net/http"
+	"os"
+	"path"
+	"sync"
+
 	"github.com/AlexxIT/go2rtc/internal/api"
 	"github.com/AlexxIT/go2rtc/internal/app"
 	"github.com/AlexxIT/go2rtc/internal/roborock"
@@ -11,16 +16,12 @@ import (
 	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/AlexxIT/go2rtc/pkg/hass"
 	"github.com/rs/zerolog"
-	"net/http"
-	"os"
-	"path"
-	"sync"
 )
 
 func Init() {
 	var conf struct {
 		API struct {
-			Listen string `json:"listen"`
+			Listen string `yaml:"listen"`
 		} `yaml:"api"`
 		Mod struct {
 			Config string `yaml:"config"`
@@ -36,9 +37,22 @@ func Init() {
 	api.HandleFunc("/streams", apiOK)
 	api.HandleFunc("/stream/", apiStream)
 
+	streams.RedirectFunc("hass", func(url string) (string, error) {
+		if location := entities[url[5:]]; location != "" {
+			return location, nil
+		}
+
+		return "", nil
+	})
+
+	streams.HandleFunc("hass", func(source string) (core.Producer, error) {
+		// support hass://supervisor?entity_id=camera.driveway_doorbell
+		return hass.NewClient(source)
+	})
+
 	// load static entries from Hass config
 	if err := importConfig(conf.Mod.Config); err != nil {
-		log.Debug().Msgf("[hass] can't import config: %s", err)
+		log.Trace().Msgf("[hass] can't import config: %s", err)
 
 		api.HandleFunc("api/hass", func(w http.ResponseWriter, _ *http.Request) {
 			http.Error(w, "no hass config", http.StatusNotFound)
@@ -56,26 +70,13 @@ func Init() {
 			}
 		})
 
-		var items []api.Stream
+		var items []*api.Source
 		for name, url := range entities {
-			items = append(items, api.Stream{Name: name, URL: url})
+			items = append(items, &api.Source{
+				Name: name, URL: "hass:" + name, Location: url,
+			})
 		}
-		api.ResponseStreams(w, items)
-	})
-
-	streams.HandleFunc("hass", func(url string) (core.Producer, error) {
-		// check entity by name
-		if url2 := entities[url[5:]]; url2 != "" {
-			return streams.GetProducer(url2)
-		}
-
-		// support hass://supervisor?entity_id=camera.driveway_doorbell
-		client, err := hass.NewClient(url)
-		if err != nil {
-			return nil, err
-		}
-
-		return client, nil
+		api.ResponseSources(w, items)
 	})
 
 	// for Addon listen on hassio interface, so WebUI feature will work

internal/hls/hls.go

@@ -2,7 +2,6 @@ package hls
 
 import (
 	"net/http"
-	"strings"
 	"sync"
 	"time"
 
@@ -13,7 +12,6 @@ import (
 	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/AlexxIT/go2rtc/pkg/mp4"
 	"github.com/AlexxIT/go2rtc/pkg/mpegts"
-	"github.com/AlexxIT/go2rtc/pkg/tcp"
 	"github.com/rs/zerolog"
 )
 
@@ -33,21 +31,12 @@ func Init() {
 	ws.HandleFunc("hls", handlerWSHLS)
 }
 
-type Consumer interface {
-	core.Consumer
-	Listen(f core.EventFunc)
-	Init() ([]byte, error)
-	MimeCodecs() string
-	Start()
-}
-
 var log zerolog.Logger
 
 const keepalive = 5 * time.Second
 
-var sessions = map[string]*Session{}
-
 // once I saw 404 on MP4 segment, so better to use mutex
+var sessions = map[string]*Session{}
 var sessionsMu sync.RWMutex
 
 func handlerStream(w http.ResponseWriter, r *http.Request) {
@@ -67,22 +56,20 @@ func handlerStream(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	var cons Consumer
+	var cons core.Consumer
 
 	// use fMP4 with codecs filter and TS without
 	medias := mp4.ParseQuery(r.URL.Query())
 	if medias != nil {
-		cons = &mp4.Consumer{
-			Desc:       "HLS/HTTP",
-			RemoteAddr: tcp.RemoteAddr(r),
-			UserAgent:  r.UserAgent(),
-			Medias:     medias,
-		}
+		c := mp4.NewConsumer(medias)
+		c.FormatName = "hls/fmp4"
+		c.WithRequest(r)
+		cons = c
 	} else {
-		cons = &mpegts.Consumer{
-			RemoteAddr: tcp.RemoteAddr(r),
-			UserAgent:  r.UserAgent(),
-		}
+		c := mpegts.NewConsumer()
+		c.FormatName = "hls/mpegts"
+		c.WithRequest(r)
+		cons = c
 	}
 
 	if err := stream.AddConsumer(cons); err != nil {
@@ -90,63 +77,22 @@ func handlerStream(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	session := &Session{cons: cons}
-
-	cons.Listen(func(msg any) {
-		if data, ok := msg.([]byte); ok {
-			session.mu.Lock()
-			session.buffer = append(session.buffer, data...)
-			session.mu.Unlock()
-		}
-	})
-
-	sid := core.RandString(8, 62)
-
+	session := NewSession(cons)
 	session.alive = time.AfterFunc(keepalive, func() {
 		sessionsMu.Lock()
-		delete(sessions, sid)
+		delete(sessions, session.id)
 		sessionsMu.Unlock()
 
 		stream.RemoveConsumer(cons)
 	})
-	session.init, _ = cons.Init()
-
-	cons.Start()
-
-	// two segments important for Chromecast
-	if medias != nil {
-		session.template = `#EXTM3U
-#EXT-X-VERSION:6
-#EXT-X-TARGETDURATION:1
-#EXT-X-MEDIA-SEQUENCE:%d
-#EXT-X-MAP:URI="init.mp4?id=` + sid + `"
-#EXTINF:0.500,
-segment.m4s?id=` + sid + `&n=%d
-#EXTINF:0.500,
-segment.m4s?id=` + sid + `&n=%d`
-	} else {
-		session.template = `#EXTM3U
-#EXT-X-VERSION:3
-#EXT-X-TARGETDURATION:1
-#EXT-X-MEDIA-SEQUENCE:%d
-#EXTINF:0.500,
-segment.ts?id=` + sid + `&n=%d
-#EXTINF:0.500,
-segment.ts?id=` + sid + `&n=%d`
-	}
 
 	sessionsMu.Lock()
-	sessions[sid] = session
+	sessions[session.id] = session
 	sessionsMu.Unlock()
 
-	codecs := strings.Replace(cons.MimeCodecs(), mp4.MimeFlac, "fLaC", 1)
+	go session.Run()
 
-	// bandwidth important for Safari, codecs useful for smooth playback
-	data := []byte(`#EXTM3U
-#EXT-X-STREAM-INF:BANDWIDTH=192000,CODECS="` + codecs + `"
-hls/playlist.m3u8?id=` + sid)
-
-	if _, err := w.Write(data); err != nil {
+	if _, err := w.Write(session.Main()); err != nil {
 		log.Error().Err(err).Caller().Send()
 	}
 }
@@ -169,7 +115,7 @@ func handlerPlaylist(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	if _, err := w.Write([]byte(session.Playlist())); err != nil {
+	if _, err := w.Write(session.Playlist()); err != nil {
 		log.Error().Err(err).Caller().Send()
 	}
 }
@@ -224,11 +170,8 @@ func handlerInit(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	data := session.init
-	session.init = nil
-
-	session.segment0 = session.Segment()
-	if session.segment0 == nil {
+	data := session.Init()
+	if data == nil {
 		log.Warn().Msgf("[hls] can't get init %s", r.URL.RawQuery)
 		http.NotFound(w, r)
 		return
@@ -261,14 +204,7 @@ func handlerSegmentMP4(w http.ResponseWriter, r *http.Request) {
 
 	session.alive.Reset(keepalive)
 
-	var data []byte
-
-	if query.Get("n") != "0" {
-		data = session.Segment()
-	} else {
-		data = session.segment0
-	}
-
+	data := session.Segment()
 	if data == nil {
 		log.Warn().Msgf("[hls] can't get segment %s", r.URL.RawQuery)
 		http.NotFound(w, r)

internal/hls/session.go

@@ -2,23 +2,105 @@ package hls
 
 import (
 	"fmt"
+	"io"
+	"strings"
 	"sync"
 	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/mp4"
 )
 
 type Session struct {
-	cons     Consumer
+	cons     core.Consumer
+	id       string
 	template string
 	init     []byte
-	segment0 []byte
 	buffer   []byte
 	seq      int
 	alive    *time.Timer
 	mu       sync.Mutex
 }
 
-func (s *Session) Playlist() string {
-	return fmt.Sprintf(s.template, s.seq, s.seq, s.seq+1)
+func NewSession(cons core.Consumer) *Session {
+	s := &Session{
+		id:   core.RandString(8, 62),
+		cons: cons,
+	}
+
+	// two segments important for Chromecast
+	if _, ok := cons.(*mp4.Consumer); ok {
+		s.template = `#EXTM3U
+#EXT-X-VERSION:6
+#EXT-X-TARGETDURATION:1
+#EXT-X-MEDIA-SEQUENCE:%d
+#EXT-X-MAP:URI="init.mp4?id=` + s.id + `"
+#EXTINF:0.500,
+segment.m4s?id=` + s.id + `&n=%d
+#EXTINF:0.500,
+segment.m4s?id=` + s.id + `&n=%d`
+	} else {
+		s.template = `#EXTM3U
+#EXT-X-VERSION:3
+#EXT-X-TARGETDURATION:1
+#EXT-X-MEDIA-SEQUENCE:%d
+#EXTINF:0.500,
+segment.ts?id=` + s.id + `&n=%d
+#EXTINF:0.500,
+segment.ts?id=` + s.id + `&n=%d`
+	}
+
+	return s
+}
+
+func (s *Session) Write(p []byte) (n int, err error) {
+	s.mu.Lock()
+	if s.init == nil {
+		s.init = p
+	} else {
+		s.buffer = append(s.buffer, p...)
+	}
+	s.mu.Unlock()
+	return len(p), nil
+}
+
+func (s *Session) Run() {
+	_, _ = s.cons.(io.WriterTo).WriteTo(s)
+}
+
+func (s *Session) Main() []byte {
+	type withCodecs interface {
+		Codecs() []*core.Codec
+	}
+
+	codecs := mp4.MimeCodecs(s.cons.(withCodecs).Codecs())
+	codecs = strings.Replace(codecs, mp4.MimeFlac, "fLaC", 1)
+
+	// bandwidth important for Safari, codecs useful for smooth playback
+	return []byte(`#EXTM3U
+#EXT-X-STREAM-INF:BANDWIDTH=192000,CODECS="` + codecs + `"
+hls/playlist.m3u8?id=` + s.id)
+}
+
+func (s *Session) Playlist() []byte {
+	return []byte(fmt.Sprintf(s.template, s.seq, s.seq, s.seq+1))
+}
+
+func (s *Session) Init() (init []byte) {
+	for i := 0; i < 60 && init == nil; i++ {
+		if i > 0 {
+			time.Sleep(50 * time.Millisecond)
+		}
+
+		s.mu.Lock()
+		// return init only when have some buffer
+		if len(s.buffer) > 0 {
+			init = s.init
+		}
+		s.mu.Unlock()
+	}
+
+	return
 }
 
 func (s *Session) Segment() (segment []byte) {
@@ -30,8 +112,12 @@ func (s *Session) Segment() (segment []byte) {
 		s.mu.Lock()
 		if len(s.buffer) > 0 {
 			segment = s.buffer
-			// for TS important to start new segment with init
-			s.buffer = s.init
+			if _, ok := s.cons.(*mp4.Consumer); ok {
+				s.buffer = nil
+			} else {
+				// for TS important to start new segment with init
+				s.buffer = s.init
+			}
 			s.seq++
 		}
 		s.mu.Unlock()

internal/hls/ws.go

@@ -2,15 +2,12 @@ package hls
 
 import (
 	"errors"
-	"strings"
 	"time"
 
 	"github.com/AlexxIT/go2rtc/internal/api"
 	"github.com/AlexxIT/go2rtc/internal/api/ws"
 	"github.com/AlexxIT/go2rtc/internal/streams"
-	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/AlexxIT/go2rtc/pkg/mp4"
-	"github.com/AlexxIT/go2rtc/pkg/tcp"
 )
 
 func handlerWSHLS(tr *ws.Transport, msg *ws.Message) error {
@@ -20,63 +17,36 @@ func handlerWSHLS(tr *ws.Transport, msg *ws.Message) error {
 	}
 
 	codecs := msg.String()
+	medias := mp4.ParseCodecs(codecs, true)
+	cons := mp4.NewConsumer(medias)
+	cons.FormatName = "hls/fmp4"
+	cons.WithRequest(tr.Request)
 
 	log.Trace().Msgf("[hls] new ws consumer codecs=%s", codecs)
 
-	cons := &mp4.Consumer{
-		Desc:       "HLS/WebSocket",
-		RemoteAddr: tcp.RemoteAddr(tr.Request),
-		UserAgent:  tr.Request.UserAgent(),
-		Medias:     mp4.ParseCodecs(codecs, true),
-	}
-
 	if err := stream.AddConsumer(cons); err != nil {
 		log.Error().Err(err).Caller().Send()
 		return err
 	}
 
-	session := &Session{cons: cons}
-
-	cons.Listen(func(msg any) {
-		if data, ok := msg.([]byte); ok {
-			session.mu.Lock()
-			session.buffer = append(session.buffer, data...)
-			session.mu.Unlock()
-		}
-	})
+	session := NewSession(cons)
 
 	session.alive = time.AfterFunc(keepalive, func() {
+		sessionsMu.Lock()
+		delete(sessions, session.id)
+		sessionsMu.Unlock()
+
 		stream.RemoveConsumer(cons)
 	})
-	session.init, _ = cons.Init()
-
-	cons.Start()
-
-	sid := core.RandString(8, 62)
-
-	// two segments important for Chromecast
-	session.template = `#EXTM3U
-#EXT-X-VERSION:6
-#EXT-X-TARGETDURATION:1
-#EXT-X-MEDIA-SEQUENCE:%d
-#EXT-X-MAP:URI="init.mp4?id=` + sid + `"
-#EXTINF:0.500,
-segment.m4s?id=` + sid + `&n=%d
-#EXTINF:0.500,
-segment.m4s?id=` + sid + `&n=%d`
 
 	sessionsMu.Lock()
-	sessions[sid] = session
+	sessions[session.id] = session
 	sessionsMu.Unlock()
 
-	codecs = strings.Replace(cons.MimeCodecs(), mp4.MimeFlac, "fLaC", 1)
+	go session.Run()
 
-	// bandwidth important for Safari, codecs useful for smooth playback
-	data := `#EXTM3U
-#EXT-X-STREAM-INF:BANDWIDTH=192000,CODECS="` + codecs + `"
-hls/playlist.m3u8?id=` + sid
-
-	tr.Write(&ws.Message{Type: "hls", Value: data})
+	main := session.Main()
+	tr.Write(&ws.Message{Type: "hls", Value: string(main)})
 
 	return nil
 }

internal/homekit/api.go

@@ -1,136 +1,139 @@
 package homekit
 
 import (
-	"github.com/AlexxIT/go2rtc/internal/api"
-	"github.com/AlexxIT/go2rtc/internal/app/store"
-	"github.com/AlexxIT/go2rtc/internal/streams"
-	"github.com/AlexxIT/go2rtc/pkg/hap"
-	"github.com/AlexxIT/go2rtc/pkg/mdns"
+	"errors"
+	"fmt"
 	"net/http"
 	"net/url"
 	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/hap"
+	"github.com/AlexxIT/go2rtc/pkg/mdns"
 )
 
 func apiHandler(w http.ResponseWriter, r *http.Request) {
 	switch r.Method {
 	case "GET":
-		items := make([]any, 0)
-
-		for name, src := range store.GetDict("streams") {
-			if src := src.(string); strings.HasPrefix(src, "homekit") {
-				u, err := url.Parse(src)
-				if err != nil {
-					continue
-				}
-				device := Device{
-					Name:   name,
-					Addr:   u.Host,
-					Paired: true,
-				}
-				items = append(items, device)
-			}
-		}
-
-		err := mdns.Discovery(mdns.ServiceHAP, func(entry *mdns.ServiceEntry) bool {
-			if entry.Complete() {
-				device := Device{
-					Name:   entry.Name,
-					Addr:   entry.Addr(),
-					ID:     entry.Info["id"],
-					Model:  entry.Info["md"],
-					Paired: entry.Info["sf"] == "0",
-				}
-				items = append(items, device)
-			}
-			return false
-		})
-
+		sources, err := discovery()
 		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
+			api.Error(w, err)
 			return
 		}
 
-		api.ResponseJSON(w, items)
+		urls := findHomeKitURLs()
+		for id, u := range urls {
+			deviceID := u.Query().Get("device_id")
+			for _, source := range sources {
+				if strings.Contains(source.URL, deviceID) {
+					source.Location = id
+					break
+				}
+			}
+		}
+
+		for _, source := range sources {
+			if source.Location == "" {
+				source.Location = " "
+			}
+		}
+
+		api.ResponseSources(w, sources)
 
 	case "POST":
-		// TODO: post params...
+		if err := r.ParseMultipartForm(1024); err != nil {
+			api.Error(w, err)
+			return
+		}
 
-		id := r.URL.Query().Get("id")
-		pin := r.URL.Query().Get("pin")
-		name := r.URL.Query().Get("name")
-		if err := hkPair(id, pin, name); err != nil {
-			log.Error().Err(err).Caller().Send()
-			http.Error(w, err.Error(), http.StatusInternalServerError)
+		if err := apiPair(r.Form.Get("id"), r.Form.Get("url")); err != nil {
+			api.Error(w, err)
 		}
 
 	case "DELETE":
-		src := r.URL.Query().Get("src")
-		if err := hkDelete(src); err != nil {
-			log.Error().Err(err).Caller().Send()
-			http.Error(w, err.Error(), http.StatusInternalServerError)
+		if err := r.ParseMultipartForm(1024); err != nil {
+			api.Error(w, err)
+			return
+		}
+
+		if err := apiUnpair(r.Form.Get("id")); err != nil {
+			api.Error(w, err)
 		}
 	}
 }
 
-func hkPair(deviceID, pin, name string) (err error) {
-	var conn *hap.Conn
+func discovery() ([]*api.Source, error) {
+	var sources []*api.Source
 
-	if conn, err = hap.Pair(deviceID, pin); err != nil {
-		return
-	}
+	// 1. Get streams from Discovery
+	err := mdns.Discovery(mdns.ServiceHAP, func(entry *mdns.ServiceEntry) bool {
+		log.Trace().Msgf("[homekit] mdns=%s", entry)
 
-	streams.New(name, conn.URL())
-
-	dict := store.GetDict("streams")
-	dict[name] = conn.URL()
-
-	return store.Set("streams", dict)
-}
-
-func hkDelete(name string) (err error) {
-	dict := store.GetDict("streams")
-	for key, rawURL := range dict {
-		if key != name {
-			continue
-		}
-
-		var conn *hap.Conn
-
-		if conn, err = hap.NewConn(rawURL.(string)); err != nil {
-			return
-		}
-
-		if err = conn.Dial(); err != nil {
-			return
-		}
-
-		go func() {
-			if err = conn.Handle(); err != nil {
-				log.Warn().Err(err).Caller().Send()
+		category := entry.Info[hap.TXTCategory]
+		if entry.Complete() && (category == hap.CategoryCamera || category == hap.CategoryDoorbell) {
+			source := &api.Source{
+				Name: entry.Name,
+				Info: entry.Info[hap.TXTModel],
+				URL: fmt.Sprintf(
+					"homekit://%s:%d?device_id=%s&feature=%s&status=%s",
+					entry.IP, entry.Port, entry.Info[hap.TXTDeviceID],
+					entry.Info[hap.TXTFeatureFlags], entry.Info[hap.TXTStatusFlags],
+				),
 			}
-		}()
 
-		if err = conn.ListPairings(); err != nil {
-			return
+			sources = append(sources, source)
 		}
+		return false
+	})
 
-		if err = conn.DeletePairing(conn.ClientID); err != nil {
-			log.Error().Err(err).Caller().Send()
-		}
-
-		delete(dict, name)
-
-		return store.Set("streams", dict)
+	if err != nil {
+		return nil, err
 	}
 
-	return nil
+	return sources, nil
 }
 
-type Device struct {
-	ID     string `json:"id"`
-	Name   string `json:"name"`
-	Addr   string `json:"addr"`
-	Model  string `json:"model"`
-	Paired bool   `json:"paired"`
-	//Type    string `json:"type"`
+func apiPair(id, url string) error {
+	conn, err := hap.Pair(url)
+	if err != nil {
+		return err
+	}
+
+	streams.New(id, conn.URL())
+
+	return app.PatchConfig([]string{"streams", id}, conn.URL())
+}
+
+func apiUnpair(id string) error {
+	stream := streams.Get(id)
+	if stream == nil {
+		return errors.New(api.StreamNotFound)
+	}
+
+	rawURL := findHomeKitURL(stream.Sources())
+	if rawURL == "" {
+		return errors.New("not homekit source")
+	}
+
+	if err := hap.Unpair(rawURL); err != nil {
+		return err
+	}
+
+	streams.Delete(id)
+
+	return app.PatchConfig([]string{"streams", id}, nil)
+}
+
+func findHomeKitURLs() map[string]*url.URL {
+	urls := map[string]*url.URL{}
+	for name, sources := range streams.GetAllSources() {
+		if rawURL := findHomeKitURL(sources); rawURL != "" {
+			if u, err := url.Parse(rawURL); err == nil {
+				urls[name] = u
+			}
+		}
+	}
+	return urls
 }

internal/homekit/homekit.go

@@ -1,32 +1,232 @@
 package homekit
 
 import (
+	"errors"
+	"io"
+	"net"
+	"net/http"
+	"strings"
+
 	"github.com/AlexxIT/go2rtc/internal/api"
 	"github.com/AlexxIT/go2rtc/internal/app"
 	"github.com/AlexxIT/go2rtc/internal/srtp"
 	"github.com/AlexxIT/go2rtc/internal/streams"
 	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/hap"
+	"github.com/AlexxIT/go2rtc/pkg/hap/camera"
 	"github.com/AlexxIT/go2rtc/pkg/homekit"
+	"github.com/AlexxIT/go2rtc/pkg/mdns"
 	"github.com/rs/zerolog"
 )
 
 func Init() {
+	var cfg struct {
+		Mod map[string]struct {
+			Pin           string   `yaml:"pin"`
+			Name          string   `yaml:"name"`
+			DeviceID      string   `yaml:"device_id"`
+			DevicePrivate string   `yaml:"device_private"`
+			Pairings      []string `yaml:"pairings"`
+		} `yaml:"homekit"`
+	}
+	app.LoadConfig(&cfg)
+
 	log = app.GetLogger("homekit")
 
 	streams.HandleFunc("homekit", streamHandler)
 
 	api.HandleFunc("api/homekit", apiHandler)
+
+	if cfg.Mod == nil {
+		return
+	}
+
+	servers = map[string]*server{}
+	var entries []*mdns.ServiceEntry
+
+	for id, conf := range cfg.Mod {
+		stream := streams.Get(id)
+		if stream == nil {
+			log.Warn().Msgf("[homekit] missing stream: %s", id)
+			continue
+		}
+
+		if conf.Pin == "" {
+			conf.Pin = "19550224" // default PIN
+		}
+
+		pin, err := hap.SanitizePin(conf.Pin)
+		if err != nil {
+			log.Error().Err(err).Caller().Send()
+			continue
+		}
+
+		deviceID := calcDeviceID(conf.DeviceID, id) // random MAC-address
+		name := calcName(conf.Name, deviceID)
+
+		srv := &server{
+			stream:   id,
+			srtp:     srtp.Server,
+			pairings: conf.Pairings,
+		}
+
+		srv.hap = &hap.Server{
+			Pin:           pin,
+			DeviceID:      deviceID,
+			DevicePrivate: calcDevicePrivate(conf.DevicePrivate, id),
+			GetPair:       srv.GetPair,
+			AddPair:       srv.AddPair,
+			Handler:       homekit.ServerHandler(srv),
+		}
+
+		if url := findHomeKitURL(stream.Sources()); url != "" {
+			// 1. Act as transparent proxy for HomeKit camera
+			dial := func() (net.Conn, error) {
+				client, err := homekit.Dial(url, srtp.Server)
+				if err != nil {
+					return nil, err
+				}
+				return client.Conn(), nil
+			}
+			srv.hap.Handler = homekit.ProxyHandler(srv, dial)
+		} else {
+			// 2. Act as basic HomeKit camera
+			srv.accessory = camera.NewAccessory("AlexxIT", "go2rtc", name, "-", app.Version)
+			srv.hap.Handler = homekit.ServerHandler(srv)
+		}
+
+		srv.mdns = &mdns.ServiceEntry{
+			Name: name,
+			Port: uint16(api.Port),
+			Info: map[string]string{
+				hap.TXTConfigNumber: "1",
+				hap.TXTFeatureFlags: "0",
+				hap.TXTDeviceID:     deviceID,
+				hap.TXTModel:        app.UserAgent,
+				hap.TXTProtoVersion: "1.1",
+				hap.TXTStateNumber:  "1",
+				hap.TXTStatusFlags:  hap.StatusNotPaired,
+				hap.TXTCategory:     hap.CategoryCamera,
+				hap.TXTSetupHash:    srv.hap.SetupHash(),
+			},
+		}
+		entries = append(entries, srv.mdns)
+
+		srv.UpdateStatus()
+
+		host := srv.mdns.Host(mdns.ServiceHAP)
+		servers[host] = srv
+	}
+
+	api.HandleFunc(hap.PathPairSetup, hapHandler)
+	api.HandleFunc(hap.PathPairVerify, hapHandler)
+
+	log.Trace().Msgf("[homekit] mdns: %s", entries)
+
+	go func() {
+		if err := mdns.Serve(mdns.ServiceHAP, entries); err != nil {
+			log.Error().Err(err).Caller().Send()
+		}
+	}()
 }
 
 var log zerolog.Logger
+var servers map[string]*server
 
-func streamHandler(url string) (core.Producer, error) {
-	conn, err := homekit.NewClient(url, srtp.Server)
-	if err != nil {
-		return nil, err
+func streamHandler(rawURL string) (core.Producer, error) {
+	if srtp.Server == nil {
+		return nil, errors.New("homekit: can't work without SRTP server")
 	}
-	if err = conn.Dial(); err != nil {
-		return nil, err
+
+	rawURL, rawQuery, _ := strings.Cut(rawURL, "#")
+	client, err := homekit.Dial(rawURL, srtp.Server)
+	if client != nil && rawQuery != "" {
+		query := streams.ParseQuery(rawQuery)
+		client.Bitrate = parseBitrate(query.Get("bitrate"))
 	}
-	return conn, nil
+
+	return client, err
+}
+
+func resolve(host string) *server {
+	if len(servers) == 1 {
+		for _, srv := range servers {
+			return srv
+		}
+	}
+	if srv, ok := servers[host]; ok {
+		return srv
+	}
+	return nil
+}
+
+func hapHandler(w http.ResponseWriter, r *http.Request) {
+	conn, rw, err := w.(http.Hijacker).Hijack()
+	if err != nil {
+		return
+	}
+
+	defer conn.Close()
+
+	// Can support multiple HomeKit cameras on single port ONLY for Apple devices.
+	// Doesn't support Home Assistant and any other open source projects
+	// because they don't send the host header in requests.
+	srv := resolve(r.Host)
+	if srv == nil {
+		log.Error().Msg("[homekit] unknown host: " + r.Host)
+		_ = hap.WriteBackoff(rw)
+		return
+	}
+
+	switch r.RequestURI {
+	case hap.PathPairSetup:
+		err = srv.hap.PairSetup(r, rw, conn)
+	case hap.PathPairVerify:
+		err = srv.hap.PairVerify(r, rw, conn)
+	}
+
+	if err != nil && err != io.EOF {
+		log.Error().Err(err).Caller().Send()
+	}
+}
+
+func findHomeKitURL(sources []string) string {
+	if len(sources) == 0 {
+		return ""
+	}
+
+	url := sources[0]
+	if strings.HasPrefix(url, "homekit") {
+		return url
+	}
+
+	if strings.HasPrefix(url, "hass") {
+		location, _ := streams.Location(url)
+		if strings.HasPrefix(location, "homekit") {
+			return url
+		}
+	}
+
+	return ""
+}
+
+func parseBitrate(s string) int {
+	n := len(s)
+	if n == 0 {
+		return 0
+	}
+
+	var k int
+	switch n--; s[n] {
+	case 'K':
+		k = 1024
+		s = s[:n]
+	case 'M':
+		k = 1024 * 1024
+		s = s[:n]
+	default:
+		k = 1
+	}
+
+	return k * core.Atoi(s)
 }

internal/homekit/server.go

@@ -0,0 +1,265 @@
+package homekit
+
+import (
+	"crypto/ed25519"
+	"crypto/sha512"
+	"encoding/hex"
+	"fmt"
+	"net"
+	"net/url"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/ffmpeg"
+	srtp2 "github.com/AlexxIT/go2rtc/internal/srtp"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/hap"
+	"github.com/AlexxIT/go2rtc/pkg/hap/camera"
+	"github.com/AlexxIT/go2rtc/pkg/hap/tlv8"
+	"github.com/AlexxIT/go2rtc/pkg/homekit"
+	"github.com/AlexxIT/go2rtc/pkg/magic"
+	"github.com/AlexxIT/go2rtc/pkg/mdns"
+	"github.com/AlexxIT/go2rtc/pkg/srtp"
+)
+
+type server struct {
+	stream    string      // stream name from YAML
+	hap       *hap.Server // server for HAP connection and encryption
+	mdns      *mdns.ServiceEntry
+	srtp      *srtp.Server
+	accessory *hap.Accessory // HAP accessory
+	pairings  []string       // pairings list
+
+	streams  map[string]*homekit.Consumer
+	consumer *homekit.Consumer
+}
+
+func (s *server) UpdateStatus() {
+	// true status is important, or device may be offline in Apple Home
+	if len(s.pairings) == 0 {
+		s.mdns.Info[hap.TXTStatusFlags] = hap.StatusNotPaired
+	} else {
+		s.mdns.Info[hap.TXTStatusFlags] = hap.StatusPaired
+	}
+}
+
+func (s *server) GetAccessories(_ net.Conn) []*hap.Accessory {
+	return []*hap.Accessory{s.accessory}
+}
+
+func (s *server) GetCharacteristic(conn net.Conn, aid uint8, iid uint64) any {
+	log.Trace().Msgf("[homekit] %s: get char aid=%d iid=0x%x", conn.RemoteAddr(), aid, iid)
+
+	char := s.accessory.GetCharacterByID(iid)
+	if char == nil {
+		log.Warn().Msgf("[homekit] get unknown characteristic: %d", iid)
+		return nil
+	}
+
+	switch char.Type {
+	case camera.TypeSetupEndpoints:
+		if s.consumer == nil {
+			return nil
+		}
+
+		answer := s.consumer.GetAnswer()
+		v, err := tlv8.MarshalBase64(answer)
+		if err != nil {
+			return nil
+		}
+
+		return v
+	}
+
+	return char.Value
+}
+
+func (s *server) SetCharacteristic(conn net.Conn, aid uint8, iid uint64, value any) {
+	log.Trace().Msgf("[homekit] %s: set char aid=%d iid=0x%x value=%v", conn.RemoteAddr(), aid, iid, value)
+
+	char := s.accessory.GetCharacterByID(iid)
+	if char == nil {
+		log.Warn().Msgf("[homekit] set unknown characteristic: %d", iid)
+		return
+	}
+
+	switch char.Type {
+	case camera.TypeSetupEndpoints:
+		var offer camera.SetupEndpoints
+		if err := tlv8.UnmarshalBase64(value, &offer); err != nil {
+			return
+		}
+
+		s.consumer = homekit.NewConsumer(conn, srtp2.Server)
+		s.consumer.SetOffer(&offer)
+
+	case camera.TypeSelectedStreamConfiguration:
+		var conf camera.SelectedStreamConfig
+		if err := tlv8.UnmarshalBase64(value, &conf); err != nil {
+			return
+		}
+
+		log.Trace().Msgf("[homekit] %s stream id=%x cmd=%d", conn.RemoteAddr(), conf.Control.SessionID, conf.Control.Command)
+
+		switch conf.Control.Command {
+		case camera.SessionCommandEnd:
+			if consumer := s.streams[conf.Control.SessionID]; consumer != nil {
+				_ = consumer.Stop()
+			}
+
+		case camera.SessionCommandStart:
+			if s.consumer == nil {
+				return
+			}
+
+			if !s.consumer.SetConfig(&conf) {
+				log.Warn().Msgf("[homekit] wrong config")
+				return
+			}
+
+			if s.streams == nil {
+				s.streams = map[string]*homekit.Consumer{}
+			}
+
+			s.streams[conf.Control.SessionID] = s.consumer
+
+			stream := streams.Get(s.stream)
+			if err := stream.AddConsumer(s.consumer); err != nil {
+				return
+			}
+
+			go func() {
+				_, _ = s.consumer.WriteTo(nil)
+				stream.RemoveConsumer(s.consumer)
+
+				delete(s.streams, conf.Control.SessionID)
+			}()
+		}
+	}
+}
+
+func (s *server) GetImage(conn net.Conn, width, height int) []byte {
+	log.Trace().Msgf("[homekit] %s: get image width=%d height=%d", conn.RemoteAddr(), width, height)
+
+	stream := streams.Get(s.stream)
+	cons := magic.NewKeyframe()
+
+	if err := stream.AddConsumer(cons); err != nil {
+		return nil
+	}
+
+	once := &core.OnceBuffer{} // init and first frame
+	_, _ = cons.WriteTo(once)
+	b := once.Buffer()
+
+	stream.RemoveConsumer(cons)
+
+	switch cons.CodecName() {
+	case core.CodecH264, core.CodecH265:
+		var err error
+		if b, err = ffmpeg.JPEGWithScale(b, width, height); err != nil {
+			return nil
+		}
+	}
+
+	return b
+}
+
+func (s *server) GetPair(conn net.Conn, id string) []byte {
+	log.Trace().Msgf("[homekit] %s: get pair id=%s", conn.RemoteAddr(), id)
+
+	for _, pairing := range s.pairings {
+		if !strings.Contains(pairing, id) {
+			continue
+		}
+
+		query, err := url.ParseQuery(pairing)
+		if err != nil {
+			continue
+		}
+
+		if query.Get("client_id") != id {
+			continue
+		}
+
+		s := query.Get("client_public")
+		b, _ := hex.DecodeString(s)
+		return b
+	}
+	return nil
+}
+
+func (s *server) AddPair(conn net.Conn, id string, public []byte, permissions byte) {
+	log.Trace().Msgf("[homekit] %s: add pair id=%s public=%x perm=%d", conn.RemoteAddr(), id, public, permissions)
+
+	query := url.Values{
+		"client_id":     []string{id},
+		"client_public": []string{hex.EncodeToString(public)},
+		"permissions":   []string{string('0' + permissions)},
+	}
+	if s.GetPair(conn, id) == nil {
+		s.pairings = append(s.pairings, query.Encode())
+		s.UpdateStatus()
+		s.PatchConfig()
+	}
+}
+
+func (s *server) DelPair(conn net.Conn, id string) {
+	log.Trace().Msgf("[homekit] %s: del pair id=%s", conn.RemoteAddr(), id)
+
+	id = "client_id=" + id
+	for i, pairing := range s.pairings {
+		if !strings.Contains(pairing, id) {
+			continue
+		}
+
+		s.pairings = append(s.pairings[:i], s.pairings[i+1:]...)
+		s.UpdateStatus()
+		s.PatchConfig()
+		break
+	}
+}
+
+func (s *server) PatchConfig() {
+	if err := app.PatchConfig([]string{"homekit", s.stream, "pairings"}, s.pairings); err != nil {
+		log.Error().Err(err).Msgf(
+			"[homekit] can't save %s pairings=%v", s.stream, s.pairings,
+		)
+	}
+}
+
+func calcName(name, seed string) string {
+	if name != "" {
+		return name
+	}
+	b := sha512.Sum512([]byte(seed))
+	return fmt.Sprintf("go2rtc-%02X%02X", b[0], b[2])
+}
+
+func calcDeviceID(deviceID, seed string) string {
+	if deviceID != "" {
+		if len(deviceID) >= 17 {
+			// 1. Returd device_id as is (ex. AA:BB:CC:DD:EE:FF)
+			return deviceID
+		}
+		// 2. Use device_id as seed if not zero
+		seed = deviceID
+	}
+	b := sha512.Sum512([]byte(seed))
+	return fmt.Sprintf("%02X:%02X:%02X:%02X:%02X:%02X", b[32], b[34], b[36], b[38], b[40], b[42])
+}
+
+func calcDevicePrivate(private, seed string) []byte {
+	if private != "" {
+		// 1. Decode private from HEX string
+		if b, _ := hex.DecodeString(private); len(b) == ed25519.PrivateKeySize {
+			// 2. Return if OK
+			return b
+		}
+		// 3. Use private as seed if not zero
+		seed = private
+	}
+	b := sha512.Sum512([]byte(seed))
+	return ed25519.NewKeyFromSeed(b[:ed25519.SeedSize])
+}

internal/http/http.go

@@ -2,17 +2,20 @@ package http
 
 import (
 	"errors"
-	"github.com/AlexxIT/go2rtc/internal/streams"
-	"github.com/AlexxIT/go2rtc/pkg/core"
-	"github.com/AlexxIT/go2rtc/pkg/magic"
-	"github.com/AlexxIT/go2rtc/pkg/mjpeg"
-	"github.com/AlexxIT/go2rtc/pkg/rtmp"
-	"github.com/AlexxIT/go2rtc/pkg/tcp"
 	"net"
 	"net/http"
 	"net/url"
 	"strings"
-	"time"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/hls"
+	"github.com/AlexxIT/go2rtc/pkg/image"
+	"github.com/AlexxIT/go2rtc/pkg/magic"
+	"github.com/AlexxIT/go2rtc/pkg/mpjpeg"
+	"github.com/AlexxIT/go2rtc/pkg/pcm"
+	"github.com/AlexxIT/go2rtc/pkg/tcp"
 )
 
 func Init() {
@@ -21,15 +24,43 @@ func Init() {
 	streams.HandleFunc("httpx", handleHTTP)
 
 	streams.HandleFunc("tcp", handleTCP)
+
+	api.HandleFunc("api/stream", apiStream)
 }
 
-func handleHTTP(url string) (core.Producer, error) {
+func handleHTTP(rawURL string) (core.Producer, error) {
+	rawURL, rawQuery, _ := strings.Cut(rawURL, "#")
+
 	// first we get the Content-Type to define supported producer
-	req, err := http.NewRequest("GET", url, nil)
+	req, err := http.NewRequest("GET", rawURL, nil)
 	if err != nil {
 		return nil, err
 	}
 
+	if rawQuery != "" {
+		query := streams.ParseQuery(rawQuery)
+
+		for _, header := range query["header"] {
+			key, value, _ := strings.Cut(header, ":")
+			req.Header.Add(key, strings.TrimSpace(value))
+		}
+	}
+
+	prod, err := do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	if info, ok := prod.(core.Info); ok {
+		info.SetProtocol("http")
+		info.SetRemoteAddr(req.URL.Host) // TODO: rewrite to net.Conn
+		info.SetURL(rawURL)
+	}
+
+	return prod, nil
+}
+
+func do(req *http.Request) (core.Producer, error) {
 	res, err := tcp.Do(req)
 	if err != nil {
 		return nil, err
@@ -39,37 +70,30 @@ func handleHTTP(url string) (core.Producer, error) {
 		return nil, errors.New(res.Status)
 	}
 
+	// 1. Guess format from content type
 	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
-
-	default: // "video/mpeg":
+	var ext string
+	if i := strings.LastIndexByte(req.URL.Path, '.'); i > 0 {
+		ext = req.URL.Path[i+1:]
 	}
 
-	client := magic.NewClient(res.Body)
-	if err = client.Probe(); err != nil {
-		return nil, err
+	switch {
+	case ct == "application/vnd.apple.mpegurl" || ext == "m3u8":
+		return hls.OpenURL(req.URL, res.Body)
+	case ct == "image/jpeg":
+		return image.Open(res)
+	case ct == "multipart/x-mixed-replace":
+		return mpjpeg.Open(res.Body)
+	//https://www.iana.org/assignments/media-types/audio/basic
+	case ct == "audio/basic":
+		return pcm.Open(res.Body)
 	}
 
-	client.Desc = "HTTP active producer"
-	client.URL = url
-
-	return client, nil
+	return magic.Open(res.Body)
 }
 
 func handleTCP(rawURL string) (core.Producer, error) {
@@ -78,18 +102,33 @@ func handleTCP(rawURL string) (core.Producer, error) {
 		return nil, err
 	}
 
-	conn, err := net.DialTimeout("tcp", u.Host, time.Second*3)
+	conn, err := net.DialTimeout("tcp", u.Host, core.ConnDialTimeout)
 	if err != nil {
 		return nil, err
 	}
 
-	client := magic.NewClient(conn)
-	if err = client.Probe(); err != nil {
-		return nil, err
+	return magic.Open(conn)
+}
+
+func apiStream(w http.ResponseWriter, r *http.Request) {
+	dst := r.URL.Query().Get("dst")
+	stream := streams.Get(dst)
+	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
+		return
 	}
 
-	client.Desc = "TCP active producer"
-	client.URL = rawURL
+	client, err := magic.Open(r.Body)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
 
-	return client, nil
+	stream.AddProducer(client)
+	defer stream.RemoveProducer(client)
+
+	if err = client.Start(); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
 }

internal/isapi/init.go

@@ -7,16 +7,7 @@ import (
 )
 
 func Init() {
-	streams.HandleFunc("isapi", handle)
-}
-
-func handle(url string) (core.Producer, error) {
-	conn, err := isapi.NewClient(url)
-	if err != nil {
-		return nil, err
-	}
-	if err = conn.Dial(); err != nil {
-		return nil, err
-	}
-	return conn, nil
+	streams.HandleFunc("isapi", func(source string) (core.Producer, error) {
+		return isapi.Dial(source)
+	})
 }

internal/ivideon/ivideon.go

@@ -2,18 +2,9 @@ package ivideon
 
 import (
 	"github.com/AlexxIT/go2rtc/internal/streams"
-	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/AlexxIT/go2rtc/pkg/ivideon"
-	"strings"
 )
 
 func Init() {
-	streams.HandleFunc("ivideon", func(url string) (core.Producer, error) {
-		id := strings.Replace(url[8:], "/", ":", 1)
-		prod := ivideon.NewClient(id)
-		if err := prod.Dial(); err != nil {
-			return nil, err
-		}
-		return prod, nil
-	})
+	streams.HandleFunc("ivideon", ivideon.Dial)
 }

internal/mjpeg/README.md

@@ -0,0 +1,38 @@
+## Stream as ASCII to Terminal
+
+[![](https://img.youtube.com/vi/sHj_3h_sX7M/mqdefault.jpg)](https://www.youtube.com/watch?v=sHj_3h_sX7M)
+
+**Tips**
+
+- this feature works only with MJPEG codec (use transcoding)
+- choose a low frame rate (FPS)
+- choose the width and height to fit in your terminal
+- different terminals support different numbers of colours (8, 256, rgb)
+- escape text param with urlencode
+- you can stream any camera or file from a disc
+
+**go2rtc.yaml** - transcoding to MJPEG, terminal size - 210x59 (16/9), fps - 10
+
+```yaml
+streams:
+  gamazda: ffmpeg:gamazda.mp4#video=mjpeg#hardware#width=210#height=59#raw=-r 10
+```
+
+**API params**
+
+- `color` - foreground color, values: empty, `8`, `256`, `rgb`, [SGR](https://en.wikipedia.org/wiki/ANSI_escape_code)
+  - example: `30` (black), `37` (white), `38;5;226` (yellow)
+- `back` - background color, values: empty, `8`, `256`, `rgb`, [SGR](https://en.wikipedia.org/wiki/ANSI_escape_code)
+  - example: `40` (black), `47` (white), `48;5;226` (yellow)
+- `text` - character set, values: empty, one char, `block`, list of chars (in order of brightness)
+  - example: `%20` (space), `block` (keyword for block elements), `ox` (two chars)
+
+**Examples**
+
+```bash
+% curl "http://192.168.1.123:1984/api/stream.ascii?src=gamazda"
+% curl "http://192.168.1.123:1984/api/stream.ascii?src=gamazda&color=256"
+% curl "http://192.168.1.123:1984/api/stream.ascii?src=gamazda&back=256&text=%20"
+% curl "http://192.168.1.123:1984/api/stream.ascii?src=gamazda&back=8&text=%20%20"
+% curl "http://192.168.1.123:1984/api/stream.ascii?src=gamazda&text=helloworld"
+```

internal/mjpeg/init.go

@@ -5,55 +5,54 @@ import (
 	"io"
 	"net/http"
 	"strconv"
+	"strings"
 	"time"
 
 	"github.com/AlexxIT/go2rtc/internal/api"
 	"github.com/AlexxIT/go2rtc/internal/api/ws"
+	"github.com/AlexxIT/go2rtc/internal/app"
 	"github.com/AlexxIT/go2rtc/internal/ffmpeg"
 	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/ascii"
 	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/AlexxIT/go2rtc/pkg/magic"
 	"github.com/AlexxIT/go2rtc/pkg/mjpeg"
-	"github.com/AlexxIT/go2rtc/pkg/tcp"
-	"github.com/rs/zerolog/log"
+	"github.com/AlexxIT/go2rtc/pkg/mpjpeg"
+	"github.com/AlexxIT/go2rtc/pkg/y4m"
+	"github.com/rs/zerolog"
 )
 
 func Init() {
 	api.HandleFunc("api/frame.jpeg", handlerKeyframe)
 	api.HandleFunc("api/stream.mjpeg", handlerStream)
+	api.HandleFunc("api/stream.ascii", handlerStream)
+	api.HandleFunc("api/stream.y4m", apiStreamY4M)
 
 	ws.HandleFunc("mjpeg", handlerWS)
+
+	log = app.GetLogger("mjpeg")
 }
 
+var log zerolog.Logger
+
 func handlerKeyframe(w http.ResponseWriter, r *http.Request) {
-	src := r.URL.Query().Get("src")
-	stream := streams.Get(src)
+	stream := streams.GetOrPatch(r.URL.Query())
 	if stream == nil {
 		http.Error(w, api.StreamNotFound, http.StatusNotFound)
 		return
 	}
 
-	exit := make(chan []byte)
-
-	cons := &magic.Keyframe{
-		RemoteAddr: tcp.RemoteAddr(r),
-		UserAgent:  r.UserAgent(),
-	}
-	cons.Listen(func(msg any) {
-		if b, ok := msg.([]byte); ok {
-			select {
-			case exit <- b:
-			default:
-			}
-		}
-	})
+	cons := magic.NewKeyframe()
+	cons.WithRequest(r)
 
 	if err := stream.AddConsumer(cons); err != nil {
 		log.Error().Err(err).Caller().Send()
 		return
 	}
 
-	data := <-exit
+	once := &core.OnceBuffer{} // init and first frame
+	_, _ = cons.WriteTo(once)
+	b := once.Buffer()
 
 	stream.RemoveConsumer(cons)
 
@@ -61,27 +60,27 @@ func handlerKeyframe(w http.ResponseWriter, r *http.Request) {
 	case core.CodecH264, core.CodecH265:
 		ts := time.Now()
 		var err error
-		if data, err = ffmpeg.TranscodeToJPEG(data, r.URL.Query()); err != nil {
+		if b, err = ffmpeg.JPEGWithQuery(b, r.URL.Query()); err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return
 		}
 		log.Debug().Msgf("[mjpeg] transcoding time=%s", time.Since(ts))
+	case core.CodecJPEG:
+		b = mjpeg.FixJPEG(b)
 	}
 
 	h := w.Header()
 	h.Set("Content-Type", "image/jpeg")
-	h.Set("Content-Length", strconv.Itoa(len(data)))
+	h.Set("Content-Length", strconv.Itoa(len(b)))
 	h.Set("Cache-Control", "no-cache")
 	h.Set("Connection", "close")
 	h.Set("Pragma", "no-cache")
 
-	if _, err := w.Write(data); err != nil {
+	if _, err := w.Write(b); err != nil {
 		log.Error().Err(err).Caller().Send()
 	}
 }
 
-const header = "--frame\r\nContent-Type: image/jpeg\r\nContent-Length: "
-
 func handlerStream(w http.ResponseWriter, r *http.Request) {
 	if r.Method != "POST" {
 		outputMjpeg(w, r)
@@ -98,26 +97,8 @@ func outputMjpeg(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	flusher := w.(http.Flusher)
-
-	cons := &mjpeg.Consumer{
-		RemoteAddr: tcp.RemoteAddr(r),
-		UserAgent:  r.UserAgent(),
-	}
-	cons.Listen(func(msg any) {
-		switch msg := msg.(type) {
-		case []byte:
-			data := []byte(header + strconv.Itoa(len(msg)))
-			data = append(data, '\r', '\n', '\r', '\n')
-			data = append(data, msg...)
-			data = append(data, '\r', '\n')
-
-			// 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()
-		}
-	})
+	cons := mjpeg.NewConsumer()
+	cons.WithRequest(r)
 
 	if err := stream.AddConsumer(cons); err != nil {
 		log.Error().Err(err).Msg("[api.mjpeg] add consumer")
@@ -125,16 +106,22 @@ func outputMjpeg(w http.ResponseWriter, r *http.Request) {
 	}
 
 	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")
 
-	<-r.Context().Done()
+	if strings.HasSuffix(r.URL.Path, "mjpeg") {
+		wr := mjpeg.NewWriter(w)
+		_, _ = cons.WriteTo(wr)
+	} else {
+		cons.FormatName = "ascii"
+
+		query := r.URL.Query()
+		wr := ascii.NewWriter(w, query.Get("color"), query.Get("back"), query.Get("text"))
+		_, _ = cons.WriteTo(wr)
+	}
 
 	stream.RemoveConsumer(cons)
-
-	//log.Trace().Msg("[api.mjpeg] close")
 }
 
 func inputMjpeg(w http.ResponseWriter, r *http.Request) {
@@ -145,17 +132,16 @@ func inputMjpeg(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	res := &http.Response{Body: r.Body, Header: r.Header, Request: r}
-	res.Header.Set("Content-Type", "multipart/mixed;boundary=")
+	prod, _ := mpjpeg.Open(r.Body)
+	prod.WithRequest(r)
 
-	client := mjpeg.NewClient(res)
-	stream.AddProducer(client)
+	stream.AddProducer(prod)
 
-	if err := client.Start(); err != nil && err != io.EOF {
+	if err := prod.Start(); err != nil && err != io.EOF {
 		log.Warn().Err(err).Caller().Send()
 	}
 
-	stream.RemoveProducer(client)
+	stream.RemoveProducer(prod)
 }
 
 func handlerWS(tr *ws.Transport, _ *ws.Message) error {
@@ -164,26 +150,42 @@ func handlerWS(tr *ws.Transport, _ *ws.Message) error {
 		return errors.New(api.StreamNotFound)
 	}
 
-	cons := &mjpeg.Consumer{
-		RemoteAddr: tcp.RemoteAddr(tr.Request),
-		UserAgent:  tr.Request.UserAgent(),
-	}
-	cons.Listen(func(msg any) {
-		if data, ok := msg.([]byte); ok {
-			tr.Write(data)
-		}
-	})
+	cons := mjpeg.NewConsumer()
+	cons.WithRequest(tr.Request)
 
 	if err := stream.AddConsumer(cons); err != nil {
-		log.Error().Err(err).Caller().Send()
+		log.Debug().Err(err).Msg("[mjpeg] add consumer")
 		return err
 	}
 
 	tr.Write(&ws.Message{Type: "mjpeg"})
 
+	go cons.WriteTo(tr.Writer())
+
 	tr.OnClose(func() {
 		stream.RemoveConsumer(cons)
 	})
 
 	return nil
 }
+
+func apiStreamY4M(w http.ResponseWriter, r *http.Request) {
+	src := r.URL.Query().Get("src")
+	stream := streams.Get(src)
+	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
+		return
+	}
+
+	cons := y4m.NewConsumer()
+	cons.WithRequest(r)
+
+	if err := stream.AddConsumer(cons); err != nil {
+		log.Error().Err(err).Caller().Send()
+		return
+	}
+
+	_, _ = cons.WriteTo(w)
+
+	stream.RemoveConsumer(cons)
+}

internal/mp4/mp4.go

@@ -1,6 +1,7 @@
 package mp4
 
 import (
+	"context"
 	"net/http"
 	"strconv"
 	"strings"
@@ -12,7 +13,6 @@ import (
 	"github.com/AlexxIT/go2rtc/internal/streams"
 	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/AlexxIT/go2rtc/pkg/mp4"
-	"github.com/AlexxIT/go2rtc/pkg/tcp"
 	"github.com/rs/zerolog"
 )
 
@@ -47,18 +47,7 @@ func handlerKeyframe(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	exit := make(chan []byte, 1)
-
-	cons := &mp4.Segment{OnlyKeyframe: true}
-	cons.Listen(func(msg any) {
-		if data, ok := msg.([]byte); ok && exit != nil {
-			select {
-			case exit <- data:
-			default:
-			}
-			exit = nil
-		}
-	})
+	cons := mp4.NewKeyframe(nil)
 
 	if err := stream.AddConsumer(cons); err != nil {
 		log.Error().Err(err).Caller().Send()
@@ -66,20 +55,21 @@ func handlerKeyframe(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	data := <-exit
+	once := &core.OnceBuffer{} // init and first frame
+	_, _ = cons.WriteTo(once)
 
 	stream.RemoveConsumer(cons)
 
 	// Apple Safari won't show frame without length
 	header := w.Header()
-	header.Set("Content-Length", strconv.Itoa(len(data)))
-	header.Set("Content-Type", cons.MimeType)
+	header.Set("Content-Length", strconv.Itoa(once.Len()))
+	header.Set("Content-Type", mp4.ContentType(cons.Codecs()))
 
 	if filename := query.Get("filename"); filename != "" {
 		header.Set("Content-Disposition", `attachment; filename="`+filename+`"`)
 	}
 
-	if _, err := w.Write(data); err != nil {
+	if _, err := once.WriteTo(w); err != nil {
 		log.Error().Err(err).Caller().Send()
 	}
 }
@@ -101,36 +91,17 @@ func handlerMP4(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	src := query.Get("src")
-	stream := streams.Get(src)
+	stream := streams.GetOrPatch(query)
 	if stream == nil {
 		http.Error(w, api.StreamNotFound, http.StatusNotFound)
 		return
 	}
 
-	exit := make(chan error, 1) // Add buffer to prevent blocking
-
-	cons := &mp4.Consumer{
-		Desc:       "MP4/HTTP",
-		RemoteAddr: tcp.RemoteAddr(r),
-		UserAgent:  r.UserAgent(),
-		Medias:     mp4.ParseQuery(r.URL.Query()),
-	}
-
-	cons.Listen(func(msg any) {
-		if exit == nil {
-			return
-		}
-		if data, ok := msg.([]byte); ok {
-			if _, err := w.Write(data); err != nil {
-				select {
-				case exit <- err:
-				default:
-				}
-				exit = nil
-			}
-		}
-	})
+	medias := mp4.ParseQuery(r.URL.Query())
+	cons := mp4.NewConsumer(medias)
+	cons.FormatName = "mp4"
+	cons.Protocol = "http"
+	cons.WithRequest(r)
 
 	if err := stream.AddConsumer(cons); err != nil {
 		log.Error().Err(err).Caller().Send()
@@ -138,61 +109,38 @@ func handlerMP4(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	defer stream.RemoveConsumer(cons)
+	if rotate := query.Get("rotate"); rotate != "" {
+		cons.Rotate = core.Atoi(rotate)
+	}
 
-	data, err := cons.Init()
-	if err != nil {
-		log.Error().Err(err).Caller().Send()
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
+	if scale := query.Get("scale"); scale != "" {
+		if sx, sy, ok := strings.Cut(scale, ":"); ok {
+			cons.ScaleX = core.Atoi(sx)
+			cons.ScaleY = core.Atoi(sy)
+		}
 	}
 
 	header := w.Header()
-	header.Set("Content-Type", cons.MimeType())
+	header.Set("Content-Type", mp4.ContentType(cons.Codecs()))
 
 	if filename := query.Get("filename"); filename != "" {
 		header.Set("Content-Disposition", `attachment; filename="`+filename+`"`)
 	}
 
-	if rotate := query.Get("rotate"); rotate != "" {
-		mp4.PatchVideoRotate(data, core.Atoi(rotate))
+	ctx := r.Context() // handle when the client drops the connection
+
+	if i := core.Atoi(query.Get("duration")); i > 0 {
+		timeout := time.Second * time.Duration(i)
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, timeout)
+		defer cancel()
 	}
 
-	if scale := query.Get("scale"); scale != "" {
-		if sx, sy, ok := strings.Cut(scale, ":"); ok {
-			mp4.PatchVideoScale(data, core.Atoi(sx), core.Atoi(sy))
-		}
-	}
+	go func() {
+		<-ctx.Done()
+		_ = cons.Stop()
+		stream.RemoveConsumer(cons)
+	}()
 
-	if _, err = w.Write(data); err != nil {
-		log.Error().Err(err).Caller().Send()
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	cons.Start()
-
-	var duration *time.Timer
-	if s := query.Get("duration"); s != "" {
-		if i, _ := strconv.Atoi(s); i > 0 {
-			duration = time.AfterFunc(time.Second*time.Duration(i), func() {
-				if exit != nil {
-					select {
-					case exit <- nil:
-					default:
-					}
-					exit = nil
-				}
-			})
-		}
-	}
-
-	err = <-exit
-	exit = nil
-
-	log.Trace().Err(err).Caller().Send()
-
-	if duration != nil {
-		duration.Stop()
-	}
+	_, _ = cons.WriteTo(w)
 }

internal/mp4/ws.go

@@ -6,8 +6,8 @@ import (
 	"github.com/AlexxIT/go2rtc/internal/api"
 	"github.com/AlexxIT/go2rtc/internal/api/ws"
 	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/AlexxIT/go2rtc/pkg/mp4"
-	"github.com/AlexxIT/go2rtc/pkg/tcp"
 )
 
 func handlerWSMSE(tr *ws.Transport, msg *ws.Message) error {
@@ -16,44 +16,29 @@ func handlerWSMSE(tr *ws.Transport, msg *ws.Message) error {
 		return errors.New(api.StreamNotFound)
 	}
 
-	cons := &mp4.Consumer{
-		Desc:       "MSE/WebSocket",
-		RemoteAddr: tcp.RemoteAddr(tr.Request),
-		UserAgent:  tr.Request.UserAgent(),
-	}
-
+	var medias []*core.Media
 	if codecs := msg.String(); codecs != "" {
 		log.Trace().Str("codecs", codecs).Msgf("[mp4] new WS/MSE consumer")
-		cons.Medias = mp4.ParseCodecs(codecs, true)
+		medias = mp4.ParseCodecs(codecs, true)
 	}
 
-	cons.Listen(func(msg any) {
-		if data, ok := msg.([]byte); ok {
-			tr.Write(data)
-		}
-	})
+	cons := mp4.NewConsumer(medias)
+	cons.FormatName = "mse/fmp4"
+	cons.WithRequest(tr.Request)
 
 	if err := stream.AddConsumer(cons); err != nil {
 		log.Debug().Err(err).Msg("[mp4] add consumer")
 		return err
 	}
 
+	tr.Write(&ws.Message{Type: "mse", Value: mp4.ContentType(cons.Codecs())})
+
+	go cons.WriteTo(tr.Writer())
+
 	tr.OnClose(func() {
 		stream.RemoveConsumer(cons)
 	})
 
-	tr.Write(&ws.Message{Type: "mse", Value: cons.MimeType()})
-
-	data, err := cons.Init()
-	if err != nil {
-		log.Warn().Err(err).Caller().Send()
-		return err
-	}
-
-	tr.Write(data)
-
-	cons.Start()
-
 	return nil
 }
 
@@ -63,29 +48,23 @@ func handlerWSMP4(tr *ws.Transport, msg *ws.Message) error {
 		return errors.New(api.StreamNotFound)
 	}
 
-	cons := &mp4.Segment{
-		RemoteAddr:   tcp.RemoteAddr(tr.Request),
-		UserAgent:    tr.Request.UserAgent(),
-		OnlyKeyframe: true,
-	}
-
+	var medias []*core.Media
 	if codecs := msg.String(); codecs != "" {
 		log.Trace().Str("codecs", codecs).Msgf("[mp4] new WS/MP4 consumer")
-		cons.Medias = mp4.ParseCodecs(codecs, false)
+		medias = mp4.ParseCodecs(codecs, false)
 	}
 
-	cons.Listen(func(msg any) {
-		if data, ok := msg.([]byte); ok {
-			tr.Write(data)
-		}
-	})
+	cons := mp4.NewKeyframe(medias)
+	cons.WithRequest(tr.Request)
 
 	if err := stream.AddConsumer(cons); err != nil {
 		log.Error().Err(err).Caller().Send()
 		return err
 	}
 
-	tr.Write(&ws.Message{Type: "mp4", Value: cons.MimeType})
+	tr.Write(&ws.Message{Type: "mse", Value: mp4.ContentType(cons.Codecs())})
+
+	go cons.WriteTo(tr.Writer())
 
 	tr.OnClose(func() {
 		stream.RemoveConsumer(cons)

internal/mpegts/aac.go

@@ -0,0 +1,32 @@
+package mpegts
+
+import (
+	"net/http"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/aac"
+)
+
+func apiStreamAAC(w http.ResponseWriter, r *http.Request) {
+	src := r.URL.Query().Get("src")
+	stream := streams.Get(src)
+	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
+		return
+	}
+
+	cons := aac.NewConsumer()
+	cons.WithRequest(r)
+
+	if err := stream.AddConsumer(cons); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Add("Content-Type", "audio/aac")
+
+	_, _ = cons.WriteTo(w)
+
+	stream.RemoveConsumer(cons)
+}

internal/mpegts/mpegts.go

@@ -1,22 +1,50 @@
 package mpegts
 
 import (
+	"net/http"
+
 	"github.com/AlexxIT/go2rtc/internal/api"
 	"github.com/AlexxIT/go2rtc/internal/streams"
 	"github.com/AlexxIT/go2rtc/pkg/mpegts"
-	"net/http"
 )
 
 func Init() {
 	api.HandleFunc("api/stream.ts", apiHandle)
+	api.HandleFunc("api/stream.aac", apiStreamAAC)
 }
 
 func apiHandle(w http.ResponseWriter, r *http.Request) {
 	if r.Method != "POST" {
-		http.Error(w, "", http.StatusMethodNotAllowed)
+		outputMpegTS(w, r)
+	} else {
+		inputMpegTS(w, r)
+	}
+}
+
+func outputMpegTS(w http.ResponseWriter, r *http.Request) {
+	src := r.URL.Query().Get("src")
+	stream := streams.Get(src)
+	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
 		return
 	}
 
+	cons := mpegts.NewConsumer()
+	cons.WithRequest(r)
+
+	if err := stream.AddConsumer(cons); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Add("Content-Type", "video/mp2t")
+
+	_, _ = cons.WriteTo(w)
+
+	stream.RemoveConsumer(cons)
+}
+
+func inputMpegTS(w http.ResponseWriter, r *http.Request) {
 	dst := r.URL.Query().Get("dst")
 	stream := streams.Get(dst)
 	if stream == nil {
@@ -24,20 +52,17 @@ func apiHandle(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	res := &http.Response{Body: r.Body, Request: r}
-	client := mpegts.NewClient(res)
-
-	if err := client.Handle(); err != nil {
+	client, err := mpegts.Open(r.Body)
+	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 
 	stream.AddProducer(client)
+	defer stream.RemoveProducer(client)
 
-	if err := client.Handle(); err != nil {
+	if err = client.Start(); err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
-
-	stream.RemoveProducer(client)
 }

internal/nest/init.go

@@ -1,27 +1,23 @@
 package nest
 
 import (
+	"net/http"
+	"strings"
+
 	"github.com/AlexxIT/go2rtc/internal/api"
 	"github.com/AlexxIT/go2rtc/internal/streams"
 	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/AlexxIT/go2rtc/pkg/nest"
-	"net/http"
 )
 
 func Init() {
-	streams.HandleFunc("nest", streamNest)
+	streams.HandleFunc("nest", func(source string) (core.Producer, error) {
+		return nest.Dial(source)
+	})
 
 	api.HandleFunc("api/nest", apiNest)
 }
 
-func streamNest(url string) (core.Producer, error) {
-	client, err := nest.NewClient(url)
-	if err != nil {
-		return nil, err
-	}
-	return client, nil
-}
-
 func apiNest(w http.ResponseWriter, r *http.Request) {
 	query := r.URL.Query()
 	cliendID := query.Get("client_id")
@@ -41,15 +37,16 @@ func apiNest(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	var items []api.Stream
+	var items []*api.Source
 
-	for name, deviceID := range devices {
-		query.Set("device_id", deviceID)
+	for _, device := range devices {
+		query.Set("device_id", device.DeviceID)
+		query.Set("protocols", strings.Join(device.Protocols, ","))
 
-		items = append(items, api.Stream{
-			Name: name, URL: "nest:?" + query.Encode(),
+		items = append(items, &api.Source{
+			Name: device.Name, URL: "nest:?" + query.Encode(),
 		})
 	}
 
-	api.ResponseStreams(w, items)
+	api.ResponseSources(w, items)
 }

internal/ngrok/ngrok.go

@@ -2,12 +2,13 @@ package ngrok
 
 import (
 	"fmt"
+	"net"
+	"strings"
+
 	"github.com/AlexxIT/go2rtc/internal/app"
 	"github.com/AlexxIT/go2rtc/internal/webrtc"
 	"github.com/AlexxIT/go2rtc/pkg/ngrok"
 	"github.com/rs/zerolog"
-	"net"
-	"strings"
 )
 
 func Init() {
@@ -39,7 +40,7 @@ func Init() {
 			}
 
 			// Addr: "//localhost:8555", URL: "tcp://1.tcp.eu.ngrok.io:12345"
-			if msg.Addr == "//localhost:"+webrtc.Port && strings.HasPrefix(msg.URL, "tcp://") {
+			if strings.HasPrefix(msg.Addr, "//localhost:") && strings.HasPrefix(msg.URL, "tcp://") {
 				// don't know if really necessary use IP
 				address, err := ConvertHostToIP(msg.URL[6:])
 				if err != nil {
@@ -49,7 +50,7 @@ func Init() {
 
 				log.Info().Str("addr", address).Msg("[ngrok] add external candidate for WebRTC")
 
-				webrtc.AddCandidate(address)
+				webrtc.AddCandidate("tcp", address)
 			}
 		}
 	})

internal/onvif/README.md

@@ -0,0 +1,25 @@
+# ONVIF
+
+A regular camera has a single video source (`GetVideoSources`) and two profiles (`GetProfiles`).
+
+Go2rtc has one video source and one profile per stream.
+
+## Tested clients
+
+Go2rtc works as ONVIF server:
+
+- Happytime onvif client (windows)
+- Home Assistant ONVIF integration (linux)
+- Onvier (android)
+- ONVIF Device Manager (windows)
+
+PS. Support only TCP transport for RTSP protocol. UDP and HTTP transports - unsupported yet.
+
+## Tested cameras
+
+Go2rtc works as ONVIF client:
+
+- Dahua IPC-K42
+- OpenIPC
+- Reolink RLC-520A
+- TP-Link Tapo TC60

internal/onvif/onvif.go

@@ -1,13 +1,6 @@
 package onvif
 
 import (
-	"github.com/AlexxIT/go2rtc/internal/api"
-	"github.com/AlexxIT/go2rtc/internal/app"
-	"github.com/AlexxIT/go2rtc/internal/rtsp"
-	"github.com/AlexxIT/go2rtc/internal/streams"
-	"github.com/AlexxIT/go2rtc/pkg/core"
-	"github.com/AlexxIT/go2rtc/pkg/onvif"
-	"github.com/rs/zerolog"
 	"io"
 	"net"
 	"net/http"
@@ -15,6 +8,14 @@ import (
 	"os"
 	"strconv"
 	"time"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/rtsp"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/onvif"
+	"github.com/rs/zerolog"
 )
 
 func Init() {
@@ -54,49 +55,73 @@ func onvifDeviceService(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	action := onvif.GetRequestAction(b)
-	if action == "" {
+	operation := onvif.GetRequestAction(b)
+	if operation == "" {
 		http.Error(w, "malformed request body", http.StatusBadRequest)
 		return
 	}
 
-	log.Trace().Msgf("[onvif] %s", action)
+	log.Trace().Msgf("[onvif] server request %s %s:\n%s", r.Method, r.RequestURI, b)
 
-	var res string
+	switch operation {
+	case onvif.DeviceGetNetworkInterfaces, // important for Hass
+		onvif.DeviceGetSystemDateAndTime, // important for Hass
+		onvif.DeviceGetDiscoveryMode,
+		onvif.DeviceGetDNS,
+		onvif.DeviceGetHostname,
+		onvif.DeviceGetNetworkDefaultGateway,
+		onvif.DeviceGetNetworkProtocols,
+		onvif.DeviceGetNTP,
+		onvif.DeviceGetScopes,
+		onvif.MediaGetVideoEncoderConfigurations,
+		onvif.MediaGetAudioEncoderConfigurations,
+		onvif.MediaGetAudioSources,
+		onvif.MediaGetAudioSourceConfigurations:
+		b = onvif.StaticResponse(operation)
 
-	switch action {
-	case onvif.ActionGetCapabilities:
+	case onvif.DeviceGetCapabilities:
 		// important for Hass: Media section
-		res = onvif.GetCapabilitiesResponse(r.Host)
+		b = onvif.GetCapabilitiesResponse(r.Host)
 
-	case onvif.ActionGetSystemDateAndTime:
-		// important for Hass
-		res = onvif.GetSystemDateAndTimeResponse()
+	case onvif.DeviceGetServices:
+		b = onvif.GetServicesResponse(r.Host)
 
-	case onvif.ActionGetNetworkInterfaces:
-		// important for Hass: none
-		res = onvif.GetNetworkInterfacesResponse()
-
-	case onvif.ActionGetDeviceInformation:
+	case onvif.DeviceGetDeviceInformation:
 		// important for Hass: SerialNumber (unique server ID)
-		res = onvif.GetDeviceInformationResponse("", "go2rtc", app.Version, r.Host)
+		b = onvif.GetDeviceInformationResponse("", "go2rtc", app.Version, r.Host)
 
-	case onvif.ActionGetServiceCapabilities:
+	case onvif.ServiceGetServiceCapabilities:
 		// important for Hass
-		res = onvif.GetServiceCapabilitiesResponse()
+		// TODO: check path links to media
+		b = onvif.GetMediaServiceCapabilitiesResponse()
 
-	case onvif.ActionSystemReboot:
-		res = onvif.SystemRebootResponse()
+	case onvif.DeviceSystemReboot:
+		b = onvif.StaticResponse(operation)
 
 		time.AfterFunc(time.Second, func() {
 			os.Exit(0)
 		})
 
-	case onvif.ActionGetProfiles:
-		// important for Hass: H264 codec, width, height
-		res = onvif.GetProfilesResponse(streams.GetAll())
+	case onvif.MediaGetVideoSources:
+		b = onvif.GetVideoSourcesResponse(streams.GetAllNames())
 
-	case onvif.ActionGetStreamUri:
+	case onvif.MediaGetProfiles:
+		// important for Hass: H264 codec, width, height
+		b = onvif.GetProfilesResponse(streams.GetAllNames())
+
+	case onvif.MediaGetProfile:
+		token := onvif.FindTagValue(b, "ProfileToken")
+		b = onvif.GetProfileResponse(token)
+
+	case onvif.MediaGetVideoSourceConfigurations:
+		// important for Happytime Onvif Client
+		b = onvif.GetVideoSourceConfigurationsResponse(streams.GetAllNames())
+
+	case onvif.MediaGetVideoSourceConfiguration:
+		token := onvif.FindTagValue(b, "ConfigurationToken")
+		b = onvif.GetVideoSourceConfigurationResponse(token)
+
+	case onvif.MediaGetStreamUri:
 		host, _, err := net.SplitHostPort(r.Host)
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
@@ -104,16 +129,23 @@ func onvifDeviceService(w http.ResponseWriter, r *http.Request) {
 		}
 
 		uri := "rtsp://" + host + ":" + rtsp.Port + "/" + onvif.FindTagValue(b, "ProfileToken")
-		res = onvif.GetStreamUriResponse(uri)
+		b = onvif.GetStreamUriResponse(uri)
+
+	case onvif.MediaGetSnapshotUri:
+		uri := "http://" + r.Host + "/api/frame.jpeg?src=" + onvif.FindTagValue(b, "ProfileToken")
+		b = onvif.GetSnapshotUriResponse(uri)
 
 	default:
-		http.Error(w, "unsupported action", http.StatusBadRequest)
+		http.Error(w, "unsupported operation", http.StatusBadRequest)
+		log.Warn().Msgf("[onvif] unsupported operation: %s", operation)
 		log.Debug().Msgf("[onvif] unsupported request:\n%s", b)
 		return
 	}
 
+	log.Trace().Msgf("[onvif] server response:\n%s", b)
+
 	w.Header().Set("Content-Type", "application/soap+xml; charset=utf-8")
-	if _, err = w.Write([]byte(res)); err != nil {
+	if _, err = w.Write(b); err != nil {
 		log.Error().Err(err).Caller().Send()
 	}
 }
@@ -121,7 +153,7 @@ func onvifDeviceService(w http.ResponseWriter, r *http.Request) {
 func apiOnvif(w http.ResponseWriter, r *http.Request) {
 	src := r.URL.Query().Get("src")
 
-	var items []api.Stream
+	var items []*api.Source
 
 	if src == "" {
 		urls, err := onvif.DiscoveryStreamingURLs()
@@ -149,7 +181,7 @@ func apiOnvif(w http.ResponseWriter, r *http.Request) {
 				u.Path = ""
 			}
 
-			items = append(items, api.Stream{Name: u.Host, URL: u.String()})
+			items = append(items, &api.Source{Name: u.Host, URL: u.String()})
 		}
 	} else {
 		client, err := onvif.NewClient(src)
@@ -159,7 +191,7 @@ func apiOnvif(w http.ResponseWriter, r *http.Request) {
 		}
 
 		if l := log.Trace(); l.Enabled() {
-			b, _ := client.GetProfiles()
+			b, _ := client.MediaRequest(onvif.MediaGetProfiles)
 			l.Msgf("[onvif] src=%s profiles:\n%s", src, b)
 		}
 
@@ -176,19 +208,19 @@ func apiOnvif(w http.ResponseWriter, r *http.Request) {
 		}
 
 		for i, token := range tokens {
-			items = append(items, api.Stream{
+			items = append(items, &api.Source{
 				Name: name + " stream" + strconv.Itoa(i),
 				URL:  src + "?subtype=" + token,
 			})
 		}
 
 		if len(tokens) > 0 && client.HasSnapshots() {
-			items = append(items, api.Stream{
+			items = append(items, &api.Source{
 				Name: name + " snapshot",
 				URL:  src + "?subtype=" + tokens[0] + "&snapshot",
 			})
 		}
 	}
 
-	api.ResponseStreams(w, items)
+	api.ResponseSources(w, items)
 }

internal/ring/ring.go

@@ -0,0 +1,102 @@
+package ring
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/url"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/ring"
+)
+
+func Init() {
+	streams.HandleFunc("ring", func(source string) (core.Producer, error) {
+		return ring.Dial(source)
+	})
+
+	api.HandleFunc("api/ring", apiRing)
+}
+
+func apiRing(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+	var ringAPI *ring.RingRestClient
+	var err error
+
+	// Check auth method
+	if email := query.Get("email"); email != "" {
+		// Email/Password Flow
+		password := query.Get("password")
+		code := query.Get("code")
+
+		ringAPI, err = ring.NewRingRestClient(ring.EmailAuth{
+			Email:    email,
+			Password: password,
+		}, nil)
+
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		// Try authentication (this will trigger 2FA if needed)
+		if _, err = ringAPI.GetAuth(code); err != nil {
+			if ringAPI.Using2FA {
+				// Return 2FA prompt
+				json.NewEncoder(w).Encode(map[string]interface{}{
+					"needs_2fa": true,
+					"prompt":    ringAPI.PromptFor2FA,
+				})
+				return
+			}
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	} else {
+		// Refresh Token Flow
+		refreshToken := query.Get("refresh_token")
+		if refreshToken == "" {
+			http.Error(w, "either email/password or refresh_token is required", http.StatusBadRequest)
+			return
+		}
+
+		ringAPI, err = ring.NewRingRestClient(ring.RefreshTokenAuth{
+			RefreshToken: refreshToken,
+		}, nil)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	}
+
+	// Fetch devices
+	devices, err := ringAPI.FetchRingDevices()
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// Create clean query with only required parameters
+	cleanQuery := url.Values{}
+	cleanQuery.Set("refresh_token", ringAPI.RefreshToken)
+
+	var items []*api.Source
+	for _, camera := range devices.AllCameras {
+		cleanQuery.Set("device_id", camera.DeviceID)
+
+		// Stream source
+		items = append(items, &api.Source{
+			Name: camera.Description,
+			URL:  "ring:?" + cleanQuery.Encode(),
+		})
+
+		// Snapshot source
+		items = append(items, &api.Source{
+			Name: camera.Description + " Snapshot",
+			URL:  "ring:?" + cleanQuery.Encode() + "&snapshot",
+		})
+	}
+
+	api.ResponseSources(w, items)
+}

internal/roborock/roborock.go

@@ -2,30 +2,22 @@ package roborock
 
 import (
 	"fmt"
+	"net/http"
+
 	"github.com/AlexxIT/go2rtc/internal/api"
 	"github.com/AlexxIT/go2rtc/internal/streams"
 	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/AlexxIT/go2rtc/pkg/roborock"
-	"net/http"
 )
 
 func Init() {
-	streams.HandleFunc("roborock", handle)
+	streams.HandleFunc("roborock", func(source string) (core.Producer, error) {
+		return roborock.Dial(source)
+	})
 
 	api.HandleFunc("api/roborock", apiHandle)
 }
 
-func handle(url string) (core.Producer, error) {
-	conn := roborock.NewClient(url)
-	if err := conn.Dial(); err != nil {
-		return nil, err
-	}
-	if err := conn.Connect(); err != nil {
-		return nil, err
-	}
-	return conn, nil
-}
-
 var Auth struct {
 	UserData *roborock.UserInfo `json:"user_data"`
 	BaseURL  string             `json:"base_url"`
@@ -84,7 +76,7 @@ func apiHandle(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	var items []api.Stream
+	var items []*api.Source
 
 	for _, device := range devices {
 		source := fmt.Sprintf(
@@ -93,8 +85,8 @@ func apiHandle(w http.ResponseWriter, r *http.Request) {
 			Auth.UserData.IoT.User, Auth.UserData.IoT.Pass, Auth.UserData.IoT.Domain,
 			device.DID, device.Key,
 		)
-		items = append(items, api.Stream{Name: device.Name, URL: source})
+		items = append(items, &api.Source{Name: device.Name, URL: source})
 	}
 
-	api.ResponseStreams(w, items)
+	api.ResponseSources(w, items)
 }

internal/rtmp/README.md

@@ -0,0 +1,60 @@
+## Tested client
+
+| From   | To                              | Comment |
+|--------|---------------------------------|---------|
+| go2rtc | Reolink RLC-520A fw. v3.1.0.801 | OK      |
+
+**go2rtc.yaml**
+
+```yaml
+streams:
+  rtmp-reolink1: rtmp://192.168.10.92/bcs/channel0_main.bcs?channel=0&stream=0&user=admin&password=password
+  rtmp-reolink2: rtmp://192.168.10.92/bcs/channel0_sub.bcs?channel=0&stream=1&user=admin&password=password
+  rtmp-reolink3: rtmp://192.168.10.92/bcs/channel0_ext.bcs?channel=0&stream=1&user=admin&password=password
+```
+
+## Tested server
+
+| From                   | To     | Comment             |
+|------------------------|--------|---------------------|
+| OBS 31.0.2             | go2rtc | OK                  |
+| OpenIPC 2.5.03.02-lite | go2rtc | OK                  |
+| FFmpeg 6.1             | go2rtc | OK                  |
+| GoPro Black 12         | go2rtc | OK, 1080p, 5000kbps |
+
+**go2rtc.yaml**
+
+```yaml
+rtmp:
+  listen: :1935
+streams:
+  tmp:
+```
+
+**OBS**
+ 
+Settings > Stream:
+
+- Service: Custom
+- Server: rtmp://192.168.10.101/tmp
+- Stream Key: <empty>
+- Use auth: <disabled>
+
+**OpenIPC**
+
+WebUI > Majestic > Settings > Outgoing
+
+- Enable
+- Address: rtmp://192.168.10.101/tmp
+- Save
+- Restart
+
+**FFmpeg**
+
+```shell
+ffmpeg -re -i bbb.mp4 -c copy -f flv rtmp://192.168.10.101/tmp
+```
+
+**GoPro**
+
+GoPro Quik > Camera > Translation > Other

internal/rtmp/rtmp.go

@@ -1,38 +1,181 @@
 package rtmp
 
 import (
+	"errors"
+	"io"
+	"net"
+	"net/http"
+
 	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/app"
 	"github.com/AlexxIT/go2rtc/internal/streams"
 	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/flv"
 	"github.com/AlexxIT/go2rtc/pkg/rtmp"
-	"github.com/rs/zerolog/log"
-	"io"
-	"net/http"
+	"github.com/rs/zerolog"
 )
 
 func Init() {
+	var conf struct {
+		Mod struct {
+			Listen string `yaml:"listen" json:"listen"`
+		} `yaml:"rtmp"`
+	}
+
+	app.LoadConfig(&conf)
+
+	log = app.GetLogger("rtmp")
+
 	streams.HandleFunc("rtmp", streamsHandle)
+	streams.HandleFunc("rtmps", streamsHandle)
+	streams.HandleFunc("rtmpx", streamsHandle)
 
 	api.HandleFunc("api/stream.flv", apiHandle)
+
+	streams.HandleConsumerFunc("rtmp", streamsConsumerHandle)
+	streams.HandleConsumerFunc("rtmps", streamsConsumerHandle)
+	streams.HandleConsumerFunc("rtmpx", streamsConsumerHandle)
+
+	address := conf.Mod.Listen
+	if address == "" {
+		return
+	}
+
+	ln, err := net.Listen("tcp", address)
+	if err != nil {
+		log.Error().Err(err).Caller().Send()
+		return
+	}
+
+	log.Info().Str("addr", address).Msg("[rtmp] listen")
+
+	go func() {
+		for {
+			conn, err := ln.Accept()
+			if err != nil {
+				return
+			}
+
+			go func() {
+				if err = tcpHandle(conn); err != nil {
+					log.Error().Err(err).Caller().Send()
+				}
+			}()
+		}
+	}()
 }
 
+func tcpHandle(netConn net.Conn) error {
+	rtmpConn, err := rtmp.NewServer(netConn)
+	if err != nil {
+		return err
+	}
+
+	if err = rtmpConn.ReadCommands(); err != nil {
+		return err
+	}
+
+	switch rtmpConn.Intent {
+	case rtmp.CommandPlay:
+		stream := streams.Get(rtmpConn.App)
+		if stream == nil {
+			return errors.New("stream not found: " + rtmpConn.App)
+		}
+
+		cons := flv.NewConsumer()
+		if err = stream.AddConsumer(cons); err != nil {
+			return err
+		}
+
+		defer stream.RemoveConsumer(cons)
+
+		if err = rtmpConn.WriteStart(); err != nil {
+			return err
+		}
+
+		_, _ = cons.WriteTo(rtmpConn)
+
+		return nil
+
+	case rtmp.CommandPublish:
+		stream := streams.Get(rtmpConn.App)
+		if stream == nil {
+			return errors.New("stream not found: " + rtmpConn.App)
+		}
+
+		if err = rtmpConn.WriteStart(); err != nil {
+			return err
+		}
+
+		prod, err := rtmpConn.Producer()
+		if err != nil {
+			return err
+		}
+
+		stream.AddProducer(prod)
+
+		defer stream.RemoveProducer(prod)
+
+		_ = prod.Start()
+
+		return nil
+	}
+
+	return errors.New("rtmp: unknown command: " + rtmpConn.Intent)
+}
+
+var log zerolog.Logger
+
 func streamsHandle(url string) (core.Producer, error) {
-	conn := rtmp.NewClient(url)
-	if err := conn.Dial(); err != nil {
-		return nil, err
+	return rtmp.DialPlay(url)
+}
+
+func streamsConsumerHandle(url string) (core.Consumer, func(), error) {
+	cons := flv.NewConsumer()
+	run := func() {
+		wr, err := rtmp.DialPublish(url, cons)
+		if err != nil {
+			return
+		}
+		_, err = cons.WriteTo(wr)
 	}
-	if err := conn.Describe(); err != nil {
-		return nil, err
-	}
-	return conn, nil
+
+	return cons, run, nil
 }
 
 func apiHandle(w http.ResponseWriter, r *http.Request) {
 	if r.Method != "POST" {
-		http.Error(w, "", http.StatusMethodNotAllowed)
+		outputFLV(w, r)
+	} else {
+		inputFLV(w, r)
+	}
+}
+
+func outputFLV(w http.ResponseWriter, r *http.Request) {
+	src := r.URL.Query().Get("src")
+	stream := streams.Get(src)
+	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
 		return
 	}
 
+	cons := flv.NewConsumer()
+	cons.WithRequest(r)
+
+	if err := stream.AddConsumer(cons); err != nil {
+		log.Error().Err(err).Caller().Send()
+		return
+	}
+
+	h := w.Header()
+	h.Set("Content-Type", "video/x-flv")
+
+	_, _ = cons.WriteTo(w)
+
+	stream.RemoveConsumer(cons)
+}
+
+func inputFLV(w http.ResponseWriter, r *http.Request) {
 	dst := r.URL.Query().Get("dst")
 	stream := streams.Get(dst)
 	if stream == nil {
@@ -40,18 +183,12 @@ func apiHandle(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	res := &http.Response{Body: r.Body, Request: r}
-	client, err := rtmp.Accept(res)
+	client, err := flv.Open(r.Body)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 
-	if err = client.Describe(); err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-
 	stream.AddProducer(client)
 
 	if err = client.Start(); err != nil && err != io.EOF {

internal/rtsp/rtsp.go

@@ -1,6 +1,7 @@
 package rtsp
 
 import (
+	"errors"
 	"io"
 	"net"
 	"net/url"
@@ -21,12 +22,12 @@ func Init() {
 			Username     string `yaml:"username" json:"-"`
 			Password     string `yaml:"password" json:"-"`
 			DefaultQuery string `yaml:"default_query" json:"default_query"`
-			PacketSize   uint16 `yaml:"pkt_size"`
+			PacketSize   uint16 `yaml:"pkt_size" json:"pkt_size,omitempty"`
 		} `yaml:"rtsp"`
 	}
 
 	// default config
-	conf.Mod.Listen = "0.0.0.0:8554"
+	conf.Mod.Listen = ":8554"
 	conf.Mod.DefaultQuery = "video&audio"
 
 	app.LoadConfig(&conf)
@@ -101,6 +102,8 @@ func rtspHandler(rawURL string) (core.Producer, error) {
 	if rawQuery != "" {
 		query := streams.ParseQuery(rawQuery)
 		conn.Backchannel = query.Get("backchannel") == "1"
+		conn.Media = query.Get("media")
+		conn.Timeout = core.Atoi(query.Get("timeout"))
 		conn.Transport = query.Get("transport")
 	}
 
@@ -145,6 +148,7 @@ func tcpHandler(conn *rtsp.Conn) {
 	var closer func()
 
 	trace := log.Trace().Enabled()
+	level := zerolog.WarnLevel
 
 	conn.Listen(func(msg any) {
 		if trace {
@@ -182,12 +186,38 @@ func tcpHandler(conn *rtsp.Conn) {
 				}
 			}
 
+			if query.Get("backchannel") == "1" {
+				conn.Medias = append(conn.Medias, &core.Media{
+					Kind:      core.KindAudio,
+					Direction: core.DirectionRecvonly,
+					Codecs: []*core.Codec{
+						{Name: core.CodecOpus, ClockRate: 48000, Channels: 2},
+						{Name: core.CodecPCM, ClockRate: 16000},
+						{Name: core.CodecPCMA, ClockRate: 16000},
+						{Name: core.CodecPCMU, ClockRate: 16000},
+						{Name: core.CodecPCM, ClockRate: 8000},
+						{Name: core.CodecPCMA, ClockRate: 8000},
+						{Name: core.CodecPCMU, ClockRate: 8000},
+					},
+				})
+			}
+
 			if s := query.Get("pkt_size"); s != "" {
 				conn.PacketSize = uint16(core.Atoi(s))
 			}
 
+			// param name like ffmpeg style https://ffmpeg.org/ffmpeg-protocols.html
+			if s := query.Get("log_level"); s != "" {
+				if lvl, err := zerolog.ParseLevel(s); err == nil {
+					level = lvl
+				}
+			}
+
+			// will help to protect looping requests to same source
+			conn.Connection.Source = query.Get("source")
+
 			if err := stream.AddConsumer(conn); err != nil {
-				log.Warn().Err(err).Str("stream", name).Msg("[rtsp]")
+				log.WithLevel(level).Err(err).Str("stream", name).Msg("[rtsp]")
 				return
 			}
 
@@ -208,6 +238,11 @@ func tcpHandler(conn *rtsp.Conn) {
 				return
 			}
 
+			query := conn.URL.Query()
+			if s := query.Get("timeout"); s != "" {
+				conn.Timeout = core.Atoi(s)
+			}
+
 			log.Debug().Str("stream", name).Msg("[rtsp] new producer")
 
 			stream.AddProducer(conn)
@@ -219,8 +254,10 @@ func tcpHandler(conn *rtsp.Conn) {
 	})
 
 	if err := conn.Accept(); err != nil {
-		if err != io.EOF {
-			log.Warn().Err(err).Caller().Send()
+		if errors.Is(err, rtsp.FailedAuth) {
+			log.Warn().Str("remote_addr", conn.Connection.RemoteAddr).Msg("[rtsp] failed authentication")
+		} else if err != io.EOF {
+			log.WithLevel(level).Err(err).Caller().Send()
 		}
 		if closer != nil {
 			closer()
@@ -237,7 +274,7 @@ func tcpHandler(conn *rtsp.Conn) {
 
 	if closer != nil {
 		if err := conn.Handle(); err != nil {
-			log.Debug().Msgf("[rtsp] handle=%s", err)
+			log.Debug().Err(err).Msg("[rtsp] handle")
 		}
 
 		closer()

internal/srtp/srtp.go

@@ -1,8 +1,6 @@
 package srtp
 
 import (
-	"net"
-
 	"github.com/AlexxIT/go2rtc/internal/app"
 	"github.com/AlexxIT/go2rtc/pkg/srtp"
 )
@@ -15,7 +13,7 @@ func Init() {
 	}
 
 	// default config
-	cfg.Mod.Listen = "0.0.0.0:8443"
+	cfg.Mod.Listen = ":8443"
 
 	// load config from YAML
 	app.LoadConfig(&cfg)
@@ -24,23 +22,8 @@ func Init() {
 		return
 	}
 
-	log := app.GetLogger("srtp")
-
-	// create SRTP server (endpoint) for receiving video from HomeKit camera
-	conn, err := net.ListenPacket("udp", cfg.Mod.Listen)
-	if err != nil {
-		log.Warn().Err(err).Caller().Send()
-	}
-
-	log.Info().Str("addr", cfg.Mod.Listen).Msg("[srtp] listen")
-
-	// run server
-	go func() {
-		Server = &srtp.Server{}
-		if err = Server.Serve(conn); err != nil {
-			log.Warn().Err(err).Caller().Send()
-		}
-	}()
+	// create SRTP server (endpoint) for receiving video from HomeKit cameras
+	Server = srtp.NewServer(cfg.Mod.Listen)
 }
 
 var Server *srtp.Server

internal/streams/README.md

@@ -0,0 +1,55 @@
+## Examples
+
+```yaml
+streams:
+  # known RTSP sources
+  rtsp-dahua1:   rtsp://admin:password@192.168.10.90/cam/realmonitor?channel=1&subtype=0&unicast=true&proto=Onvif
+  rtsp-dahua2:   rtsp://admin:password@192.168.10.90/cam/realmonitor?channel=1&subtype=1
+  rtsp-tplink1:  rtsp://admin:password@192.168.10.91/stream1
+  rtsp-tplink2:  rtsp://admin:password@192.168.10.91/stream2
+  rtsp-reolink1: rtsp://admin:password@192.168.10.92/h264Preview_01_main
+  rtsp-reolink2: rtsp://admin:password@192.168.10.92/h264Preview_01_sub
+  rtsp-sonoff1:  rtsp://admin:password@192.168.10.93/av_stream/ch0
+  rtsp-sonoff2:  rtsp://admin:password@192.168.10.93/av_stream/ch1
+
+  # known RTMP sources
+  rtmp-reolink1: rtmp://192.168.10.92/bcs/channel0_main.bcs?channel=0&stream=0&user=admin&password=password
+  rtmp-reolink2: rtmp://192.168.10.92/bcs/channel0_sub.bcs?channel=0&stream=1&user=admin&password=password
+  rtmp-reolink3: rtmp://192.168.10.92/bcs/channel0_ext.bcs?channel=0&stream=1&user=admin&password=password
+
+  # known HTTP sources
+  http-reolink1: http://192.168.10.92/flv?port=1935&app=bcs&stream=channel0_main.bcs&user=admin&password=password
+  http-reolink2: http://192.168.10.92/flv?port=1935&app=bcs&stream=channel0_sub.bcs&user=admin&password=password
+  http-reolink3: http://192.168.10.92/flv?port=1935&app=bcs&stream=channel0_ext.bcs&user=admin&password=password
+
+  # known ONVIF sources
+  onvif-dahua1:   onvif://admin:password@192.168.10.90?subtype=MediaProfile00000
+  onvif-dahua2:   onvif://admin:password@192.168.10.90?subtype=MediaProfile00001
+  onvif-dahua3:   onvif://admin:password@192.168.10.90?subtype=MediaProfile00000&snapshot
+  onvif-tplink1:  onvif://admin:password@192.168.10.91:2020?subtype=profile_1
+  onvif-tplink2:  onvif://admin:password@192.168.10.91:2020?subtype=profile_2
+  onvif-reolink1: onvif://admin:password@192.168.10.92:8000?subtype=000
+  onvif-reolink2: onvif://admin:password@192.168.10.92:8000?subtype=001
+  onvif-reolink3: onvif://admin:password@192.168.10.92:8000?subtype=000&snapshot
+  onvif-openipc1: onvif://admin:password@192.168.10.95:80?subtype=PROFILE_000
+  onvif-openipc2: onvif://admin:password@192.168.10.95:80?subtype=PROFILE_001
+
+  # some EXEC examples
+  exec-h264-pipe:   exec:ffmpeg -re -i bbb.mp4 -c copy -f h264 -
+  exec-flv-pipe:    exec:ffmpeg -re -i bbb.mp4 -c copy -f flv -
+  exec-mpegts-pipe: exec:ffmpeg -re -i bbb.mp4 -c copy -f mpegts -
+  exec-adts-pipe:   exec:ffmpeg -re -i bbb.mp4 -c copy -f adts -
+  exec-mjpeg-pipe:  exec:ffmpeg -re -i bbb.mp4 -c mjpeg -f mjpeg -
+  exec-hevc-pipe:   exec:ffmpeg -re -i bbb.mp4 -c libx265 -preset superfast -tune zerolatency -f hevc -
+  exec-wav-pipe:    exec:ffmpeg -re -i bbb.mp4 -c pcm_alaw -ar 8000 -ac 1 -f wav -
+  exec-y4m-pipe:    exec:ffmpeg -re -i bbb.mp4 -c rawvideo -f yuv4mpegpipe -
+  exec-pcma-pipe:   exec:ffmpeg -re -i numb.mp3 -c:a pcm_alaw -ar:a 8000 -ac:a 1 -f wav -
+  exec-pcmu-pipe:   exec:ffmpeg -re -i numb.mp3 -c:a pcm_mulaw -ar:a 8000 -ac:a 1 -f wav -
+  exec-s16le-pipe:  exec:ffmpeg -re -i numb.mp3 -c:a pcm_s16le -ar:a 16000 -ac:a 1 -f wav -
+
+  # some FFmpeg examples
+  ffmpeg-video-h264: ffmpeg:virtual?video#video=h264
+  ffmpeg-video-4K:   ffmpeg:virtual?video&size=4K#video=h264
+  ffmpeg-video-10s:  ffmpeg:virtual?video&duration=10#video=h264
+  ffmpeg-video-src2: ffmpeg:virtual?video=testsrc2&size=2K#video=h264
+```

internal/streams/add_consumer.go

@@ -0,0 +1,166 @@
+package streams
+
+import (
+	"errors"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func (s *Stream) AddConsumer(cons core.Consumer) (err error) {
+	// support for multiple simultaneous pending from different consumers
+	consN := s.pending.Add(1) - 1
+
+	var prodErrors = make([]error, len(s.producers))
+	var prodMedias []*core.Media
+	var prodStarts []*Producer
+
+	// Step 1. Get consumer medias
+	consMedias := cons.GetMedias()
+	for _, consMedia := range consMedias {
+		log.Trace().Msgf("[streams] check cons=%d media=%s", consN, consMedia)
+
+	producers:
+		for prodN, prod := range s.producers {
+			// check for loop request, ex. `camera1: ffmpeg:camera1`
+			if info, ok := cons.(core.Info); ok && prod.url == info.GetSource() {
+				log.Trace().Msgf("[streams] skip cons=%d prod=%d", consN, prodN)
+				continue
+			}
+
+			if prodErrors[prodN] != nil {
+				log.Trace().Msgf("[streams] skip cons=%d prod=%d", consN, prodN)
+				continue
+			}
+
+			if err = prod.Dial(); err != nil {
+				log.Trace().Err(err).Msgf("[streams] dial cons=%d prod=%d", consN, prodN)
+				prodErrors[prodN] = err
+				continue
+			}
+
+			// Step 2. Get producer medias (not tracks yet)
+			for _, prodMedia := range prod.GetMedias() {
+				log.Trace().Msgf("[streams] check cons=%d prod=%d media=%s", consN, prodN, prodMedia)
+				prodMedias = append(prodMedias, prodMedia)
+
+				// Step 3. Match consumer/producer codecs list
+				prodCodec, consCodec := prodMedia.MatchMedia(consMedia)
+				if prodCodec == nil {
+					continue
+				}
+
+				var track *core.Receiver
+
+				switch prodMedia.Direction {
+				case core.DirectionRecvonly:
+					log.Trace().Msgf("[streams] match cons=%d <= prod=%d", consN, prodN)
+
+					// Step 4. Get recvonly track from producer
+					if track, err = prod.GetTrack(prodMedia, prodCodec); err != nil {
+						log.Info().Err(err).Msg("[streams] can't get track")
+						prodErrors[prodN] = err
+						continue
+					}
+					// Step 5. Add track to consumer
+					if err = cons.AddTrack(consMedia, consCodec, track); err != nil {
+						log.Info().Err(err).Msg("[streams] can't add track")
+						continue
+					}
+
+				case core.DirectionSendonly:
+					log.Trace().Msgf("[streams] match cons=%d => prod=%d", consN, prodN)
+
+					// Step 4. Get recvonly track from consumer (backchannel)
+					if track, err = cons.(core.Producer).GetTrack(consMedia, consCodec); err != nil {
+						log.Info().Err(err).Msg("[streams] can't get track")
+						continue
+					}
+					// Step 5. Add track to producer
+					if err = prod.AddTrack(prodMedia, prodCodec, track); err != nil {
+						log.Info().Err(err).Msg("[streams] can't add track")
+						prodErrors[prodN] = err
+						continue
+					}
+				}
+
+				prodStarts = append(prodStarts, prod)
+
+				if !consMedia.MatchAll() {
+					break producers
+				}
+			}
+		}
+	}
+
+	// stop producers if they don't have readers
+	if s.pending.Add(-1) == 0 {
+		s.stopProducers()
+	}
+
+	if len(prodStarts) == 0 {
+		return formatError(consMedias, prodMedias, prodErrors)
+	}
+
+	s.mu.Lock()
+	s.consumers = append(s.consumers, cons)
+	s.mu.Unlock()
+
+	// there may be duplicates, but that's not a problem
+	for _, prod := range prodStarts {
+		prod.start()
+	}
+
+	return nil
+}
+
+func formatError(consMedias, prodMedias []*core.Media, prodErrors []error) error {
+	// 1. Return errors if any not nil
+	var text string
+
+	for _, err := range prodErrors {
+		if err != nil {
+			text = appendString(text, err.Error())
+		}
+	}
+
+	if len(text) != 0 {
+		return errors.New("streams: " + text)
+	}
+
+	// 2. Return "codecs not matched"
+	if prodMedias != nil {
+		var prod, cons string
+
+		for _, media := range prodMedias {
+			if media.Direction == core.DirectionRecvonly {
+				for _, codec := range media.Codecs {
+					prod = appendString(prod, media.Kind+":"+codec.PrintName())
+				}
+			}
+		}
+
+		for _, media := range consMedias {
+			if media.Direction == core.DirectionSendonly {
+				for _, codec := range media.Codecs {
+					cons = appendString(cons, media.Kind+":"+codec.PrintName())
+				}
+			}
+		}
+
+		return errors.New("streams: codecs not matched: " + prod + " => " + cons)
+	}
+
+	// 3. Return unknown error
+	return errors.New("streams: unknown error")
+}
+
+func appendString(s, elem string) string {
+	if strings.Contains(s, elem) {
+		return s
+	}
+	if len(s) == 0 {
+		return elem
+	}
+	return s + ", " + elem
+}

internal/streams/api.go

@@ -0,0 +1,124 @@
+package streams
+
+import (
+	"net/http"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/pkg/probe"
+)
+
+func apiStreams(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+	src := query.Get("src")
+
+	// without source - return all streams list
+	if src == "" && r.Method != "POST" {
+		api.ResponseJSON(w, streams)
+		return
+	}
+
+	// Not sure about all this API. Should be rewrited...
+	switch r.Method {
+	case "GET":
+		stream := Get(src)
+		if stream == nil {
+			http.Error(w, "", http.StatusNotFound)
+			return
+		}
+
+		cons := probe.NewProbe(query)
+		if len(cons.Medias) != 0 {
+			cons.WithRequest(r)
+			if err := stream.AddConsumer(cons); err != nil {
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+				return
+			}
+
+			api.ResponsePrettyJSON(w, stream)
+
+			stream.RemoveConsumer(cons)
+		} else {
+			api.ResponsePrettyJSON(w, streams[src])
+		}
+
+	case "PUT":
+		name := query.Get("name")
+		if name == "" {
+			name = src
+		}
+
+		if New(name, query["src"]...) == nil {
+			http.Error(w, "", http.StatusBadRequest)
+			return
+		}
+
+		if err := app.PatchConfig([]string{"streams", name}, query["src"]); err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+		}
+
+	case "PATCH":
+		name := query.Get("name")
+		if name == "" {
+			http.Error(w, "", http.StatusBadRequest)
+			return
+		}
+
+		// support {input} templates: https://github.com/AlexxIT/go2rtc#module-hass
+		if Patch(name, src) == nil {
+			http.Error(w, "", http.StatusBadRequest)
+		}
+
+	case "POST":
+		// with dst - redirect source to dst
+		if dst := query.Get("dst"); dst != "" {
+			if stream := Get(dst); stream != nil {
+				if err := Validate(src); err != nil {
+					http.Error(w, err.Error(), http.StatusBadRequest)
+				} else if err = stream.Play(src); err != nil {
+					http.Error(w, err.Error(), http.StatusInternalServerError)
+				} else {
+					api.ResponseJSON(w, stream)
+				}
+			} else if stream = Get(src); stream != nil {
+				if err := Validate(dst); err != nil {
+					http.Error(w, err.Error(), http.StatusBadRequest)
+				} else if err = stream.Publish(dst); err != nil {
+					http.Error(w, err.Error(), http.StatusInternalServerError)
+				}
+			} else {
+				http.Error(w, "", http.StatusNotFound)
+			}
+		} else {
+			http.Error(w, "", http.StatusBadRequest)
+		}
+
+	case "DELETE":
+		delete(streams, src)
+
+		if err := app.PatchConfig([]string{"streams", src}, nil); err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+		}
+	}
+}
+
+func apiStreamsDOT(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+
+	dot := make([]byte, 0, 1024)
+	dot = append(dot, "digraph {\n"...)
+	if query.Has("src") {
+		for _, name := range query["src"] {
+			if stream := streams[name]; stream != nil {
+				dot = AppendDOT(dot, stream)
+			}
+		}
+	} else {
+		for _, stream := range streams {
+			dot = AppendDOT(dot, stream)
+		}
+	}
+	dot = append(dot, '}')
+
+	api.Response(w, dot, "text/vnd.graphviz")
+}

internal/streams/dot.go

@@ -0,0 +1,176 @@
+package streams
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+func AppendDOT(dot []byte, stream *Stream) []byte {
+	for _, prod := range stream.producers {
+		if prod.conn == nil {
+			continue
+		}
+		c, err := marshalConn(prod.conn)
+		if err != nil {
+			continue
+		}
+		dot = c.appendDOT(dot, "producer")
+	}
+	for _, cons := range stream.consumers {
+		c, err := marshalConn(cons)
+		if err != nil {
+			continue
+		}
+		dot = c.appendDOT(dot, "consumer")
+	}
+	return dot
+}
+
+func marshalConn(v any) (*conn, error) {
+	b, err := json.Marshal(v)
+	if err != nil {
+		return nil, err
+	}
+	var c conn
+	if err = json.Unmarshal(b, &c); err != nil {
+		return nil, err
+	}
+	return &c, nil
+}
+
+const bytesK = "KMGTP"
+
+func humanBytes(i int) string {
+	if i < 1000 {
+		return fmt.Sprintf("%d B", i)
+	}
+
+	f := float64(i) / 1000
+	var n uint8
+	for f >= 1000 && n < 5 {
+		f /= 1000
+		n++
+	}
+	return fmt.Sprintf("%.2f %cB", f, bytesK[n])
+}
+
+type node struct {
+	ID     uint32         `json:"id"`
+	Codec  map[string]any `json:"codec"`
+	Parent uint32         `json:"parent"`
+	Childs []uint32       `json:"childs"`
+	Bytes  int            `json:"bytes"`
+	//Packets uint32         `json:"packets"`
+	//Drops   uint32         `json:"drops"`
+}
+
+var codecKeys = []string{"codec_name", "sample_rate", "channels", "profile", "level"}
+
+func (n *node) name() string {
+	if name, ok := n.Codec["codec_name"].(string); ok {
+		return name
+	}
+	return "unknown"
+}
+
+func (n *node) codec() []byte {
+	b := make([]byte, 0, 128)
+	for _, k := range codecKeys {
+		if v := n.Codec[k]; v != nil {
+			b = fmt.Appendf(b, "%s=%v\n", k, v)
+		}
+	}
+	if l := len(b); l > 0 {
+		return b[:l-1]
+	}
+	return b
+}
+
+func (n *node) appendDOT(dot []byte, group string) []byte {
+	dot = fmt.Appendf(dot, "%d [group=%s, label=%q, title=%q];\n", n.ID, group, n.name(), n.codec())
+	//for _, sink := range n.Childs {
+	//	dot = fmt.Appendf(dot, "%d -> %d;\n", n.ID, sink)
+	//}
+	return dot
+}
+
+type conn struct {
+	ID         uint32 `json:"id"`
+	FormatName string `json:"format_name"`
+	Protocol   string `json:"protocol"`
+	RemoteAddr string `json:"remote_addr"`
+	Source     string `json:"source"`
+	URL        string `json:"url"`
+	UserAgent  string `json:"user_agent"`
+	Receivers  []node `json:"receivers"`
+	Senders    []node `json:"senders"`
+	BytesRecv  int    `json:"bytes_recv"`
+	BytesSend  int    `json:"bytes_send"`
+}
+
+func (c *conn) appendDOT(dot []byte, group string) []byte {
+	host := c.host()
+	dot = fmt.Appendf(dot, "%s [group=host];\n", host)
+	dot = fmt.Appendf(dot, "%d [group=%s, label=%q, title=%q];\n", c.ID, group, c.FormatName, c.label())
+	if group == "producer" {
+		dot = fmt.Appendf(dot, "%s -> %d [label=%q];\n", host, c.ID, humanBytes(c.BytesRecv))
+	} else {
+		dot = fmt.Appendf(dot, "%d -> %s [label=%q];\n", c.ID, host, humanBytes(c.BytesSend))
+	}
+
+	for _, recv := range c.Receivers {
+		dot = fmt.Appendf(dot, "%d -> %d [label=%q];\n", c.ID, recv.ID, humanBytes(recv.Bytes))
+		dot = recv.appendDOT(dot, "node")
+	}
+	for _, send := range c.Senders {
+		dot = fmt.Appendf(dot, "%d -> %d [label=%q];\n", send.Parent, c.ID, humanBytes(send.Bytes))
+		//dot = fmt.Appendf(dot, "%d -> %d [label=%q];\n", send.ID, c.ID, humanBytes(send.Bytes))
+		//dot = send.appendDOT(dot, "node")
+	}
+	return dot
+}
+
+func (c *conn) host() (s string) {
+	if c.Protocol == "pipe" {
+		return "127.0.0.1"
+	}
+
+	if s = c.RemoteAddr; s == "" {
+		return "unknown"
+	}
+
+	if i := strings.Index(s, "forwarded"); i > 0 {
+		s = s[i+10:]
+	}
+
+	if s[0] == '[' {
+		if i := strings.Index(s, "]"); i > 0 {
+			return s[1:i]
+		}
+	}
+
+	if i := strings.IndexAny(s, " ,:"); i > 0 {
+		return s[:i]
+	}
+	return
+}
+
+func (c *conn) label() string {
+	var sb strings.Builder
+	sb.WriteString("format_name=" + c.FormatName)
+	if c.Protocol != "" {
+		sb.WriteString("\nprotocol=" + c.Protocol)
+	}
+	if c.Source != "" {
+		sb.WriteString("\nsource=" + c.Source)
+	}
+	if c.URL != "" {
+		sb.WriteString("\nurl=" + c.URL)
+	}
+	if c.UserAgent != "" {
+		sb.WriteString("\nuser_agent=" + c.UserAgent)
+	}
+	// escape quotes https://github.com/AlexxIT/go2rtc/issues/1603
+	return strings.ReplaceAll(sb.String(), `"`, `'`)
+}