fix(api): improve CORS and preflight request handling

- add support for handling OPTIONS method in middleware functions
- ensure proper CORS headers are set for preflight requests

.github/workflows/build.yml

@@ -0,0 +1,254 @@
+name: Build and Push
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - 'beta'
+      - 'dev'
+    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.26' }
+
+      - 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 }
+        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 }
+        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: 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 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: 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 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: 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 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/gh-pages.yml

@@ -0,0 +1,53 @@
+# Simple workflow for deploying static content to GitHub Pages
+name: Deploy static content to Pages
+
+on:
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+# Allow one concurrent deployment
+concurrency:
+  group: "pages"
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+      - name: Setup Node
+        uses: actions/setup-node@v6
+        with:
+          node-version: 24
+          package-manager-cache: false
+      - name: Install dependencies
+        run: npm install --no-package-lock
+      - name: Build docs
+        run: npm run docs:build
+      - name: Copy docs into website
+        run: rsync -a --exclude '.vitepress/' --exclude 'README.md' website/ website/.vitepress/dist/
+      - name: Setup Pages
+        uses: actions/configure-pages@v5
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: website/.vitepress/dist
+
+  # Single deploy job since we're just deploying
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

.github/workflows/test.yml

@@ -0,0 +1,104 @@
+name: Test Build and Run
+
+on:
+#  push:
+#    branches:
+#      - '*'
+#  pull_request:
+#  merge_group:
+  workflow_dispatch:
+
+jobs:
+  build-test:
+    strategy:
+      matrix:
+        os: [windows-latest, ubuntu-latest, macos-latest]
+        arch: [amd64, arm64]
+
+    runs-on: ${{ matrix.os }}
+    continue-on-error: true
+    env:
+      GOARCH: ${{ matrix.arch }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.26'
+
+      - name: Build Go binary
+        run: go build -ldflags "-s -w" -trimpath -o ./go2rtc
+
+      - name: Test Go binary on linux
+        if: matrix.os == 'ubuntu-latest'
+        run: |
+            if [ "${{ matrix.arch }}" = "amd64" ]; then
+              ./go2rtc -version
+            else
+              sudo apt-get update && sudo apt-get install -y qemu-user-static
+              sudo cp /usr/bin/qemu-aarch64-static .
+              sudo chown $USER:$USER ./qemu-aarch64-static
+              qemu-aarch64-static ./go2rtc -version
+            fi
+      - name: Test Go binary on macos
+        if: matrix.os == 'macos-latest'
+        run: |
+            if [ "${{ matrix.arch }}" = "amd64" ]; then
+              ./go2rtc -version
+            else
+              echo "ARM64 architecture is not yet supported on macOS"
+            fi
+      - name: Test Go binary on windows
+        if: matrix.os == 'windows-latest'
+        run: |
+            if ("${{ matrix.arch }}" -eq "amd64") {
+                .\go2rtc* -version
+            } else {
+                Write-Host "ARM64 architecture is not yet supported on Windows"
+            }
+  docker-test:
+    strategy:
+      matrix:
+        platform:
+          - amd64
+          - "386"
+          - arm/v7
+          - arm64/v8
+    continue-on-error: true
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      - name: Build and push
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: docker/Dockerfile
+          platforms: linux/${{ matrix.platform }}
+          push: false
+          load: true
+          tags: go2rtc-${{ matrix.platform }}
+      - name: test run
+        run: |
+          docker run --platform=linux/${{ matrix.platform }} --rm go2rtc-${{ matrix.platform }} go2rtc -version
+
+      - name: Build and push Hardware
+        if: matrix.platform == 'amd64'
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: docker/hardware.Dockerfile
+          platforms: linux/amd64
+          push: false
+          load: true
+          tags: go2rtc-${{ matrix.platform }}-hardware
+      - name: test run
+        if: matrix.platform == 'amd64'
+        run: |
+          docker run --platform=linux/${{ matrix.platform }} --rm go2rtc-${{ matrix.platform }}-hardware go2rtc -version

.gitignore

@@ -1,6 +1,29 @@
-
 .idea/
-
 .tmp/
 
 go2rtc.yaml
+go2rtc.json
+
+go2rtc_freebsd*
+go2rtc_linux*
+go2rtc_mac*
+go2rtc_win*
+
+/go2rtc
+/go2rtc.exe
+
+0_test.go
+
+.DS_Store
+
+website/.vitepress/cache
+website/.vitepress/dist
+
+node_modules
+package-lock.json
+CLAUDE.md
+*/**/CLAUDE.md
+.claude*
+.ruff*
+
+.omc

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Alexey Khit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,217 +1,635 @@
-# go2rtc
+<h1 align="center">
+  <a href="https://github.com/AlexxIT/go2rtc">
+    <img src="./website/images/logo.gif" alt="go2rtc - GitHub">
+  </a>
+</h1>
+<p align="center">
+  <a href="https://github.com/AlexxIT/go2rtc/stargazers" target="_blank">
+    <img style="display: inline" src="https://img.shields.io/github/stars/AlexxIT/go2rtc?style=flat-square&logo=github" alt="go2rtc - GitHub Stars">
+  </a>
+  <a href="https://hub.docker.com/r/alexxit/go2rtc" target="_blank">
+    <img style="display: inline" src="https://img.shields.io/docker/pulls/alexxit/go2rtc?style=flat-square&logo=docker&logoColor=white&label=pulls" alt="go2rtc - Docker Pulls">
+  </a>
+  <a href="https://github.com/AlexxIT/go2rtc/releases" target="_blank">
+    <img style="display: inline" src="https://img.shields.io/github/downloads/AlexxIT/go2rtc/total?color=blue&style=flat-square&logo=github" alt="go2rtc - GitHub Downloads">
+  </a>
+</p>
+<p align="center">
+  <a href="https://trendshift.io/repositories/4628" target="_blank">
+    <img src="https://trendshift.io/api/badge/repositories/4628" alt="go2rtc - Trendshift"/>
+  </a>
+</p>
 
-**go2rtc** - ultimate camera streaming application with support RTSP, WebRTC, FFmpeg, RTMP, etc.
+Ultimate camera streaming application with support for dozens formats and protocols.
 
-- zero-dependency and zero-config small app for all OS (Windows, macOS, Linux, ARM, etc.)
-- zero-delay for all supported protocols (lowest possible streaming latency)
-- zero-load on CPU for supported codecs
-- on the fly transcoding for unsupported codecs via FFmpeg
-- multi-source two-way [codecs negotiation](#codecs-negotiation)
-- streaming from private networks via Ngrok or SSH-tunnels
+---
 
-## Codecs negotiation
+> ### 🔀 Dev branch: [AlexxIT/go2rtc:dev](https://github.com/AlexxIT/go2rtc/tree/dev)
+>
+> This is a dev (bleeding-edge) branch with the following additions:
+>
+> **Features**
+> - **HomeKit Secure Video (HKSV)** — full recording support with motion detection (P-frame analysis, ONVIF events, API)
+> - **ONVIF motion detection** — automatic motion events from ONVIF cameras for HomeKit
+> - **WebCodecs streaming** — browser-native video/audio decoding via [WebCodecs API](https://developer.mozilla.org/en-US/docs/Web/API/WebCodecs_API) with H264, H265, AAC, OPUS, PCMA, PCMU support
+> - **WebP streaming** — native WebP encoding (snapshot & multipart stream) without FFmpeg
+> - **System resource monitoring** — CPU/memory usage in API (`/api/system`) and WebUI ASCII graphs
+> - **Read-only mode** — disable all write operations in API/WebUI for production security
+> - **Offline WebUI in Docker** — CDN JS dependencies bundled into Docker images
+>
+> **WebUI improvements**
+> - **Redesigned interface** — dark/light theme toggle, unified color scheme, improved layout
+> - **Stream Info & Probe pages** — detailed stream analysis with producers/consumers data
+> - **Stream Links page** — direct URLs for all supported formats (RTSP, WebRTC, MSE, HLS, etc.)
+> - **Mobile-responsive** — improved header, tables, and word wrapping on mobile devices
+>
+> **Bug fixes & maintenance**
+> - **YAML config merge fix** — corrected recursive merge behavior preserving comments
+> - **Streams race condition fix** — fixed race condition in stream schema handling
+> - **Go 1.26** — updated to the latest Go runtime
+>
+> #### Download
+>
+> **Docker images** (GHCR):
+> ```bash
+> # Standard
+> docker pull ghcr.io/AlexxIT/go2rtc:dev
+>
+> # With hardware acceleration (Intel/AMD)
+> docker pull ghcr.io/AlexxIT/go2rtc:dev-hardware
+>
+> # Rockchip
+> docker pull ghcr.io/AlexxIT/go2rtc:dev-rockchip
+> ```
+>
+> **Binaries**: download from [GitHub Actions](https://github.com/AlexxIT/go2rtc/actions/workflows/build.yml) artifacts (select the latest successful run on the `beta` branch).
+> Available for: Windows (amd64, i386, arm64), Linux (amd64, i386, arm, arm64), macOS (amd64, arm64), FreeBSD (amd64, arm64).
+>
+> #### Merged PRs (not yet in `master`)
+>
+> - [#1993](https://github.com/AlexxIT/go2rtc/pull/1993) — WebUI redesign
+> - [#2066](https://github.com/AlexxIT/go2rtc/pull/2066) — Add read-only mode to API and UI
+> - [#2098](https://github.com/AlexxIT/go2rtc/pull/2098) — Serve webui JS offline in docker images
+> - [#2093](https://github.com/AlexxIT/go2rtc/pull/2093) — Expose process PID and system resource metrics in API and UI
+> - [#2092](https://github.com/AlexxIT/go2rtc/pull/2092) — Fix schemas race condition
+> - [#2086](https://github.com/AlexxIT/go2rtc/pull/2086) — Fix YAML merge functionality
+> - [#2143](https://github.com/AlexxIT/go2rtc/pull/2143) — WebP native (pure-go) implementation
+> - [#2130](https://github.com/AlexxIT/go2rtc/pull/2130) — HomeKit Secure Video
+> - [#2160](https://github.com/AlexxIT/go2rtc/pull/2160) — WebCodecs streaming support (@seydx)
+> - [#2174](https://github.com/AlexxIT/go2rtc/pull/2174) - Socket leaks in go2rtc - creality k2plus issue
+> - [#2223](https://github.com/AlexxIT/go2rtc/pull/2223) — Fix CORS preflight requests support
+---
 
-For example, you want to watch stream from [Dahua IPC-K42](https://www.dahuasecurity.com/fr/products/All-Products/Network-Cameras/Wireless-Series/Wi-Fi-Series/4MP/IPC-K42) camera in your browser.
+## Screenshots
 
-- this camera support codecs **H264, H265** for send video, and you select `H264` in camera settings
-- this camera support codecs **AAC, PCMU, PCMA** for send audio (from mic), and you select `AAC/16000` in camera settings
-- this camera support codecs **AAC, PCMU, PCMA** for receive audio (to speaker), you don't need to select them
-- your browser support codecs **H264, VP8, VP9, AV1** for receive video, you don't need to select them
-- your browser support codecs **OPUS, PCMU, PCMA** for send and receive audio, you don't need to select them
-- you can't get camera audio directly, because their audio codecs doesn't match with your browser codecs 
-   - so you decide to use transcoding via FFmpeg and add this setting to config YAML file
-   - you have chosen `OPUS/48000/2` codec, because it is higher quality than the PCMU/8000 or PCMA/8000
-- now you have stream with two sources - **RTSP and FFmpeg**
+| Streams Dashboard | Add Stream |
+|:-:|:-:|
+| ![Streams](website/images/screenshots/01-streams-dashboard-dark.png) | ![Add Stream](website/images/screenshots/02-add-stream-dark.png) |
+| Stream list with status, actions, and system monitoring | Quick setup for dozens of protocols and integrations |
 
-`go2rtc` automatically match codecs for you browser and all your stream sources. This called **multi-source two-way codecs negotiation**. And this is one of the main features of this app.
+| Stream Info | Stream Links |
+|:-:|:-:|
+| ![Info](website/images/screenshots/03-stream-info-dark.png) | ![Links](website/images/screenshots/04-stream-links-dark.png) |
+| Producers and consumers details | Direct URLs for all supported formats |
 
-**PS.** You can select PCMU or PCMA codec in camera setting and don't use transcoding at all. Or you can select AAC codec for main stream and PCMU codec for second stream and add both RTSP to YAML config, this also will work fine.
+| Config Editor | Logs |
+|:-:|:-:|
+| ![Config](website/images/screenshots/05-config-editor-dark.png) | ![Logs](website/images/screenshots/06-logs-dark.png) |
+| YAML configuration with syntax highlighting | Real-time log viewer with auto-update |
+
+<details>
+<summary>Light theme</summary>
+
+| Streams Dashboard | Add Stream |
+|:-:|:-:|
+| ![Streams](website/images/screenshots/01-streams-dashboard-light.png) | ![Add Stream](website/images/screenshots/02-add-stream-light.png) |
+
+| Stream Info | Stream Links |
+|:-:|:-:|
+| ![Info](website/images/screenshots/03-stream-info-light.png) | ![Links](website/images/screenshots/04-stream-links-light.png) |
+
+| Config Editor | Logs |
+|:-:|:-:|
+| ![Config](website/images/screenshots/05-config-editor-light.png) | ![Logs](website/images/screenshots/06-logs-light.png) |
+
+</details>
+
+---
+
+- zero-dependency [small app](#go2rtc-binary) for all OS (Windows, macOS, Linux, FreeBSD)
+- zero-delay for many [supported protocols](#codecs-madness) (lowest possible streaming latency)
+- [streaming input](#streaming-input) from dozens formats and protocols
+- [streaming output](#streaming-output) in all popular formats
+- [streaming ingest](#streaming-ingest) in a number of popular formats
+- [publish](#publish-stream) any source to popular streaming services (YouTube, Telegram)
+- on-the-fly transcoding only if necessary via [FFmpeg](internal/ffmpeg/README.md)
+- [two-way audio](#two-way-audio) support for many formats
+- [streaming audio](#stream-to-camera) to all cameras with [two-way audio](#two-way-audio) support
+- mixing tracks from different sources to single stream
+- [auto-match](www/README.md#javascript-api) client-supported streaming formats and codecs
+- [streaming stats](#streaming-stats) for all active connections
+- can be [integrated to any project](#projects-using-go2rtc) or be used as [standalone app](#go2rtc-binary)
+
+#### Inspired by
+
+- series of streaming projects from [@deepch](https://github.com/deepch)
+- [webrtc](https://github.com/pion/webrtc) go library and whole [@pion](https://github.com/pion) team
+- [rtsp-simple-server](https://github.com/aler9/rtsp-simple-server) idea from [@aler9](https://github.com/aler9)
+- [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)
+
+<br>
+<details>
+<summary><b>Table of Contents</b></summary>
+
+- [Installation](#installation)
+  - [go2rtc: Binary](#go2rtc-binary)
+  - [go2rtc: Docker](#go2rtc-docker)
+  - [go2rtc: Home Assistant add-on](#go2rtc-home-assistant-add-on)
+  - [go2rtc: Home Assistant Integration](#go2rtc-home-assistant-integration)
+  - [go2rtc: Master version](#go2rtc-master-version)
+- [Configuration](#configuration)
+- [Features](#features)
+  - [Streaming input](#streaming-input)
+  - [Streaming output](#streaming-output)
+  - [Streaming ingest](#streaming-ingest)
+  - [Two-way audio](#two-way-audio)
+  - [Stream to camera](#stream-to-camera)
+  - [Publish stream](#publish-stream)
+  - [Preload stream](#preload-stream)
+  - [Streaming stats](#streaming-stats)
+- [Codecs](#codecs)
+  - [Codecs filters](#codecs-filters)
+  - [Codecs madness](#codecs-madness)
+  - [Built-in transcoding](#built-in-transcoding)
+  - [Codecs negotiation](#codecs-negotiation)
+- [Security](#security)
+- [Projects using go2rtc](#projects-using-go2rtc)
+- [Camera experience](#camera-experience)
+- [Tips](#tips)
+
+</details>
+
+## Installation
+
+1. Download [binary](#go2rtc-binary) or use [Docker](#go2rtc-docker) or Home Assistant [add-on](#go2rtc-home-assistant-add-on) or [integration](#go2rtc-home-assistant-integration)
+2. Open web interface: `http://localhost:1984/`
+3. Add [streams](#streaming-input) to [config](#configuration)
+
+**Developers:** integrate [HTTP API](internal/api/README.md) into your smart home platform.
+
+### go2rtc: Binary
+
+Download dev binary for your OS from [latest dev build](https://nightly.link/AlexxIT/go2rtc/workflows/build/dev):
+
+| name                                                                                                          | description                                                                                                                               |
+|---------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------|
+| [go2rtc_win64.zip](https://nightly.link/AlexxIT/go2rtc/workflows/build/dev/go2rtc_win64.zip)                  | Windows 10+ 64-bit                                                                                                                        |
+| [go2rtc_win32.zip](https://nightly.link/AlexxIT/go2rtc/workflows/build/dev/go2rtc_win32.zip)                  | Windows 10+ 32-bit                                                                                                                        |
+| [go2rtc_win_arm64.zip](https://nightly.link/AlexxIT/go2rtc/workflows/build/dev/go2rtc_win_arm64.zip)          | Windows ARM 64-bit                                                                                                                        |
+| [go2rtc_linux_amd64.zip](https://nightly.link/AlexxIT/go2rtc/workflows/build/dev/go2rtc_linux_amd64.zip)      | Linux 64-bit                                                                                                                              |
+| [go2rtc_linux_i386.zip](https://nightly.link/AlexxIT/go2rtc/workflows/build/dev/go2rtc_linux_i386.zip)        | Linux 32-bit                                                                                                                              |
+| [go2rtc_linux_arm64.zip](https://nightly.link/AlexxIT/go2rtc/workflows/build/dev/go2rtc_linux_arm64.zip)      | Linux ARM 64-bit (ex. Raspberry 64-bit OS)                                                                                                |
+| [go2rtc_linux_arm.zip](https://nightly.link/AlexxIT/go2rtc/workflows/build/dev/go2rtc_linux_arm.zip)          | Linux ARM 32-bit (ex. Raspberry 32-bit OS)                                                                                                |
+| [go2rtc_linux_armv6.zip](https://nightly.link/AlexxIT/go2rtc/workflows/build/dev/go2rtc_linux_armv6.zip)      | Linux ARMv6 (for old Raspberry 1 and Zero)                                                                                                |
+| [go2rtc_linux_mipsel.zip](https://nightly.link/AlexxIT/go2rtc/workflows/build/dev/go2rtc_linux_mipsel.zip)    | Linux MIPS (ex. [Xiaomi Gateway 3](https://github.com/AlexxIT/XiaomiGateway3), [Wyze cameras](https://github.com/gtxaspec/wz_mini_hacks)) |
+| [go2rtc_mac_amd64.zip](https://nightly.link/AlexxIT/go2rtc/workflows/build/dev/go2rtc_mac_amd64.zip)          | macOS 11+ Intel 64-bit                                                                                                                    |
+| [go2rtc_mac_arm64.zip](https://nightly.link/AlexxIT/go2rtc/workflows/build/dev/go2rtc_mac_arm64.zip)          | macOS ARM 64-bit                                                                                                                          |
+| [go2rtc_freebsd_amd64.zip](https://nightly.link/AlexxIT/go2rtc/workflows/build/dev/go2rtc_freebsd_amd64.zip)  | FreeBSD 64-bit                                                                                                                            |
+| [go2rtc_freebsd_arm64.zip](https://nightly.link/AlexxIT/go2rtc/workflows/build/dev/go2rtc_freebsd_arm64.zip)  | FreeBSD ARM 64-bit                                                                                                                        |
+
+Don't forget to fix the rights `chmod +x go2rtc_xxx_xxx` on Linux and Mac.
+
+PS. The application is compiled with the latest versions of the Go language for maximum speed and security. Therefore, the [minimum OS versions](https://go.dev/wiki/MinimumRequirements) depend on the Go language.
+
+### go2rtc: Docker
+
+The Docker containers [`alexxit/go2rtc`](https://hub.docker.com/r/alexxit/go2rtc) and [`ghcr.io/alexxit/go2rtc`](https://github.com/AlexxIT/go2rtc/pkgs/container/go2rtc) support multiple architectures including `386`, `amd64`, `arm/v6`, `arm/v7` and `arm64`.
+These containers offer the same functionality as the Home Assistant [add-on](#go2rtc-home-assistant-add-on) but are designed to operate independently of Home Assistant.
+It comes preinstalled with [FFmpeg](internal/ffmpeg/README.md) and [Python](internal/echo/README.md).
+
+### go2rtc: Home Assistant add-on
+
+[![Open your Home Assistant instance and show the add add-on repository dialog with a specific repository URL pre-filled.](https://my.home-assistant.io/badges/supervisor_add_addon_repository.svg)](https://my.home-assistant.io/redirect/supervisor_add_addon_repository/?repository_url=https%3A%2F%2Fgithub.com%2FAlexxIT%2Fhassio-addons)
+
+1. Settings > Add-ons > Plus > Repositories > Add
+   ```
+   https://github.com/AlexxIT/hassio-addons
+   ```
+2. go2rtc > Install > Start
+
+### go2rtc: Home Assistant Integration
+
+[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: Master version
+
+Latest, but maybe unstable version:
+
+- Binary: [latest master build](https://nightly.link/AlexxIT/go2rtc/workflows/build/master)
+- Docker: `ghcr.io/AlexxIT/go2rtc:dev` or `ghcr.io/AlexxIT/go2rtc:dev-hardware` versions
+- Home Assistant add-on: `go2rtc master` or `go2rtc master hardware` versions
+
+## Configuration
+
+This is the `go2rtc.yaml` file in [YAML-format](https://en.wikipedia.org/wiki/YAML).
+The configuration can be changed in the [WebUI](www/README.md) at `http://localhost:1984`.
+The editor provides syntax highlighting and checking.
+
+![go2rtc webui config](website/images/screenshots/05-config-editor-dark.png)
+
+The simplest config looks like this:
+
+```yaml
+streams:
+  hall-camera: rtsp://admin:password@192.168.1.123/cam/realmonitor?channel=1&subtype=0
+```
+
+- 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
+
+More information can be [found here](internal/app/README.md).
+
+## Features
+
+A summary table of all modules and features can be found [here](internal/README.md).
+
+**Core modules**
+
+- [`app`](internal/app/README.md) - Reading [configs](internal/app/README.md) and setting up [logs](internal/app/README.md#log).
+- [`api`](internal/api/README.md) - Handle [HTTP](internal/api/README.md) and [WebSocket](internal/api/ws/README.md) API.
+- [`streams`](internal/streams/README.md) - Handle a list of streams.
+
+### Streaming input
+
+#### public protocols
+
+- [`mpjpeg`](internal/mjpeg/README.md#mjpeg-client) - The legacy but still used [MJPEG](https://en.wikipedia.org/wiki/Motion_JPEG) protocol for real-time media transmission.
+- [`onvif`](internal/onvif/README.md#onvif-client) - A popular [ONVIF](https://en.wikipedia.org/wiki/ONVIF) protocol for receiving media in RTSP format.
+- [`rtmp`](internal/rtmp/README.md#rtmp-client) - The legacy but still used [RTMP](https://en.wikipedia.org/wiki/Real-Time_Messaging_Protocol) protocol for real-time media transmission.
+- [`rtsp`](internal/rtsp/README.md#rtsp-client) - The most common [RTSP](https://en.wikipedia.org/wiki/Real-Time_Streaming_Protocol) protocol for real-time media transmission.
+- [`webrtc`](internal/webrtc/README.md#webrtc-client) - [WebRTC](https://en.wikipedia.org/wiki/WebRTC) web-compatible protocol for real-time media transmission.
+- [`yuv4mpegpipe`](internal/http/README.md#tcp) - Raw [YUV](https://en.wikipedia.org/wiki/Y%E2%80%B2UV) frame stream with [YUV4MPEG](https://manned.org/yuv4mpeg) header.
+
+#### private protocols
+
+- [`bubble`](internal/bubble/README.md) - Some NVR from [dvr163.com](http://help.dvr163.com/) and [eseecloud.com](http://www.eseecloud.com/).
+- [`doorbird`](internal/doorbird/README.md) - [Doorbird](https://www.doorbird.com/) devices with two-way audio.
+- [`dvrip`](internal/dvrip/README.md) - DVR-IP NVR, NetSurveillance, Sofia protocol (XMeye SDK).
+- [`eseecloud`](internal/eseecloud/README.md) - Some NVR from [dvr163.com](http://help.dvr163.com/) and [eseecloud.com](http://www.eseecloud.com/).
+- [`gopro`](internal/gopro/README.md) - [GoPro](https://gopro.com/) cameras, connected via USB or Wi-Fi.
+- [`hass`](internal/hass/README.md) - Import cameras from [Home Assistant](https://www.home-assistant.io/) config files.
+- [`homekit`](internal/homekit/README.md) - Cameras with [Apple HomeKit](https://www.apple.com/home-app/accessories/) protocol.
+- [`isapi`](internal/isapi/README.md) - Two-way audio for [Hikvision ISAPI](https://tpp.hikvision.com/download/ISAPI_OTAP) protocol.
+- [`kasa`](internal/kasa/README.md) - [TP-Link Kasa](https://www.kasasmart.com/) cameras.
+- [`multitrans`](internal/multitrans/README.md) - Two-way audio for Chinese version of [TP-Link](https://www.tp-link.com.cn/) cameras.
+- [`nest`](internal/nest/README.md) - [Google Nest](https://developers.google.com/nest/device-access/supported-devices) cameras through user-unfriendly and paid APIs.
+- [`ring`](internal/ring/README.md) - Ring cameras with two-way audio support.
+- [`roborock`](internal/roborock/README.md) - [Roborock](https://roborock.com/) vacuums with cameras with two-way audio support. 
+- [`tapo`](internal/tapo/README.md) - [TP-Link Tapo](https://www.tapo.com/) cameras with two-way audio support.
+- [`vigi`](internal/tapo/README.md#tp-link-vigi) - TP-Link Vigi cameras.
+- [`tuya`](internal/tuya/README.md) - [Tuya](https://www.tuya.com/) ecosystem cameras with two-way audio support.
+- [`webtorrent`](internal/webtorrent/README.md) - Stream from another go2rtc via [WebTorrent](https://en.wikipedia.org/wiki/WebTorrent) protocol.
+- [`wyze`](internal/wyze/README.md) - [Wyze](https://wyze.com/) cameras using native P2P protocol
+- [`xiaomi`](internal/xiaomi/README.md) - [Xiaomi Mi Home](https://home.mi.com/) ecosystem cameras with two-way audio support.
+
+#### devices
+
+- [`alsa`](internal/alsa/README.md) - A [framework](https://en.wikipedia.org/wiki/Advanced_Linux_Sound_Architecture) for receiving audio from devices on Linux OS.
+- [`v4l2`](internal/v4l2/README.md) - A [framework](https://en.wikipedia.org/wiki/Video4Linux) for receiving video from devices on Linux OS.
+
+#### files
+
+- [`adts`](internal/http/README.md#tcp) - Audio stream in [AAC](https://en.wikipedia.org/wiki/Advanced_Audio_Coding) codec with Audio Data Transport Stream headers.
+- [`flv`](internal/http/README.md#tcp) - The legacy but still used [Flash Video](https://en.wikipedia.org/wiki/Flash_Video) format.
+- [`h264`](internal/http/README.md#tcp) - AVC/H.264 bitstream.
+- [`hevc`](internal/http/README.md#tcp) - HEVC/H.265 bitstream.
+- [`hls`](internal/http/README.md) - A popular [HTTP Live Streaming](https://en.wikipedia.org/wiki/HTTP_Live_Streaming) format.
+- [`mjpeg`](internal/http/README.md#tcp) - A continuous sequence of JPEG frames (without HTTP headers).
+- [`mpegts`](internal/http/README.md#tcp) - The legacy [MPEG transport stream](https://en.wikipedia.org/wiki/MPEG_transport_stream) format.
+- [`wav`](internal/http/README.md#tcp) - Audio stream in [Waveform Audio File](https://en.wikipedia.org/wiki/WAV) format.
+
+#### scripts
+
+- [`echo`](internal/echo/README.md) - If the source has a dynamic link, you can use a bash or python script to get it.
+- [`exec`](internal/exec/README.md) - You can run an external application (`ffmpeg`, `gstreamer`, `rpicam`, etc.) and receive a media stream from it.
+- [`expr`](internal/expr/README.md) - If the source has a dynamic link, you can use [Expr](https://github.com/expr-lang/expr) language to get it.
+- [`ffmpeg`](internal/ffmpeg/README.md) - Use [FFmpeg](https://ffmpeg.org/) as a stream source. Hardware-accelerated transcoding and streaming from USB devices are supported.
+
+#### webrtc
+
+- [`creality`](internal/webrtc/README.md#creality) - [Creality](https://www.creality.com/) 3D printer cameras.
+- [`kinesis`](internal/webrtc/README.md#kinesis) - [Amazon Kinesis](https://aws.amazon.com/kinesis/video-streams/) video streams.
+- [`openipc`](internal/webrtc/README.md#openipc) - Cameras on open-source [OpenIPC](https://openipc.org/) firmware.
+- [`switchbot`](internal/webrtc/README.md#switchbot) - [SwitchBot](https://us.switch-bot.com/) cameras.
+- [`whep`](internal/webrtc/README.md#whep) - [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.
+- [`wyze`](internal/webrtc/README.md#wyze) - Legacy method to connect to [Wyze](https://www.wyze.com/) cameras via [docker-wyze-bridge](https://github.com/mrlt8/docker-wyze-bridge).
+
+### Streaming output
+
+- [`adts`](internal/mpeg/README.md) - Output stream in ADTS format with [AAC](https://en.wikipedia.org/wiki/Advanced_Audio_Coding) audio.
+- [`ascii`](internal/mjpeg/README.md#ascii) - Just for fun stream as [ASCII to Terminal](https://www.youtube.com/watch?v=sHj_3h_sX7M).
+- [`flv`](internal/rtmp/README.md) - Output stream in [Flash Video](https://en.wikipedia.org/wiki/Flash_Video) format.
+- [`hls`](internal/hls/README.md) - Output stream in [HTTP Live Streaming](https://en.wikipedia.org/wiki/HTTP_Live_Streaming) format.
+- [`homekit`](internal/homekit/README.md#homekit-server) - Output stream to [Apple Home](https://www.apple.com/home-app/) using [HomeKit](https://en.wikipedia.org/wiki/Apple_Home) protocol.
+- [`jpeg`](internal/mjpeg/README.md#jpeg) - Output snapshots in [JPEG](https://en.wikipedia.org/wiki/JPEG) format.
+- [`mpjpeg`](internal/mjpeg/README.md#mpjpeg) - Output a stream in [MJPEG](https://en.wikipedia.org/wiki/Motion_JPEG) format.
+- [`mp4`](internal/mp4/README.md) - Output as [MP4 stream](https://en.wikipedia.org/wiki/Progressive_download) or [Media Source Extensions](https://developer.mozilla.org/en-US/docs/Web/API/Media_Source_Extensions_API) (MSE) compatible format.
+- [`mpegts`](internal/mpeg/README.md) - Output stream in [MPEG transport stream](https://en.wikipedia.org/wiki/MPEG_transport_stream) format.
+- [`onvif`](internal/onvif/README.md#onvif-server) - Output stream using [ONVIF](https://en.wikipedia.org/wiki/ONVIF) protocol.
+- [`rtmp`](internal/rtmp/README.md#rtmp-server) - Output stream using [Real-Time Messaging](https://en.wikipedia.org/wiki/Real-Time_Messaging_Protocol) protocol.
+- [`rtsp`](internal/rtsp/README.md#rtsp-server) - Output stream using [Real-Time Streaming](https://en.wikipedia.org/wiki/Real-Time_Streaming_Protocol) protocol.
+- [`webcodecs`](internal/webcodecs/README.md) - Output stream using [WebCodecs API](https://developer.mozilla.org/en-US/docs/Web/API/WebCodecs_API) for browser-native decoding.
+- [`webrtc`](internal/webrtc/README.md#webrtc-server) - Output stream using [Web Real-Time Communication](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API) API.
+- [`webtorrent`](internal/webtorrent/README.md#webtorrent-server) - Output stream using [WebTorrent](https://en.wikipedia.org/wiki/WebTorrent) protocol.
+- [`yuv4mpegpipe`](internal/mjpeg/README.md#yuv4mpegpipe) - Output in raw [YUV](https://en.wikipedia.org/wiki/Y%E2%80%B2UV) frame stream with [YUV4MPEG](https://manned.org/yuv4mpeg) header.
+
+### Streaming ingest
+
+Supported for: 
+[`flv`](internal/rtmp/README.md#flv-server), 
+[`mjpeg`](internal/mjpeg/README.md#streaming-ingest), 
+[`mpegts`](internal/mpeg/README.md#streaming-ingest), 
+[`rtmp`](internal/rtmp/README.md#rtmp-server), 
+[`rtsp`](internal/rtsp/README.md#streaming-ingest), 
+[`webrtc`](internal/webrtc/README.md#streaming-ingest).
+
+This is a feature when go2rtc expects to receive an incoming stream from an external application. The stream transmission is started and stopped by an external application.
+
+- You can push data only to an existing stream (create a stream with empty source in config).
+- You can push multiple incoming sources to the same stream.
+- You can push data to a non-empty stream, so it will have additional codecs inside.
+
+### Two-way audio
+
+Supported for:
+[`doorbird`](internal/doorbird/README.md), 
+[`dvrip`](internal/dvrip/README.md), 
+[`exec`](internal/exec/README.md), 
+[`isapi`](internal/isapi/README.md), 
+[`multitrans`](internal/multitrans/README.md), 
+[`ring`](internal/ring/README.md), 
+[`roborock`](internal/roborock/README.md), 
+[`rtsp`](internal/rtsp/README.md#two-way-audio), 
+[`tapo`](internal/tapo/README.md), 
+[`tuya`](internal/tuya/README.md), 
+[`webrtc`](internal/webrtc/README.md), 
+[`wyze`](internal/wyze/README.md), 
+[`xiaomi`](internal/xiaomi/README.md).
+
+Two-way audio can be used in browser with [WebRTC](internal/webrtc/README.md) 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)).
+
+### Stream to camera
+
+You can play audio files or live streams on any camera with [two-way audio](#two-way-audio) support.
+
+[read more](internal/streams/README.md#stream-to-camera)
+
+### Publish stream
+
+You can publish any stream to streaming services (YouTube, Telegram, etc.) via RTMP/RTMPS.
+
+[read more](internal/streams/README.md#publish-stream)
+
+### Preload stream
+
+You can preload any stream on go2rtc start. This is useful for cameras that take a long time to start up.
+
+[read more](internal/streams/README.md#preload-stream)
+
+### Streaming stats
+
+[WebUI](www/README.md) provides detailed information about all active connections, including IP-addresses, formats, protocols, number of packets and bytes transferred. 
+Via the [HTTP API](internal/api/README.md) in [`json`](https://en.wikipedia.org/wiki/JSON) or [`dot`](https://en.wikipedia.org/wiki/DOT_(graph_description_language)) format on an interactive connection map.
+
+![go2rtc webui net](website/images/screenshots/05-network-topology-dark.png)
+
+## Codecs
+
+If you have questions about why video or audio is not displayed, you need to read the following sections.
+
+| Name                         | FFmpeg   | RTSP          | Aliases     |
+|------------------------------|----------|---------------|-------------|
+| Advanced Audio Coding        | `aac`    | MPEG4-GENERIC |             |
+| Advanced Video Coding        | `h264`   | H264          | AVC, H.264  |
+| G.711 PCM (A-law)            | `alaw`   | PCMA          | G711A       |
+| G.711 PCM (µ-law)            | `mulaw`  | PCMU          | G711u       |
+| High Efficiency Video Coding | `hevc`   | H265          | HEVC, H.265 |
+| Motion JPEG                  | `mpjpeg` | JPEG          |             |
+| MPEG-1 Audio Layer III       | `mp3`    | MPA           |             |
+| Opus Codec                   | `opus`   | OPUS          |             |
+| PCM signed 16-bit big-endian | `s16be`  | L16           |             |
+
+### Codecs filters
+
+go2rtc can automatically detect which codecs your device supports for [WebRTC](internal/webrtc/README.md) and [MSE](internal/mp4/README.md) technologies.
+
+But it cannot be done for [RTSP](internal/rtsp/README.md), [HTTP progressive streaming](internal/mp4/README.md), [HLS](internal/hls/README.md) technologies. 
+You can manually add a codec filter when you create a link to a stream. 
+The filters work the same for all three technologies. 
+Filters do not create a new codec, they only select the suitable codec from existing sources. 
+You can add new codecs to the stream using the [FFmpeg transcoding](internal/ffmpeg/README.md).
+
+Without filters:
+
+- RTSP will provide only the first video and only the first audio (any codec)
+- MP4 will include only compatible codecs (H264, H265, AAC)
+- HLS will output in the legacy TS format (H264 without audio)
+
+Some examples:
+
+- `rtsp://192.168.1.123:8554/camera1?mp4` - useful for recording as MP4 files (e.g. Home Assistant or Frigate)
+- `rtsp://192.168.1.123:8554/camera1?video=h264,h265&audio=aac` - full version of the filter above
+- `rtsp://192.168.1.123:8554/camera1?video=h264&audio=aac&audio=opus` - H264 video codec and two separate audio tracks
+- `rtsp://192.168.1.123:8554/camera1?video&audio=all` - any video codec and all audio codecs as separate tracks
+- `http://192.168.1.123:1984/api/stream.m3u8?src=camera1&mp4` - HLS stream with MP4 compatible codecs (HLS/fMP4)
+- `http://192.168.1.123:1984/api/stream.m3u8?src=camera1&mp4=flac` - HLS stream with PCMA/PCMU/PCM audio support (HLS/fMP4), won't work on old devices
+- `http://192.168.1.123:1984/api/stream.mp4?src=camera1&mp4=flac` - MP4 file with PCMA/PCMU/PCM audio support, won't work on old devices (ex. iOS 12)
+- `http://192.168.1.123:1984/api/stream.mp4?src=camera1&mp4=all` - MP4 file with non-standard audio codecs, won't work on some players
+
+### Codecs madness
+
+`AVC/H.264` video can be played almost anywhere. But `HEVC/H.265` has many limitations in supporting different devices and browsers.
+
+| Device                                                             | WebRTC                                  | WebCodecs                                       | MSE                                     | HTTP*                                        | HLS                         |
+|--------------------------------------------------------------------|-----------------------------------------|-------------------------------------------------|-----------------------------------------|----------------------------------------------|-----------------------------|
+| *latency*                                                          | best                                    | best                                            | medium                                  | bad                                          | bad                         |
+| Desktop Chrome 136+ <br/> Desktop Edge <br/> Android Chrome 136+   | H264, H265* <br/> PCMU, PCMA <br/> OPUS | H264, H265 <br/> AAC, OPUS <br/> PCMA, PCMU     | 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, H265 <br/> AAC, OPUS <br/> PCMA, PCMU     | 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, OPUS <br/> PCMA, PCMU     | H264, H265 <br/> AAC, FLAC*             | **no!**                                      | H264, H265 <br/> AAC, FLAC* |
+| iPhone Safari 14+                                                  | H264, H265* <br/> PCMU, PCMA <br/> OPUS | H264, H265 <br/> AAC, OPUS <br/> PCMA, PCMU     | **no!**                                 | **no!**                                      | H264, H265 <br/> AAC, FLAC* |
+| macOS [Hass App][1]                                                | no                                      | no                                              | no                                      | no                                           | H264, H265 <br/> AAC, FLAC* |
+
+[1]: https://apps.apple.com/app/home-assistant/id1099568401
+
+- `HTTP*` - HTTP Progressive Streaming, not related to [progressive download](https://en.wikipedia.org/wiki/Progressive_download), because the file has no size and no end
+- `WebRTC H265` - supported in [Chrome 136+](https://developer.chrome.com/release-notes/136), supported in [Safari 18+](https://developer.apple.com/documentation/safari-release-notes/safari-18-release-notes)
+- `MSE iPhone` - supported in [iOS 17.1+](https://webkit.org/blog/14735/webkit-features-in-safari-17-1/)
+
+**Audio**
+
+- go2rtc supports [automatic repackaging](#built-in-transcoding) of `PCMA/PCMU/PCM` codecs into `FLAC` for MSE/MP4/HLS so they'll work almost anywhere
+- **WebRTC** audio codecs: `PCMU/8000`, `PCMA/8000`, `OPUS/48000/2`
+- `OPUS` and `MP3` inside **MP4** are part of the standard, but some players do not support them anyway (especially Apple)
+
+**Apple devices**
+
+- all Apple devices don't support HTTP progressive streaming
+- old iPhone firmwares don't support MSE technology because it competes with the HTTP Live Streaming (HLS) technology, invented by Apple
+- HLS is the worst technology for **live** streaming, it still exists only because of iPhones
+
+### Built-in transcoding
+
+There are no plans to embed complex transcoding algorithms inside go2rtc. 
+[FFmpeg source](internal/ffmpeg/README.md) does a great job with this. 
+Including [hardware acceleration](https://github.com/AlexxIT/go2rtc/wiki/Hardware-acceleration) support.
+
+But go2rtc has some simple algorithms. They are turned on automatically; you do not need to set them up additionally.
+
+**PCM for MSE/MP4/HLS**
+
+Go2rtc can pack `PCMA`, `PCMU` and `PCM` codecs into an MP4 container so that they work in all browsers and all built-in players on modern devices. Including Apple QuickTime:
+
+```text
+PCMA/PCMU => PCM => FLAC => MSE/MP4/HLS
+```
+
+**Resample PCMA/PCMU for WebRTC**
+
+By default WebRTC supports only `PCMA/8000` and `PCMU/8000`. But go2rtc can automatically resample PCMA and PCMU codecs with a different sample rate. Also, go2rtc can transcode `PCM` codec to `PCMA/8000`, so WebRTC can play it:
+
+```text
+PCM/xxx => PCMA/8000 => WebRTC
+PCMA/xxx => PCMA/8000 => WebRTC
+PCMU/xxx => PCMU/8000 => WebRTC
+```
+
+**Important**
+
+- FLAC codec not supported in an RTSP stream. If you are using Frigate or Home Assistant for recording MP4 files with PCMA/PCMU/PCM audio, you should set up transcoding to the AAC codec.
+- PCMA and PCMU are VERY low-quality codecs. They support only 256! different sounds. Use them only when you have no other options.
+
+### Codecs negotiation
+
+For example, you want to watch an RTSP stream from a [Dahua IPC-K42](https://www.dahuasecurity.com/fr/products/All-Products/Network-Cameras/Wireless-Series/Wi-Fi-Series/4MP/IPC-K42) camera in your Chrome browser.
+
+- this camera supports two-way audio standard **ONVIF Profile T**
+- this camera supports codecs **H264, H265** for sending video, and you select `H264` in camera settings
+- this camera supports codecs **AAC, PCMU, PCMA** for sending audio (from mic), and you select `AAC/16000` in camera settings
+- this camera supports codecs **AAC, PCMU, PCMA** for receiving audio (to speaker), you don't need to select them
+- your browser supports codecs **H264, VP8, VP9, AV1** for receiving video, you don't need to select them
+- your browser supports codecs **OPUS, PCMU, PCMA** for sending and receiving audio, you don't need to select them
+- you can't get the camera audio directly because its audio codecs don't match your browser's codecs
+    - so you decide to use transcoding via FFmpeg and add this setting to the config YAML file
+    - you have chosen `OPUS/48000/2` codec, because it is higher quality than the `PCMU/8000` or `PCMA/8000`
+
+Now you have a stream with two sources - **RTSP and FFmpeg**:
 
 ```yaml
 streams:
   dahua:
     - rtsp://admin:password@192.168.1.123/cam/realmonitor?channel=1&subtype=0&unicast=true&proto=Onvif
-    - ffmpeg:rtsp://admin:password@192.168.1.123/cam/realmonitor?channel=1&subtype=0&unicast=true&proto=Onvif#audio=opus
+    - ffmpeg:rtsp://admin:password@192.168.1.123/cam/realmonitor?channel=1&subtype=0#audio=opus
 ```
 
-![](codecs.svg)
+**go2rtc** automatically matches codecs for your browser across all of your stream sources. This is called **multi-source two-way codec negotiation**, and it's one of the main features of this app.
 
-## Configuration
+**PS.** You can select `PCMU` or `PCMA` codec in camera settings and not use transcoding at all. Or you can select `AAC` codec for main stream and `PCMU` codec for second stream and add both RTSP to YAML config, this also will work fine.
 
-Create file `go2rtc.yaml` next to the app. Modules:
+## Security
 
-- [Streams](#streams)
+> [!IMPORTANT]
+> If an attacker gains access to the API, you are in danger. Through the API, an attacker can use insecure sources such as echo and exec. And get full access to your server.
 
-### Streams
-
-**go2rtc** support different stream source types. You can setup only one link as stream source or multiple.
-
-- [RTSP/RTSPS](#rtsp-source) - most cameras on market
-- [RTMP](#rtmp-source)
-- [FFmpeg/Exec](#ffmpeg-source) - FFmpeg integration
-- [Hass](#hass-source) - Home Assistant integration
-
-#### RTSP source
-
-- Support **RTSP and RTSPS** links with multiple video and audio tracks
-- Support **2 way audio** ONLY for [ONVIF Profile T](https://www.onvif.org/specs/stream/ONVIF-Streaming-Spec.pdf) cameras (back channel connection)
-
-**Attention:** proprietary 2 way audio standards are not supported!
+For maximum (paranoid) security, go2rtc has special settings:
 
 ```yaml
-streams:
-  rtsp_camera: rtsp://rtsp:12345678@192.168.1.123:554/av_stream/ch0
+app:
+  # use only allowed modules
+  modules: [api, rtsp, webrtc, exec, ffmpeg, mjpeg]
+
+api:
+  # use only allowed API paths
+  allow_paths: [/api, /api/streams, /api/webrtc, /api/frame.jpeg]
+  # enable auth for localhost (used together with username and password)
+  local_auth: true
+  # disable write actions in WebUI/API
+  read_only: true
+
+exec:
+  # use only allowed exec paths
+  allow_paths: [ffmpeg]
 ```
 
-If your camera support 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:
+By default, `go2rtc` starts the Web interface on port `1984` and RTSP on port `8554`, as well as uses port `8555` for WebRTC connections. The three ports are accessible from your local network. So anyone on your local network can watch video from your cameras without authorization. The same rule applies to the Home Assistant add-on.
 
-**Attention:** Dahua cameras has different capabilities for different RTSP links. For example, it has support multiple codecs for two way audio with `&proto=Onvif` in link and only one coded without it.
-
-```yaml
-streams:
-  onvif_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
-```
-
-#### RTMP source
-
-You can get stream from RTMP server, for example [Frigate](https://docs.frigate.video/configuration/rtmp). Support ONLY `H264` video codec without audio.
-
-```yaml
-streams:
-  rtmp_stream: rtmp://192.168.1.123/live/camera1
-```
-
-#### FFmpeg source
-
-You can get any stream or file or device via FFmpeg and push it to go2rtc via RTSP protocol.
-
-Format: `ffmpeg:{input}#{params}`. Examples:
-
-```yaml
-streams:
-  # [FILE] all tracks will be copied without transcoding codecs
-  file1: ffmpeg:~/media/BigBuckBunny.mp4
-
-  # [FILE] video will be transcoded to H264, audio will be skipped
-  file2: ffmpeg:~/media/BigBuckBunny.mp4#video=h264
-
-  # [FILE] video will be copied, audio will be transcoded to pcmu
-  file3: ffmpeg:~/media/BigBuckBunny.mp4#video=copy&audio=pcmu
-
-  # [HLS] video will be copied, audio will be skipped
-  hls: ffmpeg:https://devstreaming-cdn.apple.com/videos/streaming/examples/bipbop_16x9/gear5/prog_index.m3u8#video=copy
-
-  # [MJPEG] video will be transcoded to H264
-  mjpeg: ffmpeg:http://185.97.122.128/cgi-bin/faststream.jpg?stream=half&fps=15#video=h264
-
-  # [RTSP] video and audio will be copied
-  rtsp: ffmpeg:rtsp://rtsp:12345678@192.168.1.123:554/av_stream/ch0#video=copy&audio=copy
-```
-
-All trascoding formats has built-in templates. But you can override them via YAML config:
-
-```yaml
-ffmpeg:
-  bin: ffmpeg                                        # path to ffmpeg binary
-  link: -hide_banner -i {input}                      # if input is link
-  file: -hide_banner -re -stream_loop -1 -i {input}  # if input not link
-  rtsp: -hide_banner -fflags nobuffer -flags low_delay -rtsp_transport tcp -i {input}  # if input is RTSP link
-  output: -rtsp_transport tcp -f rtsp {output}  # output
-
-  h264:       "-codec:v libx264 -g 30 -preset superfast -tune zerolatency -profile main -level 4.1"
-  h264/ultra: "-codec:v libx264 -g 30 -preset ultrafast -tune zerolatency"
-  h264/high:  "-codec:v libx264 -g 30 -preset superfast -tune zerolatency"
-  h265:       "-codec:v libx265 -g 30 -preset ultrafast -tune zerolatency"
-  opus:       "-codec:a libopus -ar 48000 -ac 2"
-  pcmu:       "-codec:a pcm_mulaw -ar 8000 -ac 1"
-  pcmu/16000: "-codec:a pcm_mulaw -ar 16000 -ac 1"
-  pcmu/48000: "-codec:a pcm_mulaw -ar 48000 -ac 1"
-  pcma:       "-codec:a pcm_alaw -ar 8000 -ac 1"
-  pcma/16000: "-codec:a pcm_alaw -ar 16000 -ac 1"
-  pcma/48000: "-codec:a pcm_alaw -ar 48000 -ac 1"
-  aac/16000:  "-codec:a aac -ar 16000 -ac 1"
-```
-
-#### Exec source
-
-FFmpeg source just a shortcut to exec source. You can get any stream or file or device via FFmpeg or GStreamer and push it to go2rtc via RTSP protocol: 
-
-```yaml
-streams:
-  stream1: exec:ffmpeg -hide_banner -re -stream_loop -1 -i ~/media/BigBuckBunny.mp4 -c copy -rtsp_transport tcp -f rtsp {output}
-```
-
-#### Hass source
-
-Support import camera links from [Home Assistant](https://www.home-assistant.io/) config files.
-
-- support ONLY [Generic Camera](https://www.home-assistant.io/integrations/generic/), setup via GUI
-
-```yaml
-hass:
-  config: "~/.homeassistant"
-
-streams:
-  generic_camera: hass:Camera1  # Settings > Integrations > Integration Name
-```
-
-### API server
+This is not a problem if you trust your local network as much as I do. But you can change this behaviour with a `go2rtc.yaml` config:
 
 ```yaml
 api:
-  listen: ":3000"    # HTTP API port
-  base_path: ""      # API prefix for serve on suburl
-  static_dir: "www"  # folder for static files
-```
+  listen: "127.0.0.1:1984" # localhost
 
-### RTSP server
-
-```yaml
 rtsp:
-  listen: ":554"
-```
+  listen: "127.0.0.1:8554" # localhost
 
-### WebRTC server
-
-```yaml
 webrtc:
-  listen: ":8555"  # address of your local server (TCP)
-  candidates:
-    - 216.58.210.174:8555  # if you have static public IP-address
-    - 192.168.1.123:8555   # ip you have problems with UDP in LAN
-    - stun   # if you have dynamic public IP-address (auto discovery via STUN)
-  ice_servers:
-    - urls: [stun:stun.l.google.com:19302]
-    - urls: [turn:123.123.123.123:3478]
-      username: your_user
-      credential: your_pass
+  listen: ":8555" # external TCP/UDP port
 ```
 
-### Ngrok
+- local access to RTSP is not a problem for [FFmpeg](internal/ffmpeg/README.md) integration, because it runs locally on your server
+- local access to API is not a problem for the [Home Assistant add-on](#go2rtc-home-assistant-add-on), because Home Assistant runs locally on the same server, and the add-on web UI is protected with Home Assistant authorization ([Ingress feature](https://www.home-assistant.io/blog/2019/04/15/hassio-ingress/))
+- external access to WebRTC TCP port is not a problem, because it is used only for transmitting encrypted media data
+    - anyway you need to open this port to your local network and to the Internet for WebRTC to work
 
-```yaml
-ngrok:
-  command: ngrok tcp 8555 --authtoken eW91IHNoYWxsIG5vdCBwYXNzCnlvdSBzaGFsbCBub3QgcGFzcw
-```
+If you need web interface protection without the Home Assistant add-on, you need to use a reverse proxy, like [Nginx](https://nginx.org/), [Caddy](https://caddyserver.com/), etc.
 
-or
+PS. Additionally, WebRTC will try to use the 8555 UDP port to 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.
 
-```yaml
-ngrok:
-  command: ngrok start --all --config ngrok.yml
-```
+## Projects using go2rtc
 
-### Log
+- [Home Assistant](https://www.home-assistant.io/) [2024.11+](https://www.home-assistant.io/integrations/go2rtc/) - top open-source smart home project
+- [Frigate](https://frigate.video/) [0.12+](https://docs.frigate.video/guides/configuring_go2rtc/) - open-source NVR built around real-time AI object detection
+- [Advanced Camera Card](https://github.com/dermotduffy/advanced-camera-card) - custom card for Home Assistant
+- [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 controlling Eufy security devices
+- [MMM-go2rtc](https://github.com/Anonym-tsk/MMM-go2rtc) - MagicMirror² module
+- [ring-mqtt](https://github.com/tsightler/ring-mqtt) - Ring-to-MQTT bridge
+- [lightNVR](https://github.com/opensensor/lightNVR)
 
-```yaml
-log:
-  level: info  # default level
-  api: trace
-  exec: debug
-  ngrok: info
-  rtsp: warn
-  streams: error
-  webrtc: fatal
-```
+**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://github.com/community-scripts/ProxmoxVE/)
+- [QNAP](https://www.myqnap.org/product/go2rtc/)
+- [Synology NAS](https://synocommunity.com/package/go2rtc)
+- [Unraid](https://unraid.net/community/apps?q=go2rtc)
+
+## Camera experience
+
+- [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 implementation, many bugs in SDP
+- [Hikvision](https://www.hikvision.com/) - a lot of proprietary streaming technologies
+- [Reolink](https://reolink.com/) - some models have an awful, unusable RTSP implementation and not the 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 the best protocol implementation
+- [TP-Link](https://www.tp-link.com/) - few streaming clients, packet loss?
+- Cheap noname cameras, Wyze Cams, Xiaomi cameras with hacks (usually have `/live/ch00_1` in RTSP URL) - awful but usable RTSP protocol implementation, low stream quality, few settings, packet loss?
+
+## Tips
+
+**Using apps for low RTSP delay**
+
+- `ffplay -fflags nobuffer -flags low_delay "rtsp://192.168.1.123:8554/camera1"`
+- VLC > Preferences > Input / Codecs > Default Caching Level: Lowest Latency
+
+**Snapshots to Telegram**
+
+[read more](https://github.com/AlexxIT/go2rtc/wiki/Snapshot-to-Telegram)

cmd/README.md

@@ -1,4 +0,0 @@
-**Project layout**
-
-- https://github.com/golang-standards/project-layout
-- https://github.com/micro/micro

cmd/api/api.go

@@ -1,119 +0,0 @@
-package api
-
-import (
-	"encoding/json"
-	"github.com/AlexxIT/go2rtc/cmd/app"
-	"github.com/AlexxIT/go2rtc/cmd/streams"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
-	"github.com/gorilla/websocket"
-	"github.com/rs/zerolog"
-	"net"
-	"net/http"
-)
-
-func Init() {
-	var cfg struct {
-		Mod struct {
-			Listen    string `yaml:"listen"`
-			BasePath  string `yaml:"base_path"`
-			StaticDir string `yaml:"static_dir"`
-		} `yaml:"api"`
-	}
-
-	// default config
-	cfg.Mod.Listen = ":3000"
-	cfg.Mod.StaticDir = "www"
-
-	// load config from YAML
-	app.LoadConfig(&cfg)
-
-	if cfg.Mod.Listen == "" {
-		return
-	}
-
-	basePath = cfg.Mod.BasePath
-	log = app.GetLogger("api")
-
-	if cfg.Mod.StaticDir != "" {
-		fileServer = http.FileServer(http.Dir(cfg.Mod.StaticDir))
-		HandleFunc("/", fileServerHandlder)
-	}
-
-	HandleFunc("/api/stack", stackHandler)
-	HandleFunc("/api/stats", statsHandler)
-	HandleFunc("/api/ws", apiWS)
-
-	// ensure we can listen without errors
-	listener, err := net.Listen("tcp", cfg.Mod.Listen)
-	if err != nil {
-		log.Fatal().Err(err).Msg("[api] listen")
-	}
-
-	log.Info().Str("addr", cfg.Mod.Listen).Msg("[api] listen")
-
-	go func() {
-		s := http.Server{}
-		if err = s.Serve(listener); err != nil {
-			log.Fatal().Err(err).Msg("[api] Serve")
-		}
-	}()
-}
-
-func HandleFunc(pattern string, handler http.HandlerFunc) {
-	http.HandleFunc(basePath+pattern, handler)
-}
-
-func HandleWS(msgType string, handler WSHandler) {
-	wsHandlers[msgType] = handler
-}
-
-var basePath string
-var fileServer http.Handler
-var log zerolog.Logger
-var wsHandlers = make(map[string]WSHandler)
-
-func fileServerHandlder(w http.ResponseWriter, r *http.Request) {
-	if basePath != "" {
-		r.URL.Path = r.URL.Path[len(basePath):]
-	}
-	fileServer.ServeHTTP(w, r)
-}
-
-func statsHandler(w http.ResponseWriter, _ *http.Request) {
-	v := map[string]interface{}{
-		"streams": streams.Streams,
-	}
-	data, err := json.Marshal(v)
-	if err != nil {
-		log.Error().Err(err).Msg("[api.stats] marshal")
-	}
-	if _, err = w.Write(data); err != nil {
-		log.Error().Err(err).Msg("[api.stats] write")
-	}
-}
-
-func apiWS(w http.ResponseWriter, r *http.Request) {
-	ctx := new(Context)
-	if err := ctx.Upgrade(w, r); err != nil {
-		log.Error().Err(err).Msg("[api.ws] upgrade")
-		return
-	}
-	defer ctx.Close()
-
-	for {
-		msg := new(streamer.Message)
-		if err := ctx.Conn.ReadJSON(msg); err != nil {
-			if websocket.IsUnexpectedCloseError(
-				err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure,
-			) {
-				log.Error().Err(err).Msg("[api.ws] readJSON")
-			}
-			return
-		}
-
-		handler := wsHandlers[msg.Type]
-		if handler != nil {
-			handler(ctx, msg)
-		}
-	}
-}

cmd/api/stack.go

@@ -1,52 +0,0 @@
-package api
-
-import (
-	"bytes"
-	"fmt"
-	"net/http"
-	"runtime"
-)
-
-var stackSkip = [][]byte{
-	// debug.go
-	[]byte("github.com/AlexxIT/go2rtc/cmd/debug.handler"),
-
-	// cmd.go
-	[]byte("github.com/AlexxIT/go2rtc/cmd.Run"),
-	[]byte("created by os/signal.Notify"),
-
-	// api.go
-	[]byte("created by github.com/AlexxIT/go2rtc/cmd/api.Init"),
-	[]byte("created by net/http.(*connReader).startBackgroundRead"),
-	[]byte("created by net/http.(*Server).Serve"),
-
-	[]byte("created by github.com/AlexxIT/go2rtc/cmd/rtsp.Init"),
-}
-
-func stackHandler(w http.ResponseWriter, r *http.Request) {
-	sep := []byte("\n\n")
-	buf := make([]byte, 65535)
-	i := 0
-	n := runtime.Stack(buf, true)
-	skipped := 0
-	for _, item := range bytes.Split(buf[:n], sep) {
-		for _, skip := range stackSkip {
-			if bytes.Contains(item, skip) {
-				item = nil
-				skipped++
-				break
-			}
-		}
-		if item != nil {
-			i += copy(buf[i:], item)
-			i += copy(buf[i:], sep)
-		}
-	}
-	i += copy(buf[i:], fmt.Sprintf(
-		"Total: %d, Skipped: %d", runtime.NumGoroutine(), skipped),
-	)
-
-	if _, err := w.Write(buf[:i]); err != nil {
-		panic(err)
-	}
-}

cmd/api/ws.go

@@ -1,67 +0,0 @@
-package api
-
-import (
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
-	"github.com/gorilla/websocket"
-	"net/http"
-	"sync"
-)
-
-type WSHandler func(ctx *Context, msg *streamer.Message)
-
-var apiWsUp = websocket.Upgrader{
-	ReadBufferSize:  1024,
-	WriteBufferSize: 512000,
-}
-
-type Context struct {
-	Conn     *websocket.Conn
-	Request  *http.Request
-	Consumer interface{} // TODO: rewrite
-
-	onClose []func()
-	mu      sync.Mutex
-}
-
-func (ctx *Context) Upgrade(w http.ResponseWriter, r *http.Request) (err error) {
-	ctx.Conn, err = apiWsUp.Upgrade(w, r, nil)
-	ctx.Request = r
-	return
-}
-
-func (ctx *Context) Close() {
-	for _, f := range ctx.onClose {
-		f()
-	}
-	_ = ctx.Conn.Close()
-}
-
-func (ctx *Context) Write(msg interface{}) {
-	ctx.mu.Lock()
-	defer ctx.mu.Unlock()
-
-	var err error
-
-	switch msg := msg.(type) {
-	case *streamer.Message:
-		err = ctx.Conn.WriteJSON(msg)
-	case []byte:
-		err = ctx.Conn.WriteMessage(websocket.BinaryMessage, msg)
-	default:
-		return
-	}
-
-	if err != nil {
-		//panic(err) // TODO: fix panic
-	}
-}
-
-func (ctx *Context) Error(err error) {
-	ctx.Write(&streamer.Message{
-		Type: "error", Value: err.Error(),
-	})
-}
-
-func (ctx *Context) OnClose(f func()) {
-	ctx.onClose = append(ctx.onClose, f)
-}

cmd/app/app.go

@@ -1,68 +0,0 @@
-package app
-
-import (
-	"github.com/rs/zerolog"
-	"gopkg.in/yaml.v3"
-	"io"
-	"os"
-	"runtime"
-)
-
-func Init() {
-	data, _ = os.ReadFile("go2rtc.yaml")
-
-	var cfg struct {
-		Mod map[string]string `yaml:"log"`
-	}
-
-	LoadConfig(&cfg)
-
-	var writer io.Writer = os.Stdout
-
-	// styles
-	format := cfg.Mod["format"]
-	if format != "json" {
-		writer = zerolog.ConsoleWriter{
-			Out: writer, TimeFormat: "15:04:05.000",
-			NoColor: writer != os.Stdout || format == "text",
-		}
-	}
-
-	zerolog.TimeFieldFormat = zerolog.TimeFormatUnixMs
-
-	lvl, err := zerolog.ParseLevel(cfg.Mod["level"])
-	if err != nil || lvl == zerolog.NoLevel {
-		lvl = zerolog.InfoLevel
-	}
-
-	log = zerolog.New(writer).With().Timestamp().Logger().Level(lvl)
-
-	modules = cfg.Mod
-
-	log.Info().Msgf("go2rtc %s/%s", runtime.GOOS, runtime.GOARCH)
-}
-
-func LoadConfig(v interface{}) {
-	if data != nil {
-		_ = yaml.Unmarshal(data, v)
-	}
-}
-
-func GetLogger(module string) zerolog.Logger {
-	lvl, err := zerolog.ParseLevel(modules[module])
-	if err != nil {
-		return log
-	}
-	return log.Level(lvl)
-}
-
-// internal
-
-// data - config content
-var data []byte
-
-// log - main logger
-var log zerolog.Logger
-
-// modules log levels
-var modules map[string]string

cmd/cmd.go

@@ -1,41 +0,0 @@
-package cmd
-
-import (
-	"github.com/AlexxIT/go2rtc/cmd/api"
-	"github.com/AlexxIT/go2rtc/cmd/app"
-	"github.com/AlexxIT/go2rtc/cmd/exec"
-	"github.com/AlexxIT/go2rtc/cmd/ffmpeg"
-	"github.com/AlexxIT/go2rtc/cmd/hass"
-	"github.com/AlexxIT/go2rtc/cmd/mse"
-	"github.com/AlexxIT/go2rtc/cmd/ngrok"
-	"github.com/AlexxIT/go2rtc/cmd/rtmp"
-	"github.com/AlexxIT/go2rtc/cmd/rtsp"
-	"github.com/AlexxIT/go2rtc/cmd/streams"
-	"github.com/AlexxIT/go2rtc/cmd/webrtc"
-	"os"
-	"os/signal"
-)
-
-func Run() {
-	app.Init()     // init config and logs
-	streams.Init() // load streams list
-
-	rtsp.Init()   // add support RTSP client and RTSP server
-	rtmp.Init()   // add support RTMP client
-	exec.Init()   // add support exec scheme (depends on RTSP server)
-	ffmpeg.Init() // add support ffmpeg scheme (depends on exec scheme)
-	hass.Init()   // add support hass scheme
-
-	api.Init() // init HTTP API server
-
-	webrtc.Init()
-	mse.Init()
-
-	ngrok.Init()
-
-	c := make(chan os.Signal)
-	signal.Notify(c)
-	<-c
-
-	println("exit OK")
-}

cmd/exec/exec.go

@@ -1,85 +0,0 @@
-package exec
-
-import (
-	"crypto/md5"
-	"encoding/hex"
-	"errors"
-	"github.com/AlexxIT/go2rtc/cmd/app"
-	"github.com/AlexxIT/go2rtc/cmd/rtsp"
-	"github.com/AlexxIT/go2rtc/cmd/streams"
-	pkg "github.com/AlexxIT/go2rtc/pkg/rtsp"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
-	"github.com/rs/zerolog"
-	"os"
-	"os/exec"
-	"strings"
-	"time"
-)
-
-func Init() {
-	// depends on RTSP server
-	if rtsp.Port == "" {
-		return
-	}
-
-	rtsp.OnProducer = func(prod streamer.Producer) bool {
-		if conn := prod.(*pkg.Conn); conn != nil {
-			if waiter := waiters[conn.URL.Path]; waiter != nil {
-				waiter <- prod
-				return true
-			}
-		}
-		return false
-	}
-
-	streams.HandleFunc("exec", Handle)
-
-	log = app.GetLogger("exec")
-
-	// TODO: add sync.Mutex
-	waiters = map[string]chan streamer.Producer{}
-}
-
-func Handle(url string) (streamer.Producer, error) {
-	sum := md5.Sum([]byte(url))
-	path := "/" + hex.EncodeToString(sum[:])
-
-	url = strings.Replace(
-		url, "{output}", "rtsp://localhost:"+rtsp.Port+path, 1,
-	)
-
-	// remove `exec:`
-	args := strings.Split(url[5:], " ")
-	cmd := exec.Command(args[0], args[1:]...)
-
-	if log.Trace().Enabled() {
-		cmd.Stdout = os.Stdout
-		cmd.Stderr = os.Stderr
-	}
-
-	ch := make(chan streamer.Producer)
-
-	waiters[path] = ch
-	defer delete(waiters, path)
-
-	log.Debug().Str("url", url).Msg("[exec] run")
-
-	if err := cmd.Start(); err != nil {
-		log.Error().Err(err).Str("url", url).Msg("[exec]")
-		return nil, err
-	}
-
-	select {
-	case <-time.After(time.Second * 10):
-		_ = cmd.Process.Kill()
-		log.Error().Str("url", url).Msg("[exec] timeout")
-		return nil, errors.New("timeout")
-	case prod := <-ch:
-		return prod, nil
-	}
-}
-
-// internal
-
-var log zerolog.Logger
-var waiters map[string]chan streamer.Producer

cmd/ffmpeg/README.md

@@ -1,6 +0,0 @@
-## Useful links
-
-- https://superuser.com/questions/564402/explanation-of-x264-tune
-- https://stackoverflow.com/questions/33624016/why-sliced-thread-affect-so-much-on-realtime-encoding-using-ffmpeg-x264
-- https://codec.fandom.com/ru/wiki/X264_-_%D0%BE%D0%BF%D0%B8%D1%81%D0%B0%D0%BD%D0%B8%D0%B5_%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%B9_%D0%BA%D0%BE%D0%B4%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F
-- https://html5test.com/

cmd/ffmpeg/ffmpeg.go

@@ -1,112 +0,0 @@
-package ffmpeg
-
-import (
-	"github.com/AlexxIT/go2rtc/cmd/app"
-	"github.com/AlexxIT/go2rtc/cmd/exec"
-	"github.com/AlexxIT/go2rtc/cmd/streams"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
-	"net/url"
-	"strings"
-)
-
-func Init() {
-	var cfg struct {
-		Mod map[string]string `yaml:"ffmpeg"`
-	}
-
-	// defaults
-
-	cfg.Mod = map[string]string{
-		"bin": "ffmpeg",
-
-		// inputs
-		"link": "-hide_banner -i {input}",
-		"rtsp": "-hide_banner -fflags nobuffer -flags low_delay -rtsp_transport tcp -i {input}",
-		"file": "-hide_banner -re -stream_loop -1 -i {input}",
-
-		// output
-		"out": "-rtsp_transport tcp -f rtsp {output}",
-
-		// `-g 30` - group of picture, GOP, keyframe interval
-		// `-preset superfast` - we can't use ultrafast because it doesn't support `-profile main -level 4.1`
-		// `-tune zerolatency` - for minimal latency
-		// `-profile main -level 4.1` - most used streaming profile
-		"h264":       "-codec:v libx264 -g 30 -preset superfast -tune zerolatency -profile main -level 4.1",
-		"h264/ultra": "-codec:v libx264 -g 30 -preset ultrafast -tune zerolatency",
-		"h264/high":  "-codec:v libx264 -g 30 -preset superfast -tune zerolatency",
-		"h265":       "-codec:v libx265 -g 30 -preset ultrafast -tune zerolatency",
-		"opus":       "-codec:a libopus -ar 48000 -ac 2",
-		"pcmu":       "-codec:a pcm_mulaw -ar 8000 -ac 1",
-		"pcmu/16000": "-codec:a pcm_mulaw -ar 16000 -ac 1",
-		"pcmu/48000": "-codec:a pcm_mulaw -ar 48000 -ac 1",
-		"pcma":       "-codec:a pcm_alaw -ar 8000 -ac 1",
-		"pcma/16000": "-codec:a pcm_alaw -ar 16000 -ac 1",
-		"pcma/48000": "-codec:a pcm_alaw -ar 48000 -ac 1",
-		"aac/16000":  "-codec:a aac -ar 16000 -ac 1",
-	}
-
-	app.LoadConfig(&cfg)
-
-	tpl := cfg.Mod
-
-	streams.HandleFunc("ffmpeg", func(s string) (streamer.Producer, error) {
-		s = s[7:] // remove `ffmpeg:`
-
-		var query url.Values
-		if i := strings.IndexByte(s, '#'); i > 0 {
-			query, _ = url.ParseQuery(s[i+1:])
-			s = s[:i]
-		}
-
-		var template string
-		switch {
-		case strings.HasPrefix(s, "rtsp"):
-			template = tpl["rtsp"]
-		case strings.Contains(s, "://"):
-			template = tpl["link"]
-		default:
-			template = tpl["file"]
-		}
-
-		s = "exec:" + tpl["bin"] + " " +
-			strings.Replace(template, "{input}", s, 1)
-
-		if query != nil {
-			for _, raw := range query["raw"] {
-				s += " " + raw
-			}
-
-			// TODO: multiple codecs via -map
-			// s += fmt.Sprintf(" -map 0:v:0 -c:v:%d copy", i)
-
-			for _, video := range query["video"] {
-				if video == "copy" {
-					s += " -codec:v copy"
-				} else {
-					s += " " + tpl[video]
-				}
-			}
-
-			for _, audio := range query["audio"] {
-				if audio == "copy" {
-					s += " -codec:v copy"
-				} else {
-					s += " " + tpl[audio]
-				}
-			}
-
-			if query["video"] == nil {
-				s += " -vn"
-			}
-			if query["audio"] == nil {
-				s += " -an"
-			}
-		} else {
-			s += " -c copy"
-		}
-
-		s += " " + tpl["out"]
-
-		return exec.Handle(s)
-	})
-}

cmd/hass/hass.go

@@ -1,71 +0,0 @@
-package hass
-
-import (
-	"encoding/json"
-	"fmt"
-	"github.com/AlexxIT/go2rtc/cmd/app"
-	"github.com/AlexxIT/go2rtc/cmd/streams"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
-	"os"
-	"path"
-)
-
-func Init() {
-	var conf struct {
-		Mod struct {
-			Config string `yaml:"config"`
-		} `yaml:"hass"`
-	}
-
-	app.LoadConfig(&conf)
-
-	filename := path.Join(conf.Mod.Config, ".storage/core.config_entries")
-	data, err := os.ReadFile(filename)
-	if err != nil {
-		return
-	}
-
-	ent := new(entries)
-	if err = json.Unmarshal(data, ent); err != nil {
-		return
-	}
-
-	urls := map[string]string{}
-
-	for _, entrie := range ent.Data.Entries {
-		switch entrie.Domain {
-		case "generic":
-			if entrie.Options.StreamSource != "" {
-				urls[entrie.Title] = entrie.Options.StreamSource
-			}
-		}
-	}
-
-	streams.HandleFunc("hass", func(url string) (streamer.Producer, error) {
-		if hurl := urls[url[5:]]; hurl != "" {
-			return streams.GetProducer(hurl)
-		}
-		return nil, fmt.Errorf("can't get url: %s", url)
-	})
-}
-
-type entries struct {
-	Data struct {
-		Entries []struct {
-			Title  string `json:"title"`
-			Domain string `json:"domain"`
-			Data   struct {
-				ClientID      string `json:"iOSPairingId"`
-				ClientPrivate string `json:"iOSDeviceLTSK"`
-				ClientPublic  string `json:"iOSDeviceLTPK"`
-				DeviceID      string `json:"AccessoryPairingID"`
-				DevicePublic  string `json:"AccessoryLTPK"`
-				DeviceHost    string `json:"AccessoryIP"`
-				DevicePort    uint16 `json:"AccessoryPort"`
-			} `json:"data"`
-			Options struct {
-				StreamSource string `json:"stream_source"`
-			}
-		} `json:"entries"`
-	} `json:"data"`
-}

cmd/mse/mse.go

@@ -1,42 +0,0 @@
-package mse
-
-import (
-	"github.com/AlexxIT/go2rtc/cmd/api"
-	"github.com/AlexxIT/go2rtc/cmd/streams"
-	"github.com/AlexxIT/go2rtc/pkg/mse"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
-	"github.com/rs/zerolog/log"
-)
-
-func Init() {
-	api.HandleWS("mse", handler)
-}
-
-func handler(ctx *api.Context, msg *streamer.Message) {
-	url := ctx.Request.URL.Query().Get("url")
-	stream := streams.Get(url)
-	if stream == nil {
-		return
-	}
-
-	cons := new(mse.Consumer)
-	cons.UserAgent = ctx.Request.UserAgent()
-	cons.RemoteAddr = ctx.Request.RemoteAddr
-	cons.Listen(func(msg interface{}) {
-		switch msg.(type) {
-		case *streamer.Message, []byte:
-			ctx.Write(msg)
-		}
-	})
-	if err := stream.AddConsumer(cons); err != nil {
-		log.Warn().Err(err).Msg("[api.mse] Add consumer")
-		ctx.Error(err)
-		return
-	}
-
-	ctx.OnClose(func() {
-		stream.RemoveConsumer(cons)
-	})
-
-	cons.Init()
-}

cmd/rtmp/rtmp.go

@@ -1,19 +0,0 @@
-package rtmp
-
-import (
-	"github.com/AlexxIT/go2rtc/cmd/streams"
-	"github.com/AlexxIT/go2rtc/pkg/rtmp"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
-)
-
-func Init() {
-	streams.HandleFunc("rtmp", handle)
-}
-
-func handle(url string) (streamer.Producer, error) {
-	conn := rtmp.NewClient(url)
-	if err := conn.Dial(); err != nil {
-		return nil, err
-	}
-	return conn, nil
-}

cmd/rtsp/rtsp.go

@@ -1,201 +0,0 @@
-package rtsp
-
-import (
-	"github.com/AlexxIT/go2rtc/cmd/app"
-	"github.com/AlexxIT/go2rtc/cmd/streams"
-	"github.com/AlexxIT/go2rtc/pkg/rtsp"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
-	"github.com/AlexxIT/go2rtc/pkg/tcp"
-	"github.com/rs/zerolog"
-	"net"
-)
-
-func Init() {
-	var conf struct {
-		Mod struct {
-			Listen string `yaml:"listen"`
-		} `yaml:"rtsp"`
-	}
-
-	// default config
-	conf.Mod.Listen = ":554"
-
-	app.LoadConfig(&conf)
-
-	log = app.GetLogger("rtsp")
-
-	// RTSP client support
-	streams.HandleFunc("rtsp", rtspHandler)
-	streams.HandleFunc("rtsps", rtspHandler)
-
-	// RTSP server support
-	address := conf.Mod.Listen
-	if address != "" {
-		_, Port, _ = net.SplitHostPort(address)
-
-		go worker(address)
-	}
-}
-
-var Port string
-
-var OnProducer func(conn streamer.Producer) bool // TODO: maybe rewrite...
-
-// internal
-
-var log zerolog.Logger
-
-func rtspHandler(url string) (streamer.Producer, error) {
-	conn, err := rtsp.NewClient(url)
-	if err != nil {
-		return nil, err
-	}
-
-	if log.Trace().Enabled() {
-		conn.Listen(func(msg interface{}) {
-			switch msg := msg.(type) {
-			case *tcp.Request:
-				log.Trace().Msgf("[rtsp] client request:\n%s", msg)
-			case *tcp.Response:
-				log.Trace().Msgf("[rtsp] client response:\n%s", msg)
-			}
-		})
-	}
-
-	if err = conn.Dial(); err != nil {
-		return nil, err
-	}
-	if err = conn.Describe(); err != nil {
-		return nil, err
-	}
-
-	return conn, nil
-}
-
-func worker(address string) {
-	srv, err := tcp.NewServer(address)
-	if err != nil {
-		log.Error().Err(err).Msg("[rtsp] listen")
-		return
-	}
-
-	log.Info().Str("addr", address).Msg("[rtsp] listen")
-
-	srv.Listen(func(msg interface{}) {
-		switch msg.(type) {
-		case net.Conn:
-			var name string
-			var onDisconnect func()
-
-			trace := log.Trace().Enabled()
-
-			conn := rtsp.NewServer(msg.(net.Conn))
-			conn.Listen(func(msg interface{}) {
-				if trace {
-					switch msg := msg.(type) {
-					case *tcp.Request:
-						log.Trace().Msgf("[rtsp] server request:\n%s", msg)
-					case *tcp.Response:
-						log.Trace().Msgf("[rtsp] server response:\n%s", msg)
-					}
-				}
-
-				switch msg {
-				case rtsp.MethodDescribe:
-					name = conn.URL.Path[1:]
-
-					log.Debug().Str("stream", name).Msg("[rtsp] new consumer")
-
-					stream := streams.Get(name) // TODO: rewrite
-					if stream == nil {
-						return
-					}
-
-					initMedias(conn)
-
-					if err = stream.AddConsumer(conn); err != nil {
-						log.Warn().Err(err).Str("stream", name).Msg("[rtsp]")
-						return
-					}
-
-					onDisconnect = func() {
-						stream.RemoveConsumer(conn)
-					}
-
-				case rtsp.MethodAnnounce:
-					if OnProducer != nil {
-						if OnProducer(conn) {
-							return
-						}
-					}
-
-					name = conn.URL.Path[1:]
-
-					log.Debug().Str("stream", name).Msg("[rtsp] new producer")
-
-					str := streams.Get(conn.URL.Path[1:])
-					if str == nil {
-						return
-					}
-
-					str.AddProducer(conn)
-
-					onDisconnect = func() {
-						str.RemoveProducer(conn)
-					}
-
-				case streamer.StatePlaying:
-					log.Debug().Str("stream", name).Msg("[rtsp] start")
-				}
-			})
-
-			if err = conn.Accept(); err != nil {
-				log.Warn().Err(err).Msg("[rtsp] accept")
-				return
-			}
-
-			if err = conn.Handle(); err != nil {
-				//log.Warn().Err(err).Msg("[rtsp] handle server")
-			}
-
-			if onDisconnect != nil {
-				onDisconnect()
-			}
-
-			log.Debug().Str("stream", name).Msg("[rtsp] disconnect")
-		}
-	})
-
-	srv.Serve()
-}
-
-func initMedias(conn *rtsp.Conn) {
-	// set media candidates from query list
-	for key, value := range conn.URL.Query() {
-		switch key {
-		case streamer.KindVideo, streamer.KindAudio:
-			for _, value := range value {
-				media := &streamer.Media{
-					Kind: key, Direction: streamer.DirectionRecvonly,
-				}
-
-				switch value {
-				case "", "copy": // pass empty codecs list
-				default:
-					codec := streamer.NewCodec(value)
-					media.Codecs = append(media.Codecs, codec)
-				}
-
-				conn.Medias = append(conn.Medias, media)
-			}
-		}
-	}
-
-	// set default media candidates if query is empty
-	if conn.Medias == nil {
-		conn.Medias = []*streamer.Media{
-			{Kind: streamer.KindVideo, Direction: streamer.DirectionRecvonly},
-			{Kind: streamer.KindAudio, Direction: streamer.DirectionRecvonly},
-		}
-	}
-}

cmd/streams/handlers.go

@@ -1,27 +0,0 @@
-package streams
-
-import (
-	"fmt"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
-	"strings"
-)
-
-type Handler func(url string) (streamer.Producer, error)
-
-var handlers map[string]Handler
-
-func HandleFunc(scheme string, handler Handler) {
-	if handlers == nil {
-		handlers = make(map[string]Handler)
-	}
-	handlers[scheme] = handler
-}
-
-func GetProducer(url string) (streamer.Producer, error) {
-	i := strings.IndexByte(url, ':')
-	handler := handlers[url[:i]]
-	if handler == nil {
-		return nil, fmt.Errorf("unsupported scheme: %s", url)
-	}
-	return handler(url)
-}

cmd/streams/producer.go

@@ -1,89 +0,0 @@
-package streams
-
-import (
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
-	"strings"
-)
-
-type state byte
-
-const (
-	stateNone state = iota
-	stateMedias
-	stateTracks
-	stateStart
-)
-
-type Producer struct {
-	streamer.Element
-
-	url     string
-	element streamer.Producer
-	tracks  []*streamer.Track
-
-	state state
-}
-
-func (p *Producer) GetMedias() []*streamer.Media {
-	if p.state == stateNone {
-		i := strings.IndexByte(p.url, ':')
-		handler := handlers[p.url[:i]]
-		if handler == nil {
-			log.Warn().Str("url", p.url).Msg("[streams] unsupported scheme")
-			return nil
-		}
-
-		log.Debug().Str("url", p.url).Msg("[streams] probe producer")
-
-		var err error
-		p.element, err = handler(p.url)
-		if err != nil {
-			log.Error().Err(err).Str("url", p.url).Msg("[streams] probe producer")
-			return nil
-		}
-
-		p.state = stateMedias
-	}
-
-	return p.element.GetMedias()
-}
-
-func (p *Producer) GetTrack(media *streamer.Media, codec *streamer.Codec) *streamer.Track {
-	if p.state == stateMedias {
-		p.state = stateTracks
-	}
-
-	track := p.element.GetTrack(media, codec)
-
-	for _, t := range p.tracks {
-		if track == t {
-			return track
-		}
-	}
-
-	p.tracks = append(p.tracks, track)
-
-	return track
-}
-
-// internals
-
-func (p *Producer) start() {
-	if p.state != stateTracks {
-		return
-	}
-
-	log.Debug().Str("url", p.url).Msg("[streams] start producer")
-
-	p.state = stateStart
-	go p.element.Start()
-}
-
-func (p *Producer) stop() {
-	log.Debug().Str("url", p.url).Msg("[streams] stop producer")
-
-	_ = p.element.Stop()
-	p.element = nil
-	p.tracks = nil
-	p.state = stateNone
-}

cmd/streams/stream.go

@@ -1,164 +0,0 @@
-package streams
-
-import (
-	"encoding/json"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
-)
-
-type Consumer struct {
-	element streamer.Consumer
-	tracks  []*streamer.Track
-}
-
-type Stream struct {
-	producers []*Producer
-	consumers []*Consumer
-}
-
-func newStream(source interface{}) *Stream {
-	s := new(Stream)
-
-	switch source := source.(type) {
-	case string:
-		prod := &Producer{url: source}
-		s.producers = append(s.producers, prod)
-	case []interface{}:
-		for _, source := range source {
-			prod := &Producer{url: source.(string)}
-			s.producers = append(s.producers, prod)
-		}
-	case map[string]interface{}:
-		return newStream(source["url"])
-	default:
-		panic("wrong source type")
-	}
-
-	return s
-}
-
-func (s *Stream) AddConsumer(cons streamer.Consumer) (err error) {
-	ic := len(s.consumers)
-
-	consumer := &Consumer{element: cons}
-
-	// Step 1. Get consumer medias
-	for icc, consMedia := range cons.GetMedias() {
-		log.Trace().Stringer("media", consMedia).
-			Msgf("[streams] consumer:%d:%d candidate", ic, icc)
-
-	producers:
-		for ip, prod := range s.producers {
-			// Step 2. Get producer medias (not tracks yet)
-			for ipc, prodMedia := range prod.GetMedias() {
-				log.Trace().Stringer("media", prodMedia).
-					Msgf("[streams] producer:%d:%d candidate", ip, ipc)
-
-				// Step 3. Match consumer/producer codecs list
-				prodCodec := prodMedia.MatchMedia(consMedia)
-				if prodCodec != nil {
-					log.Trace().Stringer("codec", prodCodec).
-						Msgf("[streams] match producer:%d:%d => consumer:%d:%d", ip, ipc, ic, icc)
-
-					// Step 4. Get producer track
-					prodTrack := prod.GetTrack(prodMedia, prodCodec)
-
-					// Step 5. Add track to consumer and get new track
-					consTrack := consumer.element.AddTrack(consMedia, prodTrack)
-
-					consumer.tracks = append(consumer.tracks, consTrack)
-					break producers
-				}
-			}
-		}
-	}
-
-	// can't match tracks for consumer
-	if len(consumer.tracks) == 0 {
-		return nil
-	}
-
-	s.consumers = append(s.consumers, consumer)
-
-	for _, prod := range s.producers {
-		prod.start()
-	}
-
-	return nil
-}
-
-func (s *Stream) RemoveConsumer(cons streamer.Consumer) {
-	for i, consumer := range s.consumers {
-		if consumer.element == cons {
-			// remove consumer pads from all producers
-			for _, track := range consumer.tracks {
-				track.Unbind()
-			}
-			// remove consumer from slice
-			s.removeConsumer(i)
-			break
-		}
-	}
-
-	for _, producer := range s.producers {
-		var sink bool
-		for _, track := range producer.tracks {
-			if len(track.Sink) > 0 {
-				sink = true
-			}
-		}
-		if !sink {
-			producer.stop()
-		}
-	}
-}
-
-func (s *Stream) AddProducer(prod streamer.Producer) {
-	panic("not implemented")
-}
-
-func (s *Stream) RemoveProducer(prod streamer.Producer) {
-	panic("not implemented")
-}
-
-func (s *Stream) MarshalJSON() ([]byte, error) {
-	var v []interface{}
-	for _, prod := range s.producers {
-		if prod.element != nil {
-			v = append(v, prod.element)
-		}
-	}
-	for _, cons := range s.consumers {
-		// cons.element always not nil
-		v = append(v, cons.element)
-	}
-	if len(v) == 0 {
-		v = nil
-	}
-	return json.Marshal(v)
-}
-
-func (s *Stream) removeConsumer(i int) {
-	switch {
-	case len(s.consumers) == 1: // only one element
-		s.consumers = nil
-	case i == 0: // first element
-		s.consumers = s.consumers[1:]
-	case i == len(s.consumers)-1: // last element
-		s.consumers = s.consumers[:i]
-	default: // middle element
-		s.consumers = append(s.consumers[:i], s.consumers[i+1:]...)
-	}
-}
-
-func (s *Stream) removeProducer(i int) {
-	switch {
-	case len(s.producers) == 1: // only one element
-		s.producers = nil
-	case i == 0: // first element
-		s.producers = s.producers[1:]
-	case i == len(s.producers)-1: // last element
-		s.producers = s.producers[:i]
-	default: // middle element
-		s.producers = append(s.producers[:i], s.producers[i+1:]...)
-	}
-}

cmd/streams/stream_test.go

@@ -1,134 +0,0 @@
-package streams
-
-import (
-	"github.com/AlexxIT/go2rtc/pkg/fake"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
-	"github.com/stretchr/testify/assert"
-	"testing"
-	"time"
-)
-
-// Google Chrome 104.0.5112.79
-const chrome = `v=0
-o=- 0 0 IN IP4 0.0.0.0
-s=-
-t=0 0
-m=audio 9 UDP/TLS/RTP/SAVPF 111 63 103 104 9 0 8 110 112 113 126
-a=sendrecv
-a=rtpmap:111 opus/48000/2
-a=rtpmap:63 red/48000/2
-a=rtpmap:103 ISAC/16000
-a=rtpmap:104 ISAC/32000
-a=rtpmap:9 G722/8000
-a=rtpmap:0 PCMU/8000
-a=rtpmap:8 PCMA/8000
-a=rtpmap:110 telephone-event/48000
-a=rtpmap:112 telephone-event/32000
-a=rtpmap:113 telephone-event/16000
-a=rtpmap:126 telephone-event/8000
-m=video 9 UDP/TLS/RTP/SAVPF 96 97 98 99 100 101 102 122 127 121 125 107 108 109 124 120 123 119 35 36 37 38 39 40 41 42 114 115 116 117 118 43
-a=recvonly
-a=rtpmap:96 VP8/90000
-a=rtpmap:97 rtx/90000
-a=rtpmap:98 VP9/90000
-a=rtpmap:99 rtx/90000
-a=rtpmap:100 VP9/90000
-a=rtpmap:101 rtx/90000
-a=rtpmap:102 VP9/90000
-a=rtpmap:122 rtx/90000
-a=rtpmap:127 H264/90000
-a=fmtp:127 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42001f
-a=rtpmap:121 rtx/90000
-a=rtpmap:125 H264/90000
-a=fmtp:125 level-asymmetry-allowed=1;packetization-mode=0;profile-level-id=42001f
-a=rtpmap:107 rtx/90000
-a=rtpmap:108 H264/90000
-a=fmtp:108 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f
-a=rtpmap:109 rtx/90000
-a=rtpmap:124 H264/90000
-a=fmtp:124 level-asymmetry-allowed=1;packetization-mode=0;profile-level-id=42e01f
-a=rtpmap:120 rtx/90000
-a=rtpmap:123 H264/90000
-a=fmtp:123 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=4d001f
-a=rtpmap:119 rtx/90000
-a=rtpmap:35 H264/90000
-a=fmtp:35 level-asymmetry-allowed=1;packetization-mode=0;profile-level-id=4d001f
-a=rtpmap:36 rtx/90000
-a=rtpmap:37 H264/90000
-a=fmtp:37 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=f4001f
-a=rtpmap:38 rtx/90000
-a=rtpmap:39 H264/90000
-a=fmtp:39 level-asymmetry-allowed=1;packetization-mode=0;profile-level-id=f4001f
-a=rtpmap:40 rtx/90000
-a=rtpmap:41 AV1/90000
-a=rtpmap:42 rtx/90000
-a=rtpmap:114 H264/90000
-a=fmtp:114 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=64001f
-a=rtpmap:115 rtx/90000
-a=rtpmap:116 red/90000
-a=rtpmap:117 rtx/90000
-a=rtpmap:118 ulpfec/90000
-a=rtpmap:43 flexfec-03/90000
-`
-
-const dahuaSimple = `v=0
-o=- 0 0 IN IP4 0.0.0.0
-s=-
-t=0 0
-m=video 0 RTP/AVP 96
-a=control:trackID=0
-a=rtpmap:96 H264/90000
-a=fmtp:96 packetization-mode=1;profile-level-id=42401E;sprop-parameter-sets=Z0JAHqaAoD2QAA==,aM48gAA=
-a=recvonly
-m=audio 0 RTP/AVP 97
-a=control:trackID=1
-a=rtpmap:97 MPEG4-GENERIC/16000
-a=fmtp:97 streamtype=5;profile-level-id=1;mode=AAC-hbr;sizelength=13;indexlength=3;indexdeltalength=3;config=1408
-a=recvonly
-m=audio 0 RTP/AVP 8
-a=control:trackID=5
-a=rtpmap:8 PCMA/8000
-a=sendonly
-`
-
-const ffmpegPCMU48000 = `v=0
-o=- 0 0 IN IP4 127.0.0.1
-s=-
-t=0 0
-m=audio 0 RTP/AVP 96
-b=AS:384
-a=rtpmap:96 PCMU/48000/1
-a=control:streamid=0
-`
-
-func TestRouting(t *testing.T) {
-	prod := &fake.Producer{}
-	prod.Medias, _ = streamer.UnmarshalRTSPSDP([]byte(dahuaSimple))
-	assert.Len(t, prod.Medias, 3)
-
-	HandleFunc("fake", func(url string) (streamer.Producer, error) {
-		return prod, nil
-	})
-
-	cons := &fake.Consumer{}
-	cons.Medias, _ = streamer.UnmarshalSDP([]byte(chrome))
-	assert.Len(t, cons.Medias, 3)
-
-	// setup stream with one producer
-	stream := newStream("fake:")
-
-	// main check:
-	err := stream.AddConsumer(cons)
-	assert.Nil(t, err)
-
-	assert.Len(t, prod.Tracks, 2)
-	assert.Len(t, cons.Tracks, 2)
-
-	time.Sleep(time.Second)
-
-	assert.Greater(t, prod.SendPackets,0)
-	assert.Greater(t, cons.RecvPackets,0)
-
-	assert.Greater(t, prod.RecvPackets,0)
-	assert.Greater(t, cons.SendPackets,0)
-}

cmd/streams/streams.go

@@ -1,28 +0,0 @@
-package streams
-
-import (
-	"github.com/AlexxIT/go2rtc/cmd/app"
-	"github.com/rs/zerolog"
-)
-
-var Streams = map[string]*Stream{}
-
-func Init() {
-	var cfg struct {
-		Mod map[string]interface{} `yaml:"streams"`
-	}
-
-	app.LoadConfig(&cfg)
-
-	log = app.GetLogger("streams")
-
-	for name, item := range cfg.Mod {
-		Streams[name] = newStream(item)
-	}
-}
-
-func Get(name string) *Stream {
-	return Streams[name]
-}
-
-var log zerolog.Logger

cmd/webrtc/webrtc.go

@@ -1,265 +0,0 @@
-package webrtc
-
-import (
-	"github.com/AlexxIT/go2rtc/cmd/api"
-	"github.com/AlexxIT/go2rtc/cmd/app"
-	"github.com/AlexxIT/go2rtc/cmd/streams"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
-	"github.com/AlexxIT/go2rtc/pkg/webrtc"
-	pion "github.com/pion/webrtc/v3"
-	"github.com/rs/zerolog"
-	"io/ioutil"
-	"net"
-	"net/http"
-	"strings"
-)
-
-func Init() {
-	var cfg struct {
-		Mod struct {
-			Listen     string           `yaml:"listen"`
-			Candidates []string         `yaml:"candidates"`
-			IceServers []pion.ICEServer `yaml:"ice_servers"`
-		} `yaml:"webrtc"`
-	}
-
-	cfg.Mod.IceServers = []pion.ICEServer{
-		{URLs: []string{"stun:stun.l.google.com:19302"}},
-	}
-
-	app.LoadConfig(&cfg)
-
-	log = app.GetLogger("webrtc")
-
-	address := cfg.Mod.Listen
-	pionAPI, err := webrtc.NewAPI(address)
-	if pionAPI == nil {
-		log.Error().Err(err).Msg("[webrtc] Init API")
-		return
-	}
-
-	if err != nil {
-		log.Warn().Err(err).Msg("[webrtc] Listen")
-	} else if address != "" {
-		log.Info().Str("addr", address).Msg("[webrtc] Listen")
-		_, Port, _ = net.SplitHostPort(address)
-	}
-
-	pionConf := pion.Configuration{
-		ICEServers:   cfg.Mod.IceServers,
-		SDPSemantics: pion.SDPSemanticsUnifiedPlanWithFallback,
-	}
-
-	NewPConn = func() (*pion.PeerConnection, error) {
-		return pionAPI.NewPeerConnection(pionConf)
-	}
-
-	candidates = cfg.Mod.Candidates
-
-	api.HandleFunc("/api/webrtc", apiHandler)
-	api.HandleFunc("/api/webrtc/camera", cameraHandler)
-	api.HandleWS(webrtc.MsgTypeOffer, offerHandler)
-	api.HandleWS(webrtc.MsgTypeCandidate, candidateHandler)
-}
-
-func AddCandidate(address string) {
-	log.Info().Str("addr", address).Msg("[webrtc] new candidate")
-	candidates = append(candidates, address)
-}
-
-var Port string
-var log zerolog.Logger
-var candidates []string
-
-var NewPConn func() (*pion.PeerConnection, error)
-
-func apiHandler(w http.ResponseWriter, r *http.Request) {
-	url := r.URL.Query().Get("url")
-	stream := streams.Get(url)
-	if stream == nil {
-		return
-	}
-
-	// get offer
-	offer, err := ioutil.ReadAll(r.Body)
-	if err != nil {
-		log.Error().Err(err).Msg("[webrtc] read offer")
-		return
-	}
-
-	// create new webrtc instance
-	cons := new(webrtc.Conn)
-	cons.Conn, err = NewPConn()
-	if err != nil {
-		log.Error().Err(err).Msg("[webrtc] new conn")
-		return
-	}
-
-	cons.UserAgent = r.UserAgent()
-	cons.Listen(func(msg interface{}) {
-		if msg == streamer.StateNull {
-			stream.RemoveConsumer(cons)
-		}
-	})
-
-	if err = stream.AddConsumer(cons); err != nil {
-		log.Warn().Err(err).Msg("[api.webrtc] add consumer")
-		return
-	}
-
-	cons.Init()
-
-	// exchange sdp with waiting all candidates
-	answer, err := cons.ExchangeSDP(string(offer), true)
-
-	// send SDP to client
-	if _, err = w.Write([]byte(answer)); err != nil {
-		log.Error().Err(err).Msg("[api.webrtc] send answer")
-	}
-}
-
-func cameraHandler(w http.ResponseWriter, r *http.Request) {
-	url := r.URL.Query().Get("url")
-	stream := streams.Get(url)
-	if stream == nil {
-		return
-	}
-
-	// get offer
-	offer, err := ioutil.ReadAll(r.Body)
-	if err != nil {
-		log.Error().Err(err).Msg("[webrtc] read offer")
-		return
-	}
-
-	// create new webrtc instance
-	conn := new(webrtc.Conn)
-	conn.Conn, err = NewPConn()
-	if err != nil {
-		log.Error().Err(err).Msg("[webrtc] new conn")
-		return
-	}
-
-	conn.UserAgent = r.UserAgent()
-	conn.Listen(func(msg interface{}) {
-		switch msg.(type) {
-		case pion.PeerConnectionState:
-			if msg == pion.PeerConnectionStateDisconnected {
-				stream.RemoveConsumer(conn)
-			}
-		case streamer.Track:
-			//stream.AddProducer(conn)
-		}
-	})
-
-	conn.Init()
-
-	// exchange sdp with waiting all candidates
-	answer, err := conn.ExchangeSDP(string(offer), true)
-
-	// send SDP to client
-	if _, err = w.Write([]byte(answer)); err != nil {
-		log.Error().Err(err).Msg("[api.webrtc] send answer")
-	}
-}
-
-func offerHandler(ctx *api.Context, msg *streamer.Message) {
-	name := ctx.Request.URL.Query().Get("url")
-	stream := streams.Get(name)
-	if stream == nil {
-		return
-	}
-
-	log.Debug().Str("stream", name).Msg("[webrtc] new consumer")
-
-	var err error
-
-	// create new webrtc instance
-	conn := new(webrtc.Conn)
-	conn.Conn, err = NewPConn()
-	if err != nil {
-		log.Error().Err(err).Msg("[webrtc] new conn")
-		return
-	}
-
-	conn.UserAgent = ctx.Request.UserAgent()
-	conn.Listen(func(msg interface{}) {
-		switch msg := msg.(type) {
-		case streamer.EventType:
-			if msg == streamer.StateNull {
-				stream.RemoveConsumer(conn)
-			}
-		case *streamer.Message:
-			// subscribe on webrtc server candidates
-			log.Trace().Str("candidate", msg.Value.(string)).Msg("[webrtc] local")
-			ctx.Write(msg)
-		}
-	})
-
-	// 1. SetOffer, so we can get remote client codecs
-	offer := msg.Value.(string)
-	log.Trace().Msgf("[webrtc] offer:\n%s", offer)
-
-	if err = conn.SetOffer(offer); err != nil {
-		log.Warn().Err(err).Msg("[api.webrtc] set offer")
-		ctx.Error(err)
-		return
-	}
-
-	// 2. AddConsumer, so we get new tracks
-	if err = stream.AddConsumer(conn); err != nil {
-		log.Warn().Err(err).Msg("[api.webrtc] add consumer")
-		ctx.Error(err)
-		return
-	}
-
-	conn.Init()
-
-	// exchange sdp without waiting all candidates
-	//answer, err := conn.ExchangeSDP(offer, false)
-	answer, err := conn.GetAnswer()
-	log.Trace().Msgf("[webrtc] answer\n%s", answer)
-
-	if err != nil {
-		log.Error().Err(err).Msg("[webrtc] get answer")
-		ctx.Error(err)
-		return
-	}
-
-	ctx.Write(&streamer.Message{
-		Type: webrtc.MsgTypeAnswer, Value: answer,
-	})
-
-	for _, address := range candidates {
-		if strings.HasPrefix(address, "stun:") {
-			ip, err := webrtc.GetPublicIP()
-			if err != nil {
-				log.Warn().Err(err).Msg("[webrtc] public IP")
-				continue
-			}
-			address = ip.String() + address[4:]
-		}
-
-		cand, err := webrtc.NewCandidate(address)
-		if err != nil {
-			log.Warn().Err(err).Msg("[webrtc] candidate")
-			continue
-		}
-
-		conn.Fire(&streamer.Message{
-			Type: webrtc.MsgTypeCandidate, Value: cand,
-		})
-	}
-
-	ctx.Consumer = conn
-}
-
-func candidateHandler(ctx *api.Context, msg *streamer.Message) {
-	if ctx.Consumer == nil {
-		return
-	}
-	if conn := ctx.Consumer.(*webrtc.Conn); conn != nil {
-		log.Trace().Str("candidate", msg.Value.(string)).Msg("[webrtc] Remote")
-		conn.Push(msg)
-	}
-}

docker/Dockerfile

@@ -0,0 +1,64 @@
+# syntax=docker/dockerfile:labs
+
+# 0. Prepare images
+ARG PYTHON_VERSION="3.13"
+ARG GO_VERSION="1.26"
+
+
+# 1. Build go2rtc binary
+FROM --platform=$BUILDPLATFORM golang:${GO_VERSION}-alpine AS build
+ARG TARGETPLATFORM
+ARG TARGETOS
+ARG TARGETARCH
+
+ENV GOOS=${TARGETOS}
+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
+
+COPY . .
+RUN --mount=type=cache,target=/root/.cache/go-build CGO_ENABLED=0 go build -ldflags "-s -w" -trimpath
+
+
+# 2. Download CDN dependencies for offline web UI
+FROM alpine AS download-cdn
+RUN apk add --no-cache wget
+COPY www/ /web/
+COPY docker/download_cdn.sh /tmp/
+RUN sh /tmp/download_cdn.sh /web
+
+
+# 3. 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 ffplay bash curl jq alsa-plugins-pulse font-droid
+
+# Hardware Acceleration for Intel CPU (+50MB)
+ARG TARGETARCH
+
+RUN if [ "${TARGETARCH}" = "amd64" ]; then apk add --no-cache libva-intel-driver intel-media-driver; fi
+
+# Hardware: AMD and NVidia VAAPI (not sure about this)
+# RUN libva-glx mesa-va-gallium
+# Hardware: AMD and NVidia VDPAU (not sure about this)
+# RUN libva-vdpau-driver mesa-vdpau-gallium (+150MB total)
+
+COPY --from=build /build/go2rtc /usr/local/bin/
+COPY --from=download-cdn /web /var/www/go2rtc
+COPY --chmod=755 docker/entrypoint.sh /usr/local/bin/
+
+EXPOSE 1984 8554 8555 8555/udp
+ENTRYPOINT ["/sbin/tini", "--", "/usr/local/bin/entrypoint.sh"]
+VOLUME /config
+WORKDIR /config
+

docker/README.md

@@ -0,0 +1,54 @@
+# Docker
+
+Images are built automatically via [GitHub actions](https://github.com/AlexxIT/go2rtc/actions) and published on [Docker Hub](https://hub.docker.com/r/alexxit/go2rtc) and [GitHub](https://github.com/AlexxIT/go2rtc/pkgs/container/go2rtc).
+
+## Versions
+
+- `alexxit/go2rtc:latest` - latest release based on `alpine` (`amd64`, `386`, `arm/v6`, `arm/v7`, `arm64`) with support for hardware transcoding for Intel iGPU and Raspberry
+- `alexxit/go2rtc:latest-hardware` - latest release based on `debian 13` (`amd64`) with support for hardware transcoding for Intel iGPU, AMD GPU and NVidia GPU
+- `alexxit/go2rtc:latest-rockchip` - latest release based on `debian 12` (`arm64`) with support for hardware transcoding for Rockchip RK35xx
+- `ghcr.io/AlexxIT/go2rtc:dev` - latest unstable version based on `alpine`
+- `ghcr.io/AlexxIT/go2rtc:dev-hardware` - latest unstable version based on `debian 13` (`amd64`)
+- `ghcr.io/AlexxIT/go2rtc:dev-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/cdn_test.go

@@ -0,0 +1,407 @@
+package docker_test
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+	"testing"
+)
+
+// cdnURLPattern is the same regex used by download_cdn.sh to extract CDN URLs.
+var cdnURLPattern = regexp.MustCompile(`https://cdn\.jsdelivr\.net/npm/[^"' )\x60]*`)
+
+// HTML fixtures that mirror the real www/*.html files.
+var htmlFixtures = map[string]string{
+	"hls.html": `<!doctype html>
+<html lang="en">
+<body>
+<script src="https://cdn.jsdelivr.net/npm/hls.js@1"></script>
+<video id="video"></video>
+</body>
+</html>`,
+
+	"config.html": `<!DOCTYPE html>
+<html lang="en">
+<body>
+<script src="https://cdn.jsdelivr.net/npm/monaco-editor@0.55.1/min/vs/loader.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/js-yaml@4.1.0/dist/js-yaml.min.js"></script>
+<script>
+    const monacoRoot = 'https://cdn.jsdelivr.net/npm/monaco-editor@0.55.1/min';
+    window.MonacoEnvironment = {
+        getWorkerUrl: function () {
+            return ` + "`" + `data:text/javascript;charset=utf-8,${encodeURIComponent(` + "`" + `
+                self.MonacoEnvironment = { baseUrl: '${monacoRoot}/' };
+                importScripts('${monacoRoot}/vs/base/worker/workerMain.js');
+            ` + "`" + `)}` + "`" + `;
+        }
+    };
+    require.config({paths: {vs: ` + "`" + `${monacoRoot}/vs` + "`" + `}});
+</script>
+</body>
+</html>`,
+
+	"net.html": `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <script src="https://cdn.jsdelivr.net/npm/vis-network@10.0.2/standalone/umd/vis-network.min.js"></script>
+</head>
+<body></body>
+</html>`,
+
+	"links.html": `<!DOCTYPE html>
+<html lang="en">
+<body>
+<script>
+    const script = document.createElement('script');
+    script.src = 'https://cdn.jsdelivr.net/npm/qrcodejs@1.0.0/qrcode.min.js';
+    document.head.appendChild(script);
+</script>
+</body>
+</html>`,
+}
+
+func parseCDNURL(rawURL string) (pkgName, filePath, localURL string) {
+	npmPath := strings.TrimPrefix(rawURL, "https://cdn.jsdelivr.net/npm/")
+
+	parts := strings.SplitN(npmPath, "/", 2)
+	pkgVer := parts[0]
+
+	if len(parts) > 1 {
+		filePath = parts[1]
+	}
+
+	// Remove @version suffix to get package name
+	if idx := strings.LastIndex(pkgVer, "@"); idx > 0 {
+		pkgName = pkgVer[:idx]
+	} else {
+		pkgName = pkgVer
+	}
+
+	if filePath != "" {
+		localURL = "cdn/" + pkgName + "/" + filePath
+	} else {
+		localURL = "cdn/" + pkgName + "/index.js"
+	}
+	return
+}
+
+// extractURLs finds all CDN URLs in the given HTML content.
+func extractURLs(htmlFiles map[string]string) []string {
+	seen := map[string]bool{}
+	for _, content := range htmlFiles {
+		for _, match := range cdnURLPattern.FindAllString(content, -1) {
+			seen[match] = true
+		}
+	}
+	urls := make([]string, 0, len(seen))
+	for u := range seen {
+		urls = append(urls, u)
+	}
+	sort.Strings(urls)
+	return urls
+}
+
+// patchHTML replaces all CDN URLs in content with local paths.
+func patchHTML(content string, urls []string) string {
+	for _, u := range urls {
+		_, _, localURL := parseCDNURL(u)
+		content = strings.ReplaceAll(content, u, localURL)
+	}
+	return content
+}
+
+func TestExtractURLs(t *testing.T) {
+	urls := extractURLs(htmlFixtures)
+
+	expected := []string{
+		"https://cdn.jsdelivr.net/npm/hls.js@1",
+		"https://cdn.jsdelivr.net/npm/js-yaml@4.1.0/dist/js-yaml.min.js",
+		"https://cdn.jsdelivr.net/npm/monaco-editor@0.55.1/min",
+		"https://cdn.jsdelivr.net/npm/monaco-editor@0.55.1/min/vs/loader.js",
+		"https://cdn.jsdelivr.net/npm/qrcodejs@1.0.0/qrcode.min.js",
+		"https://cdn.jsdelivr.net/npm/vis-network@10.0.2/standalone/umd/vis-network.min.js",
+	}
+
+	if len(urls) != len(expected) {
+		t.Fatalf("expected %d URLs, got %d: %v", len(expected), len(urls), urls)
+	}
+	for i, u := range urls {
+		if u != expected[i] {
+			t.Errorf("URL[%d]: expected %q, got %q", i, expected[i], u)
+		}
+	}
+}
+
+func TestParseCDNURL(t *testing.T) {
+	tests := []struct {
+		url      string
+		pkgName  string
+		filePath string
+		localURL string
+	}{
+		{
+			url:      "https://cdn.jsdelivr.net/npm/hls.js@1",
+			pkgName:  "hls.js",
+			filePath: "",
+			localURL: "cdn/hls.js/index.js",
+		},
+		{
+			url:      "https://cdn.jsdelivr.net/npm/js-yaml@4.1.0/dist/js-yaml.min.js",
+			pkgName:  "js-yaml",
+			filePath: "dist/js-yaml.min.js",
+			localURL: "cdn/js-yaml/dist/js-yaml.min.js",
+		},
+		{
+			url:      "https://cdn.jsdelivr.net/npm/monaco-editor@0.55.1/min/vs/loader.js",
+			pkgName:  "monaco-editor",
+			filePath: "min/vs/loader.js",
+			localURL: "cdn/monaco-editor/min/vs/loader.js",
+		},
+		{
+			url:      "https://cdn.jsdelivr.net/npm/monaco-editor@0.55.1/min",
+			pkgName:  "monaco-editor",
+			filePath: "min",
+			localURL: "cdn/monaco-editor/min",
+		},
+		{
+			url:      "https://cdn.jsdelivr.net/npm/vis-network@10.0.2/standalone/umd/vis-network.min.js",
+			pkgName:  "vis-network",
+			filePath: "standalone/umd/vis-network.min.js",
+			localURL: "cdn/vis-network/standalone/umd/vis-network.min.js",
+		},
+		{
+			url:      "https://cdn.jsdelivr.net/npm/qrcodejs@1.0.0/qrcode.min.js",
+			pkgName:  "qrcodejs",
+			filePath: "qrcode.min.js",
+			localURL: "cdn/qrcodejs/qrcode.min.js",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.pkgName, func(t *testing.T) {
+			pkgName, filePath, localURL := parseCDNURL(tt.url)
+			if pkgName != tt.pkgName {
+				t.Errorf("pkgName: expected %q, got %q", tt.pkgName, pkgName)
+			}
+			if filePath != tt.filePath {
+				t.Errorf("filePath: expected %q, got %q", tt.filePath, filePath)
+			}
+			if localURL != tt.localURL {
+				t.Errorf("localURL: expected %q, got %q", tt.localURL, localURL)
+			}
+		})
+	}
+}
+
+func TestPatchHTML(t *testing.T) {
+	urls := extractURLs(htmlFixtures)
+
+	t.Run("hls", func(t *testing.T) {
+		patched := patchHTML(htmlFixtures["hls.html"], urls)
+		if !strings.Contains(patched, `src="cdn/hls.js/index.js"`) {
+			t.Error("hls.js src not patched")
+		}
+		if strings.Contains(patched, "cdn.jsdelivr.net") {
+			t.Error("CDN URL still present")
+		}
+		if !strings.Contains(patched, `<video id="video">`) {
+			t.Error("non-CDN content damaged")
+		}
+	})
+
+	t.Run("config", func(t *testing.T) {
+		patched := patchHTML(htmlFixtures["config.html"], urls)
+		if !strings.Contains(patched, `src="cdn/monaco-editor/min/vs/loader.js"`) {
+			t.Error("monaco loader.js src not patched")
+		}
+		if !strings.Contains(patched, `src="cdn/js-yaml/dist/js-yaml.min.js"`) {
+			t.Error("js-yaml src not patched")
+		}
+		if !strings.Contains(patched, "monacoRoot = 'cdn/monaco-editor/min'") {
+			t.Error("monacoRoot variable not patched")
+		}
+		// Dynamic references via ${monacoRoot} must remain untouched
+		if !strings.Contains(patched, "${monacoRoot}/") {
+			t.Error("dynamic monacoRoot references damaged")
+		}
+		if strings.Contains(patched, "cdn.jsdelivr.net") {
+			t.Error("CDN URL still present")
+		}
+		if !strings.Contains(patched, "require.config") {
+			t.Error("non-CDN content damaged")
+		}
+	})
+
+	t.Run("net", func(t *testing.T) {
+		patched := patchHTML(htmlFixtures["net.html"], urls)
+		if !strings.Contains(patched, `src="cdn/vis-network/standalone/umd/vis-network.min.js"`) {
+			t.Error("vis-network src not patched")
+		}
+		if strings.Contains(patched, "cdn.jsdelivr.net") {
+			t.Error("CDN URL still present")
+		}
+	})
+
+	t.Run("links", func(t *testing.T) {
+		patched := patchHTML(htmlFixtures["links.html"], urls)
+		if !strings.Contains(patched, "src = 'cdn/qrcodejs/qrcode.min.js'") {
+			t.Error("qrcodejs src not patched")
+		}
+		if strings.Contains(patched, "cdn.jsdelivr.net") {
+			t.Error("CDN URL still present")
+		}
+		if !strings.Contains(patched, "document.createElement") {
+			t.Error("non-CDN content damaged")
+		}
+	})
+}
+
+func TestExtractURLsFromRealFiles(t *testing.T) {
+	// Verify the regex works against the actual www/*.html files
+	wwwDir := filepath.Join("..", "www")
+	entries, err := filepath.Glob(filepath.Join(wwwDir, "*.html"))
+	if err != nil || len(entries) == 0 {
+		t.Skip("www/*.html not found, skipping real file test")
+	}
+
+	realFiles := map[string]string{}
+	for _, path := range entries {
+		data, err := os.ReadFile(path)
+		if err != nil {
+			t.Fatalf("reading %s: %v", path, err)
+		}
+		realFiles[filepath.Base(path)] = string(data)
+	}
+
+	urls := extractURLs(realFiles)
+	if len(urls) < 5 {
+		t.Errorf("expected at least 5 CDN URLs in real files, got %d: %v", len(urls), urls)
+	}
+
+	// Every URL must be parseable
+	for _, u := range urls {
+		pkgName, _, localURL := parseCDNURL(u)
+		if pkgName == "" {
+			t.Errorf("failed to parse package name from %q", u)
+		}
+		if localURL == "" {
+			t.Errorf("failed to generate local URL for %q", u)
+		}
+	}
+}
+
+func TestMonacoVersionExtraction(t *testing.T) {
+	urls := extractURLs(htmlFixtures)
+
+	var monacoVer string
+	for _, u := range urls {
+		pkgName, _, _ := parseCDNURL(u)
+		if pkgName == "monaco-editor" {
+			npmPath := strings.TrimPrefix(u, "https://cdn.jsdelivr.net/npm/")
+			pkgVer := strings.SplitN(npmPath, "/", 2)[0]
+			if idx := strings.LastIndex(pkgVer, "@"); idx > 0 {
+				monacoVer = pkgVer[idx+1:]
+			}
+			break
+		}
+	}
+
+	if monacoVer != "0.55.1" {
+		t.Errorf("expected monaco version 0.55.1, got %q", monacoVer)
+	}
+}
+
+func TestEntrypoint(t *testing.T) {
+	// Find the entrypoint.sh relative to the test file
+	entrypoint := filepath.Join("entrypoint.sh")
+	if _, err := os.Stat(entrypoint); err != nil {
+		t.Skipf("entrypoint.sh not found: %v", err)
+	}
+
+	tmpDir := t.TempDir()
+
+	// Create a mock go2rtc that prints its arguments
+	mockBin := filepath.Join(tmpDir, "go2rtc")
+	os.WriteFile(mockBin, []byte("#!/bin/sh\necho \"$@\"\n"), 0755)
+
+	// Read the entrypoint script and adapt for testing:
+	// replace "exec " with "" so the mock go2rtc output is captured,
+	// replace hardcoded /var/www/go2rtc with our temp path.
+	data, err := os.ReadFile(entrypoint)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	webDir := filepath.Join(tmpDir, "var", "www", "go2rtc")
+	script := strings.ReplaceAll(string(data), "exec ", "")
+	script = strings.ReplaceAll(script, "/var/www/go2rtc", webDir)
+	script = strings.ReplaceAll(script, "/config/go2rtc.yaml", "/tmp/test.yaml")
+
+	testScript := filepath.Join(tmpDir, "test_entrypoint.sh")
+	os.WriteFile(testScript, []byte(script), 0755)
+
+	run := func(extraArgs ...string) string {
+		args := append([]string{testScript}, extraArgs...)
+		cmd := exec.Command("sh", args...)
+		cmd.Env = append(os.Environ(), "PATH="+tmpDir+":"+os.Getenv("PATH"))
+		out, err := cmd.Output()
+		if err != nil {
+			t.Fatalf("entrypoint failed: %v", err)
+		}
+		return strings.TrimSpace(string(out))
+	}
+
+	t.Run("with_web_dir", func(t *testing.T) {
+		os.MkdirAll(webDir, 0755)
+		defer os.RemoveAll(filepath.Join(tmpDir, "var"))
+
+		result := run("--extra-flag")
+
+		if !strings.Contains(result, "static_dir") {
+			t.Error("static_dir not added when web dir exists")
+		}
+		if !strings.Contains(result, "-config /tmp/test.yaml") {
+			t.Error("user config not present")
+		}
+		if !strings.Contains(result, "--extra-flag") {
+			t.Error("extra args not passed through")
+		}
+	})
+
+	t.Run("without_web_dir", func(t *testing.T) {
+		os.RemoveAll(filepath.Join(tmpDir, "var"))
+
+		result := run("--extra-flag")
+
+		if strings.Contains(result, "static_dir") {
+			t.Error("static_dir added when web dir absent")
+		}
+		if !strings.Contains(result, "-config /tmp/test.yaml") {
+			t.Error("user config not present")
+		}
+		if !strings.Contains(result, "--extra-flag") {
+			t.Error("extra args not passed through")
+		}
+	})
+
+	t.Run("config_order", func(t *testing.T) {
+		os.MkdirAll(webDir, 0755)
+		defer os.RemoveAll(filepath.Join(tmpDir, "var"))
+
+		result := run()
+
+		// static_dir config must come BEFORE user config
+		// so user config can override it
+		staticIdx := strings.Index(result, "static_dir")
+		yamlIdx := strings.Index(result, "/tmp/test.yaml")
+		if staticIdx < 0 || yamlIdx < 0 {
+			t.Fatalf("expected both configs in output: %q", result)
+		}
+		if staticIdx > yamlIdx {
+			t.Errorf("static_dir config should come before user config for correct override order, got: %q", result)
+		}
+	})
+}

docker/download_cdn.sh

@@ -0,0 +1,105 @@
+#!/bin/sh
+# Downloads CDN dependencies from jsdelivr for offline web UI.
+# Automatically parses CDN URLs from HTML files, so updating
+# a library version in HTML is all that's needed.
+#
+# Usage: download_cdn.sh <web_dir>
+set -e
+
+WEB_DIR="${1:?Usage: download_cdn.sh <web_dir>}"
+CDN_DIR="$WEB_DIR/cdn"
+mkdir -p "$CDN_DIR"
+
+# Step 1: Extract all jsdelivr CDN URLs from HTML files
+URLS=$(grep -roh 'https://cdn\.jsdelivr\.net/npm/[^"'"'"' )`]*' "$WEB_DIR"/*.html | sort -u)
+
+echo "=== Found CDN URLs ==="
+echo "$URLS"
+echo ""
+
+# Step 2: Process each URL
+MONACO_VER=""
+for url in $URLS; do
+    # Remove CDN prefix to get npm path
+    npm_path="${url#https://cdn.jsdelivr.net/npm/}"
+
+    # Extract package@version and file path
+    pkg_ver=$(echo "$npm_path" | cut -d/ -f1)
+    remaining=$(echo "$npm_path" | cut -d/ -f2-)
+    if [ "$remaining" = "$npm_path" ]; then
+        file_path=""
+    else
+        file_path="$remaining"
+    fi
+
+    pkg_name=$(echo "$pkg_ver" | sed 's/@[^@]*$//')
+
+    # Monaco editor: remember version, download as tarball later
+    case "$pkg_name" in
+        monaco-editor)
+            MONACO_VER=$(echo "$pkg_ver" | sed 's/.*@//')
+            echo "Monaco editor v$MONACO_VER (will download tarball)"
+            continue
+            ;;
+    esac
+
+    # Determine local file path
+    if [ -n "$file_path" ]; then
+        local_file="$CDN_DIR/$pkg_name/$file_path"
+    else
+        local_file="$CDN_DIR/$pkg_name/index.js"
+    fi
+
+    mkdir -p "$(dirname "$local_file")"
+    echo "Downloading $pkg_ver -> $local_file"
+    wget -q -O "$local_file" "$url"
+done
+
+# Step 3: Download monaco-editor tarball and extract min/ directory
+# The AMD loader dynamically loads modules, so we need the entire min/vs/ tree
+if [ -n "$MONACO_VER" ]; then
+    echo ""
+    echo "=== Downloading monaco-editor@$MONACO_VER tarball ==="
+
+    TARBALL_URL=$(wget -q -O - "https://registry.npmjs.org/monaco-editor/$MONACO_VER" | \
+        grep -o '"tarball":"[^"]*"' | head -1 | cut -d'"' -f4)
+
+    mkdir -p /tmp/monaco "$CDN_DIR/monaco-editor"
+    wget -q -O /tmp/monaco.tgz "$TARBALL_URL"
+    tar xzf /tmp/monaco.tgz -C /tmp/monaco
+
+    cp -r /tmp/monaco/package/min "$CDN_DIR/monaco-editor/"
+    rm -rf /tmp/monaco /tmp/monaco.tgz
+
+    echo "  Extracted min/ directory ($(du -sh "$CDN_DIR/monaco-editor/min" | cut -f1))"
+fi
+
+# Step 4: Patch HTML files to use local paths instead of CDN URLs
+echo ""
+echo "=== Patching HTML files ==="
+for url in $URLS; do
+    npm_path="${url#https://cdn.jsdelivr.net/npm/}"
+
+    pkg_ver=$(echo "$npm_path" | cut -d/ -f1)
+    remaining=$(echo "$npm_path" | cut -d/ -f2-)
+    if [ "$remaining" = "$npm_path" ]; then
+        file_path=""
+    else
+        file_path="$remaining"
+    fi
+
+    pkg_name=$(echo "$pkg_ver" | sed 's/@[^@]*$//')
+
+    if [ -n "$file_path" ]; then
+        local_url="cdn/$pkg_name/$file_path"
+    else
+        local_url="cdn/$pkg_name/index.js"
+    fi
+
+    echo "  $url -> $local_url"
+    sed -i "s|$url|$local_url|g" "$WEB_DIR"/*.html
+done
+
+echo ""
+echo "=== Done ==="
+du -sh "$CDN_DIR"

docker/entrypoint.sh

@@ -0,0 +1,12 @@
+#!/bin/sh
+# Entrypoint wrapper for go2rtc Docker container.
+# If /var/www/go2rtc exists (CDN files bundled), automatically
+# configures static_dir to serve web UI without internet access.
+if [ -d /var/www/go2rtc ]; then
+    exec go2rtc \
+        -config '{"api":{"static_dir":"/var/www/go2rtc"}}' \
+        -config /config/go2rtc.yaml \
+        "$@"
+else
+    exec go2rtc -config /config/go2rtc.yaml "$@"
+fi

docker/hardware.Dockerfile

@@ -0,0 +1,69 @@
+# syntax=docker/dockerfile:labs
+
+# 0. Prepare images
+# only debian 13 (trixie) has latest ffmpeg
+# https://packages.debian.org/trixie/ffmpeg
+ARG DEBIAN_VERSION="trixie-slim"
+ARG GO_VERSION="1.26-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. Download CDN dependencies for offline web UI
+FROM alpine AS download-cdn
+RUN apk add --no-cache wget
+COPY www/ /web/
+COPY docker/download_cdn.sh /tmp/
+RUN sh /tmp/download_cdn.sh /web
+
+
+# 3. Final image
+FROM debian:${DEBIAN_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.
+# 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 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 \
+        mesa-va-drivers \
+        libasound2-plugins && \
+    apt-get clean && rm -rf /var/lib/apt/lists/*
+
+COPY --from=build /build/go2rtc /usr/local/bin/
+COPY --from=download-cdn /web /var/www/go2rtc
+COPY --chmod=755 docker/entrypoint.sh /usr/local/bin/
+
+EXPOSE 1984 8554 8555 8555/udp
+ENTRYPOINT ["/usr/bin/tini", "--", "/usr/local/bin/entrypoint.sh"]
+VOLUME /config
+WORKDIR /config
+# https://github.com/NVIDIA/nvidia-docker/wiki/Installation-(Native-GPU-Support)
+ENV NVIDIA_VISIBLE_DEVICES all
+ENV NVIDIA_DRIVER_CAPABILITIES compute,video,utility
+

docker/rockchip.Dockerfile

@@ -0,0 +1,59 @@
+# syntax=docker/dockerfile:labs
+
+# 0. Prepare images
+ARG PYTHON_VERSION="3.13-slim-bookworm"
+ARG GO_VERSION="1.26-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. Download CDN dependencies for offline web UI
+FROM alpine AS download-cdn
+RUN apk add --no-cache wget
+COPY www/ /web/
+COPY docker/download_cdn.sh /tmp/
+RUN sh /tmp/download_cdn.sh /web
+
+
+# 3. 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
+COPY --from=download-cdn /web /var/www/go2rtc
+COPY --chmod=755 docker/entrypoint.sh /usr/local/bin/
+
+EXPOSE 1984 8554 8555 8555/udp
+ENTRYPOINT ["/usr/bin/tini", "--", "/usr/local/bin/entrypoint.sh"]
+VOLUME /config
+WORKDIR /config

examples/go2rtc_hass/main.go

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

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/go2rtc_rtsp/main.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/rtsp"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/shell"
+)
+
+func main() {
+	app.Init()
+	streams.Init()
+
+	rtsp.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/mdns/main.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"log"
+	"os"
+
+	"github.com/AlexxIT/go2rtc/pkg/mdns"
+)
+
+func main() {
+	var service = mdns.ServiceHAP
+
+	if len(os.Args) >= 2 {
+		service = os.Args[1]
+	}
+
+	onentry := func(entry *mdns.ServiceEntry) bool {
+		log.Printf("name=%s, addr=%s, info=%s\n", entry.Name, entry.Addr(), entry.Info)
+		return false
+	}
+
+	var err error
+
+	if len(os.Args) >= 3 {
+		host := os.Args[2]
+
+		log.Printf("run discovery service=%s host=%s\n", service, host)
+
+		err = mdns.QueryOrDiscovery(host, service, onentry)
+	} else {
+		log.Printf("run discovery service=%s\n", service)
+
+		err = mdns.Discovery(service, onentry)
+	}
+
+	if err != nil {
+		log.Println(err)
+	}
+}

examples/mod_pinggy/go.mod

@@ -0,0 +1,9 @@
+module pinggy
+
+go 1.26
+
+require (
+	github.com/Pinggy-io/pinggy-go/pinggy v0.6.9 // indirect
+	golang.org/x/crypto v0.8.0 // indirect
+	golang.org/x/sys v0.7.0 // indirect
+)

examples/mod_pinggy/go.sum

@@ -0,0 +1,39 @@
+github.com/Pinggy-io/pinggy-go/pinggy v0.6.9 h1:lzZ00JK6BUGQXnpkJZ+cVj8kIkXsmiVBUci9uEkSwEY=
+github.com/Pinggy-io/pinggy-go/pinggy v0.6.9/go.mod h1:V1Sxb+4zyr36o9atZiqtT4XhsKtW1RSb2GvsbTbTJYw=
+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-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.8.0 h1:pd9TJtTueMTVQXzk8E2XESSMQDj/U7OUu0PqJqPXQjQ=
+golang.org/x/crypto v0.8.0/go.mod h1:mRqEX+O9/h5TFCrQhkgjo2yKi0yYA+9ecGkdQoHrywE=
+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/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/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/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/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=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU=
+golang.org/x/sys v0.7.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.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
+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.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+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.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

examples/mod_pinggy/main.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"log"
+	"os"
+
+	"github.com/Pinggy-io/pinggy-go/pinggy"
+)
+
+func main() {
+	tunType := os.Args[1]
+	address := os.Args[2]
+
+	log.SetFlags(log.Llongfile | log.LstdFlags)
+
+	config := pinggy.Config{
+		Type:              pinggy.TunnelType(tunType),
+		TcpForwardingAddr: address,
+
+		//SshOverSsl: true,
+		//Stdout:     os.Stderr,
+		//Stderr:     os.Stderr,
+	}
+
+	if tunType == "http" {
+		hman := pinggy.CreateHeaderManipulationAndAuthConfig()
+		//hman.SetReverseProxy(address)
+		//hman.SetPassPreflight(true)
+		//hman.SetNoReverseProxy()
+		config.HeaderManipulationAndAuth = hman
+	}
+
+	pl, err := pinggy.ConnectWithConfig(config)
+	if err != nil {
+		log.Panicln(err)
+	}
+	log.Println("Addrs: ", pl.RemoteUrls())
+	//err = pl.InitiateWebDebug("localhost:3424")
+	//log.Println(err)
+	pl.StartForwarding()
+}

examples/onvif_client/README.md

@@ -0,0 +1,5 @@
+## ONVIF Client
+
+```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.go

@@ -1,58 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"github.com/AlexxIT/go2rtc/pkg/rtsp"
-	"github.com/pion/rtp"
-	"os"
-	"time"
-)
-
-func main() {
-	client, err := rtsp.NewClient(os.Args[1])
-	if err != nil {
-		panic(err)
-	}
-
-	if err = client.Dial(); err != nil {
-		panic(err)
-	}
-	if err = client.Describe(); err != nil {
-		panic(err)
-	}
-
-	for _, media := range client.GetMedias() {
-		fmt.Printf("Media: %v\n", media)
-
-		if media.AV() {
-			track := client.GetTrack(media, media.Codecs[0])
-			fmt.Printf("Track: %v, %v\n", track, track.Codec)
-
-			track.Bind(func(packet *rtp.Packet) error {
-				nalUnitType := packet.Payload[0] & 0x1F
-				fmt.Printf(
-					"[RTP] codec: %s, nalu: %2d, size: %6d, ts: %10d, pt: %2d, ssrc: %d\n",
-					track.Codec.Name, nalUnitType, len(packet.Payload), packet.Timestamp,
-					packet.PayloadType, packet.SSRC,
-				)
-				return nil
-			})
-		}
-	}
-
-	if err = client.Play(); err != nil {
-		panic(err)
-	}
-
-	time.AfterFunc(time.Second*5, func() {
-		if err = client.Close(); err != nil {
-			panic(err)
-		}
-	})
-
-	if err = client.Handle(); err != nil {
-		panic(err)
-	}
-
-	fmt.Println("The End")
-}

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()
+}

examples/tutk_decoder/README.md

@@ -0,0 +1,5 @@
+# tutk_decoder
+
+1. Wireshark > Select any packet > Follow > UDP Stream
+2. Wireshark > File > Export Packet Dissections > As JSON > Displayed, Values
+3. `tutk_decoder wireshark.json decoded.txt`

examples/tutk_decoder/main.go

@@ -0,0 +1,82 @@
+package main
+
+import (
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"log"
+	"os"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/pkg/tutk"
+)
+
+func main() {
+	if len(os.Args) != 3 {
+		fmt.Println("Usage: tutk_decoder wireshark.json decoded.txt")
+		return
+	}
+
+	src, err := os.Open(os.Args[1])
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer src.Close()
+
+	dst, err := os.Create(os.Args[2])
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer dst.Close()
+
+	var items []item
+	if err = json.NewDecoder(src).Decode(&items); err != nil {
+		log.Fatal(err)
+	}
+
+	var b []byte
+
+	for _, v := range items {
+		if v.Source.Layers.Data.DataData == "" {
+			continue
+		}
+
+		s := strings.ReplaceAll(v.Source.Layers.Data.DataData, ":", "")
+		b, err = hex.DecodeString(s)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		tutk.ReverseTransCodePartial(b, b)
+
+		ts := v.Source.Layers.Frame.FrameTimeRelative
+
+		_, _ = fmt.Fprintf(dst, "%8s: %s -> %s [%4d] %x\n",
+			ts[:len(ts)-6],
+			v.Source.Layers.Ip.IpSrc, v.Source.Layers.Ip.IpDst,
+			len(b), b)
+	}
+}
+
+type item struct {
+	Source struct {
+		Layers struct {
+			Frame struct {
+				FrameTimeRelative string `json:"frame.time_relative"`
+				FrameNumber       string `json:"frame.number"`
+			} `json:"frame"`
+			Ip struct {
+				IpSrc string `json:"ip.src"`
+				IpDst string `json:"ip.dst"`
+			} `json:"ip"`
+			Udp struct {
+				UdpSrcport string `json:"udp.srcport"`
+				UdpDstport string `json:"udp.dstport"`
+			} `json:"udp"`
+			Data struct {
+				DataData string `json:"data.data"`
+				DataLen  string `json:"data.len"`
+			} `json:"data"`
+		} `json:"layers"`
+	} `json:"_source"`
+}

go.mod

@@ -1,41 +1,50 @@
 module github.com/AlexxIT/go2rtc
 
-go 1.17
+go 1.26.1
 
 require (
-	github.com/deepch/vdk v0.0.19
-	github.com/gorilla/websocket v1.5.0
-	github.com/pion/ice/v2 v2.2.6
-	github.com/pion/interceptor v0.1.11
-	github.com/pion/logging v0.2.2
-	github.com/pion/rtcp v1.2.9
-	github.com/pion/rtp v1.7.13
-	github.com/pion/sdp/v3 v3.0.5
-	github.com/pion/stun v0.3.5
-	github.com/pion/webrtc/v3 v3.1.43
-	github.com/rs/zerolog v1.27.0
-	github.com/stretchr/testify v1.7.1
+	github.com/eclipse/paho.mqtt.golang v1.5.1
+	github.com/expr-lang/expr v1.17.7
+	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.70
+	github.com/pion/dtls/v3 v3.0.10
+	github.com/pion/ice/v4 v4.2.0
+	github.com/pion/interceptor v0.1.43
+	github.com/pion/rtcp v1.2.16
+	github.com/pion/rtp v1.10.0
+	github.com/pion/sdp/v3 v3.0.17
+	github.com/pion/srtp/v3 v3.0.10
+	github.com/pion/stun/v3 v3.1.1
+	github.com/pion/webrtc/v4 v4.2.3
+	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/skrashevich/go-webp v0.1.0
+	github.com/stretchr/testify v1.11.1
+	github.com/tadglines/go-pkgs v0.0.0-20210623144937-b983b20f54f9
+	golang.org/x/crypto v0.47.0
+	golang.org/x/net v0.49.0
 	gopkg.in/yaml.v3 v3.0.1
 )
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/google/uuid v1.3.0 // indirect
-	github.com/mattn/go-colorable v0.1.12 // indirect
-	github.com/mattn/go-isatty v0.0.14 // indirect
-	github.com/pion/datachannel v1.5.2 // indirect
-	github.com/pion/dtls/v2 v2.1.5 // indirect
-	github.com/pion/mdns v0.0.5 // indirect
+	github.com/kr/pretty v0.3.1 // indirect
+	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/pion/datachannel v1.6.0 // indirect
+	github.com/pion/logging v0.2.4 // indirect
+	github.com/pion/mdns/v2 v2.1.0 // indirect
 	github.com/pion/randutil v0.1.0 // indirect
-	github.com/pion/sctp v1.8.2 // indirect
-	github.com/pion/srtp/v2 v2.0.10 // indirect
-	github.com/pion/transport v0.13.1 // indirect
-	github.com/pion/turn/v2 v2.0.8 // indirect
-	github.com/pion/udp v0.1.1 // indirect
+	github.com/pion/sctp v1.9.2 // indirect
+	github.com/pion/transport/v4 v4.0.1 // indirect
+	github.com/pion/turn/v4 v4.1.4 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	golang.org/x/crypto v0.0.0-20220516162934-403b01795ae8 // indirect
-	golang.org/x/net v0.0.0-20220630215102-69896b714898 // indirect
-	golang.org/x/sys v0.0.0-20220622161953-175b2fd9d664 // indirect
+	github.com/wlynxg/anet v0.0.5 // indirect
+	golang.org/x/mod v0.32.0 // indirect
+	golang.org/x/sync v0.19.0 // indirect
+	golang.org/x/sys v0.40.0 // indirect
+	golang.org/x/time v0.14.0 // indirect
+	golang.org/x/tools v0.41.0 // indirect
 )
-
-replace github.com/deepch/vdk v0.0.19 => github.com/AlexxIT/vdk v0.0.18-0.20220616041030-b0d122807b2e

go.sum

@@ -1,221 +1,109 @@
-github.com/AlexxIT/vdk v0.0.18-0.20220616041030-b0d122807b2e h1:NAgHHZB+JUN3/J4/yq1q1EAc8xwJ8bb/Qp0AcjkfzAA=
-github.com/AlexxIT/vdk v0.0.18-0.20220616041030-b0d122807b2e/go.mod h1:KqQ/KU3hOc4a62l/jPRH5Hiz5fhTq5cGCl8IqeCxWQI=
-github.com/cheekybits/genny v1.0.0/go.mod h1:+tQajlRqAUrPI7DOSpB0XAqZYtQakVtB7wXkRAgjxjQ=
-github.com/coreos/go-systemd/v22 v22.3.3-0.20220203105225-a9a7ef127534/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/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.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-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
+github.com/eclipse/paho.mqtt.golang v1.5.1 h1:/VSOv3oDLlpqR2Epjn1Q7b2bSTplJIeV2ISgCl2W7nE=
+github.com/eclipse/paho.mqtt.golang v1.5.1/go.mod h1:1/yJCneuyOoCOzKSsOTUc0AJfpsItBGWvYpBLimhArU=
+github.com/expr-lang/expr v1.17.7 h1:Q0xY/e/2aCIp8g9s/LGvMDCC5PxYlvHgDZRQ4y16JX8=
+github.com/expr-lang/expr v1.17.7/go.mod h1:8/vRC7+7HBzESEqt5kKpYXxrxkr31SaO8r40VO/1IT4=
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
-github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
-github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
-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.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
-github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
-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 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/lucas-clemente/quic-go v0.7.1-0.20190401152353-907071221cf9/go.mod h1:PpMmPfPKO9nKJ/psF49ESTAGQSdfXxlg1otPbEB2nOw=
-github.com/marten-seemann/qtls v0.2.3/go.mod h1:xzjG7avBwGGbdZ8dTGxlBnLArsVKLvwmjgmPuiQEcYk=
-github.com/mattn/go-colorable v0.1.12 h1:jF+Du6AlPIjs2BiUiQlKOX0rt3SujHxPnksPKZbaA40=
-github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
-github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
-github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
-github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
-github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
-github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
-github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0=
-github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU=
-github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
-github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
-github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
-github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY=
-github.com/pion/datachannel v1.4.21/go.mod h1:oiNyP4gHx2DIwRzX/MFyH0Rz/Gz05OgBlayAI2hAWjg=
-github.com/pion/datachannel v1.5.2 h1:piB93s8LGmbECrpO84DnkIVWasRMk3IimbcXkTQLE6E=
-github.com/pion/datachannel v1.5.2/go.mod h1:FTGQWaHrdCwIJ1rw6xBIfZVkslikjShim5yr05XFuCQ=
-github.com/pion/dtls/v2 v2.0.1/go.mod h1:uMQkz2W0cSqY00xav7WByQ4Hb+18xeQh2oH2fRezr5U=
-github.com/pion/dtls/v2 v2.0.2/go.mod h1:27PEO3MDdaCfo21heT59/vsdmZc0zMt9wQPcSlLu/1I=
-github.com/pion/dtls/v2 v2.1.3/go.mod h1:o6+WvyLDAlXF7YiPB/RlskRoeK+/JtuaZa5emwQcWus=
-github.com/pion/dtls/v2 v2.1.5 h1:jlh2vtIyUBShchoTDqpCCqiYCyRFJ/lvf/gQ8TALs+c=
-github.com/pion/dtls/v2 v2.1.5/go.mod h1:BqCE7xPZbPSubGasRoDFJeTsyJtdD1FanJYL0JGheqY=
-github.com/pion/ice v0.7.18 h1:KbAWlzWRUdX9SmehBh3gYpIFsirjhSQsCw6K2MjYMK0=
-github.com/pion/ice v0.7.18/go.mod h1:+Bvnm3nYC6Nnp7VV6glUkuOfToB/AtMRZpOU8ihuf4c=
-github.com/pion/ice/v2 v2.2.6 h1:R/vaLlI1J2gCx141L5PEwtuGAGcyS6e7E0hDeJFq5Ig=
-github.com/pion/ice/v2 v2.2.6/go.mod h1:SWuHiOGP17lGromHTFadUe1EuPgFh/oCU6FCMZHooVE=
-github.com/pion/interceptor v0.1.11 h1:00U6OlqxA3FFB50HSg25J/8cWi7P6FbSzw4eFn24Bvs=
-github.com/pion/interceptor v0.1.11/go.mod h1:tbtKjZY14awXd7Bq0mmWvgtHB5MDaRN7HV3OZ/uy7s8=
-github.com/pion/logging v0.2.2 h1:M9+AIj/+pxNsDfAT64+MAVgJO0rsyLnoJKCqf//DoeY=
-github.com/pion/logging v0.2.2/go.mod h1:k0/tDVsRCX2Mb2ZEmTqNa7CWsQPc+YYCB7Q+5pahoms=
-github.com/pion/mdns v0.0.4/go.mod h1:R1sL0p50l42S5lJs91oNdUL58nm0QHrhxnSegr++qC0=
-github.com/pion/mdns v0.0.5 h1:Q2oj/JB3NqfzY9xGZ1fPzZzK7sDSD8rZPOvcIQ10BCw=
-github.com/pion/mdns v0.0.5/go.mod h1:UgssrvdD3mxpi8tMxAXbsppL3vJ4Jipw1mTCW+al01g=
-github.com/pion/quic v0.1.1/go.mod h1:zEU51v7ru8Mp4AUBJvj6psrSth5eEFNnVQK5K48oV3k=
-github.com/pion/randutil v0.0.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+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-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/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+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.70 h1:DZ4u2AV35VJxdD9Fo9fIWm119BsQL5cZU1cQ9s0LkqA=
+github.com/miekg/dns v1.1.70/go.mod h1:+EuEPhdHOsfk6Wk5TT2CzssZdqkmFhf8r+aVyDEToIs=
+github.com/pion/datachannel v1.6.0 h1:XecBlj+cvsxhAMZWFfFcPyUaDZtd7IJvrXqlXD/53i0=
+github.com/pion/datachannel v1.6.0/go.mod h1:ur+wzYF8mWdC+Mkis5Thosk+u/VOL287apDNEbFpsIk=
+github.com/pion/dtls/v3 v3.0.10 h1:k9ekkq1kaZoxnNEbyLKI8DI37j/Nbk1HWmMuywpQJgg=
+github.com/pion/dtls/v3 v3.0.10/go.mod h1:YEmmBYIoBsY3jmG56dsziTv/Lca9y4Om83370CXfqJ8=
+github.com/pion/ice/v4 v4.2.0 h1:jJC8S+CvXCCvIQUgx+oNZnoUpt6zwc34FhjWwCU4nlw=
+github.com/pion/ice/v4 v4.2.0/go.mod h1:EgjBGxDgmd8xB0OkYEVFlzQuEI7kWSCFu+mULqaisy4=
+github.com/pion/interceptor v0.1.43 h1:6hmRfnmjogSs300xfkR0JxYFZ9k5blTEvCD7wxEDuNQ=
+github.com/pion/interceptor v0.1.43/go.mod h1:BSiC1qKIJt1XVr3l3xQ2GEmCFStk9tx8fwtCZxxgR7M=
+github.com/pion/logging v0.2.4 h1:tTew+7cmQ+Mc1pTBLKH2puKsOvhm32dROumOZ655zB8=
+github.com/pion/logging v0.2.4/go.mod h1:DffhXTKYdNZU+KtJ5pyQDjvOAh/GsNSyv1lbkFbe3so=
+github.com/pion/mdns/v2 v2.1.0 h1:3IJ9+Xio6tWYjhN6WwuY142P/1jA0D5ERaIqawg/fOY=
+github.com/pion/mdns/v2 v2.1.0/go.mod h1:pcez23GdynwcfRU1977qKU0mDxSeucttSHbCSfFOd9A=
 github.com/pion/randutil v0.1.0 h1:CFG1UdESneORglEsnimhUjf33Rwjubwj6xfiOXBa3mA=
 github.com/pion/randutil v0.1.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8=
-github.com/pion/rtcp v1.2.3/go.mod h1:zGhIv0RPRF0Z1Wiij22pUt5W/c9fevqSzT4jje/oK7I=
-github.com/pion/rtcp v1.2.9 h1:1ujStwg++IOLIEoOiIQ2s+qBuJ1VN81KW+9pMPsif+U=
-github.com/pion/rtcp v1.2.9/go.mod h1:qVPhiCzAm4D/rxb6XzKeyZiQK69yJpbUDJSF7TgrqNo=
-github.com/pion/rtp v1.6.0/go.mod h1:QgfogHsMBVE/RFNno467U/KBqfUywEH+HK+0rtnwsdI=
-github.com/pion/rtp v1.7.13 h1:qcHwlmtiI50t1XivvoawdCGTP4Uiypzfrsap+bijcoA=
-github.com/pion/rtp v1.7.13/go.mod h1:bDb5n+BFZxXx0Ea7E5qe+klMuqiBrP+w8XSjiWtCUko=
-github.com/pion/sctp v1.7.10/go.mod h1:EhpTUQu1/lcK3xI+eriS6/96fWetHGCvBi9MSsnaBN0=
-github.com/pion/sctp v1.8.0/go.mod h1:xFe9cLMZ5Vj6eOzpyiKjT9SwGM4KpK/8Jbw5//jc+0s=
-github.com/pion/sctp v1.8.2 h1:yBBCIrUMJ4yFICL3RIvR4eh/H2BTTvlligmSTy+3kiA=
-github.com/pion/sctp v1.8.2/go.mod h1:xFe9cLMZ5Vj6eOzpyiKjT9SwGM4KpK/8Jbw5//jc+0s=
-github.com/pion/sdp/v2 v2.4.0/go.mod h1:L2LxrOpSTJbAns244vfPChbciR/ReU1KWfG04OpkR7E=
-github.com/pion/sdp/v3 v3.0.5 h1:ouvI7IgGl+V4CrqskVtr3AaTrPvPisEOxwgpdktctkU=
-github.com/pion/sdp/v3 v3.0.5/go.mod h1:iiFWFpQO8Fy3S5ldclBkpXqmWy02ns78NOKoLLL0YQw=
-github.com/pion/srtp v1.5.1 h1:9Q3jAfslYZBt+C69SI/ZcONJh9049JUHZWYRRf5KEKw=
-github.com/pion/srtp v1.5.1/go.mod h1:B+QgX5xPeQTNc1CJStJPHzOlHK66ViMDWTT0HZTCkcA=
-github.com/pion/srtp/v2 v2.0.9/go.mod h1:5TtM9yw6lsH0ppNCehB/EjEUli7VkUgKSPJqWVqbhQ4=
-github.com/pion/srtp/v2 v2.0.10 h1:b8ZvEuI+mrL8hbr/f1YiJFB34UMrOac3R3N1yq2UN0w=
-github.com/pion/srtp/v2 v2.0.10/go.mod h1:XEeSWaK9PfuMs7zxXyiN252AHPbH12NX5q/CFDWtUuA=
-github.com/pion/stun v0.3.5 h1:uLUCBCkQby4S1cf6CGuR9QrVOKcvUwFeemaC865QHDg=
-github.com/pion/stun v0.3.5/go.mod h1:gDMim+47EeEtfWogA37n6qXZS88L5V6LqFcf+DZA2UA=
-github.com/pion/transport v0.6.0/go.mod h1:iWZ07doqOosSLMhZ+FXUTq+TamDoXSllxpbGcfkCmbE=
-github.com/pion/transport v0.8.10/go.mod h1:tBmha/UCjpum5hqTWhfAEs3CO4/tHSg0MYRhSzR+CZ8=
-github.com/pion/transport v0.10.0/go.mod h1:BnHnUipd0rZQyTVB2SBGojFHT9CBt5C5TcsJSQGkvSE=
-github.com/pion/transport v0.10.1/go.mod h1:PBis1stIILMiis0PewDw91WJeLJkyIMcEk+DwKOzf4A=
-github.com/pion/transport v0.12.2/go.mod h1:N3+vZQD9HlDP5GWkZ85LohxNsDcNgofQmyL6ojX5d8Q=
-github.com/pion/transport v0.12.3/go.mod h1:OViWW9SP2peE/HbwBvARicmAVnesphkNkCVZIWJ6q9A=
-github.com/pion/transport v0.13.0/go.mod h1:yxm9uXpK9bpBBWkITk13cLo1y5/ur5VQpG22ny6EP7g=
-github.com/pion/transport v0.13.1 h1:/UH5yLeQtwm2VZIPjxwnNFxjS4DFhyLfS4GlfuKUzfA=
-github.com/pion/transport v0.13.1/go.mod h1:EBxbqzyv+ZrmDb82XswEE0BjfQFtuw1Nu6sjnjWCsGg=
-github.com/pion/turn/v2 v2.0.4/go.mod h1:1812p4DcGVbYVBTiraUmP50XoKye++AMkbfp+N27mog=
-github.com/pion/turn/v2 v2.0.8 h1:KEstL92OUN3k5k8qxsXHpr7WWfrdp7iJZHx99ud8muw=
-github.com/pion/turn/v2 v2.0.8/go.mod h1:+y7xl719J8bAEVpSXBXvTxStjJv3hbz9YFflvkpcGPw=
-github.com/pion/udp v0.1.0/go.mod h1:BPELIjbwE9PRbd/zxI/KYBnbo7B6+oA6YuEaNE8lths=
-github.com/pion/udp v0.1.1 h1:8UAPvyqmsxK8oOjloDk4wUt63TzFe9WEJkg5lChlj7o=
-github.com/pion/udp v0.1.1/go.mod h1:6AFo+CMdKQm7UiA0eUPA8/eVCTx8jBIITLZHc9DWX5M=
-github.com/pion/webrtc/v2 v2.2.26/go.mod h1:XMZbZRNHyPDe1gzTIHFcQu02283YO45CbiwFgKvXnmc=
-github.com/pion/webrtc/v3 v3.1.41/go.mod h1:sUcW9SFPEWerDqGOBmdYEMfRvbdd7rgwo4bNzfsXww4=
-github.com/pion/webrtc/v3 v3.1.43 h1:YT3ZTO94UT4kSBvZnRAH82+0jJPUruiKr9CEstdlQzk=
-github.com/pion/webrtc/v3 v3.1.43/go.mod h1:G/J8k0+grVsjC/rjCZ24AKoCCxcFFODgh7zThNZGs0M=
+github.com/pion/rtcp v1.2.16 h1:fk1B1dNW4hsI78XUCljZJlC4kZOPk67mNRuQ0fcEkSo=
+github.com/pion/rtcp v1.2.16/go.mod h1:/as7VKfYbs5NIb4h6muQ35kQF/J0ZVNz2Z3xKoCBYOo=
+github.com/pion/rtp v1.10.0 h1:XN/xca4ho6ZEcijpdF2VGFbwuHUfiIMf3ew8eAAE43w=
+github.com/pion/rtp v1.10.0/go.mod h1:rF5nS1GqbR7H/TCpKwylzeq6yDM+MM6k+On5EgeThEM=
+github.com/pion/sctp v1.9.2 h1:HxsOzEV9pWoeggv7T5kewVkstFNcGvhMPx0GvUOUQXo=
+github.com/pion/sctp v1.9.2/go.mod h1:OTOlsQ5EDQ6mQ0z4MUGXt2CgQmKyafBEXhUVqLRB6G8=
+github.com/pion/sdp/v3 v3.0.17 h1:9SfLAW/fF1XC8yRqQ3iWGzxkySxup4k4V7yN8Fs8nuo=
+github.com/pion/sdp/v3 v3.0.17/go.mod h1:9tyKzznud3qiweZcD86kS0ff1pGYB3VX+Bcsmkx6IXo=
+github.com/pion/srtp/v3 v3.0.10 h1:tFirkpBb3XccP5VEXLi50GqXhv5SKPxqrdlhDCJlZrQ=
+github.com/pion/srtp/v3 v3.0.10/go.mod h1:3mOTIB0cq9qlbn59V4ozvv9ClW/BSEbRp4cY0VtaR7M=
+github.com/pion/stun/v3 v3.1.1 h1:CkQxveJ4xGQjulGSROXbXq94TAWu8gIX2dT+ePhUkqw=
+github.com/pion/stun/v3 v3.1.1/go.mod h1:qC1DfmcCTQjl9PBaMa5wSn3x9IPmKxSdcCsxBcDBndM=
+github.com/pion/transport/v3 v3.1.1 h1:Tr684+fnnKlhPceU+ICdrw6KKkTms+5qHMgw6bIkYOM=
+github.com/pion/transport/v3 v3.1.1/go.mod h1:+c2eewC5WJQHiAA46fkMMzoYZSuGzA/7E2FPrOYHctQ=
+github.com/pion/transport/v4 v4.0.1 h1:sdROELU6BZ63Ab7FrOLn13M6YdJLY20wldXW2Cu2k8o=
+github.com/pion/transport/v4 v4.0.1/go.mod h1:nEuEA4AD5lPdcIegQDpVLgNoDGreqM/YqmEx3ovP4jM=
+github.com/pion/turn/v4 v4.1.4 h1:EU11yMXKIsK43FhcUnjLlrhE4nboHZq+TXBIi3QpcxQ=
+github.com/pion/turn/v4 v4.1.4/go.mod h1:ES1DXVFKnOhuDkqn9hn5VJlSWmZPaRJLyBXoOeO/BmQ=
+github.com/pion/webrtc/v4 v4.2.3 h1:RtdWDnkenNQGxUrZqWa5gSkTm5ncsLg5d+zu0M4cXt4=
+github.com/pion/webrtc/v4 v4.2.3/go.mod h1:7vsyFzRzaKP5IELUnj8zLcglPyIT6wWwqTppBZ1k6Kc=
+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/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.3.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
-github.com/rs/zerolog v1.27.0 h1:1T7qCieN22GVc8S4Q2yuexzBb1EqjbgjSH9RohbMjKs=
-github.com/rs/zerolog v1.27.0/go.mod h1:7frBqO0oezxmnO7GF86FY++uy8I0Tk/If5ni1G9Qc0U=
-github.com/sclevine/agouti v3.0.0+incompatible/go.mod h1:b4WX9W9L1sfQKXeJf1mUTLZKJ48R1S7H23Ji7oFO5Bw=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
-github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.7.1 h1:5TQK59W5E3v0r2duFAb7P95B6hEeOyEnHRa8MjYSMTY=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-golang.org/x/crypto v0.0.0-20190228161510-8dd112bcdc25/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200602180216-279210d13fed/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20200709230013-948cd5f35899/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20220131195533-30dcbda58838/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/crypto v0.0.0-20220427172511-eb4f295cb31f/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/crypto v0.0.0-20220516162934-403b01795ae8 h1:y+mHpWoQJNAHt26Nhh6JP7hvM71IRZureyvZhoVALIs=
-golang.org/x/crypto v0.0.0-20220516162934-403b01795ae8/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20191126235420-ef20fe5d7933/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200602114024-627f9648deb9/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-20201201195509-5d6afe98e0b7/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
-golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20211201190559-0a0e4e1bb54c/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
-golang.org/x/net v0.0.0-20220401154927-543a649e0bdd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
-golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
-golang.org/x/net v0.0.0-20220531201128-c960675eff93/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.0.0-20220630215102-69896b714898 h1:K7wO6V1IrczY9QOQ2WkVpw4JQSwCd52UsxVEirZUfiw=
-golang.org/x/net v0.0.0-20220630215102-69896b714898/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-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/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190228124157-a34e9553db1e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200724161237-0e2f3a69832c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-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-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220608164250-635b8c9b7f68/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220622161953-175b2fd9d664 h1:wEZYwx+kK+KlZ0hpvP2Ls1Xr4+RWnlzGFwPP0aiDjIU=
-golang.org/x/sys v0.0.0-20220622161953-175b2fd9d664/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-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/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/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=
+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/skrashevich/go-webp v0.1.0 h1:C+dtldBorS5ISATYR5mvG9HFj8GRLDGRywT0xs/ZLUQ=
+github.com/skrashevich/go-webp v0.1.0/go.mod h1:9QtuNP/H9q/qzqgaZeYalNIk7n5lfyqVs1WTaPtC/Ao=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+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/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.47.0 h1:V6e3FRj+n4dbpw86FJ8Fv7XVOql7TEwpHapKoMJ/GO8=
+golang.org/x/crypto v0.47.0/go.mod h1:ff3Y9VzzKbwSSEzWqJsJVBnWmRwRSHt/6Op5n9bQc4A=
+golang.org/x/image v0.36.0 h1:Iknbfm1afbgtwPTmHnS2gTM/6PPZfH+z2EFuOkSbqwc=
+golang.org/x/image v0.36.0/go.mod h1:YsWD2TyyGKiIX1kZlu9QfKIsQ4nAAK9bdgdrIsE7xy4=
+golang.org/x/mod v0.32.0 h1:9F4d3PHLljb6x//jOyokMv3eX+YDeepZSEo3mFJy93c=
+golang.org/x/mod v0.32.0/go.mod h1:SgipZ/3h2Ci89DlEtEXWUk/HteuRin+HHhN+WbNhguU=
+golang.org/x/net v0.49.0 h1:eeHFmOGUTtaaPSGNmjBKpbng9MulQsJURQUAfUwY++o=
+golang.org/x/net v0.49.0/go.mod h1:/ysNB2EvaqvesRkuLAyjI1ycPZlQHM3q01F02UY/MV8=
+golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
+golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.40.0 h1:DBZZqJ2Rkml6QMQsZywtnjnnGvHza6BTfYFWY9kjEWQ=
+golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/term v0.39.0 h1:RclSuaJf32jOqZz74CkPA9qFuVTX7vhLlpfj/IGWlqY=
+golang.org/x/term v0.39.0/go.mod h1:yxzUCTP/U+FzoxfdKmLaA0RV1WgE0VY7hXBwKtY/4ww=
+golang.org/x/time v0.14.0 h1:MRx4UaLrDotUKUdCIqzPC48t1Y9hANFKIRpNx+Te8PI=
+golang.org/x/time v0.14.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4=
+golang.org/x/tools v0.41.0 h1:a9b8iMweWG+S0OBnlU36rzLp20z1Rp10w+IY2czHTQc=
+golang.org/x/tools v0.41.0/go.mod h1:XSY6eDqxVNiYgezAVqqCeihT4j1U2CCsqvH3WhQpnlg=
 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.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.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/README.md

@@ -0,0 +1,113 @@
+# Modules
+
+go2rtc tries to name formats, protocols and codecs the same way they are named in FFmpeg.
+Some formats and protocols go2rtc supports exclusively. They have no equivalent in FFmpeg.
+
+- The [`echo`], [`expr`], [`hass`] and [`onvif`] modules receive a link to a stream. They don't know the protocol in advance.
+- The [`exec`] and [`ffmpeg`] modules support many formats. They are identical to the [`http`] module.
+- The [`api`], [`app`], [`debug`], [`ngrok`], [`pinggy`], [`srtp`], [`streams`] are supporting modules.
+
+**Modules** implement communication APIs: authorization, encryption, command set, structure of media packets.
+
+**Formats** describe the structure of the data being transmitted.
+
+**Protocols** implement transport for data transmission.
+
+| module         | formats         | protocols        | input | output | ingest | two-way |
+|----------------|-----------------|------------------|-------|--------|--------|---------|
+| [`alsa`]       | `pcm`           | `ioctl`          | yes   |        |        |         |
+| [`bubble`]     | -               | `http`           | yes   |        |        |         |
+| [`doorbird`]   | `mulaw`         | `http`           | yes   |        |        | yes     |
+| [`dvrip`]      | -               | `tcp`            | yes   |        |        | yes     |
+| [`echo`]       | *               | *                | yes   |        |        |         |
+| [`eseecloud`]  | `rtp`           | `http`           | yes   |        |        |         |
+| [`exec`]       | *               | `pipe`, `rtsp`   | yes   |        |        | yes     |
+| [`expr`]       | *               | *                | yes   |        |        |         |
+| [`ffmpeg`]     | *               | `pipe`, `rtsp`   | yes   |        |        |         |
+| [`flussonic`]  | `mp4`           | `ws`             | yes   |        |        |         |
+| [`gopro`]      | `mpegts`        | `udp`            | yes   |        |        |         |
+| [`hass`]       | *               | *                | yes   |        |        |         |
+| [`hls`]        | `mpegts`, `mp4` | `http`           |       | yes    |        |         |
+| [`homekit`]    | `srtp`          | `hap`            | yes   | yes    |        | no      |
+| [`http`]       | `adts`          | `http`, `tcp`    | yes   |        |        |         |
+| [`http`]       | `flv`           | `http`, `tcp`    | yes   |        |        |         |
+| [`http`]       | `h264`          | `http`, `tcp`    | yes   |        |        |         |
+| [`http`]       | `hevc`          | `http`, `tcp`    | yes   |        |        |         |
+| [`http`]       | `hls`           | `http`, `tcp`    | yes   |        |        |         |
+| [`http`]       | `mjpeg`         | `http`, `tcp`    | yes   |        |        |         |
+| [`http`]       | `mpjpeg`        | `http`           | yes   |        |        |         |
+| [`http`]       | `mpegts`        | `http`, `tcp`    | yes   |        |        |         |
+| [`http`]       | `wav`           | `http`, `tcp`    | yes   |        |        |         |
+| [`http`]       | `yuv4mpegpipe`  | `http`, `tcp`    | yes   |        |        |         |
+| [`isapi`]      | `alaw`, `mulaw` | `http`           |       |        |        | yes     |
+| [`ivideon`]    | `mp4`           | `ws`             | yes   |        |        |         |
+| [`kasa`]       | `h264`, `mulaw` | `http`           | yes   |        |        |         |
+| [`mjpeg`]      | `ascii`         | `http`           |       | yes    |        |         |
+| [`mjpeg`]      | `jpeg`          | `http`           |       | yes    |        |         |
+| [`mjpeg`]      | `mpjpeg`        | `http`           |       | yes    | yes    |         |
+| [`mjpeg`]      | `yuv4mpegpipe`  | `http`           |       | yes    |        |         |
+| [`mp4`]        | `mp4`           | `http`, `ws`     |       | yes    |        |         |
+| [`mpeg`]       | `adts`          | `http`           |       | yes    |        |         |
+| [`mpeg`]       | `mpegts`        | `http`           |       | yes    | yes    |         |
+| [`multitrans`] | `rtp`           | `tcp`            |       |        |        | yes     |
+| [`nest`]       | `srtp`          | `rtsp`, `webrtc` | yes   |        |        | no      |
+| [`onvif`]      | `rtp`           | *                | yes   | yes    |        |         |
+| [`ring`]       | `srtp`          | `webrtc`         | yes   |        |        | yes     |
+| [`roborock`]   | `srtp`          | `webrtc`         | yes   |        |        | yes     |
+| [`rtmp`]       | `flv`           | `rtmp`           | yes   | yes    | yes    |         |
+| [`rtmp`]       | `flv`           | `http`           |       | yes    | yes    |         |
+| [`rtsp`]       | `rtsp`          | `rtsp`           | yes   | yes    | yes    | yes     |
+| [`tapo`]       | `mpegts`        | `http`           | yes   |        |        | yes     |
+| [`tuya`]       | `srtp`          | `webrtc`         | yes   |        |        | yes     |
+| [`v4l2`]       | `rawvideo`      | `ioctl`          | yes   |        |        |         |
+| [`webrtc`]     | `srtp`          | `webrtc`         | yes   | yes    | yes    | yes     |
+| [`webtorrent`] | `srtp`          | `webrtc`         | yes   | yes    |        |         |
+| [`wyoming`]    | `pcm`           | `tcp`            |       | yes    |        |         |
+| [`wyze`]       | -               | `tutk`           | yes   |        |        | yes     |
+| [`xiaomi`]     | -               | `cs2`, `tutk`    | yes   |        |        | yes     |
+| [`yandex`]     | `srtp`          | `webrtc`         | yes   |        |        |         |
+
+[`alsa`]: alsa/README.md
+[`api`]: api/README.md
+[`app`]: app/README.md
+[`bubble`]: bubble/README.md
+[`debug`]: debug/README.md
+[`doorbird`]: doorbird/README.md
+[`dvrip`]: dvrip/README.md
+[`echo`]: echo/README.md
+[`eseecloud`]: eseecloud/README.md
+[`exec`]: exec/README.md
+[`expr`]: expr/README.md
+[`ffmpeg`]: ffmpeg/README.md
+[`flussonic`]: flussonic/README.md
+[`gopro`]: gopro/README.md
+[`hass`]: hass/README.md
+[`hls`]: hls/README.md
+[`homekit`]: homekit/README.md
+[`http`]: http/README.md
+[`isapi`]: isapi/README.md
+[`ivideon`]: ivideon/README.md
+[`kasa`]: kasa/README.md
+[`mjpeg`]: mjpeg/README.md
+[`mp4`]: mp4/README.md
+[`mpeg`]: mpeg/README.md
+[`multitrans`]: multitrans/README.md
+[`nest`]: nest/README.md
+[`ngrok`]: ngrok/README.md
+[`onvif`]: onvif/README.md
+[`pinggy`]: pinggy/README.md
+[`ring`]: ring/README.md
+[`roborock`]: roborock/README.md
+[`rtmp`]: rtmp/README.md
+[`rtsp`]: rtsp/README.md
+[`srtp`]: srtp/README.md
+[`streams`]: streams/README.md
+[`tapo`]: tapo/README.md
+[`tuya`]: tuya/README.md
+[`v4l2`]: v4l2/README.md
+[`webrtc`]: webrtc/README.md
+[`webtorrent`]: webtorrent/README.md
+[`wyoming`]: wyze/README.md
+[`wyze`]: wyze/README.md
+[`xiaomi`]: xiaomi/README.md
+[`yandex`]: yandex/README.md

internal/alsa/README.md

@@ -0,0 +1,12 @@
+# ALSA
+
+[`new in v1.9.10`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.9.10)
+
+> [!WARNING]
+> This source is under development and does not always work well.
+
+[Advanced Linux Sound Architecture](https://en.wikipedia.org/wiki/Advanced_Linux_Sound_Architecture) - a framework for receiving audio from devices on Linux OS.
+
+Easy to add via **WebUI > add > ALSA**.
+
+Alternatively, you can use FFmpeg source.

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/README.md

@@ -0,0 +1,45 @@
+# HTTP API
+
+The HTTP API is the main part for interacting with the application. Default address: `http://localhost:1984/`.
+
+The HTTP API is described in [OpenAPI](../../website/api/openapi.yaml) format. It can be explored in [interactive viewer](https://go2rtc.org/api/). WebSocket API described [here](ws/README.md).
+
+The project's static HTML and JS files are located in the [www](../../www/README.md) folder. An external developer can use them as a basis for integrating go2rtc into their project or for developing a custom web interface for go2rtc.
+
+The contents of `www` folder are built into go2rtc when building, but you can use configuration to specify an external folder as the source of static files.
+
+## Configuration
+
+**Important!** go2rtc passes requests from localhost and Unix sockets without HTTP authorization, even if you have it configured. It is your responsibility to set up secure external access to the API. If not properly configured, an attacker can gain access to your cameras and even your server.
+
+- you can disable HTTP API with `listen: ""` and use, for example, only RTSP client/server protocol
+- you can enable HTTP API only on localhost with `listen: "127.0.0.1:1984"` setting
+- you can change the 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:
+  listen: ":1984"    # default ":1984", HTTP API port ("" - disabled)
+  username: "admin"  # default "", Basic auth for WebUI
+  password: "pass"   # default "", Basic auth for WebUI
+  local_auth: true   # default false, Enable auth check for localhost requests
+  base_path: "/rtc"  # default "", API prefix for serving on suburl (/api => /rtc/api)
+  static_dir: "www"  # default "", folder for static files (custom web interface)
+  origin: "*"        # default "", allow CORS requests (only * supported)
+  tls_listen: ":443" # default "", enable HTTPS server
+  tls_cert: |        # default "", PEM-encoded fullchain certificate for HTTPS
+    -----BEGIN CERTIFICATE-----
+    ...
+    -----END CERTIFICATE-----
+  tls_key: |         # default "", PEM-encoded private key for HTTPS
+    -----BEGIN PRIVATE KEY-----
+    ...
+    -----END PRIVATE KEY-----
+  unix_listen: "/tmp/go2rtc.sock"  # default "", unix socket listener for API
+```
+
+**PS:**
+
+- MJPEG over WebSocket plays better than native MJPEG because Chrome [bug](https://bugs.chromium.org/p/chromium/issues/detail?id=527446)
+- MP4 over WebSocket was created only for Apple iOS because it doesn't support file streaming

internal/api/api.go

@@ -0,0 +1,359 @@
+package api
+
+import (
+	"crypto/tls"
+	"encoding/json"
+	"fmt"
+	"net"
+	"net/http"
+	"os"
+	"slices"
+	"strconv"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/rs/zerolog"
+)
+
+func Init() {
+	var cfg struct {
+		Mod struct {
+			Listen     string `yaml:"listen"`
+			Username   string `yaml:"username"`
+			Password   string `yaml:"password"`
+			LocalAuth  bool   `yaml:"local_auth"`
+			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"`
+			ReadOnly   bool   `yaml:"read_only"`
+
+			AllowPaths []string `yaml:"allow_paths"`
+		} `yaml:"api"`
+	}
+
+	// default config
+	cfg.Mod.Listen = ":1984"
+
+	// load config from YAML
+	app.LoadConfig(&cfg)
+
+	if cfg.Mod.Listen == "" && cfg.Mod.UnixListen == "" && cfg.Mod.TLSListen == "" {
+		return
+	}
+
+	allowPaths = cfg.Mod.AllowPaths
+	basePath = cfg.Mod.BasePath
+	log = app.GetLogger("api")
+	ReadOnly = cfg.Mod.ReadOnly
+	app.ConfigReadOnly = ReadOnly
+	app.Info["read_only"] = ReadOnly
+
+	initStatic(cfg.Mod.StaticDir)
+
+	HandleFunc("api", apiHandler)
+	HandleFunc("api/config", configHandler)
+	HandleFunc("api/exit", exitHandler)
+	HandleFunc("api/restart", restartHandler)
+	HandleFunc("api/log", logHandler)
+
+	Handler = http.DefaultServeMux // 4th
+
+	if cfg.Mod.Origin == "*" {
+		Handler = middlewareCORS(Handler) // 3rd
+	}
+
+	if cfg.Mod.Username != "" {
+		Handler = middlewareAuth(cfg.Mod.Username, cfg.Mod.Password, cfg.Mod.LocalAuth, Handler) // 2nd
+	}
+
+	if log.Trace().Enabled() {
+		Handler = middlewareLog(Handler) // 1st
+	}
+
+	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 != "" {
+		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"
+)
+
+var Handler http.Handler
+var ReadOnly bool
+
+func IsReadOnly() bool {
+	return ReadOnly
+}
+
+func ReadOnlyError(w http.ResponseWriter) {
+	http.Error(w, "read-only", http.StatusForbidden)
+}
+
+// HandleFunc handle pattern with relative path:
+// - "api/streams" => "{basepath}/api/streams"
+// - "/streams"    => "/streams"
+func HandleFunc(pattern string, handler http.HandlerFunc) {
+	if len(pattern) == 0 || pattern[0] != '/' {
+		pattern = basePath + "/" + pattern
+	}
+	if allowPaths != nil && !slices.Contains(allowPaths, pattern) {
+		log.Trace().Str("path", pattern).Msg("[api] ignore path not in allow_paths")
+		return
+	}
+	log.Trace().Str("path", pattern).Msg("[api] register path")
+	http.HandleFunc(pattern, handler)
+}
+
+// ResponseJSON important always add Content-Type
+// so go won't need to call http.DetectContentType
+func ResponseJSON(w http.ResponseWriter, v any) {
+	w.Header().Set("Content-Type", MimeJSON)
+	_ = json.NewEncoder(w).Encode(v)
+}
+
+func ResponsePrettyJSON(w http.ResponseWriter, v any) {
+	w.Header().Set("Content-Type", MimeJSON)
+	enc := json.NewEncoder(w)
+	enc.SetIndent("", "  ")
+	_ = enc.Encode(v)
+}
+
+func Response(w http.ResponseWriter, body any, contentType string) {
+	w.Header().Set("Content-Type", contentType)
+
+	switch v := body.(type) {
+	case []byte:
+		_, _ = w.Write(v)
+	case string:
+		_, _ = w.Write([]byte(v))
+	default:
+		_, _ = fmt.Fprint(w, body)
+	}
+}
+
+const StreamNotFound = "stream not found"
+
+var allowPaths []string
+var basePath string
+var log zerolog.Logger
+
+func middlewareLog(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		log.Trace().Msgf("[api] %s %s %s", r.Method, r.URL, r.RemoteAddr)
+		next.ServeHTTP(w, r)
+	})
+}
+
+func isLoopback(remoteAddr string) bool {
+	return strings.HasPrefix(remoteAddr, "127.") || strings.HasPrefix(remoteAddr, "[::1]") || remoteAddr == "@"
+}
+
+func middlewareAuth(username, password string, localAuth bool, next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method == "OPTIONS" {
+			next.ServeHTTP(w, r)
+			return
+		}
+
+		if localAuth || !isLoopback(r.RemoteAddr) {
+			user, pass, ok := r.BasicAuth()
+			if !ok || user != username || pass != password {
+				w.Header().Set("Www-Authenticate", `Basic realm="go2rtc"`)
+				http.Error(w, "Unauthorized", http.StatusUnauthorized)
+				return
+			}
+		}
+
+		next.ServeHTTP(w, r)
+	})
+}
+
+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, Content-Type")
+		if r.Method == "OPTIONS" {
+			w.WriteHeader(http.StatusNoContent)
+			return
+		}
+		next.ServeHTTP(w, r)
+	})
+}
+
+var mu sync.Mutex
+
+func apiHandler(w http.ResponseWriter, r *http.Request) {
+	mu.Lock()
+	app.Info["host"] = r.Host
+	app.Info["pid"] = os.Getpid()
+	app.Info["system"] = getSystemInfo()
+	mu.Unlock()
+
+	ResponseJSON(w, app.Info)
+}
+
+func exitHandler(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		http.Error(w, "", http.StatusBadRequest)
+		return
+	}
+
+	if IsReadOnly() {
+		ReadOnlyError(w)
+		return
+	}
+
+	s := r.URL.Query().Get("code")
+	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)
+}
+
+func restartHandler(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		http.Error(w, "", http.StatusBadRequest)
+		return
+	}
+
+	if IsReadOnly() {
+		ReadOnlyError(w)
+		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 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":
+		if IsReadOnly() {
+			ReadOnlyError(w)
+			return
+		}
+		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 {
+		Sources []*Source `json:"sources"`
+	}{
+		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

@@ -0,0 +1,162 @@
+package api
+
+import (
+	"errors"
+	"io"
+	"maps"
+	"net/http"
+	"os"
+	"slices"
+
+	"github.com/AlexxIT/go2rtc/internal/app"
+	pkgyaml "github.com/AlexxIT/go2rtc/pkg/yaml"
+	"gopkg.in/yaml.v3"
+)
+
+func configHandler(w http.ResponseWriter, r *http.Request) {
+	if app.ConfigPath == "" {
+		http.Error(w, "", http.StatusGone)
+		return
+	}
+
+	switch r.Method {
+	case "GET":
+		data, err := os.ReadFile(app.ConfigPath)
+		if err != nil {
+			http.Error(w, "", http.StatusNotFound)
+			return
+		}
+		// https://www.ietf.org/archive/id/draft-ietf-httpapi-yaml-mediatypes-00.html
+		Response(w, data, "application/yaml")
+
+	case "POST", "PATCH":
+		if IsReadOnly() {
+			ReadOnlyError(w)
+			return
+		}
+		data, err := io.ReadAll(r.Body)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		if r.Method == "PATCH" {
+			// no need to validate after merge
+			data, err = mergeYAML(app.ConfigPath, data)
+			if err != nil {
+				http.Error(w, err.Error(), http.StatusBadRequest)
+				return
+			}
+		} else {
+			// validate config
+			if err = yaml.Unmarshal(data, map[string]any{}); err != nil {
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+				return
+			}
+		}
+
+		if err = os.WriteFile(app.ConfigPath, data, 0644); err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	}
+}
+
+func mergeYAML(file1 string, yaml2 []byte) ([]byte, error) {
+	data1, err := os.ReadFile(file1)
+	if err != nil {
+		return nil, err
+	}
+
+	var patch map[string]any
+	if err = yaml.Unmarshal(yaml2, &patch); err != nil {
+		return nil, err
+	}
+
+	data1, err = mergeYAMLMap(data1, nil, patch)
+	if err != nil {
+		return nil, err
+	}
+
+	// validate config after merge
+	if err = yaml.Unmarshal(data1, map[string]any{}); err != nil {
+		return nil, err
+	}
+
+	return data1, nil
+}
+
+// mergeYAMLMap recursively applies patch values onto config bytes.
+func mergeYAMLMap(data []byte, path []string, patch map[string]any) ([]byte, error) {
+	for _, key := range slices.Sorted(maps.Keys(patch)) {
+		value := patch[key]
+		currPath := append(append([]string(nil), path...), key)
+
+		if valueMap, ok := value.(map[string]any); ok {
+			isMap, exists, err := pathIsMapping(data, currPath)
+			if err != nil {
+				return nil, err
+			}
+
+			if exists && isMap {
+				data, err = mergeYAMLMap(data, currPath, valueMap)
+			} else {
+				data, err = pkgyaml.Patch(data, currPath, valueMap)
+			}
+			if err != nil {
+				return nil, err
+			}
+			continue
+		}
+
+		var err error
+		data, err = pkgyaml.Patch(data, currPath, value)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return data, nil
+}
+
+// pathIsMapping reports whether path exists and ends with a mapping node.
+func pathIsMapping(data []byte, path []string) (isMap, exists bool, err error) {
+	var root yaml.Node
+	if err = yaml.Unmarshal(data, &root); err != nil {
+		return false, false, err
+	}
+
+	if len(root.Content) == 0 {
+		return false, false, nil
+	}
+
+	if len(root.Content) != 1 || root.Content[0].Kind != yaml.MappingNode {
+		return false, false, errors.New("yaml: expected mapping document")
+	}
+
+	node := root.Content[0]
+	for i, part := range path {
+		idx := -1
+		for j := 0; j < len(node.Content); j += 2 {
+			if node.Content[j].Value == part {
+				idx = j
+				break
+			}
+		}
+		if idx < 0 {
+			return false, false, nil
+		}
+
+		valueNode := node.Content[idx+1]
+		if i == len(path)-1 {
+			return valueNode.Kind == yaml.MappingNode, true, nil
+		}
+
+		if valueNode.Kind != yaml.MappingNode {
+			return false, false, nil
+		}
+
+		node = valueNode
+	}
+
+	return false, false, nil
+}

internal/api/config_readonly_test.go

@@ -0,0 +1,36 @@
+package api
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/stretchr/testify/require"
+)
+
+func TestConfigHandlerReadOnly(t *testing.T) {
+	prevPath := app.ConfigPath
+	prevReadOnly := ReadOnly
+	t.Cleanup(func() {
+		app.ConfigPath = prevPath
+		ReadOnly = prevReadOnly
+	})
+
+	app.ConfigPath = filepath.Join(t.TempDir(), "config.yaml")
+	ReadOnly = true
+
+	for _, method := range []string{"POST", "PATCH"} {
+		t.Run(method, func(t *testing.T) {
+			req := httptest.NewRequest(method, "/api/config", strings.NewReader("log:\n  level: info\n"))
+			w := httptest.NewRecorder()
+
+			configHandler(w, req)
+
+			require.Equal(t, http.StatusForbidden, w.Code)
+			require.Contains(t, w.Body.String(), "read-only")
+		})
+	}
+}

internal/api/config_test.go

@@ -0,0 +1,283 @@
+package api
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"gopkg.in/yaml.v3"
+)
+
+func TestMergeYAMLPreserveCommentedStreamList(t *testing.T) {
+	base := `streams:
+  yard:
+    - #http://1.1.1.1
+    - #http://2.2.2.2
+    - http://3.3.3.3
+    - #http://4.4.4.4
+log:
+  level: trace
+`
+	patch := `log:
+  api: debug
+`
+
+	path := filepath.Join(t.TempDir(), "go2rtc.yaml")
+	require.NoError(t, os.WriteFile(path, []byte(base), 0o644))
+
+	out, err := mergeYAML(path, []byte(patch))
+	require.NoError(t, err)
+
+	merged := string(out)
+	require.Contains(t, merged, "#http://1.1.1.1")
+	require.Contains(t, merged, "#http://2.2.2.2")
+	require.Contains(t, merged, "#http://4.4.4.4")
+	require.Contains(t, merged, "- http://3.3.3.3")
+	require.NotContains(t, merged, "- null")
+	require.Contains(t, merged, "api: debug")
+
+	var cfg map[string]any
+	require.NoError(t, yaml.Unmarshal(out, &cfg))
+}
+
+func TestMergeYAMLPreserveUnchangedComments(t *testing.T) {
+	base := `api:
+  username: admin
+streams:
+  yard:
+    - #http://1.1.1.1
+    - http://3.3.3.3
+`
+	patch := `api:
+  password: secret
+`
+
+	path := filepath.Join(t.TempDir(), "go2rtc.yaml")
+	require.NoError(t, os.WriteFile(path, []byte(base), 0o644))
+
+	out, err := mergeYAML(path, []byte(patch))
+	require.NoError(t, err)
+
+	merged := string(out)
+	require.Contains(t, merged, "username: admin")
+	require.Contains(t, merged, "password: secret")
+	require.Contains(t, merged, "#http://1.1.1.1")
+	require.NotContains(t, merged, "- null")
+}
+
+func TestMergeYAMLPreserveCommentsAndFormattingAcrossSections(t *testing.T) {
+	base := `# global config comment
+api: # api section comment
+  username: admin # inline username comment
+streams:
+  # stream comment
+  yard:
+    - #http://1.1.1.1
+    - http://3.3.3.3
+log:
+  format: |
+    line1
+    line2
+`
+	patch := `api:
+  password: "secret value"
+ffmpeg:
+  bin: /usr/bin/ffmpeg
+`
+
+	path := filepath.Join(t.TempDir(), "go2rtc.yaml")
+	require.NoError(t, os.WriteFile(path, []byte(base), 0o644))
+
+	out, err := mergeYAML(path, []byte(patch))
+	require.NoError(t, err)
+
+	merged := string(out)
+	require.Contains(t, merged, "# global config comment")
+	require.Contains(t, merged, "# api section comment")
+	require.Contains(t, merged, "# inline username comment")
+	require.Contains(t, merged, "# stream comment")
+	require.Contains(t, merged, "#http://1.1.1.1")
+	require.Contains(t, merged, "password: secret value")
+	require.Contains(t, merged, "format: |")
+	require.NotContains(t, merged, "- null")
+
+	assertOrder(t, merged, "api:", "streams:", "log:", "ffmpeg:")
+
+	var cfg map[string]any
+	require.NoError(t, yaml.Unmarshal(out, &cfg))
+	require.Equal(t, "admin", cfg["api"].(map[string]any)["username"])
+	require.Equal(t, "secret value", cfg["api"].(map[string]any)["password"])
+	require.Equal(t, "/usr/bin/ffmpeg", cfg["ffmpeg"].(map[string]any)["bin"])
+}
+
+func TestMergeYAMLPreserveQuotedValuesAndNestedStructure(t *testing.T) {
+	base := `api:
+  username: "admin user"
+  listen: ":1984"
+webrtc:
+  candidates:
+    - "stun:stun.l.google.com:19302"
+streams:
+  porch:
+    - "rtsp://cam.local/stream?token=a:b"
+    - #disabled source
+`
+	patch := `webrtc:
+  ice_servers:
+    - urls:
+        - stun:stun.cloudflare.com:3478
+`
+
+	path := filepath.Join(t.TempDir(), "go2rtc.yaml")
+	require.NoError(t, os.WriteFile(path, []byte(base), 0o644))
+
+	out, err := mergeYAML(path, []byte(patch))
+	require.NoError(t, err)
+
+	merged := string(out)
+	require.Contains(t, merged, `username: "admin user"`)
+	require.Contains(t, merged, `listen: ":1984"`)
+	require.Contains(t, merged, `"rtsp://cam.local/stream?token=a:b"`)
+	require.Contains(t, merged, "#disabled source")
+	require.Contains(t, merged, "ice_servers:")
+	require.NotContains(t, merged, "- null")
+
+	var cfg map[string]any
+	require.NoError(t, yaml.Unmarshal(out, &cfg))
+	require.Equal(t, "admin user", cfg["api"].(map[string]any)["username"])
+	require.Equal(t, ":1984", cfg["api"].(map[string]any)["listen"])
+	require.NotNil(t, cfg["streams"])
+	require.NotNil(t, cfg["webrtc"].(map[string]any)["candidates"])
+	require.NotNil(t, cfg["webrtc"].(map[string]any)["ice_servers"])
+}
+
+func TestMergeYAMLPatchLogKeepsCommentedYardEntriesInline(t *testing.T) {
+	base := `api:
+    listen: :1984
+    read_only: false
+    static_dir: www
+log:
+    level: trace
+mcp:
+    enabled: true
+    http: true
+    sse: true
+streams:
+    cam_main:
+        - https://example.local/stream.m3u8
+    yard:
+        - #http://camera.local/disabled-source-a
+        - #ffmpeg:http://camera.local/disabled-source-b#video=h264
+        - ffmpeg:yard#video=mjpeg
+        - #homekit://camera.local/disabled-source-c
+        - homekit://camera.local/enabled-source
+`
+	patch := `log:
+  api: debug
+`
+
+	path := filepath.Join(t.TempDir(), "go2rtc.yaml")
+	require.NoError(t, os.WriteFile(path, []byte(base), 0o644))
+
+	out, err := mergeYAML(path, []byte(patch))
+	require.NoError(t, err)
+
+	merged := string(out)
+	require.Contains(t, merged, "    level: trace")
+	require.Contains(t, merged, "    api: debug")
+	require.Contains(t, merged, "        - #http://camera.local/disabled-source-a")
+	require.Contains(t, merged, "        - #ffmpeg:http://camera.local/disabled-source-b#video=h264")
+	require.Contains(t, merged, "        - #homekit://camera.local/disabled-source-c")
+	require.NotContains(t, merged, "\n        -\n")
+
+	var cfg map[string]any
+	require.NoError(t, yaml.Unmarshal(out, &cfg))
+	require.Equal(t, "debug", cfg["log"].(map[string]any)["api"])
+}
+
+func TestMergeYAMLPatchLogWithTrailingSpaces(t *testing.T) {
+	// trailing spaces on "- #comment" lines could confuse node parsing
+	base := "api:\n    listen: :1984\nlog:\n    level: trace\nstreams:\n    yard:\n" +
+		"        - #http://192.168.88.100/long/path/to/resource  \n" +
+		"        - #ffmpeg:http://192.168.88.100/path#video=h264  \n" +
+		"        - ffmpeg:yard#video=mjpeg\n"
+
+	patch := "log:\n  api: debug\n"
+
+	path := filepath.Join(t.TempDir(), "go2rtc.yaml")
+	require.NoError(t, os.WriteFile(path, []byte(base), 0o644))
+
+	out, err := mergeYAML(path, []byte(patch))
+	require.NoError(t, err)
+
+	merged := string(out)
+	require.Contains(t, merged, "        - #http://192.168.88.100/long/path/to/resource")
+	require.Contains(t, merged, "        - #ffmpeg:http://192.168.88.100/path#video=h264")
+	require.NotContains(t, merged, "\n        -\n")
+}
+
+func TestMergeYAMLPatchLogPreservesLongCommentedURLs(t *testing.T) {
+	base := "api:\n" +
+		"    listen: :1984\n" +
+		"    read_only: false\n" +
+		"    static_dir: www\n" +
+		"log:\n" +
+		"    level: trace\n" +
+		"mcp:\n" +
+		"    enabled: true\n" +
+		"    http: true\n" +
+		"    sse: true\n" +
+		"streams:\n" +
+		"    sf_i280_us101:\n" +
+		"        - https://wzmedia.dot.ca.gov/D4/N280_at_JCT_101.stream/playlist.m3u8\n" +
+		"    testsrc_h264:\n" +
+		"        - exec:ffmpeg -hide_banner -re -f lavfi -i testsrc=size=320x240:rate=15 -c:v libx264 -preset ultrafast -tune zerolatency -profile:v baseline -pix_fmt yuv420p -crf 28 -f h264 -\n" +
+		"    yard:\n" +
+		"        - #http://192.168.88.100/c17d5873fa8f1ca5e0f94daa46e29343/live/files/high/index.m3u8\n" +
+		"        - #ffmpeg:http://192.168.88.100/c17d5873fa8f1ca5e0f94daa46e29343/live/files/high/index.m3u8#audio=opus/16000#video=h264\n" +
+		"        - ffmpeg:yard#video=mjpeg\n" +
+		"        - #homekit://192.168.88.100:5001?client_id=00000000-0000-0000-0000-000000000001&client_private=0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001&device_id=00:00:00:00:00:01&device_public=0000000000000000000000000000000000000000000000000000000000000001\n" +
+		"        - homekit://192.168.88.100:5001?client_id=00000000-0000-0000-0000-000000000002&client_private=0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002&device_id=00:00:00:00:00:02&device_public=0000000000000000000000000000000000000000000000000000000000000002\n"
+
+	patch := "log:\n  api: debug\n"
+
+	path := filepath.Join(t.TempDir(), "go2rtc.yaml")
+	require.NoError(t, os.WriteFile(path, []byte(base), 0o644))
+
+	out, err := mergeYAML(path, []byte(patch))
+	require.NoError(t, err)
+
+	merged := string(out)
+
+	// patch applied
+	require.Contains(t, merged, "    api: debug")
+	require.Contains(t, merged, "    level: trace")
+
+	// commented entries must stay on same line as dash
+	require.Contains(t, merged, "        - #http://192.168.88.100/")
+	require.Contains(t, merged, "        - #ffmpeg:http://192.168.88.100/")
+	require.Contains(t, merged, "        - #homekit://192.168.88.100:")
+	require.NotContains(t, merged, "\n        -\n")
+
+	// non-commented entries preserved
+	require.Contains(t, merged, "        - ffmpeg:yard#video=mjpeg")
+	require.Contains(t, merged, "        - homekit://192.168.88.100:5001?client_id=00000000-0000-0000-0000-000000000002")
+
+	var cfg map[string]any
+	require.NoError(t, yaml.Unmarshal(out, &cfg))
+	require.Equal(t, "debug", cfg["log"].(map[string]any)["api"])
+}
+
+func assertOrder(t *testing.T, s string, items ...string) {
+	t.Helper()
+
+	last := -1
+	for _, item := range items {
+		idx := strings.Index(s, item)
+		require.NotEqualf(t, -1, idx, "expected %q in output", item)
+		require.Greaterf(t, idx, last, "expected %q after previous sections", item)
+		last = idx
+	}
+}

internal/api/static.go

@@ -0,0 +1,27 @@
+package api
+
+import (
+	"net/http"
+
+	"github.com/AlexxIT/go2rtc/www"
+)
+
+func initStatic(staticDir string) {
+	var root http.FileSystem
+	if staticDir != "" {
+		log.Info().Str("dir", staticDir).Msg("[api] serve static")
+		root = http.Dir(staticDir)
+	} else {
+		root = http.FS(www.Static)
+	}
+
+	base := len(basePath)
+	fileServer := http.FileServer(root)
+
+	HandleFunc("", func(w http.ResponseWriter, r *http.Request) {
+		if base > 0 {
+			r.URL.Path = r.URL.Path[base:]
+		}
+		fileServer.ServeHTTP(w, r)
+	})
+}

internal/api/system.go

@@ -0,0 +1,16 @@
+package api
+
+type systemInfo struct {
+	CPUUsage float64 `json:"cpu_usage"` // percent 0-100
+	MemTotal uint64  `json:"mem_total"` // bytes
+	MemUsed  uint64  `json:"mem_used"`  // bytes
+}
+
+func getSystemInfo() systemInfo {
+	memTotal, memUsed := getMemoryInfo()
+	return systemInfo{
+		CPUUsage: getCPUUsage(),
+		MemTotal: memTotal,
+		MemUsed:  memUsed,
+	}
+}

internal/api/system_darwin.go

@@ -0,0 +1,104 @@
+//go:build darwin
+
+package api
+
+import (
+	"os/exec"
+	"runtime"
+	"strconv"
+	"strings"
+	"syscall"
+	"unsafe"
+)
+
+func getMemoryInfo() (total, used uint64) {
+	total = sysctl64("hw.memsize")
+	if total == 0 {
+		return 0, 0
+	}
+
+	pageSize, err := syscall.SysctlUint32("hw.pagesize")
+	if err != nil {
+		return total, 0
+	}
+
+	freeCount, _ := syscall.SysctlUint32("vm.page_free_count")
+	purgeableCount, _ := syscall.SysctlUint32("vm.page_purgeable_count")
+	speculativeCount, _ := syscall.SysctlUint32("vm.page_speculative_count")
+
+	// inactive pages not available via sysctl, parse vm_stat
+	inactiveCount := vmStatPages("Pages inactive")
+
+	available := uint64(freeCount+purgeableCount+speculativeCount)*uint64(pageSize) +
+		inactiveCount*uint64(pageSize)
+	if available > total {
+		return total, 0
+	}
+	return total, total - available
+}
+
+// vmStatPages parses vm_stat output for a specific counter
+func vmStatPages(key string) uint64 {
+	out, err := exec.Command("vm_stat").Output()
+	if err != nil {
+		return 0
+	}
+	for _, line := range strings.Split(string(out), "\n") {
+		if strings.HasPrefix(line, key) {
+			// format: "Pages inactive:          479321."
+			parts := strings.Split(line, ":")
+			if len(parts) < 2 {
+				continue
+			}
+			s := strings.TrimSpace(parts[1])
+			s = strings.TrimSuffix(s, ".")
+			val, err := strconv.ParseUint(s, 10, 64)
+			if err != nil {
+				return 0
+			}
+			return val
+		}
+	}
+	return 0
+}
+
+func sysctl64(name string) uint64 {
+	s, err := syscall.Sysctl(name)
+	if err != nil {
+		return 0
+	}
+	b := []byte(s)
+	for len(b) < 8 {
+		b = append(b, 0)
+	}
+	return *(*uint64)(unsafe.Pointer(&b[0]))
+}
+
+func getCPUUsage() float64 {
+	s, err := syscall.Sysctl("vm.loadavg")
+	if err != nil {
+		return 0
+	}
+
+	raw := []byte(s)
+	for len(raw) < 24 {
+		raw = append(raw, 0)
+	}
+
+	// struct loadavg { fixpt_t ldavg[3]; long fscale; }
+	ldavg0 := *(*uint32)(unsafe.Pointer(&raw[0]))
+	fscale := *(*int64)(unsafe.Pointer(&raw[16]))
+
+	if fscale == 0 {
+		return 0
+	}
+
+	load1 := float64(ldavg0) / float64(fscale)
+	numCPU := float64(runtime.NumCPU())
+
+	usage := load1 / numCPU * 100
+	if usage > 100 {
+		usage = 100
+	}
+	return usage
+}

internal/api/system_darwin_test.go

@@ -0,0 +1,116 @@
+//go:build darwin
+
+package api
+
+import (
+	"os/exec"
+	"runtime"
+	"strconv"
+	"strings"
+	"syscall"
+	"testing"
+)
+
+func TestGetMemoryInfo(t *testing.T) {
+	total, used := getMemoryInfo()
+
+	if total == 0 {
+		t.Fatal("mem_total is 0")
+	}
+	if total < 512*1024*1024 {
+		t.Fatalf("mem_total too small: %d", total)
+	}
+
+	// total should match sysctl64("hw.memsize")
+	expectedTotal := sysctl64("hw.memsize")
+	if total != expectedTotal {
+		t.Errorf("mem_total %d != hw.memsize %d", total, expectedTotal)
+	}
+
+	if used == 0 {
+		t.Fatal("mem_used is 0")
+	}
+	if used > total {
+		t.Fatalf("mem_used (%d) > mem_total (%d)", used, total)
+	}
+
+	// cross-check: used should be >= wired+active pages (minimum real usage)
+	pageSize, _ := syscall.SysctlUint32("hw.pagesize")
+	wired := vmStatPages("Pages wired down")
+	active := vmStatPages("Pages active")
+	minUsed := (wired + active) * uint64(pageSize)
+
+	if used < minUsed/2 {
+		t.Errorf("mem_used (%d) is less than half of wired+active (%d)", used, minUsed)
+	}
+
+	avail := total - used
+	t.Logf("RAM total: %.1f GB, used: %.1f GB, avail: %.1f GB",
+		float64(total)/1024/1024/1024,
+		float64(used)/1024/1024/1024,
+		float64(avail)/1024/1024/1024)
+}
+
+func TestGetCPUUsage(t *testing.T) {
+	usage := getCPUUsage()
+
+	// cross-check with sysctl vm.loadavg
+	out, err := exec.Command("sysctl", "-n", "vm.loadavg").Output()
+	if err != nil {
+		t.Fatal("sysctl vm.loadavg:", err)
+	}
+
+	// format: { 4.24 4.57 5.76 } or { 4,24 4,57 5,76 }
+	s := strings.Trim(string(out), "{ }\n")
+	fields := strings.Fields(s)
+	if len(fields) < 1 {
+		t.Fatal("cannot parse vm.loadavg:", string(out))
+	}
+	load1Str := strings.ReplaceAll(fields[0], ",", ".")
+	load1, err := strconv.ParseFloat(load1Str, 64)
+	if err != nil {
+		t.Fatal("parse load1:", err)
+	}
+
+	numCPU := float64(runtime.NumCPU())
+	expected := load1 / numCPU * 100
+	if expected > 100 {
+		expected = 100
+	}
+
+	if usage < 0 || usage > 100 {
+		t.Fatalf("cpu_usage out of range: %.1f%%", usage)
+	}
+
+	// allow 15% absolute deviation (load average fluctuates between reads)
+	diff := usage - expected
+	if diff < 0 {
+		diff = -diff
+	}
+	if diff > 15 {
+		t.Errorf("cpu_usage %.1f%% deviates from expected %.1f%% (load1=%.2f, cpus=%d) by %.1f%%",
+			usage, expected, load1, int(numCPU), diff)
+	}
+
+	t.Logf("CPU usage: %.1f%%, expected: %.1f%% (load1=%.2f, cpus=%d)",
+		usage, expected, load1, int(numCPU))
+}
+
+func TestVmStatPages(t *testing.T) {
+	inactive := vmStatPages("Pages inactive")
+	if inactive == 0 {
+		t.Error("Pages inactive returned 0")
+	}
+
+	free := vmStatPages("Pages free")
+	if free == 0 {
+		t.Error("Pages free returned 0")
+	}
+
+	bogus := vmStatPages("Pages nonexistent")
+	if bogus != 0 {
+		t.Errorf("nonexistent key returned %d", bogus)
+	}
+
+	t.Logf("inactive=%d, free=%d pages", inactive, free)
+}

internal/api/system_linux.go

@@ -0,0 +1,84 @@
+//go:build linux
+
+package api
+
+import (
+	"bytes"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func getMemoryInfo() (total, used uint64) {
+	data, err := os.ReadFile("/proc/meminfo")
+	if err != nil {
+		return 0, 0
+	}
+
+	var memTotal, memAvailable uint64
+	for _, line := range strings.Split(string(data), "\n") {
+		fields := strings.Fields(line)
+		if len(fields) < 2 {
+			continue
+		}
+		val, err := strconv.ParseUint(fields[1], 10, 64)
+		if err != nil {
+			continue
+		}
+		switch fields[0] {
+		case "MemTotal:":
+			memTotal = val * 1024 // kB to bytes
+		case "MemAvailable:":
+			memAvailable = val * 1024
+		}
+	}
+
+	if memTotal > 0 && memAvailable <= memTotal {
+		return memTotal, memTotal - memAvailable
+	}
+	return memTotal, 0
+}
+
+// previous CPU times for delta calculation
+var prevIdle, prevTotal uint64
+
+func getCPUUsage() float64 {
+	data, err := os.ReadFile("/proc/stat")
+	if err != nil {
+		return 0
+	}
+
+	// first line: cpu  user nice system idle iowait irq softirq steal
+	idx := bytes.IndexByte(data, '\n')
+	if idx < 0 {
+		return 0
+	}
+	line := string(data[:idx])
+	fields := strings.Fields(line)
+	if len(fields) < 5 || fields[0] != "cpu" {
+		return 0
+	}
+
+	var total, idle uint64
+	for i := 1; i < len(fields); i++ {
+		val, err := strconv.ParseUint(fields[i], 10, 64)
+		if err != nil {
+			continue
+		}
+		total += val
+		if i == 4 { // idle is the 4th value (index 4 in fields, 1-based field 4)
+			idle = val
+		}
+	}
+
+	deltaTotal := total - prevTotal
+	deltaIdle := idle - prevIdle
+	prevIdle = idle
+	prevTotal = total
+
+	if deltaTotal == 0 {
+		return 0
+	}
+
+	return float64(deltaTotal-deltaIdle) / float64(deltaTotal) * 100
+}

internal/api/system_other.go

@@ -0,0 +1,11 @@
+//go:build !linux && !darwin && !windows
+
+package api
+
+func getMemoryInfo() (total, used uint64) {
+	return 0, 0
+}
+
+func getCPUUsage() float64 {
+	return 0
+}

internal/api/system_windows.go

@@ -0,0 +1,77 @@
+//go:build windows
+
+package api
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+var (
+	kernel32              = syscall.NewLazyDLL("kernel32.dll")
+	globalMemoryStatusEx  = kernel32.NewProc("GlobalMemoryStatusEx")
+	getSystemTimes        = kernel32.NewProc("GetSystemTimes")
+)
+
+// MEMORYSTATUSEX structure
+type memoryStatusEx struct {
+	dwLength                uint32
+	dwMemoryLoad            uint32
+	ullTotalPhys            uint64
+	ullAvailPhys            uint64
+	ullTotalPageFile        uint64
+	ullAvailPageFile        uint64
+	ullTotalVirtual         uint64
+	ullAvailVirtual         uint64
+	ullAvailExtendedVirtual uint64
+}
+
+func getMemoryInfo() (total, used uint64) {
+	var ms memoryStatusEx
+	ms.dwLength = uint32(unsafe.Sizeof(ms))
+
+	ret, _, _ := globalMemoryStatusEx.Call(uintptr(unsafe.Pointer(&ms)))
+	if ret == 0 {
+		return 0, 0
+	}
+
+	return ms.ullTotalPhys, ms.ullTotalPhys - ms.ullAvailPhys
+}
+
+type filetime struct {
+	dwLowDateTime  uint32
+	dwHighDateTime uint32
+}
+
+func (ft filetime) ticks() uint64 {
+	return uint64(ft.dwHighDateTime)<<32 | uint64(ft.dwLowDateTime)
+}
+
+var prevIdleWin, prevTotalWin uint64
+
+func getCPUUsage() float64 {
+	var idleTime, kernelTime, userTime filetime
+
+	ret, _, _ := getSystemTimes.Call(
+		uintptr(unsafe.Pointer(&idleTime)),
+		uintptr(unsafe.Pointer(&kernelTime)),
+		uintptr(unsafe.Pointer(&userTime)),
+	)
+	if ret == 0 {
+		return 0
+	}
+
+	idle := idleTime.ticks()
+	total := kernelTime.ticks() + userTime.ticks() // kernel includes idle
+
+	deltaTotal := total - prevTotalWin
+	deltaIdle := idle - prevIdleWin
+	prevIdleWin = idle
+	prevTotalWin = total
+
+	if deltaTotal == 0 {
+		return 0
+	}
+
+	return float64(deltaTotal-deltaIdle) / float64(deltaTotal) * 100
+}

internal/api/ws/README.md

@@ -0,0 +1,69 @@
+# WebSocket
+
+Endpoint: `/api/ws`
+
+Query parameters:
+
+- `src` (required) - Stream name
+
+### WebRTC
+
+Request SDP:
+
+```json
+{"type":"webrtc/offer","value":"v=0\r\n..."}
+```
+
+Response SDP:
+
+```json
+{"type":"webrtc/answer","value":"v=0\r\n..."}
+```
+
+Request/response candidate:
+
+- empty value also allowed and optional
+
+```json
+{"type":"webrtc/candidate","value":"candidate:3277516026 1 udp 2130706431 192.168.1.123 54321 typ host"}
+```
+
+### MSE
+
+Request:
+
+- codecs list optional
+
+```json
+{"type":"mse","value":"avc1.640029,avc1.64002A,avc1.640033,hvc1.1.6.L153.B0,mp4a.40.2,mp4a.40.5,flac,opus"}
+```
+
+Response:
+
+```json
+{"type":"mse","value":"video/mp4; codecs=\"avc1.64001F,mp4a.40.2\""}
+```
+
+### HLS
+
+Request:
+
+```json
+{"type":"hls","value":"avc1.640029,avc1.64002A,avc1.640033,hvc1.1.6.L153.B0,mp4a.40.2,mp4a.40.5,flac"}
+```
+
+Response:
+
+- you MUST rewrite full HTTP path to `http://192.168.1.123:1984/api/hls/playlist.m3u8`
+
+```json
+{"type":"hls","value":"#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=1000000,CODECS=\"avc1.64001F,mp4a.40.2\"\nhls/playlist.m3u8?id=DvmHdd9w"}
+```
+
+### MJPEG
+
+Request/response:
+
+```json
+{"type":"mjpeg"}
+```

internal/api/ws/ws.go

@@ -0,0 +1,227 @@
+package ws
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/pkg/creds"
+	"github.com/gorilla/websocket"
+	"github.com/rs/zerolog"
+)
+
+func Init() {
+	var cfg struct {
+		Mod struct {
+			Origin string `yaml:"origin"`
+		} `yaml:"api"`
+	}
+
+	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() (value string) {
+	if s, ok := m.Value.(string); ok {
+		return s
+	}
+	return
+}
+
+func (m *Message) Unmarshal(v any) error {
+	b, err := json.Marshal(m.Value)
+	if err != nil {
+		return err
+	}
+	return json.Unmarshal(b, v)
+}
+
+type WSHandler func(tr *Transport, msg *Message) error
+
+func HandleFunc(msgType string, handler WSHandler) {
+	wsHandlers[msgType] = handler
+}
+
+var wsHandlers = make(map[string]WSHandler)
+
+func initWS(origin string) {
+	wsUp = &websocket.Upgrader{
+		ReadBufferSize:  4096,       // for SDP
+		WriteBufferSize: 512 * 1024, // 512K
+	}
+
+	switch origin {
+	case "":
+		// same origin + ignore port
+		wsUp.CheckOrigin = func(r *http.Request) bool {
+			origin := r.Header["Origin"]
+			if len(origin) == 0 {
+				return true
+			}
+			o, err := url.Parse(origin[0])
+			if err != nil {
+				return false
+			}
+			if o.Host == r.Host {
+				return true
+			}
+			log.Trace().Msgf("[api] ws origin=%s, host=%s", o.Host, r.Host)
+			// https://github.com/AlexxIT/go2rtc/issues/118
+			if i := strings.IndexByte(o.Host, ':'); i > 0 {
+				return o.Host[:i] == r.Host
+			}
+			return false
+		}
+	case "*":
+		// any origin
+		wsUp.CheckOrigin = func(r *http.Request) bool {
+			return true
+		}
+	}
+}
+
+func apiWS(w http.ResponseWriter, r *http.Request) {
+	ws, err := wsUp.Upgrade(w, r, nil)
+	if err != nil {
+		origin := r.Header.Get("Origin")
+		log.Error().Err(err).Caller().Msgf("host=%s origin=%s", r.Host, origin)
+		return
+	}
+
+	tr := &Transport{Request: r}
+	tr.OnWrite(func(msg any) error {
+		_ = ws.SetWriteDeadline(time.Now().Add(time.Second * 5))
+
+		if data, ok := msg.([]byte); ok {
+			return ws.WriteMessage(websocket.BinaryMessage, data)
+		} else {
+			return ws.WriteJSON(msg)
+		}
+	})
+
+	for {
+		msg := new(Message)
+		if err = ws.ReadJSON(msg); err != nil {
+			if !websocket.IsCloseError(err, websocket.CloseNoStatusReceived) {
+				log.Trace().Err(err).Caller().Send()
+			}
+			_ = ws.Close()
+			break
+		}
+
+		log.Trace().Str("type", msg.Type).Msg("[api] ws msg")
+
+		if handler := wsHandlers[msg.Type]; handler != nil {
+			go func() {
+				if err = handler(tr, msg); err != nil {
+					errMsg := creds.SecretString(err.Error())
+					tr.Write(&Message{Type: "error", Value: msg.Type + ": " + errMsg})
+				}
+			}()
+		}
+	}
+
+	tr.Close()
+}
+
+var wsUp *websocket.Upgrader
+
+type Transport struct {
+	Request *http.Request
+
+	ctx map[any]any
+
+	closed bool
+	mx     sync.Mutex
+	wrmx   sync.Mutex
+
+	onChange func()
+	onWrite  func(msg any) error
+	onClose  []func()
+}
+
+func (t *Transport) OnWrite(f func(msg any) error) {
+	t.mx.Lock()
+	if t.onChange != nil {
+		t.onChange()
+	}
+	t.onWrite = f
+	t.mx.Unlock()
+}
+
+func (t *Transport) Write(msg any) {
+	t.wrmx.Lock()
+	_ = t.onWrite(msg)
+	t.wrmx.Unlock()
+}
+
+func (t *Transport) Close() {
+	t.mx.Lock()
+	for _, f := range t.onClose {
+		f()
+	}
+	t.closed = true
+	t.mx.Unlock()
+}
+
+func (t *Transport) OnChange(f func()) {
+	t.mx.Lock()
+	t.onChange = f
+	t.mx.Unlock()
+}
+
+func (t *Transport) OnClose(f func()) {
+	t.mx.Lock()
+	if t.closed {
+		f()
+	} else {
+		t.onClose = append(t.onClose, f)
+	}
+	t.mx.Unlock()
+}
+
+// WithContext - run function with Context variable
+func (t *Transport) WithContext(f func(ctx map[any]any)) {
+	t.mx.Lock()
+	if t.ctx == nil {
+		t.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,97 @@
+# App
+
+The application module is responsible for reading configuration files, running other modules and setting up [logs](#log).
+
+The configuration can be edited through the application's WebUI with code highlighting, syntax and specification checking.
+
+- By default, go2rtc will search for the `go2rtc.yaml` config file in the current working directory
+- go2rtc supports multiple config files:
+  - `go2rtc -c config1.yaml -c config2.yaml -c config3.yaml`
+- go2rtc supports inline config in multiple formats from the command line:
+  - **YAML**: `go2rtc -c '{log: {format: text}}'`
+  - **JSON**: `go2rtc -c '{"log":{"format":"text"}}'`
+  - **key=value**: `go2rtc -c log.format=text`
+- Each subsequent config will overwrite the previous one (but only for defined params)
+
+```
+go2rtc -config "{log: {format: text}}" -config /config/go2rtc.yaml -config "{rtsp: {listen: ''}}" -config /usr/local/go2rtc/go2rtc.yaml
+```
+
+or a simpler 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 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/) support autocomplete and syntax validation.
+
+```yaml
+# yaml-language-server: $schema=https://raw.githubusercontent.com/AlexxIT/go2rtc/master/www/schema.json
+```
+
+or from a running go2rtc:
+
+```yaml
+# yaml-language-server: $schema=http://localhost:1984/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"  # default public port for WebUI and HTTP API
+
+ffmpeg:
+  bin: "ffmpeg"    # default binary path for FFmpeg
+
+log:
+  level: "info"    # default log level
+  output: "stdout"
+  time: "UNIXMS"
+
+rtsp:
+  listen: ":8554"  # default public port for RTSP server
+  default_query: "video&audio"
+
+srtp:
+  listen: ":8443"  # default public port for SRTP server (used for HomeKit)
+
+webrtc:
+  listen: ":8555"  # default public port for WebRTC server (TCP and UDP)
+  ice_servers:
+    - urls: [ "stun:stun.cloudflare.com:3478", "stun:stun.l.google.com:19302" ]
+```
+
+## Log
+
+You can set different log levels for different modules.
+
+```yaml
+log:
+  format: ""        # empty (default, autodetect color support), color, json, text 
+  level: "info"     # disabled, trace, debug, info (default), warn, error
+  output: "stdout"  # empty (only to memory), stderr, stdout (default)
+  time: "UNIXMS"    # empty (disable timestamp), UNIXMS (default), UNIXMICRO, UNIXNANO
+  
+  api: trace   # module name: log level
+```
+
+Modules: `api`, `streams`, `rtsp`, `webrtc`, `mp4`, `hls`, `mjpeg`, `hass`, `homekit`, `onvif`, `rtmp`, `webtorrent`, `wyoming`, `echo`, `exec`, `expr`, `ffmpeg`, `wyze`, `xiaomi`.

internal/app/app.go

@@ -0,0 +1,122 @@
+package app
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"os/exec"
+	"runtime"
+	"runtime/debug"
+)
+
+var (
+	Version    string
+	Modules    []string
+	UserAgent  string
+	ConfigPath string
+	Info       = make(map[string]any)
+)
+
+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 config flagConfig
+	var daemon bool
+	var version bool
+
+	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.Printf("go2rtc version %s (%s) %s/%s\n", Version, revision, runtime.GOOS, runtime.GOARCH)
+		os.Exit(0)
+	}
+
+	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 != "" {
+		Logger.Info().Str("path", ConfigPath).Msg("config")
+	}
+
+	var cfg struct {
+		Mod struct {
+			Modules []string `yaml:"modules"`
+		} `yaml:"app"`
+	}
+
+	LoadConfig(&cfg)
+
+	Modules = cfg.Mod.Modules
+}
+
+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 += ".dirty"
+				}
+			}
+		}
+
+		// Check version from -buildvcs info
+		// Format for tagged version : v1.9.13
+		// Format for modified code:   v1.9.14-0.20251215184105-753d6617ab58+dirty
+		if info.Main.Version != "v"+Version {
+			// Format: 1.9.13+dev.753d661[.dirty]
+			// Compatible with "awesomeversion" and "packaging.version" from python.
+			// Version will be larger than the previous release, but smaller than the next release.
+			Version += "+dev." + revision
+		}
+	}
+	return
+}

internal/app/config.go

@@ -0,0 +1,121 @@
+package app
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	"github.com/AlexxIT/go2rtc/pkg/creds"
+	"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()
+		}
+	}
+}
+
+var configMu sync.Mutex
+var ConfigReadOnly bool
+
+func PatchConfig(path []string, value any) error {
+	if ConfigPath == "" {
+		return errors.New("config file disabled")
+	}
+	if ConfigReadOnly {
+		return errors.New("config is read-only")
+	}
+
+	configMu.Lock()
+	defer configMu.Unlock()
+
+	// 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
+				initStorage()
+			}
+
+			if data, _ = os.ReadFile(conf); data == nil {
+				continue
+			}
+
+			loadEnv(data)
+			data = creds.ReplaceVars(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/config_readonly_test.go

@@ -0,0 +1,29 @@
+package app
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestPatchConfigReadOnly(t *testing.T) {
+	prevPath := ConfigPath
+	prevReadOnly := ConfigReadOnly
+	t.Cleanup(func() {
+		ConfigPath = prevPath
+		ConfigReadOnly = prevReadOnly
+	})
+
+	dir := t.TempDir()
+	path := filepath.Join(dir, "config.yaml")
+	require.NoError(t, os.WriteFile(path, []byte(""), 0644))
+
+	ConfigPath = path
+	ConfigReadOnly = true
+
+	err := PatchConfig([]string{"streams", "cam"}, "rtsp://example.com")
+	require.Error(t, err)
+	require.EqualError(t, err, "config is read-only")
+}

internal/app/log.go

@@ -0,0 +1,191 @@
+package app
+
+import (
+	"io"
+	"os"
+	"strings"
+	"sync"
+
+	"github.com/AlexxIT/go2rtc/pkg/creds"
+	"github.com/mattn/go-isatty"
+	"github.com/rs/zerolog"
+)
+
+var MemoryLog = newBuffer()
+
+func GetLogger(module string) zerolog.Logger {
+	Logger.Trace().Str("module", module).Msgf("[log] init")
+
+	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
+	}
+
+	writer = creds.SecretWriter(writer)
+
+	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/storage.go

@@ -0,0 +1,56 @@
+package app
+
+import (
+	"sync"
+
+	"github.com/AlexxIT/go2rtc/pkg/creds"
+	"github.com/AlexxIT/go2rtc/pkg/yaml"
+)
+
+func initStorage() {
+	storage = &envStorage{data: make(map[string]string)}
+	creds.SetStorage(storage)
+}
+
+func loadEnv(data []byte) {
+	var cfg struct {
+		Env map[string]string `yaml:"env"`
+	}
+
+	if err := yaml.Unmarshal(data, &cfg); err != nil {
+		return
+	}
+
+	storage.mu.Lock()
+	for name, value := range cfg.Env {
+		storage.data[name] = value
+		creds.AddSecret(value)
+	}
+	storage.mu.Unlock()
+}
+
+var storage *envStorage
+
+type envStorage struct {
+	data map[string]string
+	mu   sync.Mutex
+}
+
+func (s *envStorage) SetValue(name, value string) error {
+	if err := PatchConfig([]string{"env", name}, value); err != nil {
+		return err
+	}
+
+	s.mu.Lock()
+	s.data[name] = value
+	s.mu.Unlock()
+
+	return nil
+}
+
+func (s *envStorage) GetValue(name string) (value string, ok bool) {
+	s.mu.Lock()
+	value, ok = s.data[name]
+	s.mu.Unlock()
+	return
+}

internal/bubble/README.md

@@ -0,0 +1,15 @@
+# Bubble
+
+[`new in v1.6.1`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.6.1)
+
+Private format in some cameras from [dvr163.com](http://help.dvr163.com/) and [eseecloud.com](http://www.eseecloud.com/).
+
+## Configuration
+
+- you can skip `username`, `password`, `port`, `ch` and `stream` if they are default
+- set up separate streams for different channels and streams
+
+```yaml
+streams:
+  camera1: bubble://username:password@192.168.1.123:34567/bubble/live?ch=0&stream=0
+```

internal/bubble/bubble.go

@@ -0,0 +1,13 @@
+package bubble
+
+import (
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/bubble"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func Init() {
+	streams.HandleFunc("bubble", func(source string) (core.Producer, error) {
+		return bubble.Dial(source)
+	})
+}

internal/debug/README.md

@@ -0,0 +1,3 @@
+# Debug
+
+This module provides `GET /api/stack`, with which you can find hanging goroutines

internal/debug/debug.go

@@ -0,0 +1,9 @@
+package debug
+
+import (
+	"github.com/AlexxIT/go2rtc/internal/api"
+)
+
+func Init() {
+	api.HandleFunc("api/stack", stackHandler)
+}

internal/debug/stack.go

@@ -0,0 +1,60 @@
+package debug
+
+import (
+	"bytes"
+	"fmt"
+	"net/http"
+	"runtime"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+)
+
+var stackSkip = [][]byte{
+	// main.go
+	[]byte("main.main()"),
+	[]byte("created by os/signal.Notify"),
+
+	// api/stack.go
+	[]byte("github.com/AlexxIT/go2rtc/internal/api.stackHandler"),
+
+	// api/api.go
+	[]byte("created by github.com/AlexxIT/go2rtc/internal/api.Init"),
+	[]byte("created by net/http.(*connReader).startBackgroundRead"),
+	[]byte("created by net/http.(*Server).Serve"), // TODO: why two?
+
+	[]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/v4.NewTCPMuxDefault"),
+	[]byte("created by github.com/pion/ice/v4.NewUDPMuxDefault"),
+}
+
+func stackHandler(w http.ResponseWriter, r *http.Request) {
+	sep := []byte("\n\n")
+	buf := make([]byte, 65535)
+	i := 0
+	n := runtime.Stack(buf, true)
+	skipped := 0
+	for _, item := range bytes.Split(buf[:n], sep) {
+		for _, skip := range stackSkip {
+			if bytes.Contains(item, skip) {
+				item = nil
+				skipped++
+				break
+			}
+		}
+		if item != nil {
+			i += copy(buf[i:], item)
+			i += copy(buf[i:], sep)
+		}
+	}
+	i += copy(buf[i:], fmt.Sprintf(
+		"Total: %d, Skipped: %d", runtime.NumGoroutine(), skipped),
+	)
+
+	api.Response(w, buf[:i], api.MimeText)
+}

internal/doorbird/README.md

@@ -0,0 +1,21 @@
+# Doorbird
+
+[`new in v1.9.8`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.9.8)
+
+This source type supports [Doorbird](https://www.doorbird.com/) devices including MJPEG stream, audio stream as well as two-way audio.
+
+It is recommended to create a separate user within your doorbird setup for go2rtc. Minimum permissions for the user are:
+
+- Watch always
+- API operator
+
+## Configuration
+
+```yaml
+streams:
+  doorbird1:
+    - rtsp://admin:password@192.168.1.123:8557/mpeg/720p/media.amp  # RTSP stream
+    - doorbird://admin:password@192.168.1.123?media=video           # MJPEG stream
+    - doorbird://admin:password@192.168.1.123?media=audio           # audio stream
+    - doorbird://admin:password@192.168.1.123                       # two-way audio
+```

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/README.md

@@ -0,0 +1,21 @@
+# DVR-IP
+
+[`new in v1.2.0`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.2.0)
+
+Private format from DVR-IP NVR, NetSurveillance, Sofia protocol (NETsurveillance ActiveX plugin XMeye SDK).
+
+## Configuration
+
+- you can skip `username`, `password`, `port`, `channel` and `subtype` if they are default
+- set up separate streams for different channels
+- use `subtype=0` for Main stream, and `subtype=1` for Extra1 stream
+- only the TCP protocol is supported
+
+```yaml
+streams:
+  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
+```

internal/dvrip/dvrip.go

@@ -0,0 +1,161 @@
+package dvrip
+
+import (
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"net"
+	"net/http"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/dvrip"
+)
+
+func Init() {
+	streams.HandleFunc("dvrip", dvrip.Dial)
+
+	// DVRIP client autodiscovery
+	api.HandleFunc("api/dvrip", apiDvrip)
+}
+
+const Port = 34569 // UDP port number for dvrip discovery
+
+func apiDvrip(w http.ResponseWriter, r *http.Request) {
+	items, err := discover()
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	api.ResponseSources(w, items)
+}
+
+func discover() ([]*api.Source, error) {
+	addr := &net.UDPAddr{
+		Port: Port,
+		IP:   net.IP{239, 255, 255, 250},
+	}
+
+	conn, err := net.ListenUDP("udp4", addr)
+	if err != nil {
+		return nil, err
+	}
+
+	defer conn.Close()
+
+	go sendBroadcasts(conn)
+
+	var items []*api.Source
+
+	for _, info := range getResponses(conn) {
+		if info.HostIP == "" || info.HostName == "" {
+			continue
+		}
+
+		host, err := hexToDecimalBytes(info.HostIP)
+		if err != nil {
+			continue
+		}
+
+		items = append(items, &api.Source{
+			Name: info.HostName,
+			URL:  "dvrip://user:pass@" + host + "?channel=0&subtype=0",
+		})
+	}
+
+	return items, nil
+}
+
+func sendBroadcasts(conn *net.UDPConn) {
+	// broadcasting the same multiple times because the devies some times don't answer
+	data, err := hex.DecodeString("ff00000000000000000000000000fa0500000000")
+	if err != nil {
+		return
+	}
+
+	addr := &net.UDPAddr{
+		Port: Port,
+		IP:   net.IP{255, 255, 255, 255},
+	}
+
+	for range 3 {
+		time.Sleep(100 * time.Millisecond)
+		_, _ = conn.WriteToUDP(data, addr)
+	}
+}
+
+type Message struct {
+	NetCommon NetCommon `json:"NetWork.NetCommon"`
+	Ret       int       `json:"Ret"`
+	SessionID string    `json:"SessionID"`
+}
+
+type NetCommon struct {
+	BuildDate       string `json:"BuildDate"`
+	ChannelNum      int    `json:"ChannelNum"`
+	DeviceType      int    `json:"DeviceType"`
+	GateWay         string `json:"GateWay"`
+	HostIP          string `json:"HostIP"`
+	HostName        string `json:"HostName"`
+	HttpPort        int    `json:"HttpPort"`
+	MAC             string `json:"MAC"`
+	MonMode         string `json:"MonMode"`
+	NetConnectState int    `json:"NetConnectState"`
+	OtherFunction   string `json:"OtherFunction"`
+	SN              string `json:"SN"`
+	SSLPort         int    `json:"SSLPort"`
+	Submask         string `json:"Submask"`
+	TCPMaxConn      int    `json:"TCPMaxConn"`
+	TCPPort         int    `json:"TCPPort"`
+	UDPPort         int    `json:"UDPPort"`
+	UseHSDownLoad   bool   `json:"UseHSDownLoad"`
+	Version         string `json:"Version"`
+}
+
+func getResponses(conn *net.UDPConn) (infos []*NetCommon) {
+	if err := conn.SetReadDeadline(time.Now().Add(time.Second * 2)); err != nil {
+		return
+	}
+
+	var ips []net.IP // processed IPs
+
+	b := make([]byte, 4096)
+loop:
+	for {
+		n, addr, err := conn.ReadFromUDP(b)
+		if err != nil {
+			break
+		}
+
+		for _, ip := range ips {
+			if ip.Equal(addr.IP) {
+				continue loop
+			}
+		}
+
+		if n <= 20+1 {
+			continue
+		}
+
+		var msg Message
+
+		if err = json.Unmarshal(b[20:n-1], &msg); err != nil {
+			continue
+		}
+
+		infos = append(infos, &msg.NetCommon)
+		ips = append(ips, addr.IP)
+	}
+
+	return
+}
+
+func hexToDecimalBytes(hexIP string) (string, error) {
+	b, err := hex.DecodeString(hexIP[2:]) // remove the '0x' prefix
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("%d.%d.%d.%d", b[3], b[2], b[1], b[0]), nil
+}

internal/echo/README.md

@@ -0,0 +1,48 @@
+# Echo
+
+Some sources may have a dynamic link. And you will need to get it using a Bash or Python script. Your script should echo a link to the source. RTSP, FFmpeg or any of the supported sources.
+
+**Docker** and **Home Assistant add-on** users have preinstalled `python3`, `curl`, `jq`.
+
+## Configuration
+
+```yaml
+streams:
+  apple_hls: echo:python3 hls.py https://developer.apple.com/streaming/examples/basic-stream-osx-ios5.html
+```
+
+## Install python libraries
+
+**Docker** and **Hass Add-on** users have preinstalled `python3` without any additional libraries, like [requests](https://requests.readthedocs.io/) or others. If you need some additional libraries - you need to install them to folder with your script:
+
+1. Install [SSH & Web Terminal](https://github.com/hassio-addons/addon-ssh)
+2. Goto Add-on Web UI
+3. Install library: `pip install requests -t /config/echo`
+4. Add your script to `/config/echo/myscript.py`
+5. Use your script as source `echo:python3 /config/echo/myscript.py`
+
+## Example: Apple HLS
+
+```yaml
+streams:
+  apple_hls: echo:python3 hls.py https://developer.apple.com/streaming/examples/basic-stream-osx-ios5.html
+```
+
+**hls.py**
+
+```python
+import re
+import sys
+from urllib.parse import urljoin
+from urllib.request import urlopen
+
+html = urlopen(sys.argv[1]).read().decode("utf-8")
+url = re.search(r"https.+?m3u8", html)[0]
+
+html = urlopen(url).read().decode("utf-8")
+m = re.search(r"^[a-z0-1/_]+\.m3u8$", html, flags=re.MULTILINE)
+url = urljoin(url, m[0])
+
+# ffmpeg:https://devstreaming-cdn.apple.com/videos/streaming/examples/bipbop_16x9/gear1/prog_index.m3u8#video=copy
+print("ffmpeg:" + url + "#video=copy")
+```

internal/echo/echo.go

@@ -0,0 +1,46 @@
+package echo
+
+import (
+	"bytes"
+	"errors"
+	"os/exec"
+	"slices"
+
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/shell"
+)
+
+func Init() {
+	var cfg struct {
+		Mod struct {
+			AllowPaths []string `yaml:"allow_paths"`
+		} `yaml:"echo"`
+	}
+
+	app.LoadConfig(&cfg)
+
+	allowPaths := cfg.Mod.AllowPaths
+
+	log := app.GetLogger("echo")
+
+	streams.RedirectFunc("echo", func(url string) (string, error) {
+		args := shell.QuoteSplit(url[5:])
+
+		if allowPaths != nil && !slices.Contains(allowPaths, args[0]) {
+			return "", errors.New("echo: bin not in allow_paths: " + args[0])
+		}
+
+		b, err := exec.Command(args[0], args[1:]...).Output()
+		if err != nil {
+			return "", err
+		}
+
+		b = bytes.TrimSpace(b)
+
+		log.Debug().Str("url", url).Msgf("[echo] %s", b)
+
+		return string(b), nil
+	})
+	streams.MarkInsecure("echo")
+}

internal/eseecloud/README.md

@@ -0,0 +1,12 @@
+# EseeCloud
+
+[`new in v1.9.10`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.9.10)
+
+This source is for cameras with a link like this `http://admin:@192.168.1.123:80/livestream/12`. Related [issue](https://github.com/AlexxIT/go2rtc/issues/1690).
+
+## Configuration
+
+```yaml
+streams:
+  camera1: eseecloud://user:pass@192.168.1.123:80/livestream/12
+```

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,48 @@
+# Exec
+
+Exec source can run any external application and expect data from it. Two transports are supported - **pipe** ([`new in 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**. 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 is 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 of your own software
+
+## Configuration
+
+Pipe commands support parameters (format: `exec:{command}#{param1}#{param2}`):
+
+- `killsignal` - signal which will be sent to stop the process (numeric form)
+- `killtimeout` - time in seconds for forced termination with sigkill
+- `backchannel` - enable backchannel for two-way audio
+- `starttimeout` - time in seconds for waiting first byte from RTSP
+
+```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
+```
+
+## 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

@@ -0,0 +1,279 @@
+package exec
+
+import (
+	"bufio"
+	"crypto/md5"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+	"net/url"
+	"os"
+	"slices"
+	"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"
+)
+
+func Init() {
+	var cfg struct {
+		Mod struct {
+			AllowPaths []string `yaml:"allow_paths"`
+		} `yaml:"exec"`
+	}
+
+	app.LoadConfig(&cfg)
+
+	allowPaths = cfg.Mod.AllowPaths
+
+	rtsp.HandleFunc(func(conn *pkg.Conn) bool {
+		waitersMu.Lock()
+		waiter := waiters[conn.URL.Path]
+		waitersMu.Unlock()
+
+		if waiter == nil {
+			return false
+		}
+
+		// unblocking write to channel
+		select {
+		case waiter <- conn:
+			return true
+		default:
+			return false
+		}
+	})
+
+	streams.HandleFunc("exec", execHandle)
+	streams.MarkInsecure("exec")
+
+	log = app.GetLogger("exec")
+}
+
+var allowPaths []string
+
+func execHandle(rawURL string) (prod core.Producer, err error) {
+	rawURL, rawQuery, _ := strings.Cut(rawURL, "#")
+	query := streams.ParseQuery(rawQuery)
+
+	var path string
+
+	// 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(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 allowPaths != nil && !slices.Contains(allowPaths, cmd.Args[0]) {
+		_ = cmd.Close()
+		return nil, errors.New("exec: bin not in allow_paths: " + cmd.Args[0])
+	}
+
+	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)
+		}
+	}
+
+	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"))
+	}
+
+	var timeout time.Duration
+	if s := query.Get("starttimeout"); s != "" {
+		timeout = time.Duration(core.Atoi(s)) * time.Second
+	} else {
+		timeout = 30 * time.Second
+	}
+
+	if path == "" {
+		prod, err = handlePipe(rawURL, cmd)
+	} else {
+		prod, err = handleRTSP(rawURL, cmd, path, timeout)
+	}
+
+	if err != nil {
+		_ = cmd.Close()
+	}
+
+	return
+}
+
+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
+	}
+
+	prod, err := magic.Open(rd)
+	if err != nil {
+		return nil, fmt.Errorf("exec/pipe: %w\n%s", err, cmd.Stderr)
+	}
+
+	if info, ok := prod.(core.Info); ok {
+		info.SetProtocol("pipe")
+		setRemoteInfo(info, source, cmd.Args)
+	}
+
+	log.Debug().Stringer("launch", time.Since(ts)).Msg("[exec] run pipe")
+
+	return prod, nil
+}
+
+func handleRTSP(source string, cmd *shell.Command, path string, timeout time.Duration) (core.Producer, error) {
+	if log.Trace().Enabled() {
+		cmd.Stdout = os.Stdout
+	}
+
+	waiter := make(chan *pkg.Conn, 1)
+
+	waitersMu.Lock()
+	waiters[path] = waiter
+	waitersMu.Unlock()
+
+	defer func() {
+		waitersMu.Lock()
+		delete(waiters, path)
+		waitersMu.Unlock()
+	}()
+
+	log.Debug().Strs("args", cmd.Args).Msg("[exec] run rtsp")
+
+	ts := time.Now()
+
+	if err := cmd.Start(); err != nil {
+		log.Error().Err(err).Str("source", source).Msg("[exec]")
+		return nil, err
+	}
+
+	timer := time.NewTimer(timeout)
+	defer timer.Stop()
+
+	select {
+	case <-timer.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
+	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/expr/README.md

@@ -0,0 +1,153 @@
+# Expr
+
+[`new in v1.8.2`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.8.2)
+
+[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
+
+## Fetch examples
+
+Multiple fetch requests are executed within a single session. They share the same cookie.
+
+**HTTP GET**
+
+```js
+var r = fetch('https://example.org/products.json');
+```
+
+**HTTP POST JSON**
+
+```js
+var r = fetch('https://example.org/post', {
+    method: 'POST',
+    // Content-Type: application/json will be set automatically
+    json: {username: 'example'}
+});
+```
+
+**HTTP POST Form**
+
+```js
+var r = fetch('https://example.org/post', {
+    method: 'POST',
+    // Content-Type: application/x-www-form-urlencoded will be set automatically
+    data: {username: 'example', password: 'password'}
+});
+```
+
+## Script examples
+
+**Two way audio for Dahua VTO**
+
+```yaml
+streams:
+  dahua_vto: |
+    expr:
+    let host = 'admin:password@192.168.1.123';
+
+    var r = fetch('http://' + host + '/cgi-bin/configManager.cgi?action=setConfig&Encode[0].MainFormat[0].Audio.Compression=G.711A&Encode[0].MainFormat[0].Audio.Frequency=8000');
+
+    'rtsp://' + host + '/cam/realmonitor?channel=1&subtype=0&unicast=true&proto=Onvif'
+```
+
+**dom.ru**
+
+You can get credentials from https://github.com/ad/domru
+
+```yaml
+streams:
+  dom_ru: |
+    expr:
+    let camera   = '***';
+    let token    = '***';
+    let operator = '***';
+
+    fetch('https://myhome.proptech.ru/rest/v1/forpost/cameras/' + camera + '/video', {
+      headers: {
+        'Authorization': 'Bearer ' + token,
+        'User-Agent': 'Google sdkgphone64x8664 | Android 14 | erth | 8.26.0 (82600010) | 0 | 0 | 0',
+        'Operator': operator
+      }
+    }).json().data.URL
+```
+
+**dom.ufanet.ru**
+
+```yaml
+streams:
+  ufanet_ru: |
+    expr:
+    let username = '***';
+    let password = '***';
+    let cameraid = '***';
+
+    let r1 = fetch('https://ucams.ufanet.ru/api/internal/login/', {
+      method: 'POST',
+      data: {username: username, password: password}
+    });
+    let r2 = fetch('https://ucams.ufanet.ru/api/v0/cameras/this/?lang=ru', {
+      method: 'POST',
+      json: {'fields': ['token_l', 'server'], 'token_l_ttl': 3600, 'numbers': [cameraid]},
+    }).json().results[0];
+
+    'rtsp://' + r2.server.domain + '/' + r2.number + '?token=' + r2.token_l
+```
+
+**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"
+```
+
+## Comparison
+
+| 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,29 @@
+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
+	})
+	streams.MarkInsecure("expr")
+}

internal/ffmpeg/README.md

@@ -0,0 +1,62 @@
+# FFmpeg
+
+You can get any stream, file or device via FFmpeg and push it to go2rtc. The app will automatically start FFmpeg with the proper arguments when someone starts watching the stream.
+
+- FFmpeg preinstalled for **Docker** and **Home Assistant add-on** users
+- **Home Assistant add-on** users can target files from [/media](https://www.home-assistant.io/more-info/local-media/setup-media/) folder
+
+## Configuration
+
+Format: `ffmpeg:{input}#{param1}#{param2}#{param3}`. Examples:
+
+```yaml
+streams:
+  # [FILE] all tracks will be copied without transcoding codecs
+  file1: ffmpeg:/media/BigBuckBunny.mp4
+
+  # [FILE] video will be transcoded to H264, audio will be skipped
+  file2: ffmpeg:/media/BigBuckBunny.mp4#video=h264
+
+  # [FILE] video will be copied, audio will be transcoded to PCMU
+  file3: ffmpeg:/media/BigBuckBunny.mp4#video=copy#audio=pcmu
+
+  # [HLS] video will be copied, audio will be skipped
+  hls: ffmpeg:https://devstreaming-cdn.apple.com/videos/streaming/examples/bipbop_16x9/gear5/prog_index.m3u8#video=copy
+
+  # [MJPEG] video will be transcoded to H264
+  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://12345678@192.168.1.123/av_stream/ch0#video=h264#rotate=90
+```
+
+All transcoding formats have [built-in templates](ffmpeg.go): `h264`, `h265`, `opus`, `pcmu`, `pcmu/16000`, `pcmu/48000`, `pcma`, `pcma/16000`, `pcma/48000`, `aac`, `aac/16000`.
+
+But you can override them via YAML config. You can also add your own formats to the config and use them with source params.
+
+```yaml
+ffmpeg:
+  bin: ffmpeg  # path to ffmpeg binary
+  global: "-hide_banner"
+  timeout: 5  # default timeout in seconds for rtsp inputs
+  h264: "-codec:v libx264 -g:v 30 -preset:v superfast -tune:v zerolatency -profile:v main -level:v 4.1"
+  mycodec: "-any args that supported by ffmpeg..."
+  myinput: "-fflags nobuffer -flags low_delay -timeout {timeout} -i {input}"
+  myraw: "-ss 00:00:20"
+```
+
+- You can use go2rtc stream name as ffmpeg input (ex. `ffmpeg:camera1#video=h264`)
+- You can use `video` and `audio` params multiple times (ex. `#video=copy#audio=copy#audio=pcmu`)
+- You can use `rotate` param with `90`, `180`, `270` or `-90` values, important with transcoding (ex. `#video=h264#rotate=90`)
+- You can use `width` and/or `height` params, important with transcoding (ex. `#video=h264#width=1280`)
+- You can use `drawtext` to add a timestamp (ex. `drawtext=x=2:y=2:fontsize=12:fontcolor=white:box=1:boxcolor=black`)
+    - This will greatly increase the CPU of the server, even with hardware acceleration
+- You can use `timeout` param to set RTSP input timeout in seconds (ex. `#timeout=10`)
+- You can use `raw` param for any additional FFmpeg arguments (ex. `#raw=-vf transpose=1`)
+- You can use `input` param to override default input template (ex. `#input=rtsp/udp` will change RTSP transport from TCP to UDP+TCP)
+    - You can use raw input value (ex. `#input=-timeout {timeout} -i {input}`)
+    - You can add your own input templates
+
+Read more about [hardware acceleration](hardware/README.md).
+
+**PS.** It is recommended to check the available hardware in the WebUI add page.

internal/ffmpeg/api.go

@@ -0,0 +1,56 @@
+package ffmpeg
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+)
+
+func apiFFmpeg(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		http.Error(w, "", http.StatusMethodNotAllowed)
+		return
+	}
+	if api.IsReadOnly() {
+		api.ReadOnlyError(w)
+		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/api_readonly_test.go

@@ -0,0 +1,26 @@
+package ffmpeg
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/stretchr/testify/require"
+)
+
+func TestApiFFmpegReadOnly(t *testing.T) {
+	prevReadOnly := api.ReadOnly
+	t.Cleanup(func() {
+		api.ReadOnly = prevReadOnly
+	})
+
+	api.ReadOnly = true
+
+	req := httptest.NewRequest("POST", "/api/ffmpeg?dst=cam&text=hello", nil)
+	w := httptest.NewRecorder()
+
+	apiFFmpeg(w, req)
+
+	require.Equal(t, http.StatusForbidden, w.Code)
+}

internal/ffmpeg/device/README.md

@@ -0,0 +1,22 @@
+# FFmpeg Device
+
+You can get video from any USB camera or Webcam as RTSP or WebRTC stream. This is part of FFmpeg integration.
+
+- check available devices in web interface
+- `video_size` and `framerate` must be supported by your camera!
+- for Linux supported only video for now
+- for macOS you can stream FaceTime camera or whole desktop!
+- for macOS important to set right framerate
+
+## Configuration
+
+Format: `ffmpeg:device?{input-params}#{param1}#{param2}#{param3}`
+
+```yaml
+streams:
+  linux_usbcam:   ffmpeg:device?video=0&video_size=1280x720#video=h264
+  windows_webcam: ffmpeg:device?video=0#video=h264
+  macos_facetime: ffmpeg:device?video=0&audio=1&video_size=1280x720&framerate=30#video=h264#audio=pcma
+```
+
+**PS.** It is recommended to check the available devices in the WebUI add page.

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

@@ -0,0 +1,88 @@
+//go:build darwin || ios
+
+package device
+
+import (
+	"net/url"
+	"os/exec"
+	"regexp"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func queryToInput(query url.Values) string {
+	video := query.Get("video")
+	audio := query.Get("audio")
+
+	if video == "" && audio == "" {
+		return ""
+	}
+
+	// https://ffmpeg.org/ffmpeg-devices.html#avfoundation
+	input := "-f avfoundation"
+
+	if video != "" {
+		video = indexToItem(videos, video)
+
+		for key, value := range query {
+			switch key {
+			case "resolution":
+				input += " -video_size " + value[0]
+			case "pixel_format", "framerate", "video_size", "capture_cursor", "capture_mouse_clicks", "capture_raw_data":
+				input += " -" + key + " " + value[0]
+			}
+		}
+	}
+
+	if audio != "" {
+		audio = indexToItem(audios, audio)
+	}
+
+	return input + ` -i "` + video + `:` + audio + `"`
+}
+
+func initDevices() {
+	// [AVFoundation indev @ 0x147f04510] AVFoundation video devices:
+	// [AVFoundation indev @ 0x147f04510] [0] FaceTime HD Camera
+	// [AVFoundation indev @ 0x147f04510] [1] Capture screen 0
+	// [AVFoundation indev @ 0x147f04510] AVFoundation audio devices:
+	// [AVFoundation indev @ 0x147f04510] [0] MacBook Pro Microphone
+	cmd := exec.Command(
+		Bin, "-hide_banner", "-list_devices", "true", "-f", "avfoundation", "-i", "",
+	)
+	b, _ := cmd.CombinedOutput()
+
+	re := regexp.MustCompile(`\[\d+] (.+)`)
+
+	var kind string
+	for _, line := range strings.Split(string(b), "\n") {
+		switch {
+		case strings.HasSuffix(line, "video devices:"):
+			kind = core.KindVideo
+			continue
+		case strings.HasSuffix(line, "audio devices:"):
+			kind = core.KindAudio
+			continue
+		}
+
+		m := re.FindStringSubmatch(line)
+		if m == nil {
+			continue
+		}
+
+		name := m[1]
+
+		switch kind {
+		case core.KindVideo:
+			videos = append(videos, name)
+		case core.KindAudio:
+			audios = append(audios, name)
+		}
+
+		streams = append(streams, &api.Source{
+			Name: name, URL: "ffmpeg:device?" + kind + "=" + name,
+		})
+	}
+}

internal/ffmpeg/device/device_unix.go

@@ -0,0 +1,101 @@
+//go:build unix && !darwin && !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 != "" {
+		// https://trac.ffmpeg.org/wiki/Capture/ALSA
+		input := "-f alsa"
+
+		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 @ 0x204e1c0] Compressed:       mjpeg :          Motion-JPEG : 640x360 1280x720 1920x1080
+		// [video4linux2,v4l2 @ 0x204e1c0] Raw       :     yuyv422 :           YUYV 4:2:2 : 640x360 1280x720 1920x1080
+		// [video4linux2,v4l2 @ 0x204e1c0] Compressed:        h264 :                H.264 : 640x360 1280x720 1920x1080
+		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", "alsa", "-i", "default", "-t", "1", "-f", "null", "-").Run()
+	if err == nil {
+		stream := &api.Source{
+			Name: "ALSA 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_windows.go

@@ -0,0 +1,90 @@
+//go:build windows
+
+package device
+
+import (
+	"net/url"
+	"os/exec"
+	"regexp"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func queryToInput(query url.Values) string {
+	video := query.Get("video")
+	audio := query.Get("audio")
+
+	if video == "" && audio == "" {
+		return ""
+	}
+
+	// https://ffmpeg.org/ffmpeg-devices.html#dshow
+	input := "-f dshow"
+
+	if video != "" {
+		video = indexToItem(videos, video)
+
+		for key, value := range query {
+			switch key {
+			case "resolution":
+				input += " -video_size " + value[0]
+			case "video_size", "framerate", "pixel_format":
+				input += " -" + key + " " + value[0]
+			}
+		}
+	}
+
+	if audio != "" {
+		audio = indexToItem(audios, audio)
+
+		for key, value := range query {
+			switch key {
+			case "sample_rate", "sample_size", "channels", "audio_buffer_size":
+				input += " -" + key + " " + value[0]
+			}
+		}
+	}
+
+	if video != "" {
+		input += ` -i "video=` + video
+
+		if audio != "" {
+			input += `:audio=` + audio
+		}
+
+		input += `"`
+	} else {
+		input += ` -i "audio=` + audio + `"`
+	}
+
+	return input
+}
+
+func initDevices() {
+	cmd := exec.Command(
+		Bin, "-hide_banner", "-list_devices", "true", "-f", "dshow", "-i", "",
+	)
+	b, _ := cmd.CombinedOutput()
+
+	re := regexp.MustCompile(`"([^"]+)" \((video|audio)\)`)
+	for _, m := range re.FindAllStringSubmatch(string(b), -1) {
+		name := m[1]
+		kind := m[2]
+
+		stream := &api.Source{
+			Name: name, URL: "ffmpeg:device?" + kind + "=" + name,
+		}
+
+		switch kind {
+		case core.KindVideo:
+			videos = append(videos, name)
+			stream.URL += "#video=h264#hardware"
+		case core.KindAudio:
+			audios = append(audios, name)
+			stream.URL += "&channels=1&sample_rate=16000&audio_buffer_size=10"
+		}
+
+		streams = append(streams, stream)
+	}
+}

internal/ffmpeg/device/devices.go

@@ -0,0 +1,46 @@
+package device
+
+import (
+	"net/http"
+	"net/url"
+	"strconv"
+	"sync"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+)
+
+func Init(bin string) {
+	Bin = bin
+
+	api.HandleFunc("api/ffmpeg/devices", apiDevices)
+}
+
+func GetInput(src string) string {
+	query, err := url.ParseQuery(src)
+	if err != nil {
+		return ""
+	}
+
+	runonce.Do(initDevices)
+
+	return queryToInput(query)
+}
+
+var Bin string
+
+var videos, audios []string
+var streams []*api.Source
+var runonce sync.Once
+
+func apiDevices(w http.ResponseWriter, r *http.Request) {
+	runonce.Do(initDevices)
+
+	api.ResponseSources(w, streams)
+}
+
+func indexToItem(items []string, index string) string {
+	if i, err := strconv.Atoi(index); err == nil && i < len(items) {
+		return items[i]
+	}
+	return index
+}

internal/ffmpeg/ffmpeg.go

@@ -0,0 +1,388 @@
+package ffmpeg
+
+import (
+	"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)
+
+	log = app.GetLogger("ffmpeg")
+
+	// 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
+		}
+		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"])
+}
+
+var defaults = map[string]string{
+	"bin":     "ffmpeg",
+	"global":  "-hide_banner",
+	"timeout": "5",
+
+	// inputs
+	"file":     "-re -i {input}",
+	"http":     "-fflags nobuffer -flags low_delay -i {input}",
+	"rtsp":     "-fflags nobuffer -flags low_delay -timeout {timeout} -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i {input}",
+	"rtsp/udp": "-fflags nobuffer -flags low_delay -timeout {timeout} -user_agent go2rtc/ffmpeg -i {input}",
+
+	// 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
+	// `-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 -x265-params level=5.1:high-tier=0 -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 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 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 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 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 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 != "" {
+		return s
+	}
+	return template
+}
+
+// inputTemplate - select input template from YAML config by template name
+// if query has input param - select another template by this name
+// if there is no another template - use input param as template
+func inputTemplate(name, s string, query url.Values) string {
+	var template string
+	if input := query.Get("input"); input != "" {
+		template = configTemplate(input)
+	} else {
+		template = defaults[name]
+	}
+	if strings.Contains(template, "{timeout}") {
+		timeout := query.Get("timeout")
+		if timeout == "" {
+			timeout = defaults["timeout"]
+		}
+		template = strings.Replace(template, "{timeout}", timeout+"000000", 1)
+	}
+	return strings.Replace(template, "{input}", s, 1)
+}
+
+func parseArgs(s string) *ffmpeg.Args {
+	// init FFmpeg arguments
+	args := &ffmpeg.Args{
+		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 {
+		query = streams.ParseQuery(s[i+1:])
+		args.Video = len(query["video"])
+		args.Audio = len(query["audio"])
+		s = s[:i]
+	}
+
+	// Parse input:
+	//   1. Input as xxxx:// link (http or rtsp or any other)
+	//   2. Input as stream name
+	//   3. Input as FFmpeg device (local USB camera)
+	if i := strings.Index(s, "://"); i > 0 {
+		switch s[:i] {
+		case "http", "https", "rtmp":
+			args.Input = inputTemplate("http", s, query)
+		case "rtsp", "rtsps":
+			// https://ffmpeg.org/ffmpeg-protocols.html#rtsp
+			// skip unnecessary input tracks
+			switch {
+			case (args.Video > 0 && args.Audio > 0) || (args.Video == 0 && args.Audio == 0):
+				args.Input = "-allowed_media_types video+audio "
+			case args.Video > 0:
+				args.Input = "-allowed_media_types video "
+			case args.Audio > 0:
+				args.Input = "-allowed_media_types audio "
+			}
+
+			args.Input += inputTemplate("rtsp", s, query)
+		default:
+			args.Input = "-i " + s
+		}
+	} else if streams.Get(s) != nil {
+		s = "rtsp://127.0.0.1:" + rtsp.Port + "/" + s
+		switch {
+		case args.Video > 0 && args.Audio == 0:
+			s += "?video"
+		case args.Audio > 0 && args.Video == 0:
+			s += "?audio"
+		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 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)
+	}
+
+	if query["async"] != nil {
+		args.Input = "-use_wallclock_as_timestamps 1 -async 1 " + args.Input
+	}
+
+	// Parse query params:
+	//   1. `width`/`height` params
+	//   2. `rotate` param
+	//   3. `video` params (support multiple)
+	//   4. `audio` params (support multiple)
+	//   5. `hardware` param
+	if query != nil {
+		// 1. Process raw params for FFmpeg
+		for _, raw := range query["raw"] {
+			// support templates https://github.com/AlexxIT/go2rtc/issues/487
+			raw = configTemplate(raw)
+			args.AddCodec(raw)
+		}
+
+		// 2. Process video filters (resize and rotation)
+		if query["width"] != nil || query["height"] != nil {
+			filter := "scale="
+			if query["width"] != nil {
+				filter += query["width"][0]
+			} else {
+				filter += "-1"
+			}
+			filter += ":"
+			if query["height"] != nil {
+				filter += query["height"][0]
+			} else {
+				filter += "-1"
+			}
+			args.AddFilter(filter)
+		}
+
+		if query["rotate"] != nil {
+			var filter string
+			switch query["rotate"][0] {
+			case "90":
+				filter = "transpose=1" // 90 degrees clockwise
+			case "180":
+				filter = "transpose=1,transpose=1"
+			case "-90", "270":
+				filter = "transpose=2" // 90 degrees counterclockwise
+			}
+			if filter != "" {
+				args.AddFilter(filter)
+			}
+		}
+
+		for _, drawtext := range query["drawtext"] {
+			// support templates https://github.com/AlexxIT/go2rtc/issues/487
+			drawtext = configTemplate(drawtext)
+
+			// support default timestamp format
+			if !strings.Contains(drawtext, "text=") {
+				drawtext += `:text='%{localtime\:%Y-%m-%d %X}'`
+			}
+
+			args.AddFilter("drawtext=" + drawtext)
+		}
+
+		// 3. Process video codecs
+		if args.Video > 0 {
+			for _, video := range query["video"] {
+				if video != "copy" {
+					if codec := defaults[video]; codec != "" {
+						args.AddCodec(codec)
+					} else {
+						args.AddCodec(video)
+					}
+				} else {
+					args.AddCodec("-c:v copy")
+				}
+			}
+		}
+
+		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"] {
+				if audio != "copy" {
+					if codec := defaults[audio]; codec != "" {
+						args.AddCodec(codec)
+					} else {
+						args.AddCodec(audio)
+					}
+				} else {
+					args.AddCodec("-c:a copy")
+				}
+			}
+		}
+
+		if query["hardware"] != nil {
+			hardware.MakeHardware(args, query["hardware"][0], defaults)
+		}
+	}
+
+	switch {
+	case args.Video == 0 && args.Audio == 0:
+		args.AddCodec("-c copy")
+	case args.Video == 0:
+		args.AddCodec("-vn")
+	case args.Audio == 0:
+		args.AddCodec("-an")
+	}
+
+	// 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
+}