Update version to 1.3.0

Code refactoring

.github/workflows/builder.yml

@@ -1,59 +0,0 @@
-# https://github.com/home-assistant/builder
-name: 'Builder'
-
-on:
-  push:
-    tags: [ 'v*' ]
-  workflow_dispatch:
-
-jobs:
-  hassio:
-    name: Hassio Addon
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@v3
-
-      - name: Login to DockerHub
-        uses: docker/login-action@v2
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Branch name
-        run: |
-          VERSION="${GITHUB_REF#refs/tags/v}"
-          echo "REPO=alexxit/go2rtc" >> $GITHUB_ENV
-          echo "TAG=${VERSION}" >> $GITHUB_ENV
-          echo "IMAGE=alexxit/go2rtc:${VERSION}" >> $GITHUB_ENV
-
-      - name: Build amd64
-        uses: home-assistant/builder@master
-        with:
-          args: --amd64 --target build/hassio --version $TAG-amd64 --no-latest --docker-hub-check
-
-      - name: Build i386
-        uses: home-assistant/builder@master
-        with:
-          args: --i386 --target build/hassio --version $TAG-i386 --no-latest --docker-hub-check
-
-      - name: Build aarch64
-        uses: home-assistant/builder@master
-        with:
-          args: --aarch64 --target build/hassio --version $TAG-aarch64 --no-latest --docker-hub-check
-
-      - name: Build armv7
-        uses: home-assistant/builder@master
-        with:
-          args: --armv7 --target build/hassio --version $TAG-armv7 --no-latest --docker-hub-check
-
-      - name: Docker manifest
-        run: |
-          # thanks to https://github.com/aler9/rtsp-simple-server/blob/main/Makefile
-          docker manifest create "${IMAGE}" \
-            "${IMAGE}-amd64" "${IMAGE}-i386" "${IMAGE}-aarch64" "${IMAGE}-armv7"
-          docker manifest push "${IMAGE}"
-
-          docker manifest create "${REPO}:latest" \
-            "${IMAGE}-amd64" "${IMAGE}-i386" "${IMAGE}-aarch64" "${IMAGE}-armv7"
-          docker manifest push "${REPO}:latest"

.github/workflows/docker.yml

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

.github/workflows/gh-pages.yml

@@ -0,0 +1,37 @@
+# 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:
+  # Single deploy job since we're just deploying
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Setup Pages
+        uses: actions/configure-pages@v3
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v1
+        with:
+          path: './website'
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v1

.github/workflows/release.yml

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

Dockerfile

@@ -0,0 +1,61 @@
+# syntax=docker/dockerfile:labs
+
+# 0. Prepare images
+ARG PYTHON_VERSION="3.11"
+ARG GO_VERSION="1.19"
+ARG NGROK_VERSION="3"
+
+FROM python:${PYTHON_VERSION}-alpine AS base
+FROM ngrok/ngrok:${NGROK_VERSION}-alpine AS ngrok
+
+
+# 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
+
+# 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. Collect all files
+FROM scratch AS rootfs
+
+COPY --from=build /build/go2rtc /usr/local/bin/
+COPY --from=ngrok /bin/ngrok /usr/local/bin/
+
+
+# 3. Final image
+FROM base
+
+# Install ffmpeg, tini (for signal handling),
+# and other common tools for the echo source.
+RUN apk add --no-cache tini ffmpeg bash curl jq
+
+# 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=rootfs / /
+
+ENTRYPOINT ["/sbin/tini", "--"]
+VOLUME /config
+WORKDIR /config
+
+CMD ["go2rtc", "-config", "/config/go2rtc.yaml"]

README.md

@@ -6,15 +6,17 @@ Ultimate camera streaming application with support RTSP, WebRTC, HomeKit, FFmpeg
 
 - zero-dependency and zero-config [small app](#go2rtc-binary) for all OS (Windows, macOS, Linux, ARM)
 - zero-delay for many supported protocols (lowest possible streaming latency)
-- streaming from [RTSP](#source-rtsp), [RTMP](#source-rtmp), [MJPEG](#source-ffmpeg), [HLS/HTTP](#source-ffmpeg), [USB Cameras](#source-ffmpeg-device) and [other sources](#module-streams)
-- streaming to [RTSP](#module-rtsp), [WebRTC](#module-webrtc), [MSE/MP4](#module-mp4) or [MJPEG](#module-mjpeg)
+- streaming from [RTSP](#source-rtsp), [RTMP](#source-rtmp), [DVRIP](#source-dvrip), [HTTP](#source-http) (FLV/MJPEG/JPEG/TS), [USB Cameras](#source-ffmpeg-device) and [other sources](#module-streams)
+- streaming from any sources, supported by [FFmpeg](#source-ffmpeg)
+- streaming to [RTSP](#module-rtsp), [WebRTC](#module-webrtc), [MSE/MP4](#module-mp4), [HLS](#module-hls) or [MJPEG](#module-mjpeg)
 - first project in the World with support streaming from [HomeKit Cameras](#source-homekit)
-- first project in the World with support H265 for WebRTC in browser ([read more](https://github.com/AlexxIT/Blog/issues/5))
+- first project in the World with support H265 for WebRTC in browser (Safari only, [read more](https://github.com/AlexxIT/Blog/issues/5))
 - on the fly transcoding for unsupported codecs via [FFmpeg](#source-ffmpeg)
+- play audio files and live streams on some cameras with [speaker](#stream-to-camera)
 - multi-source 2-way [codecs negotiation](#codecs-negotiation)
    - mixing tracks from different sources to single stream
    - auto match client supported codecs
-   - 2-way audio for `ONVIF Profile T` Cameras
+   - [2-way audio](#two-way-audio) for some cameras
 - streaming from private networks via [Ngrok](#module-ngrok)
 - can be [integrated to](#module-api) any smart home platform or be used as [standalone app](#go2rtc-binary)
 
@@ -27,17 +29,57 @@ Ultimate camera streaming application with support RTSP, WebRTC, HomeKit, FFmpeg
 - [MediaSoup](https://mediasoup.org/) framework routing idea
 - HomeKit Accessory Protocol from [@brutella](https://github.com/brutella/hap)
 
+---
+
+* [Fast start](#fast-start)
+  * [go2rtc: Binary](#go2rtc-binary)
+  * [go2rtc: Docker](#go2rtc-docker)
+  * [go2rtc: Home Assistant Add-on](#go2rtc-home-assistant-add-on)
+  * [go2rtc: Home Assistant Integration](#go2rtc-home-assistant-integration)
+* [Configuration](#configuration)
+  * [Module: Streams](#module-streams)
+    * [Two way audio](#two-way-audio)
+    * [Source: RTSP](#source-rtsp)
+    * [Source: RTMP](#source-rtmp)
+    * [Source: HTTP](#source-http)
+    * [Source: FFmpeg](#source-ffmpeg)
+    * [Source: FFmpeg Device](#source-ffmpeg-device)
+    * [Source: Exec](#source-exec)
+    * [Source: Echo](#source-echo)
+    * [Source: HomeKit](#source-homekit)
+    * [Source: DVRIP](#source-dvrip)
+    * [Source: Tapo](#source-tapo)
+    * [Source: Ivideon](#source-ivideon)
+    * [Source: Hass](#source-hass)
+    * [Incoming sources](#incoming-sources)
+    * [Stream to camera](#stream-to-camera)
+  * [Module: API](#module-api)
+  * [Module: RTSP](#module-rtsp)
+  * [Module: WebRTC](#module-webrtc)
+  * [Module: Ngrok](#module-ngrok)
+  * [Module: Hass](#module-hass)
+  * [Module: MP4](#module-mp4)
+  * [Module: HLS](#module-hls)
+  * [Module: MJPEG](#module-mjpeg)
+  * [Module: Log](#module-log)
+* [Security](#security)
+* [Codecs filters](#codecs-filters)
+* [Codecs madness](#codecs-madness)
+* [Codecs negotiation](#codecs-negotiation)
+* [Projects using go2rtc](#projects-using-go2rtc)
+* [Camera experience](#cameras-experience)
+* [TIPS](#tips)
+* [FAQ](#faq)
+
 ## Fast start
 
-1. Download [binary](#go2rtc-binary) or use [Docker](#go2rtc-docker) or [Home Assistant Add-on](#go2rtc-home-assistant-add-on)
+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/`
 
 **Optionally:**
 
 - add your [streams](#module-streams) to [config](#configuration) file
 - setup [external access](#module-webrtc) to webrtc
-- setup [external access](#module-ngrok) to web interface
-- install [ffmpeg](#source-ffmpeg) for transcoding
 
 **Developers:**
 
@@ -54,12 +96,16 @@ Download binary for your OS from [latest release](https://github.com/AlexxIT/go2
 - `go2rtc_linux_i386` - Linux 32-bit
 - `go2rtc_linux_arm64` - Linux ARM 64-bit (ex. Raspberry 64-bit OS)
 - `go2rtc_linux_arm` - Linux ARM 32-bit (ex. Raspberry 32-bit OS)
-- `go2rtc_linux_mipsel` - Linux on MIPS (ex. [Xiaomi Gateway 3](https://github.com/AlexxIT/XiaomiGateway3))
-- `go2rtc_mac_amd64` - Mac with Intel
-- `go2rtc_mac_arm64` - Mac with M1
+- `go2rtc_linux_mipsel` - Linux MIPS (ex. [Xiaomi Gateway 3](https://github.com/AlexxIT/XiaomiGateway3))
+- `go2rtc_mac_amd64.zip` - Mac Intel 64-bit
+- `go2rtc_mac_arm64.zip` - Mac ARM 64-bit
 
 Don't forget to fix the rights `chmod +x go2rtc_xxx_xxx` on Linux and Mac.
 
+### go2rtc: Docker
+
+Container [alexxit/go2rtc](https://hub.docker.com/r/alexxit/go2rtc) with support `amd64`, `386`, `arm64`, `arm`. This container is the same as [Home Assistant Add-on](#go2rtc-home-assistant-add-on), but can be used separately from Home Assistant. Container has preinstalled [FFmpeg](#source-ffmpeg), [Ngrok](#module-ngrok) and [Python](#source-echo).
+
 ### go2rtc: Home Assistant Add-on
 
 [![](https://my.home-assistant.io/badges/supervisor_addon.svg)](https://my.home-assistant.io/redirect/supervisor_addon/?addon=a889bffc_go2rtc&repository_url=https%3A%2F%2Fgithub.com%2FAlexxIT%2Fhassio-addons)
@@ -69,29 +115,19 @@ Don't forget to fix the rights `chmod +x go2rtc_xxx_xxx` on Linux and Mac.
     - go2rtc > Install > Start
 2. Setup [Integration](#module-hass)
 
-### go2rtc: Docker
+### go2rtc: Home Assistant Integration
 
-Container [alexxit/go2rtc](https://hub.docker.com/r/alexxit/go2rtc) with support `amd64`, `386`, `arm64`, `arm`. This container same as [Home Assistant Add-on](#go2rtc-home-assistant-add-on), but can be used separately from the Home Assistant. Container has preinstalled [FFmpeg](#source-ffmpeg), [Ngrok](#module-ngrok) and [Python](#source-echo).
-
-```yaml
-services:
-  go2rtc:
-    image: alexxit/go2rtc
-    network_mode: host
-    restart: always
-    volumes:
-      - "~/go2rtc.yaml:/config/go2rtc.yaml"
-```
+[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.
 
 ## Configuration
 
-Create file `go2rtc.yaml` next to the app.
+- by default go2rtc will search `go2rtc.yaml` in the current work dirrectory
+- `api` server will start on default **1984 port** (TCP)
+- `rtsp` server will start on default **8554 port** (TCP)
+- `webrtc` will use port **8555** (TCP/UDP) for connections
+- `ffmpeg` will use default transcoding options
 
-- by default, you need to config only your `streams` links
-- `api` server will start on default **1984 port**
-- `rtsp` server will start on default **8554 port**
-- `webrtc` will use random UDP port for each connection
-- `ffmpeg` will use default transcoding options (you may install it [manually](https://ffmpeg.org/))
+Configuration options and a complete list of settings can be found in [the wiki](https://github.com/AlexxIT/go2rtc/wiki/Configuration).
 
 Available modules:
 
@@ -100,6 +136,7 @@ Available modules:
 - [rtsp](#module-rtsp) - RTSP Server (important for FFmpeg support)
 - [webrtc](#module-webrtc) - WebRTC Server
 - [mp4](#module-mp4) - MSE, MP4 stream and MP4 shapshot Server
+- [hls](#module-hls) - HLS TS or fMP4 stream Server
 - [mjpeg](#module-mjpeg) - MJPEG Server
 - [ffmpeg](#source-ffmpeg) - FFmpeg integration
 - [ngrok](#module-ngrok) - Ngrok integration (external access for private network)
@@ -112,41 +149,55 @@ Available modules:
 
 Available source types:
 
-- [rtsp](#source-rtsp) - `RTSP` and `RTSPS` cameras
+- [rtsp](#source-rtsp) - `RTSP` and `RTSPS` cameras with [two way audio](#two-way-audio) support
 - [rtmp](#source-rtmp) - `RTMP` streams
-- [http](#source-http) - `HTTP-FLV`, `JPEG` (snapshots), `MJPEG` streams 
+- [http](#source-http) - `HTTP-FLV`, `MPEG-TS`, `JPEG` (snapshots), `MJPEG` streams 
 - [ffmpeg](#source-ffmpeg) - FFmpeg integration (`HLS`, `files` and many others)
 - [ffmpeg:device](#source-ffmpeg-device) - local USB Camera or Webcam
 - [exec](#source-exec) - advanced FFmpeg and GStreamer integration
 - [echo](#source-echo) - get stream link from bash or python
 - [homekit](#source-homekit) - streaming from HomeKit Camera
+- [dvrip](#source-dvrip) - streaming from DVR-IP NVR
+- [tapo](#source-tapo) - TP-Link Tapo cameras with [two way audio](#two-way-audio) support
 - [ivideon](#source-ivideon) - public cameras from [Ivideon](https://tv.ivideon.com/) service
 - [hass](#source-hass) - Home Assistant integration
 
+Read more about [incoming sources](#incoming-sources)
+
+#### Two way audio
+
+Supported for sources:
+
+- RTSP cameras with [ONVIF Profile T](https://www.onvif.org/specs/stream/ONVIF-Streaming-Spec.pdf) (back channel connection)
+- TP-Link Tapo cameras
+
+Two way audio can be used in browser with [WebRTC](#module-webrtc) technology. The browser will give access to the microphone only for HTTPS sites ([read more](https://stackoverflow.com/questions/52759992/how-to-access-camera-and-microphone-in-chrome-without-https)).
+
+go2rtc also support [play audio](#stream-to-camera) files and live streams on this cameras.
+
 #### Source: RTSP
 
-- 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:** other 2-way audio standards are not supported! ONVIF without Profile T is not supported!
-
 ```yaml
 streams:
   sonoff_camera: rtsp://rtsp:12345678@192.168.1.123/av_stream/ch0
-```
-
-If your camera has two RTSP links - you can add both of them as sources. This is useful when streams has different codecs, as example AAC audio with main stream and PCMU/PCMA audio with second stream.
-
-**Attention:** Dahua cameras has different capabilities for different RTSP links. For example, it has support multiple codecs for 2-way audio with `&proto=Onvif` in link and only one codec without it.
-
-```yaml
-streams:
   dahua_camera:
     - rtsp://admin:password@192.168.1.123/cam/realmonitor?channel=1&subtype=0&unicast=true&proto=Onvif
     - rtsp://admin:password@192.168.1.123/cam/realmonitor?channel=1&subtype=1
+  amcrest_doorbell:
+    - rtsp://username:password@192.168.1.123:554/cam/realmonitor?channel=1&subtype=0#backchannel=0
+  unify_camera: rtspx://192.168.1.123:7441/fD6ouM72bWoFijxK
+  glichy_camera: ffmpeg:rstp://username:password@192.168.1.123/live/ch00_1 
 ```
 
-**PS.** For disable bachannel just add `#backchannel=0` to end of RTSP link.
+**Recommendations**
+
+- **Amcrest Doorbell** users may want to disable two way audio, because with an active stream you won't have a call button working. You need to add `#backchannel=0` to the end of your RTSP link in YAML config file
+- **Dahua Doorbell** users may want to change backchannel [audio codec](https://github.com/AlexxIT/go2rtc/issues/52)
+- **Unify** users may want to disable HTTPS verification. Use `rtspx://` prefix instead of `rtsps://`. And don't use `?enableSrtp` [suffix](https://github.com/AlexxIT/go2rtc/issues/81)
+- **TP-Link Tapo** users may skip login and password, because go2rtc support login [without them](https://drmnsamoliu.github.io/video.html)
+- If your camera has two RTSP links - you can add both of them as sources. This is useful when streams has different codecs, as example AAC audio with main stream and PCMU/PCMA audio with second stream
+- If the stream from your camera is glitchy, try using [ffmpeg source](#source-ffmpeg). It will not add CPU load if you won't use transcoding
+- If the stream from your camera is very glitchy, try to use transcoding with [ffmpeg source](#source-ffmpeg)
 
 #### Source: RTMP
 
@@ -164,6 +215,7 @@ Support Content-Type:
 - **HTTP-FLV** (`video/x-flv`) - same as RTMP, but over HTTP
 - **HTTP-JPEG** (`image/jpeg`) - camera snapshot link, can be converted by go2rtc to MJPEG stream
 - **HTTP-MJPEG** (`multipart/x`) - simple MJPEG stream over HTTP
+- **MPEG-TS** (`video/mpeg`) - legacy [streaming format](https://en.wikipedia.org/wiki/MPEG_transport_stream)
 
 ```yaml
 streams:
@@ -209,21 +261,28 @@ streams:
   rotate: ffmpeg:rtsp://rtsp:12345678@192.168.1.123/av_stream/ch0#video=h264#rotate=90
 ```
 
-All trascoding formats has [built-in templates](https://github.com/AlexxIT/go2rtc/blob/master/cmd/ffmpeg/ffmpeg.go): `h264`, `h264/ultra`, `h264/high`, `h265`, `opus`, `pcmu`, `pcmu/16000`, `pcmu/48000`, `pcma`, `pcma/16000`, `pcma/48000`, `aac`, `aac/16000`.
+All trascoding formats has [built-in templates](https://github.com/AlexxIT/go2rtc/blob/master/cmd/ffmpeg/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 config and use them with source params.
 
 ```yaml
 ffmpeg:
-  bin: ffmpeg                                        # path to ffmpeg binary
+  bin: ffmpeg  # path to ffmpeg binary
   h264: "-codec:v libx264 -g:v 30 -preset:v superfast -tune:v zerolatency -profile:v main -level:v 4.1"
   mycodec: "-any args that support ffmpeg..."
+  myinput: "-fflags nobuffer -flags low_delay -timeout 5000000 -i {input}"
 ```
 
 - You can use `video` and `audio` params multiple times (ex. `#video=copy#audio=copy#audio=pcmu`)
 - You can use go2rtc stream name as ffmpeg input (ex. `ffmpeg:camera1#video=h264`)
 - You can use `rotate` params with `90`, `180`, `270` or `-90` values, important with transcoding (ex. `#video=h264#rotate=90`)
-- You can use `raw` param for any additional FFmpeg arguments (ex. `#raw=-vf transpose=1`).
+- You can use `width` and/or `height` params, important with transcoding (ex. `#video=h264#width=1280`)
+- You can use `raw` param for any additional FFmpeg arguments (ex. `#raw=-vf transpose=1`)
+- 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 5000000 -i {input}`)
+  - You can add your own input templates
+
+Read more about encoding [hardware acceleration](https://github.com/AlexxIT/go2rtc/wiki/Hardware-acceleration).
 
 #### Source: FFmpeg Device
 
@@ -298,6 +357,36 @@ RTSP link with "normal" audio for any player: `rtsp://192.168.1.123:8554/aqara_g
 
 **This source is in active development!** Tested only with [Aqara Camera Hub G3](https://www.aqara.com/eu/product/camera-hub-g3) (both EU and CN versions).
 
+#### Source: DVRIP
+
+Other names: DVR-IP, NetSurveillance, Sofia protocol (NETsurveillance ActiveX plugin XMeye SDK).
+
+- you can skip `username`, `password`, `port`, `channel` and `subtype` if they are default
+- setup 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:
+  camera1: dvrip://username:password@192.168.1.123:34567?channel=0&subtype=0
+```
+
+#### Source: Tapo
+
+[TP-Link Tapo](https://www.tapo.com/) proprietary camera protocol with **two way audio** support.
+
+- stream quality is the same as [RTSP protocol](https://www.tapo.com/en/faq/34/)
+- use the **cloud password**, this is not the RTSP password! you do not need to add a login!
+- you can also use UPPERCASE MD5 hash from your cloud password with `admin` username
+
+```yaml
+streams:
+  # cloud password without username
+  camera1: tapo://cloud-password@192.168.1.123
+  # admin username and UPPERCASE MD5 cloud-password hash
+  camera2: tapo://admin:MD5-PASSWORD-HASH@192.168.1.123
+```
+
 #### Source: Ivideon
 
 Support public cameras from service [Ivideon](https://tv.ivideon.com/).
@@ -325,11 +414,87 @@ streams:
 
 More cameras, like [Tuya](https://www.home-assistant.io/integrations/tuya/), [ONVIF](https://www.home-assistant.io/integrations/onvif/), and possibly others can also be imported by using [this method](https://github.com/felipecrs/hass-expose-camera-stream-source#importing-home-assistant-cameras-to-go2rtc-andor-frigate).
 
+### Incoming sources
+
+By default, go2rtc establishes a connection to the source when any client requests it. Go2rtc drops the connection to the source when it has no clients left.
+
+- Go2rtc also can accepts incoming sources in [RTSP](#source-rtsp) and [HTTP](#source-http) formats
+- Go2rtc won't stop such a source if it has no clients
+- You can push data only to existing stream (create stream with empty source in config)
+- You can push multiple incoming sources to same stream
+- You can push data to non empty stream, so it will have additional codecs inside
+
+**Examples**
+
+- RTSP with any codec
+  ```yaml
+  ffmpeg -re -i BigBuckBunny.mp4 -c copy -rtsp_transport tcp -f rtsp rtsp://localhost:8554/camera1
+  ```
+- HTTP-MJPEG with MJPEG codec
+  ```yaml
+  ffmpeg -re -i BigBuckBunny.mp4 -c mjpeg -f mpjpeg http://localhost:1984/api/stream.mjpeg?dst=camera1
+  ```
+- HTTP-FLV with H264, AAC codecs
+  ```yaml
+  ffmpeg -re -i BigBuckBunny.mp4 -c copy -f flv http://localhost:1984/api/stream.flv?dst=camera1
+  ```
+- MPEG-TS with H264 codec
+  ```yaml
+  ffmpeg -re -i BigBuckBunny.mp4 -c copy -f mpegts http://localhost:1984/api/stream.ts?dst=camera1
+  ```
+
+#### Stream to camera
+
+go2rtc support play audio files (ex. music or [TTS](https://www.home-assistant.io/integrations/#text-to-speech)) and live streams (ex. radio) on cameras with [two way audio](#two-way-audio) support.
+
+API example:
+
+```
+POST http://localhost:1984/api/streams?dst=camera1&src=ffmpeg:http://example.com/song.mp3#audio=pcma#input=file
+```
+
+- you can stream: local files, web files, live streams or any format, supported by FFmpeg 
+- you should use [ffmpeg source](#source-ffmpeg) for transcoding audio to codec, that your camera supports
+- you can check camera codecs on the go2rtc WebUI info page when the stream is active
+- some cameras support only low quality `PCMA/8000` codec (ex. [Tapo](#source-tapo))
+- it is recommended to choose higher quality formats if your camera supports them (ex. `PCMA/48000` for some Dahua cameras)
+- if you play files over http-link, you need to add `#input=file` params for transcoding, so file will be transcoded and played in real time
+- if you play live streams, you should skip `#input` param, because it is already in real time
+- you can stop active playback by calling the API with the empty `src` parameter
+- you will see one active producer and one active consumer in go2rtc WebUI info page during streaming
+
 ### Module: API
 
 The HTTP API is the main part for interacting with the application. Default address: `http://127.0.0.1:1984/`.
 
-- you can use WebRTC only when HTTP API enabled
+go2rtc has its own JS video player (`video-rtc.js`) with:
+
+- support technologies:
+   - WebRTC over UDP or TCP
+   - MSE or MP4 or MJPEG over WebSocket 
+- automatic selection best technology according on:
+   - codecs inside your stream
+   - current browser capabilities
+   - current network configuration
+- automatic stop stream while browser or page not active
+- automatic stop stream while player not inside page viewport
+- automatic reconnection
+
+Technology selection based on priorities:
+
+1. Video and Audio better than just Video
+2. H265 better than H264
+3. WebRTC better than MSE, than MP4, than MJPEG
+
+go2rtc has simple HTML page (`stream.html`) with support params in URL:
+
+- multiple streams on page `src=camera1&src=camera2...`
+- stream technology autoselection `mode=webrtc,mse,mp4,mjpeg`
+- stream technology comparison `src=camera1&mode=webrtc&mode=mse&mode=mp4`
+- player width setting in pixels `width=320px` or percents `width=50%`
+
+**Module config**
+
 - 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 API `base_path` and host go2rtc on your main app webserver suburl
@@ -337,77 +502,89 @@ The HTTP API is the main part for interacting with the application. Default addr
 
 ```yaml
 api:
-  listen: ":1984"    # HTTP API port ("" - disabled)
-  base_path: "/rtc"  # API prefix for serve on suburl (/api => /rtc/api)
-  static_dir: "www"  # folder for static files (custom web interface)
-  origin: "*"        # allow CORS requests (only * supported)
+  listen: ":1984"    # default ":1984", HTTP API port ("" - disabled)
+  username: "admin"  # default "", Basic auth for WebUI
+  password: "pass"   # default "", Basic auth for WebUI
+  base_path: "/rtc"  # default "", API prefix for serve on suburl (/api => /rtc/api)
+  static_dir: "www"  # default "", folder for static files (custom web interface)
+  origin: "*"        # default "", allow CORS requests (only * supported)
 ```
 
-**PS. go2rtc** doesn't provide HTTPS or password protection. Use [Nginx](https://nginx.org/) or [Ngrok](#module-ngrok) or [Home Assistant Add-on](#go2rtc-home-assistant-add-on) for this tasks.
+**PS:**
 
-**PS2.** You can access microphone (for 2-way audio) only with HTTPS ([read more](https://stackoverflow.com/questions/52759992/how-to-access-camera-and-microphone-in-chrome-without-https)).
+- go2rtc doesn't provide HTTPS. Use [Nginx](https://nginx.org/) or [Ngrok](#module-ngrok) or [Home Assistant Add-on](#go2rtc-home-assistant-add-on) for this tasks
+- MJPEG over WebSocket plays better than native MJPEG because Chrome [bug](https://bugs.chromium.org/p/chromium/issues/detail?id=527446)
+- MP4 over WebSocket was created only for Apple iOS because it doesn't support MSE and native MP4
 
 ### Module: RTSP
 
 You can get any stream as RTSP-stream: `rtsp://192.168.1.123:8554/{stream_name}`
 
-- you can omit the codec filters, so one first video and one first audio will be selected
-- you can set `?video=copy` or just `?video`, so only one first video without audio will be selected
-- you can set multiple video or audio, so all of them will be selected
-- you can enable external password protection for your RTSP streams
-
-Password protection always disabled for localhost calls (ex. FFmpeg or Hass on same server)
+You can enable external password protection for your RTSP streams. Password protection always disabled for localhost calls (ex. FFmpeg or Hass on same server).
 
 ```yaml
 rtsp:
-  listen: ":8554"  # RTSP Server TCP port, default - 8554
-  username: admin  # optional, default - disabled
-  password: pass   # optional, default - disabled
+  listen: ":8554"    # RTSP Server TCP port, default - 8554
+  username: "admin"  # optional, default - disabled
+  password: "pass"   # optional, default - disabled
+  default_query: "video&audio"  # optional, default codecs filters 
 ```
 
+By default go2rtc provide RTSP-stream with only one first video and only one first audio. You can change it with the `default_query` setting:
+
+- `default_query: "mp4"` - MP4 compatible codecs (H264, H265, AAC)
+- `default_query: "video=all&audio=all"` - all tracks from all source (not all players can handle this)
+- `default_query: "video=h264,h265"` - only one video track (H264 or H265)
+- `default_query: "video&audio=all"` - only one first any video and all audio as separate tracks
+
+Read more about [codecs filters](#codecs-filters).
+
 ### Module: WebRTC
 
-WebRTC usually works without problems in the local network. But external access may require additional settings. It depends on what type of Internet do you have.
+In most cases [WebRTC](https://en.wikipedia.org/wiki/WebRTC) uses direct peer-to-peer connection from your browser to go2rtc and sends media data via UDP.
+It **can't pass** media data through your Nginx or Cloudflare or [Nabu Casa](https://www.nabucasa.com/) HTTP TCP connection!
+It can automatically detects your external IP via public [STUN](https://en.wikipedia.org/wiki/STUN) server.
+It can establish a external direct connection via [UDP hole punching](https://en.wikipedia.org/wiki/UDP_hole_punching) technology even if you not open your server to the World.
 
-- by default, WebRTC use two random UDP ports for each connection (video and audio)
-- you can enable one additional TCP port for all connections and use it for external access
+But about 10-20% of users may need to configure additional settings for external access if **mobile phone** or **go2rtc server** behing [Symmetric NAT](https://tomchen.github.io/symmetric-nat-test/).
+
+- by default, WebRTC uses both TCP and UDP on port 8555 for connections
+- you can use this port for external access
+- you can change the port in YAML config:
+
+```yaml
+webrtc:
+  listen: ":8555"  # address of your local server and port (TCP/UDP)
+```
 
 **Static public IP**
 
-- add some TCP port to YAML config (ex. 8555)
-- forward this port on your router (you can use same 8555 port or any other)
+- forward the port 8555 on your router (you can use same 8555 port or any other as external port)
 - add your external IP-address and external port to YAML config
 
 ```yaml
 webrtc:
-  listen: ":8555"  # address of your local server (TCP)
   candidates:
     - 216.58.210.174:8555  # if you have static public IP-address
 ```
 
 **Dynamic public IP**
 
-- add some TCP port to YAML config (ex. 8555)
-- forward this port on your router (you can use same 8555 port or any other)
+- forward the port 8555 on your router (you can use same 8555 port or any other as the external port)
 - add `stun` word and external port to YAML config
   - go2rtc automatically detects your external address with STUN-server
 
 ```yaml
 webrtc:
-  listen: ":8555"  # address of your local server (TCP)
   candidates:
     - stun:8555  # if you have dynamic public IP-address
 ```
 
 **Private IP**
 
-- add some TCP port to YAML config (ex. 8555)
 - setup integration with [Ngrok service](#module-ngrok)
 
 ```yaml
-webrtc:
-  listen: ":8555"  # address of your local server (TCP)
-
 ngrok:
   command: ...
 ```
@@ -485,23 +662,29 @@ tunnels:
 
 ### Module: Hass
 
-If you install **go2rtc** as [Hass Add-on](#go2rtc-home-assistant-add-on) - you need to use localhost IP-address. In other cases you need to use IP-address of server with **go2rtc** application.
+The best and easiest way to use go2rtc inside the Home Assistant is to install the custom integration [WebRTC Camera](#go2rtc-home-assistant-integration) and custom lovelace card.
 
-#### From go2rtc to Hass
+But go2rtc is also compatible and can be used with [RTSPtoWebRTC](https://www.home-assistant.io/integrations/rtsp_to_webrtc/) built-in integration.
 
-Add any supported [stream source](#module-streams) as [Generic Camera](https://www.home-assistant.io/integrations/generic/) and view stream with built-in [Stream](https://www.home-assistant.io/integrations/stream/) integration. Technology `HLS`, supported codecs: `H264`, poor latency.
+You have several options on how to add a camera to Home Assistant:
 
-1. Add your stream to [go2rtc config](#configuration)
-2. Hass > Settings > Integrations > Add Integration > [Generic Camera](https://my.home-assistant.io/redirect/config_flow_start/?domain=generic) > `rtsp://127.0.0.1:8554/camera1`
+1. Camera RTSP source => [Generic Camera](https://www.home-assistant.io/integrations/generic/)
+2. Camera [any source](#module-streams) => [go2rtc config](#configuration) => [Generic Camera](https://www.home-assistant.io/integrations/generic/)
+   - Install any [go2rtc](#fast-start)
+   - Add your stream to [go2rtc config](#configuration)
+   - Hass > Settings > Integrations > Add Integration > [Generic Camera](https://my.home-assistant.io/redirect/config_flow_start/?domain=generic) > `rtsp://127.0.0.1:8554/camera1` (change to your stream name)
 
-#### From Hass to go2rtc
+You have several options on how to watch the stream from the cameras in Home Assistant:
 
-View almost any Hass camera using `WebRTC` technology, supported codecs `H264`/`PCMU`/`PCMA`/`OPUS`, best latency.
-
-When the stream starts - the camera `entity_id` will be added to go2rtc "on the fly". You don't need to add cameras manually to [go2rtc config](#configuration). Some cameras (like [Nest](https://www.home-assistant.io/integrations/nest/)) have a dynamic link to the stream, it will be updated each time a stream is started from the Hass interface. 
-
-1. Hass > Settings > Integrations > Add Integration > [RTSPtoWebRTC](https://my.home-assistant.io/redirect/config_flow_start/?domain=rtsp_to_webrtc) > `http://127.0.0.1:1984/`
-2. Use Picture Entity or Picture Glance lovelace card
+1. `Camera Entity` => `Picture Entity Card` => Technology `HLS`, codecs: `H264/H265/AAC`, poor latency.
+2. `Camera Entity` => [RTSPtoWebRTC](https://www.home-assistant.io/integrations/rtsp_to_webrtc/) => `Picture Entity Card` => Technology `WebRTC`, codecs: `H264/PCMU/PCMA/OPUS`, best latency.
+   - Install any [go2rtc](#fast-start)
+   - Hass > Settings > Integrations > Add Integration > [RTSPtoWebRTC](https://my.home-assistant.io/redirect/config_flow_start/?domain=rtsp_to_webrtc) > `http://127.0.0.1:1984/`
+   - RTSPtoWebRTC > Configure > STUN server: `stun.l.google.com:19302`
+   - Use Picture Entity or Picture Glance lovelace card
+3. `Camera Entity` or `Camera URL` => [WebRTC Camera](https://github.com/AlexxIT/WebRTC) => Technology: `WebRTC/MSE/MP4/MJPEG`, codecs: `H264/H265/AAC/PCMU/PCMA/OPUS`, best latency, best compatibility.
+   - Install and add [WebRTC Camera](https://github.com/AlexxIT/WebRTC) custom integration
+   - Use WebRTC Camera custom lovelace card
 
 You can add camera `entity_id` to [go2rtc config](#configuration) if you need transcoding:
 
@@ -517,8 +700,28 @@ PS. Default Home Assistant lovelace cards don't support 2-way audio. You can use
 Provides several features:
 
 1. MSE stream (fMP4 over WebSocket)
-2. Camera snapshots in MP4 format (single frame), can be sent to [Telegram](https://www.telegram.org/)
-3. MP4 "file stream" - bad format for streaming because of high latency, doesn't work in Safari 
+2. Camera snapshots in MP4 format (single frame), can be sent to [Telegram](https://github.com/AlexxIT/go2rtc/wiki/Snapshot-to-Telegram)
+3. HTTP progressive streaming (MP4 file stream) - bad format for streaming because of high start delay. This format doesn't work in all Safari browsers, but go2rtc will automatically redirect it to HLS/fMP4 it this case.
+
+API examples:
+
+- MP4 stream: `http://192.168.1.123:1984/api/stream.mp4?src=camera1`
+- MP4 snapshot: `http://192.168.1.123:1984/api/frame.mp4?src=camera1`
+
+Read more about [codecs filters](#codecs-filters).
+
+### Module: HLS
+
+[HLS](https://en.wikipedia.org/wiki/HTTP_Live_Streaming) is the worst technology for real-time streaming. It can only be useful on devices that do not support more modern technology, like [WebRTC](#module-webrtc), [MSE/MP4](#module-mp4).
+
+The go2rtc implementation differs from the standards and may not work with all players.
+
+API examples:
+
+- HLS/TS stream: `http://192.168.1.123:1984/api/stream.m3u8?src=camera1` (H264)
+- HLS/fMP4 stream: `http://192.168.1.123:1984/api/stream.m3u8?src=camera1&mp4` (H264, H265, AAC)
+
+Read more about [codecs filters](#codecs-filters).
 
 ### Module: MJPEG
 
@@ -562,7 +765,7 @@ log:
 
 ## Security
 
-By default `go2rtc` start Web interface on port `1984` and RTSP on port `8554`. Both ports are accessible from your local network. So anyone on your local network can watch video from your cameras without authorization. The same rule applies to the Home Assistant Add-on.
+By default `go2rtc` starts the Web interface on port `1984` and RTSP on port `8554`, as well as use port `8555` for WebRTC connections. The three ports are accessible from your local network. So anyone on your local network can watch video from your cameras without authorization. The same rule applies to the Home Assistant Add-on.
 
 This is not a problem if you trust your local network as much as I do. But you can change this behaviour with a `go2rtc.yaml` config:
 
@@ -574,7 +777,7 @@ rtsp:
   listen: "127.0.0.1:8554" # localhost
 
 webrtc:
-  listen: ":8555" # external TCP port
+  listen: ":8555" # external TCP/UDP port
 ```
 
 - local access to RTSP is not a problem for [FFmpeg](#source-ffmpeg) integration, because it runs locally on your server
@@ -584,23 +787,44 @@ webrtc:
 
 If you need Web interface protection without Home Assistant Add-on - you need to use reverse proxy, like [Nginx](https://nginx.org/), [Caddy](https://caddyserver.com/), [Ngrok](https://ngrok.com/), etc.
 
-PS. Additionally WebRTC opens a lot of random UDP ports for transmit encrypted media. They work without problems on the local network. And sometimes work for external access, even if you haven't opened ports on your router. But for stable external WebRTC access, you need to configure the TCP port.
+PS. Additionally WebRTC will try to use the 8555 UDP port for transmit encrypted media. It works without problems on the local network. And sometimes also works for external access, even if you haven't opened this port on your router ([read more](https://en.wikipedia.org/wiki/UDP_hole_punching)). But for stable external WebRTC access, you need to open the 8555 port on your router for both TCP and UDP.
+
+## Codecs filters
+
+go2rtc can automatically detect which codecs your device supports for [WebRTC](#module-webrtc) and [MSE](#module-mp4) technologies.
+
+But it cannot be done for [RTSP](#module-rtsp), [HTTP progressive streaming](#module-mp4), [HLS](#module-hls) 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](#source-ffmpeg).
+
+Without filters:
+
+- RTSP will provide only the first video and only the first audio
+- 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. Hass 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.mp4?src=camera1&video=h264,h265&audio=aac,opus,mp3,pcma,pcmu` - MP4 file with non standard audio codecs, does not work in some players
 
 ## Codecs madness
 
-`AVC/H.264` codec can be played almost anywhere. But `HEVC/H.265` has a lot of limitations in supporting with different devices and browsers. It's all about patents and money, you can't do anything about it.
+`AVC/H.264` video can be played almost anywhere. But `HEVC/H.265` has a lot of limitations in supporting with different devices and browsers. It's all about patents and money, you can't do anything about it.
 
-| Device              | WebRTC      | MSE         | MP4         |
-|---------------------|-------------|-------------|-------------|
-| *latency*           | best        | medium      | bad         |
-| Desktop Chrome 107+ | H264        | H264, H265* | H264, H265* |
-| Desktop Edge        | H264        | H264, H265* | H264, H265* |
-| Desktop Safari      | H264, H265* | H264, H265  | **no!**     |
-| Desktop Firefox     | H264        | H264        | H264        |
-| Android Chrome 107+ | H264        | H264, H265* | H264        |
-| iPad Safari 13+     | H264, H265* | H264, H265  | **no!**     |
-| iPhone Safari 13+   | H264, H265* | **no!**     | **no!**     |
-| masOS Hass App      | no          | no          | no          |
+| Device              | WebRTC                        | MSE                    | HTTP Progressive Streaming              |
+|---------------------|-------------------------------|------------------------|-----------------------------------------|
+| *latency*           | best                          | medium                 | bad                                     |
+| Desktop Chrome 107+ | H264, OPUS, PCMU, PCMA        | H264, H265*, AAC, OPUS | H264, H265*, AAC, OPUS, PCMU, PCMA, MP3 |
+| Desktop Edge        | H264, OPUS, PCMU, PCMA        | H264, H265*, AAC, OPUS | H264, H265*, AAC, OPUS, PCMU, PCMA, MP3 |
+| Desktop Safari      | H264, H265*, OPUS, PCMU, PCMA | H264, H265, AAC        | **no!**                                 |
+| Desktop Firefox     | H264, OPUS, PCMU, PCMA        | H264, AAC, OPUS        | H264, AAC, OPUS                         |
+| Android Chrome 107+ | H264, OPUS, PCMU, PCMA        | H264, H265*, AAC, OPUS | H264, ?, AAC, OPUS, PCMU, PCMA, MP3     |
+| iPad Safari 13+     | H264, H265*, OPUS, PCMU, PCMA | H264, H265, AAC        | **no!**                                 |
+| iPhone Safari 13+   | H264, H265*, OPUS, PCMU, PCMA | **no!**                | **no!**                                 |
+| masOS Hass App      | no                            | no                     | no                                      |
 
 - Chrome H265: [read this](https://chromestatus.com/feature/5186511939567616) and [read this](https://github.com/StaZhu/enable-chromium-hevc-hardware-decoding)
 - Edge H265: [read this](https://www.reddit.com/r/MicrosoftEdge/comments/v9iw8k/enable_hevc_support_in_edge/)
@@ -609,13 +833,14 @@ PS. Additionally WebRTC opens a lot of random UDP ports for transmit encrypted m
 
 **Audio**
 
-- WebRTC audio codecs: `PCMU/8000`, `PCMA/8000`, `OPUS/48000/2`
-- MSE/MP4 audio codecs: `AAC`
+- **WebRTC** audio codecs: `PCMU/8000`, `PCMA/8000`, `OPUS/48000/2`
+- `OPUS` and `MP3` inside **MP4** is part of the standard, but some players do not support them anyway (especially Apple)
+- `PCMU` and `PCMA` inside **MP4** isn't a standard, but some players support them, for example Chromium browsers
 
 **Apple devices**
 
-- all Apple devices don't support MP4 stream (they only support progressive loading of static files)
-- iPhones don't support MSE technology because it competes with the HLS technology, invented by Apple
+- all Apple devices don't support HTTP progressive streaming
+- iPhones 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
 
 ## Codecs negotiation
@@ -647,6 +872,23 @@ streams:
 
 **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.
 
+## Projects using go2rtc
+
+- [Frigate 12+](https://frigate.video/) - open source NVR built around real-time AI object detection
+- [ring-mqtt](https://github.com/tsightler/ring-mqtt) - Ring devices to MQTT Bridge
+- [EufyP2PStream](https://github.com/oischinger/eufyp2pstream) - A small project that provides a Video/Audio Stream from Eufy cameras that don't directly support RTSP
+- [Proxmox Helper Scripts](https://tteck.github.io/Proxmox/)
+- [Unraid](https://unraid.net/community/apps?q=go2rtc)
+
+## Cameras experience
+
+- [Dahua](https://www.dahuasecurity.com/) - reference implementation streaming protocols, a lot of settings, high stream quality, multiple streaming clients
+- [Hikvision](https://www.hikvision.com/) - a lot of proprietary streaming technologies
+- [Reolink](https://reolink.com/) - some models has awful unusable RTSP realisation and not best HTTP-FLV alternative (I recommend that you contact Reolink support for new firmware), few settings
+- [Sonoff](https://sonoff.tech/) - very low stream quality, no settings, not best protocol implementation
+- [TP-Link](https://www.tp-link.com/) - few streaming clients, packet loss?
+- Chinese cheap noname cameras, Wyze Cams, Xiaomi cameras with hacks (usual has `/live/ch00_1` in RTSP URL) - awful but usable RTSP protocol realisation, low stream quality, few settings, packet loss?
+
 ## TIPS
 
 **Using apps for low RTSP delay**
@@ -654,23 +896,27 @@ streams:
 - `ffplay -fflags nobuffer -flags low_delay "rtsp://192.168.1.123:8554/camera1"`
 - VLC > Preferences > Input / Codecs > Default Caching Level: Lowest Latency
 
+**Snapshots to Telegram**
+
+[read more](https://github.com/AlexxIT/go2rtc/wiki/Snapshot-to-Telegram)
+
 ## FAQ
 
 **Q. What's the difference between go2rtc, WebRTC Camera and RTSPtoWebRTC?**
 
 **go2rtc** is a new version of the server-side [WebRTC Camera](https://github.com/AlexxIT/WebRTC) integration, completely rewritten from scratch, with a number of fixes and a huge number of new features. It is compatible with native Home Assistant [RTSPtoWebRTC](https://www.home-assistant.io/integrations/rtsp_to_webrtc/) integration. So you [can use](#module-hass) default lovelace Picture Entity or Picture Glance.
 
-**Q. Why go2rtc is an addon and not an integration?**
+**Q. Should I use go2rtc addon or WebRTC Camera integration?**
 
-Because **go2rtc** is more than just viewing your stream online with WebRTC. You can use it all the time for your various tasks. But every time the Hass is rebooted - all integrations are also rebooted. So your streams may be interrupted if you use them in additional tasks.
+**go2rtc** is more than just viewing your stream online with WebRTC/MSE/HLS/etc. You can use it all the time for your various tasks. But every time the Hass is rebooted - all integrations are also rebooted. So your streams may be interrupted if you use them in additional tasks.
 
-When **go2rtc** is released, the **WebRTC Camera** integration will be updated. And you can decide whether to use the integration or the addon.
+Basic users can use **WebRTC Camera** integration. Advanced users can use go2rtc addon or Frigate 12+ addon.
 
 **Q. Which RTSP link should I use inside Hass?**
 
 You can use direct link to your cameras there (as you always do). **go2rtc** support zero-config feature. You may leave `streams` config section empty. And your streams will be created on the fly on first start from Hass. And your cameras will have multiple connections. Some from Hass directly and one from **go2rtc**.
 
-Also you can specify your streams in **go2rtc** [config file](#configuration) and use RTSP links to this addon. With additional features: multi-source [codecs negotiation](#codecs-negotiation) or FFmpeg [transcoding](#source-ffmpeg) for unsupported codecs. Or use them as source for Frigate. And your cameras will have one connection from **go2rtc**. And **go2rtc** will have multiple connection - some from Hass via RTSP protocol, some from your browser via WebRTC protocol.
+Also you can specify your streams in **go2rtc** [config file](#configuration) and use RTSP links to this addon. With additional features: multi-source [codecs negotiation](#codecs-negotiation) or FFmpeg [transcoding](#source-ffmpeg) for unsupported codecs. Or use them as source for Frigate. And your cameras will have one connection from **go2rtc**. And **go2rtc** will have multiple connection - some from Hass via RTSP protocol, some from your browser via WebRTC/MSE/HLS protocols.
 
 Use any config what you like.
 

build/docker/run.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+
+set -euo pipefail
+
+echo "Starting go2rtc..." >&2
+
+readonly config_path="/config"
+
+if [[ -x "${config_path}/go2rtc" ]]; then
+  readonly binary_path="${config_path}/go2rtc"
+  echo "Using go2rtc binary from '${binary_path}' instead of the embedded one" >&2
+else
+  readonly binary_path="/usr/local/bin/go2rtc"
+fi
+
+# set cwd for go2rtc (for config file, Hass integration, etc)
+cd "${config_path}" || echo "Could not change working directory to '${config_path}'" >&2
+
+exec "${binary_path}"

build/hassio/Dockerfile

@@ -1,41 +0,0 @@
-ARG BUILD_FROM
-
-FROM $BUILD_FROM as build
-
-# 1. Build go2rtc
-RUN apk add --no-cache git go
-
-RUN git clone https://github.com/AlexxIT/go2rtc \
-    && cd go2rtc \
-    && CGO_ENABLED=0 go build -ldflags "-s -w" -trimpath
-
-# 2. Download ngrok
-ARG BUILD_ARCH
-
-# https://github.com/home-assistant/docker-base/blob/master/alpine/Dockerfile
-RUN if [ "${BUILD_ARCH}" = "aarch64" ]; then BUILD_ARCH="arm64"; \
-    elif [ "${BUILD_ARCH}" = "armv7" ]; then BUILD_ARCH="arm"; fi \
-    && cd go2rtc \
-    && curl $(curl -s "https://raw.githubusercontent.com/ngrok/docker-ngrok/main/releases.json" | jq -r ".${BUILD_ARCH}.url") -o ngrok.zip \
-    && unzip ngrok
-
-
-
-# https://devopscube.com/reduce-docker-image-size/
-FROM $BUILD_FROM
-
-# 3. Copy go2rtc and ngrok to release
-COPY --from=build /go2rtc/go2rtc /usr/local/bin
-COPY --from=build /go2rtc/ngrok /usr/local/bin
-
-# 4. Install ffmpeg
-# apk base  OK: 22  MiB in 40  packages
-# ffmpeg    OK: 113 MiB in 110 packages
-# python3   OK: 161 MiB in 114 packages
-RUN apk add --no-cache ffmpeg python3
-
-# 5. Copy run to release
-COPY run.sh /
-RUN chmod a+x /run.sh
-
-CMD [ "/run.sh" ]

build/hassio/config.yaml

@@ -1,6 +0,0 @@
-# https://github.com/home-assistant/builder/blob/master/builder.sh
-name: go2rtc
-description: Ultimate camera streaming application
-url: https://github.com/AlexxIT/go2rtc
-image: alexxit/go2rtc
-arch: [ amd64, aarch64, i386, armv7 ]

build/hassio/run.sh

@@ -1,14 +0,0 @@
-#!/usr/bin/with-contenv bashio
-
-set +e
-
-# set cwd for go2rtc (for config file, Hass integration, etc)
-cd /config
-
-# add the feature to override go2rtc binary from Hass config folder
-export PATH="/config:$PATH"
-
-while true; do
-  go2rtc
-  sleep 5
-done

cmd/api/api.go

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

cmd/api/config.go

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

cmd/api/ws.go

@@ -6,12 +6,29 @@ import (
 	"net/url"
 	"strings"
 	"sync"
+	"time"
 )
 
 // Message - struct for data exchange in Web API
 type Message struct {
-	Type  string      `json:"type"`
-	Value interface{} `json:"value,omitempty"`
+	Type  string `json:"type"`
+	Value any    `json:"value,omitempty"`
+}
+
+func (m *Message) String() string {
+	if s, ok := m.Value.(string); ok {
+		return s
+	}
+	return ""
+}
+
+func (m *Message) GetString(key string) string {
+	if v, ok := m.Value.(map[string]any); ok {
+		if s, ok := v[key].(string); ok {
+			return s
+		}
+	}
+	return ""
 }
 
 type WSHandler func(tr *Transport, msg *Message) error
@@ -24,8 +41,8 @@ var wsHandlers = make(map[string]WSHandler)
 
 func initWS(origin string) {
 	wsUp = &websocket.Upgrader{
-		ReadBufferSize:  1024,
-		WriteBufferSize: 512000,
+		ReadBufferSize:  4096,       // for SDP
+		WriteBufferSize: 512 * 1024, // 512K
 	}
 
 	switch origin {
@@ -67,7 +84,9 @@ func apiWS(w http.ResponseWriter, r *http.Request) {
 	}
 
 	tr := &Transport{Request: r}
-	tr.OnWrite(func(msg interface{}) {
+	tr.OnWrite(func(msg any) {
+		_ = ws.SetWriteDeadline(time.Now().Add(time.Second * 5))
+
 		if data, ok := msg.([]byte); ok {
 			_ = ws.WriteMessage(websocket.BinaryMessage, data)
 		} else {
@@ -78,11 +97,15 @@ func apiWS(w http.ResponseWriter, r *http.Request) {
 	for {
 		msg := new(Message)
 		if err = ws.ReadJSON(msg); err != nil {
-			log.Trace().Err(err).Caller().Send()
+			if !websocket.IsCloseError(err, websocket.CloseNoStatusReceived) {
+				log.Trace().Err(err).Caller().Send()
+			}
 			_ = ws.Close()
 			break
 		}
 
+		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 {
@@ -98,17 +121,20 @@ func apiWS(w http.ResponseWriter, r *http.Request) {
 var wsUp *websocket.Upgrader
 
 type Transport struct {
-	Request  *http.Request
-	Consumer interface{} // TODO: rewrite
+	Request *http.Request
 
-	mx sync.Mutex
+	ctx map[any]any
+
+	closed bool
+	mx     sync.Mutex
+	wrmx   sync.Mutex
 
 	onChange func()
-	onWrite  func(msg interface{})
+	onWrite  func(msg any)
 	onClose  []func()
 }
 
-func (t *Transport) OnWrite(f func(msg interface{})) {
+func (t *Transport) OnWrite(f func(msg any)) {
 	t.mx.Lock()
 	if t.onChange != nil {
 		t.onChange()
@@ -117,22 +143,43 @@ func (t *Transport) OnWrite(f func(msg interface{})) {
 	t.mx.Unlock()
 }
 
-func (t *Transport) Write(msg interface{}) {
-	t.mx.Lock()
+func (t *Transport) Write(msg any) {
+	t.wrmx.Lock()
 	t.onWrite(msg)
-	t.mx.Unlock()
+	t.wrmx.Unlock()
 }
 
 func (t *Transport) Close() {
+	t.mx.Lock()
 	for _, f := range t.onClose {
 		f()
 	}
+	t.closed = true
+	t.mx.Unlock()
 }
 
 func (t *Transport) OnChange(f func()) {
+	t.mx.Lock()
 	t.onChange = f
+	t.mx.Unlock()
 }
 
 func (t *Transport) OnClose(f func()) {
-	t.onClose = append(t.onClose, f)
+	t.mx.Lock()
+	if t.closed {
+		f()
+	} else {
+		t.onClose = append(t.onClose, f)
+	}
+	t.mx.Unlock()
+}
+
+// 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()
 }

cmd/app/app.go

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

cmd/app/store/store.go

@@ -8,7 +8,7 @@ import (
 
 const name = "go2rtc.json"
 
-var store map[string]interface{}
+var store map[string]any
 
 func load() {
 	data, _ := os.ReadFile(name)
@@ -20,7 +20,7 @@ func load() {
 	}
 
 	if store == nil {
-		store = make(map[string]interface{})
+		store = make(map[string]any)
 	}
 }
 
@@ -33,7 +33,7 @@ func save() error {
 	return os.WriteFile(name, data, 0644)
 }
 
-func GetRaw(key string) interface{} {
+func GetRaw(key string) any {
 	if store == nil {
 		load()
 	}
@@ -41,16 +41,16 @@ func GetRaw(key string) interface{} {
 	return store[key]
 }
 
-func GetDict(key string) map[string]interface{} {
+func GetDict(key string) map[string]any {
 	raw := GetRaw(key)
 	if raw != nil {
-		return raw.(map[string]interface{})
+		return raw.(map[string]any)
 	}
 
-	return make(map[string]interface{})
+	return make(map[string]any)
 }
 
-func Set(key string, v interface{}) error {
+func Set(key string, v any) error {
 	if store == nil {
 		load()
 	}

cmd/debug/debug.go

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

cmd/debug/stack.go

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

cmd/dvrip/dvrip.go

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

cmd/echo/echo.go

@@ -4,15 +4,15 @@ import (
 	"bytes"
 	"github.com/AlexxIT/go2rtc/cmd/app"
 	"github.com/AlexxIT/go2rtc/cmd/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/AlexxIT/go2rtc/pkg/shell"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"os/exec"
 )
 
 func Init() {
 	log := app.GetLogger("echo")
 
-	streams.HandleFunc("echo", func(url string) (streamer.Producer, error) {
+	streams.HandleFunc("echo", func(url string) (core.Producer, error) {
 		args := shell.QuoteSplit(url[5:])
 
 		b, err := exec.Command(args[0], args[1:]...).Output()

cmd/exec/exec.go

@@ -8,9 +8,9 @@ import (
 	"github.com/AlexxIT/go2rtc/cmd/app"
 	"github.com/AlexxIT/go2rtc/cmd/rtsp"
 	"github.com/AlexxIT/go2rtc/cmd/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	pkg "github.com/AlexxIT/go2rtc/pkg/rtsp"
 	"github.com/AlexxIT/go2rtc/pkg/shell"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/rs/zerolog"
 	"os"
 	"os/exec"
@@ -34,8 +34,13 @@ func Init() {
 			return false
 		}
 
-		waiter <- conn
-		return true
+		// unblocking write to channel
+		select {
+		case waiter <- conn:
+			return true
+		default:
+			return false
+		}
 	})
 
 	streams.HandleFunc("exec", Handle)
@@ -43,7 +48,7 @@ func Init() {
 	log = app.GetLogger("exec")
 }
 
-func Handle(url string) (streamer.Producer, error) {
+func Handle(url string) (core.Producer, error) {
 	sum := md5.Sum([]byte(url))
 	path := "/" + hex.EncodeToString(sum[:])
 
@@ -62,7 +67,7 @@ func Handle(url string) (streamer.Producer, error) {
 		cmd.Stderr = os.Stderr
 	}
 
-	ch := make(chan streamer.Producer)
+	ch := make(chan core.Producer)
 
 	waitersMu.Lock()
 	waiters[path] = ch
@@ -86,7 +91,13 @@ func Handle(url string) (streamer.Producer, error) {
 	chErr := make(chan error)
 
 	go func() {
-		chErr <- cmd.Wait()
+		err := cmd.Wait()
+		// unblocking write to channel
+		select {
+		case chErr <- err:
+		default:
+			log.Trace().Str("url", url).Msg("[exec] close")
+		}
 	}()
 
 	select {
@@ -105,5 +116,5 @@ func Handle(url string) (streamer.Producer, error) {
 // internal
 
 var log zerolog.Logger
-var waiters = map[string]chan streamer.Producer{}
+var waiters = map[string]chan core.Producer{}
 var waitersMu sync.Mutex

cmd/ffmpeg/device/device_darwin.go

@@ -2,7 +2,7 @@ package device
 
 import (
 	"bytes"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	"os/exec"
 	"strings"
 )
@@ -11,15 +11,15 @@ import (
 const deviceInputPrefix = "-f avfoundation"
 
 func deviceInputSuffix(videoIdx, audioIdx int) string {
-	video := findMedia(streamer.KindVideo, videoIdx)
-	audio := findMedia(streamer.KindAudio, audioIdx)
+	video := findMedia(core.KindVideo, videoIdx)
+	audio := findMedia(core.KindAudio, audioIdx)
 	switch {
 	case video != nil && audio != nil:
-		return `"` + video.Title + `:` + audio.Title + `"`
+		return `"` + video.ID + `:` + audio.ID + `"`
 	case video != nil:
-		return `"` + video.Title + `"`
+		return `"` + video.ID + `"`
 	case audio != nil:
-		return `"` + audio.Title + `"`
+		return `"` + audio.ID + `"`
 	}
 	return ""
 }
@@ -40,10 +40,10 @@ process:
 	for _, line := range lines {
 		switch {
 		case strings.HasSuffix(line, "video devices:"):
-			kind = streamer.KindVideo
+			kind = core.KindVideo
 			continue
 		case strings.HasSuffix(line, "audio devices:"):
-			kind = streamer.KindAudio
+			kind = core.KindAudio
 			continue
 		case strings.HasPrefix(line, "dummy"):
 			break process
@@ -56,8 +56,6 @@ process:
 	}
 }
 
-func loadMedia(kind, name string) *streamer.Media {
-	return &streamer.Media{
-		Kind: kind, Title: name,
-	}
+func loadMedia(kind, name string) *core.Media {
+	return &core.Media{Kind: kind, ID: name}
 }

cmd/ffmpeg/device/device_linux.go

@@ -2,7 +2,7 @@ package device
 
 import (
 	"bytes"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	"io/ioutil"
 	"os/exec"
 	"strings"
@@ -12,8 +12,8 @@ import (
 const deviceInputPrefix = "-f v4l2"
 
 func deviceInputSuffix(videoIdx, audioIdx int) string {
-	video := findMedia(streamer.KindVideo, videoIdx)
-	return video.Title
+	video := findMedia(core.KindVideo, videoIdx)
+	return video.ID
 }
 
 func loadMedias() {
@@ -23,8 +23,8 @@ func loadMedias() {
 	}
 	for _, file := range files {
 		log.Trace().Msg("[ffmpeg] " + file.Name())
-		if strings.HasPrefix(file.Name(), streamer.KindVideo) {
-			media := loadMedia(streamer.KindVideo, "/dev/"+file.Name())
+		if strings.HasPrefix(file.Name(), core.KindVideo) {
+			media := loadMedia(core.KindVideo, "/dev/"+file.Name())
 			if media != nil {
 				medias = append(medias, media)
 			}
@@ -32,7 +32,7 @@ func loadMedias() {
 	}
 }
 
-func loadMedia(kind, name string) *streamer.Media {
+func loadMedia(kind, name string) *core.Media {
 	cmd := exec.Command(
 		Bin, "-hide_banner", "-f", "v4l2", "-list_formats", "all", "-i", name,
 	)
@@ -44,7 +44,5 @@ func loadMedia(kind, name string) *streamer.Media {
 		return nil
 	}
 
-	return &streamer.Media{
-		Kind: kind, Title: name,
-	}
+	return &core.Media{Kind: kind, ID: name}
 }

cmd/ffmpeg/device/device_windows.go

@@ -2,7 +2,7 @@ package device
 
 import (
 	"bytes"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	"os/exec"
 	"strings"
 )
@@ -11,15 +11,15 @@ import (
 const deviceInputPrefix = "-f dshow"
 
 func deviceInputSuffix(videoIdx, audioIdx int) string {
-	video := findMedia(streamer.KindVideo, videoIdx)
-	audio := findMedia(streamer.KindAudio, audioIdx)
+	video := findMedia(core.KindVideo, videoIdx)
+	audio := findMedia(core.KindAudio, audioIdx)
 	switch {
 	case video != nil && audio != nil:
-		return `video="` + video.Title + `":audio=` + audio.Title + `"`
+		return `video="` + video.ID + `":audio=` + audio.ID + `"`
 	case video != nil:
-		return `video="` + video.Title + `"`
+		return `video="` + video.ID + `"`
 	case audio != nil:
-		return `audio="` + audio.Title + `"`
+		return `audio="` + audio.ID + `"`
 	}
 	return ""
 }
@@ -37,9 +37,9 @@ func loadMedias() {
 	for _, line := range lines {
 		var kind string
 		if strings.HasSuffix(line, "(video)") {
-			kind = streamer.KindVideo
+			kind = core.KindVideo
 		} else if strings.HasSuffix(line, "(audio)") {
-			kind = streamer.KindAudio
+			kind = core.KindAudio
 		} else {
 			continue
 		}
@@ -52,8 +52,6 @@ func loadMedias() {
 	}
 }
 
-func loadMedia(kind, name string) *streamer.Media {
-	return &streamer.Media{
-		Kind: kind, Title: name,
-	}
+func loadMedia(kind, name string) *core.Media {
+	return &core.Media{Kind: kind, ID: name}
 }

cmd/ffmpeg/device/devices.go

@@ -1,10 +1,9 @@
 package device
 
 import (
-	"encoding/json"
 	"github.com/AlexxIT/go2rtc/cmd/api"
 	"github.com/AlexxIT/go2rtc/cmd/app"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/rs/zerolog"
 	"net/http"
 	"net/url"
@@ -52,9 +51,9 @@ func GetInput(src string) (string, error) {
 
 var Bin string
 var log zerolog.Logger
-var medias []*streamer.Media
+var medias []*core.Media
 
-func findMedia(kind string, index int) *streamer.Media {
+func findMedia(kind string, index int) *core.Media {
 	for _, media := range medias {
 		if media.Kind != kind {
 			continue
@@ -72,12 +71,21 @@ func handle(w http.ResponseWriter, r *http.Request) {
 		loadMedias()
 	}
 
-	data, err := json.Marshal(medias)
-	if err != nil {
-		log.Error().Err(err).Msg("[api.ffmpeg]")
-		return
-	}
-	if _, err = w.Write(data); err != nil {
-		log.Error().Err(err).Msg("[api.ffmpeg]")
+	var items []api.Stream
+	var iv, ia int
+
+	for _, media := range medias {
+		var source string
+		switch media.Kind {
+		case core.KindVideo:
+			source = "ffmpeg:device?video=" + strconv.Itoa(iv)
+			iv++
+		case core.KindAudio:
+			source = "ffmpeg:device?audio=" + strconv.Itoa(ia)
+			ia++
+		}
+		items = append(items, api.Stream{Name: media.ID, URL: source})
 	}
+
+	api.ResponseStreams(w, items)
 }

cmd/ffmpeg/ffmpeg.go

@@ -1,12 +1,14 @@
 package ffmpeg
 
 import (
+	"bytes"
+	"errors"
 	"github.com/AlexxIT/go2rtc/cmd/app"
 	"github.com/AlexxIT/go2rtc/cmd/exec"
 	"github.com/AlexxIT/go2rtc/cmd/ffmpeg/device"
 	"github.com/AlexxIT/go2rtc/cmd/rtsp"
 	"github.com/AlexxIT/go2rtc/cmd/streams"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	"net/url"
 	"strconv"
 	"strings"
@@ -17,190 +19,258 @@ func Init() {
 		Mod map[string]string `yaml:"ffmpeg"`
 	}
 
-	// defaults
-
-	cfg.Mod = map[string]string{
-		"bin": "ffmpeg",
-
-		// inputs
-		"file": "-re -stream_loop -1 -i {input}",
-		"http": "-fflags nobuffer -flags low_delay -i {input}",
-		"rtsp": "-fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_transport tcp -i {input}",
-
-		// output
-		"output": "-user_agent ffmpeg/go2rtc -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
-		// `-pix_fmt yuv420p` - if input pix format 4:2:2
-		"h264":       "-c:v libx264 -g:v 30 -preset:v superfast -tune:v zerolatency -profile:v main -level:v 4.1 -pix_fmt:v yuv420p",
-		"h264/ultra": "-c:v libx264 -g:v 30 -preset:v ultrafast -tune:v zerolatency",
-		"h264/high":  "-c:v libx264 -g:v 30 -preset:v superfast -tune:v zerolatency",
-		"h265":       "-c:v libx265 -g:v 30 -preset:v superfast -tune:v zerolatency -profile:v main -level:v 5.1 -pix_fmt:v yuv420p",
-		"mjpeg":      "-c:v mjpeg -force_duplicated_matrix:v 1 -huffman:v 0 -pix_fmt:v yuvj420p",
-		"opus":       "-c:a libopus -ar:a 48000 -ac:a 2",
-		"pcmu":       "-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/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",
-	}
+	cfg.Mod = defaults // will be overriden from yaml
 
 	app.LoadConfig(&cfg)
 
-	tpl := cfg.Mod
-
-	cmd := "exec:" + tpl["bin"] + " -hide_banner "
-
 	if app.GetLogger("exec").GetLevel() >= 0 {
-		cmd += "-v error "
+		defaults["global"] += " -v error"
 	}
 
-	streams.HandleFunc("ffmpeg", func(s string) (streamer.Producer, error) {
-		s = s[7:] // remove `ffmpeg:`
-
-		var query url.Values
-		var queryVideo, queryAudio bool
-
-		if i := strings.IndexByte(s, '#'); i > 0 {
-			query = parseQuery(s[i+1:])
-			queryVideo = query["video"] != nil
-			queryAudio = query["audio"] != nil
-			s = s[:i]
-		} else {
-			// by default query both video and audio
-			queryVideo = true
-			queryAudio = true
+	streams.HandleFunc("ffmpeg", func(url string) (core.Producer, error) {
+		args := parseArgs(url[7:]) // remove `ffmpeg:`
+		if args == nil {
+			return nil, errors.New("can't generate ffmpeg command")
 		}
-
-		var input string
-		if i := strings.Index(s, "://"); i > 0 {
-			switch s[:i] {
-			case "http", "https", "rtmp":
-				input = strings.Replace(tpl["http"], "{input}", s, 1)
-			case "rtsp", "rtsps":
-				// https://ffmpeg.org/ffmpeg-protocols.html#rtsp
-				// skip unnecessary input tracks
-				switch {
-				case queryVideo && queryAudio:
-					input = "-allowed_media_types video+audio "
-				case queryVideo:
-					input = "-allowed_media_types video "
-				case queryAudio:
-					input = "-allowed_media_types audio "
-				}
-
-				input += strings.Replace(tpl["rtsp"], "{input}", s, 1)
-			default:
-				input = "-i " + s
-			}
-		} else if streams.Get(s) != nil {
-			s = "rtsp://localhost:" + rtsp.Port + "/" + s
-			switch {
-			case queryVideo && !queryAudio:
-				s += "?video"
-			case queryAudio && !queryVideo:
-				s += "?audio"
-			}
-			input = strings.Replace(tpl["rtsp"], "{input}", s, 1)
-		} else if strings.HasPrefix(s, "device?") {
-			var err error
-			input, err = device.GetInput(s)
-			if err != nil {
-				return nil, err
-			}
-		} else {
-			input = strings.Replace(tpl["file"], "{input}", s, 1)
-		}
-
-		if _, ok := query["async"]; ok {
-			input = "-use_wallclock_as_timestamps 1 -async 1 " + input
-		}
-
-		s = cmd + input
-
-		if query != nil {
-			for _, raw := range query["raw"] {
-				s += " " + raw
-			}
-
-			for _, rotate := range query["rotate"] {
-				switch rotate {
-				case "90":
-					s += " -vf transpose=1" // 90 degrees clockwise
-				case "180":
-					s += " -vf transpose=1,transpose=1"
-				case "-90", "270":
-					s += " -vf transpose=2" // 90 degrees counterclockwise
-				}
-				break
-			}
-
-			switch len(query["video"]) {
-			case 0:
-				s += " -vn"
-			case 1:
-				if len(query["audio"]) > 1 {
-					s += " -map 0:v:0?"
-				}
-				for _, video := range query["video"] {
-					if video == "copy" {
-						s += " -c:v copy"
-					} else {
-						s += " " + tpl[video]
-					}
-				}
-			default:
-				for i, video := range query["video"] {
-					if video == "copy" {
-						s += " -map 0:v:0? -c:v:" + strconv.Itoa(i) + " copy"
-					} else {
-						s += " -map 0:v:0? " + strings.ReplaceAll(tpl[video], ":v ", ":v:"+strconv.Itoa(i)+" ")
-					}
-				}
-			}
-
-			switch len(query["audio"]) {
-			case 0:
-				s += " -an"
-			case 1:
-				if len(query["video"]) > 1 {
-					s += " -map 0:a:0?"
-				}
-				for _, audio := range query["audio"] {
-					if audio == "copy" {
-						s += " -c:a copy"
-					} else {
-						s += " " + tpl[audio]
-					}
-				}
-			default:
-				for i, audio := range query["audio"] {
-					if audio == "copy" {
-						s += " -map 0:a:0? -c:a:" + strconv.Itoa(i) + " copy"
-					} else {
-						s += " -map 0:a:0? " + strings.ReplaceAll(tpl[audio], ":a ", ":a:"+strconv.Itoa(i)+" ")
-					}
-				}
-			}
-		} else {
-			s += " -c copy"
-		}
-
-		s += " " + tpl["output"]
-
-		return exec.Handle(s)
+		return exec.Handle("exec:" + args.String())
 	})
 
-	device.Bin = cfg.Mod["bin"]
+	device.Bin = defaults["bin"]
 	device.Init()
 }
 
+var defaults = map[string]string{
+	"bin":    "ffmpeg",
+	"global": "-hide_banner",
+
+	// inputs
+	"file": "-re -i {input}",
+	"http": "-fflags nobuffer -flags low_delay -i {input}",
+	"rtsp": "-fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_transport tcp -i {input}",
+
+	"rtsp/udp": "-fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -i {input}",
+
+	// output
+	"output": "-user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}",
+
+	// `-preset superfast` - we can't use ultrafast because it doesn't support `-profile main -level 4.1`
+	// `-tune zerolatency` - for minimal latency
+	// `-profile high -level 4.1` - most used streaming profile
+	"h264":  "-c:v libx264 -g 50 -profile:v high -level:v 4.1 -preset:v superfast -tune:v zerolatency",
+	"h265":  "-c:v libx265 -g 50 -profile:v high -level:v 5.1 -preset:v superfast -tune:v zerolatency",
+	"mjpeg": "-c:v mjpeg -force_duplicated_matrix:v 1 -huffman:v 0 -pix_fmt:v yuvj420p",
+
+	"opus":       "-c:a libopus -ar:a 48000 -ac:a 2",
+	"pcmu":       "-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/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",
+	"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",
+
+	// hardware Intel and AMD on Linux
+	// better not to set `-async_depth:v 1` like for QSV, because framedrops
+	// `-bf 0` - disable B-frames is very important
+	"h264/vaapi":  "-c:v h264_vaapi -g 50 -bf 0 -profile:v high -level:v 4.1 -sei:v 0",
+	"h265/vaapi":  "-c:v hevc_vaapi -g 50 -bf 0 -profile:v high -level:v 5.1 -sei:v 0",
+	"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 NVidia on Linux and Windows
+	// preset=p2 - faster, tune=ll - low latency
+	"h264/cuda": "-c:v h264_nvenc -g 50 -profile:v high -level:v auto -preset:v p2 -tune:v ll",
+	"h265/cuda": "-c:v hevc_nvenc -g 50 -profile:v high -level:v auto",
+
+	// hardware Intel on Windows
+	"h264/dxva2":  "-c:v h264_qsv -g 50 -bf 0 -profile:v high -level:v 4.1 -async_depth:v 1",
+	"h265/dxva2":  "-c:v hevc_qsv -g 50 -bf 0 -profile:v high -level:v 5.1 -async_depth:v 1",
+	"mjpeg/dxva2": "-c:v mjpeg_qsv -profile:v high -level:v 5.1",
+
+	// hardware macOS
+	"h264/videotoolbox": "-c:v h264_videotoolbox -g 50 -bf 0 -profile:v high -level:v 4.1",
+	"h265/videotoolbox": "-c:v hevc_videotoolbox -g 50 -bf 0 -profile:v high -level:v 5.1",
+}
+
+// inputTemplate - select input template from YAML config by template name
+// if query has input param - select another tempalte 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 != "" {
+		if template = defaults[input]; template == "" {
+			template = input
+		}
+	} else {
+		template = defaults[name]
+	}
+	return strings.Replace(template, "{input}", s, 1)
+}
+
+func parseArgs(s string) *Args {
+	// init FFmpeg arguments
+	args := &Args{
+		bin:    defaults["bin"],
+		global: defaults["global"],
+		output: defaults["output"],
+	}
+
+	var query url.Values
+	if i := strings.IndexByte(s, '#'); i > 0 {
+		query = 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://localhost:" + 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"
+		}
+		args.input = inputTemplate("rtsp", s, query)
+	} else if strings.HasPrefix(s, "device?") {
+		var err error
+		args.input, err = device.GetInput(s)
+		if err != nil {
+			return nil
+		}
+	} else {
+		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"] {
+			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)
+			}
+		}
+
+		// 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")
+				}
+			}
+		} else {
+			args.AddCodec("-vn")
+		}
+
+		// 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")
+				}
+			}
+		} else {
+			args.AddCodec("-an")
+		}
+
+		if query["hardware"] != nil {
+			MakeHardware(args, query["hardware"][0])
+		}
+	}
+
+	if args.codecs == nil {
+		args.AddCodec("-c copy")
+	}
+
+	return args
+}
+
 func parseQuery(s string) map[string][]string {
 	query := map[string][]string{}
 	for _, key := range strings.Split(s, "#") {
@@ -213,3 +283,76 @@ func parseQuery(s string) map[string][]string {
 	}
 	return query
 }
+
+type Args struct {
+	bin     string   // ffmpeg
+	global  string   // -hide_banner -v error
+	input   string   // -re -stream_loop -1 -i /media/bunny.mp4
+	codecs  []string // -c:v libx264 -g:v 30 -preset:v ultrafast -tune:v zerolatency
+	filters []string // scale=1920:1080
+	output  string   // -f rtsp {output}
+
+	video, audio int // count of video and audio params
+}
+
+func (a *Args) AddCodec(codec string) {
+	a.codecs = append(a.codecs, codec)
+}
+
+func (a *Args) AddFilter(filter string) {
+	a.filters = append(a.filters, filter)
+}
+
+func (a *Args) InsertFilter(filter string) {
+	a.filters = append([]string{filter}, a.filters...)
+}
+
+func (a *Args) String() string {
+	b := bytes.NewBuffer(make([]byte, 0, 512))
+
+	b.WriteString(a.bin)
+
+	if a.global != "" {
+		b.WriteByte(' ')
+		b.WriteString(a.global)
+	}
+
+	b.WriteByte(' ')
+	b.WriteString(a.input)
+
+	multimode := a.video > 1 || a.audio > 1
+	var iv, ia int
+
+	for _, codec := range a.codecs {
+		// support multiple video and/or audio codecs
+		if multimode && len(codec) >= 5 {
+			switch codec[:5] {
+			case "-c:v ":
+				codec = "-map 0:v:0? " + strings.ReplaceAll(codec, ":v ", ":v:"+strconv.Itoa(iv)+" ")
+				iv++
+			case "-c:a ":
+				codec = "-map 0:a:0? " + strings.ReplaceAll(codec, ":a ", ":a:"+strconv.Itoa(ia)+" ")
+				ia++
+			}
+		}
+
+		b.WriteByte(' ')
+		b.WriteString(codec)
+	}
+
+	if a.filters != nil {
+		for i, filter := range a.filters {
+			if i == 0 {
+				b.WriteString(" -vf ")
+			} else {
+				b.WriteByte(',')
+			}
+			b.WriteString(filter)
+		}
+	}
+
+	b.WriteByte(' ')
+	b.WriteString(a.output)
+
+	return b.String()
+}

cmd/ffmpeg/hardware.go

@@ -0,0 +1,112 @@
+package ffmpeg
+
+import (
+	"github.com/rs/zerolog/log"
+	"os/exec"
+	"strings"
+)
+
+const (
+	EngineSoftware     = "software"
+	EngineVAAPI        = "vaapi"        // Intel iGPU and AMD GPU
+	EngineV4L2M2M      = "v4l2m2m"      // Raspberry Pi 3 and 4
+	EngineCUDA         = "cuda"         // NVidia on Windows and Linux
+	EngineDXVA2        = "dxva2"        // Intel on Windows
+	EngineVideoToolbox = "videotoolbox" // macOS
+)
+
+var cache = map[string]string{}
+
+// MakeHardware converts software FFmpeg args to hardware args
+// empty engine for autoselect
+func MakeHardware(args *Args, engine string) {
+	for i, codec := range args.codecs {
+		if len(codec) < 12 {
+			continue // skip short line (-c:v libx264...)
+		}
+
+		// get current codec name
+		name := cut(codec, ' ', 1)
+		switch name {
+		case "libx264":
+			name = "h264"
+		case "libx265":
+			name = "h265"
+		case "mjpeg":
+		default:
+			continue // skip unsupported codec
+		}
+
+		// temporary disable probe for H265 and MJPEG
+		if engine == "" && name == "h264" {
+			if engine = cache[name]; engine == "" {
+				engine = ProbeHardware(name)
+				cache[name] = engine
+			}
+		}
+
+		switch engine {
+		case EngineVAAPI:
+			args.input = "-hwaccel vaapi -hwaccel_output_format vaapi " + args.input
+			args.codecs[i] = defaults[name+"/"+engine]
+
+			for i, filter := range args.filters {
+				if strings.HasPrefix(filter, "scale=") {
+					args.filters[i] = "scale_vaapi=" + filter[6:]
+				}
+			}
+
+			// fix if input doesn't support hwaccel, do nothing when support
+			args.InsertFilter("format=vaapi|nv12,hwupload")
+
+		case EngineCUDA:
+			args.input = "-hwaccel cuda -hwaccel_output_format cuda -extra_hw_frames 2 " + args.input
+			args.codecs[i] = defaults[name+"/"+engine]
+
+			for i, filter := range args.filters {
+				if strings.HasPrefix(filter, "scale=") {
+					args.filters[i] = "scale_cuda=" + filter[6:]
+				}
+			}
+
+		case EngineDXVA2:
+			args.input = "-hwaccel dxva2 -hwaccel_output_format dxva2_vld " + args.input
+			args.codecs[i] = defaults[name+"/"+engine]
+
+			for i, filter := range args.filters {
+				if strings.HasPrefix(filter, "scale=") {
+					args.filters[i] = "scale_qsv=" + filter[6:]
+				}
+			}
+
+			args.InsertFilter("hwmap=derive_device=qsv,format=qsv")
+
+		case EngineVideoToolbox:
+			args.input = "-hwaccel videotoolbox -hwaccel_output_format videotoolbox_vld " + args.input
+			args.codecs[i] = defaults[name+"/"+engine]
+
+		case EngineV4L2M2M:
+			args.codecs[i] = defaults[name+"/"+engine]
+		}
+	}
+}
+
+func run(arg ...string) bool {
+	err := exec.Command(defaults["bin"], arg...).Run()
+	log.Printf("%v %v", arg, err)
+	return err == nil
+}
+
+func cut(s string, sep byte, pos int) string {
+	for n := 0; n < pos; n++ {
+		if i := strings.IndexByte(s, sep); i > 0 {
+			s = s[i+1:]
+		} else {
+			return ""
+		}
+	}
+	if i := strings.IndexByte(s, sep); i > 0 {
+		return s[:i]
+	}
+	return s
+}

cmd/ffmpeg/hardware_darwin.go

@@ -0,0 +1,21 @@
+package ffmpeg
+
+func ProbeHardware(name string) string {
+	switch name {
+	case "h264":
+		if run(
+			"-f", "lavfi", "-i", "testsrc2", "-t", "1",
+			"-c", "h264_videotoolbox", "-f", "null", "-") {
+			return EngineVideoToolbox
+		}
+
+	case "h265":
+		if run(
+			"-f", "lavfi", "-i", "testsrc2", "-t", "1",
+			"-c", "hevc_videotoolbox", "-f", "null", "-") {
+			return EngineVideoToolbox
+		}
+	}
+
+	return EngineSoftware
+}

cmd/ffmpeg/hardware_linux.go

@@ -0,0 +1,67 @@
+package ffmpeg
+
+import (
+	"runtime"
+)
+
+func ProbeHardware(name string) string {
+	if runtime.GOARCH == "arm64" || runtime.GOARCH == "arm" {
+		switch name {
+		case "h264":
+			if run(
+				"-f", "lavfi", "-i", "testsrc2", "-t", "1",
+				"-c", "h264_v4l2m2m", "-f", "null", "-") {
+				return EngineV4L2M2M
+			}
+
+		case "h265":
+			if run(
+				"-f", "lavfi", "-i", "testsrc2", "-t", "1",
+				"-c", "hevc_v4l2m2m", "-f", "null", "-") {
+				return EngineV4L2M2M
+			}
+		}
+
+		return EngineSoftware
+	}
+
+	switch name {
+	case "h264":
+		if run("-init_hw_device", "cuda",
+			"-f", "lavfi", "-i", "testsrc2", "-t", "1",
+			"-c", "h264_nvenc", "-f", "null", "-") {
+			return EngineCUDA
+		}
+
+		if run("-init_hw_device", "vaapi",
+			"-f", "lavfi", "-i", "testsrc2", "-t", "1",
+			"-vf", "format=nv12,hwupload",
+			"-c", "h264_vaapi", "-f", "null", "-") {
+			return EngineVAAPI
+		}
+
+	case "h265":
+		if run("-init_hw_device", "cuda",
+			"-f", "lavfi", "-i", "testsrc2", "-t", "1",
+			"-c", "hevc_nvenc", "-f", "null", "-") {
+			return EngineCUDA
+		}
+
+		if run("-init_hw_device", "vaapi",
+			"-f", "lavfi", "-i", "testsrc2", "-t", "1",
+			"-vf", "format=nv12,hwupload",
+			"-c", "hevc_vaapi", "-f", "null", "-") {
+			return EngineVAAPI
+		}
+
+	case "mjpeg":
+		if run("-init_hw_device", "vaapi",
+			"-f", "lavfi", "-i", "testsrc2", "-t", "1",
+			"-vf", "format=nv12,hwupload",
+			"-c", "mjpeg_vaapi", "-f", "null", "-") {
+			return EngineVAAPI
+		}
+	}
+
+	return EngineSoftware
+}

cmd/ffmpeg/hardware_windows.go

@@ -0,0 +1,40 @@
+package ffmpeg
+
+func ProbeHardware(name string) string {
+	switch name {
+	case "h264":
+		if run("-init_hw_device", "cuda",
+			"-f", "lavfi", "-i", "testsrc2", "-t", "1",
+			"-c", "h264_nvenc", "-f", "null", "-") {
+			return EngineCUDA
+		}
+
+		if run("-init_hw_device", "dxva2",
+			"-f", "lavfi", "-i", "testsrc2", "-t", "1",
+			"-c", "h264_qsv", "-f", "null", "-") {
+			return EngineDXVA2
+		}
+
+	case "h265":
+		if run("-init_hw_device", "cuda",
+			"-f", "lavfi", "-i", "testsrc2", "-t", "1",
+			"-c", "hevc_nvenc", "-f", "null", "-") {
+			return EngineCUDA
+		}
+
+		if run("-init_hw_device", "dxva2",
+			"-f", "lavfi", "-i", "testsrc2", "-t", "1",
+			"-c", "hevc_qsv", "-f", "null", "-") {
+			return EngineDXVA2
+		}
+
+	case "mjpeg":
+		if run("-init_hw_device", "dxva2",
+			"-f", "lavfi", "-i", "testsrc2", "-t", "1",
+			"-c", "mjpeg_qsv", "-f", "null", "-") {
+			return EngineDXVA2
+		}
+	}
+
+	return EngineSoftware
+}

cmd/hass/api.go

@@ -79,7 +79,7 @@ func initAPI() {
 				return
 			}
 
-			s, err = webrtc.ExchangeSDP(stream, string(offer), r.UserAgent())
+			s, err = webrtc.ExchangeSDP(stream, string(offer), "WebRTC/Hass sync", r.UserAgent())
 			if err != nil {
 				log.Error().Err(err).Msg("[api.hass] exchange SDP")
 				return
@@ -117,7 +117,7 @@ func initAPI() {
 			}
 		}
 
-		str, err = webrtc.ExchangeSDP(stream, string(offer), r.UserAgent())
+		str, err = webrtc.ExchangeSDP(stream, string(offer), "WebRTC/Hass sync", r.UserAgent())
 		if err != nil {
 			return
 		}

cmd/hass/hass.go

@@ -1,12 +1,16 @@
 package hass
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
+	"github.com/AlexxIT/go2rtc/cmd/api"
 	"github.com/AlexxIT/go2rtc/cmd/app"
+	"github.com/AlexxIT/go2rtc/cmd/roborock"
 	"github.com/AlexxIT/go2rtc/cmd/streams"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/rs/zerolog"
+	"net/http"
 	"os"
 	"path"
 )
@@ -26,19 +30,27 @@ func Init() {
 
 	// support load cameras from Hass config file
 	filename := path.Join(conf.Mod.Config, ".storage/core.config_entries")
-	data, err := os.ReadFile(filename)
+	b, err := os.ReadFile(filename)
 	if err != nil {
 		return
 	}
 
 	storage := new(entries)
-	if err = json.Unmarshal(data, storage); err != nil {
+	if err = json.Unmarshal(b, storage); err != nil {
 		return
 	}
 
 	urls := map[string]string{}
 
-	streams.HandleFunc("hass", func(url string) (streamer.Producer, error) {
+	api.HandleFunc("api/hass", func(w http.ResponseWriter, r *http.Request) {
+		var items []api.Stream
+		for name, url := range urls {
+			items = append(items, api.Stream{Name: name, URL: url})
+		}
+		api.ResponseStreams(w, items)
+	})
+
+	streams.HandleFunc("hass", func(url string) (core.Producer, error) {
 		if hurl := urls[url[5:]]; hurl != "" {
 			return streams.GetProducer(hurl)
 		}
@@ -48,22 +60,41 @@ func Init() {
 	for _, entrie := range storage.Data.Entries {
 		switch entrie.Domain {
 		case "generic":
-			if entrie.Options.StreamSource == "" {
+			var options struct {
+				StreamSource string `json:"stream_source"`
+			}
+			if err = json.Unmarshal(entrie.Options, &options); err != nil {
 				continue
 			}
-			urls[entrie.Title] = entrie.Options.StreamSource
+			urls[entrie.Title] = options.StreamSource
 
 		case "homekit_controller":
-			if entrie.Data.ClientID == "" {
+			if !bytes.Contains(entrie.Data, []byte("iOSPairingId")) {
+				continue
+			}
+
+			var 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"`
+			}
+			if err = json.Unmarshal(entrie.Data, &data); err != nil {
 				continue
 			}
 			urls[entrie.Title] = fmt.Sprintf(
 				"homekit://%s:%d?client_id=%s&client_private=%s%s&device_id=%s&device_public=%s",
-				entrie.Data.DeviceHost, entrie.Data.DevicePort,
-				entrie.Data.ClientID, entrie.Data.ClientPrivate, entrie.Data.ClientPublic,
-				entrie.Data.DeviceID, entrie.Data.DevicePublic,
+				data.DeviceHost, data.DevicePort,
+				data.ClientID, data.ClientPrivate, data.ClientPublic,
+				data.DeviceID, data.DevicePublic,
 			)
 
+		case "roborock":
+			_ = json.Unmarshal(entrie.Data, &roborock.Auth)
+
 		default:
 			continue
 		}
@@ -78,20 +109,10 @@ var log zerolog.Logger
 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"`
-			}
+			Title   string          `json:"title"`
+			Domain  string          `json:"domain"`
+			Data    json.RawMessage `json:"data"`
+			Options json.RawMessage `json:"options"`
 		} `json:"entries"`
 	} `json:"data"`
 }

cmd/hls/hls.go

@@ -0,0 +1,261 @@
+package hls
+
+import (
+	"fmt"
+	"github.com/AlexxIT/go2rtc/cmd/api"
+	"github.com/AlexxIT/go2rtc/cmd/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/mp4"
+	"github.com/AlexxIT/go2rtc/pkg/mpegts"
+	"github.com/rs/zerolog/log"
+	"net/http"
+	"strconv"
+	"sync"
+	"time"
+)
+
+func Init() {
+	api.HandleFunc("api/stream.m3u8", handlerStream)
+	api.HandleFunc("api/hls/playlist.m3u8", handlerPlaylist)
+
+	// HLS (TS)
+	api.HandleFunc("api/hls/segment.ts", handlerSegmentTS)
+
+	// HLS (fMP4)
+	api.HandleFunc("api/hls/init.mp4", handlerInit)
+	api.HandleFunc("api/hls/segment.m4s", handlerSegmentMP4)
+}
+
+type Consumer interface {
+	core.Consumer
+	Init() ([]byte, error)
+	MimeCodecs() string
+	Start()
+}
+
+type Session struct {
+	cons     Consumer
+	playlist string
+	init     []byte
+	segment  []byte
+	seq      int
+	alive    *time.Timer
+	mu       sync.Mutex
+}
+
+const keepalive = 5 * time.Second
+
+var sessions = map[string]*Session{}
+
+func handlerStream(w http.ResponseWriter, r *http.Request) {
+	// CORS important for Chromecast
+	w.Header().Set("Access-Control-Allow-Origin", "*")
+	w.Header().Set("Content-Type", "application/vnd.apple.mpegurl")
+
+	if r.Method == "OPTIONS" {
+		w.Header().Set("Access-Control-Allow-Methods", "GET")
+		return
+	}
+
+	src := r.URL.Query().Get("src")
+	stream := streams.GetOrNew(src)
+	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
+		return
+	}
+
+	var cons Consumer
+
+	// use fMP4 with codecs filter and TS without
+	medias := mp4.ParseQuery(r.URL.Query())
+	if medias != nil {
+		cons = &mp4.Consumer{
+			RemoteAddr: r.RemoteAddr,
+			UserAgent:  r.UserAgent(),
+			Medias:     medias,
+		}
+	} else {
+		cons = &mpegts.Consumer{
+			RemoteAddr: r.RemoteAddr,
+			UserAgent:  r.UserAgent(),
+		}
+	}
+
+	session := &Session{cons: cons}
+
+	cons.(any).(*core.Listener).Listen(func(msg any) {
+		if data, ok := msg.([]byte); ok {
+			session.mu.Lock()
+			session.segment = append(session.segment, data...)
+			session.mu.Unlock()
+		}
+	})
+
+	if err := stream.AddConsumer(cons); err != nil {
+		log.Error().Err(err).Caller().Send()
+		return
+	}
+
+	session.alive = time.AfterFunc(keepalive, func() {
+		stream.RemoveConsumer(cons)
+	})
+	session.init, _ = cons.Init()
+
+	cons.Start()
+
+	sid := strconv.FormatInt(time.Now().UnixNano(), 10)
+
+	// two segments important for Chromecast
+	if medias != nil {
+		session.playlist = `#EXTM3U
+#EXT-X-VERSION:6
+#EXT-X-TARGETDURATION:1
+#EXT-X-MEDIA-SEQUENCE:%d
+#EXT-X-MAP:URI="init.mp4?id=` + sid + `"
+#EXTINF:0.500,
+segment.m4s?id=` + sid + `&n=%d
+#EXTINF:0.500,
+segment.m4s?id=` + sid + `&n=%d`
+	} else {
+		session.playlist = `#EXTM3U
+#EXT-X-VERSION:3
+#EXT-X-TARGETDURATION:1
+#EXT-X-MEDIA-SEQUENCE:%d
+#EXTINF:0.500,
+segment.ts?id=` + sid + `&n=%d
+#EXTINF:0.500,
+segment.ts?id=` + sid + `&n=%d`
+	}
+
+	sessions[sid] = session
+
+	// bandwidth important for Safari, codecs useful for smooth playback
+	data := []byte(`#EXTM3U
+#EXT-X-STREAM-INF:BANDWIDTH=1000000,CODECS="` + cons.MimeCodecs() + `"
+hls/playlist.m3u8?id=` + sid)
+
+	if _, err := w.Write(data); err != nil {
+		log.Error().Err(err).Caller().Send()
+	}
+}
+
+func handlerPlaylist(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Access-Control-Allow-Origin", "*")
+	w.Header().Set("Content-Type", "application/vnd.apple.mpegurl")
+
+	if r.Method == "OPTIONS" {
+		w.Header().Set("Access-Control-Allow-Methods", "GET")
+		return
+	}
+
+	sid := r.URL.Query().Get("id")
+	session := sessions[sid]
+	if session == nil {
+		http.NotFound(w, r)
+		return
+	}
+
+	s := fmt.Sprintf(session.playlist, session.seq, session.seq, session.seq+1)
+
+	if _, err := w.Write([]byte(s)); err != nil {
+		log.Error().Err(err).Caller().Send()
+	}
+}
+
+func handlerSegmentTS(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Access-Control-Allow-Origin", "*")
+	w.Header().Set("Content-Type", "video/mp2t")
+
+	if r.Method == "OPTIONS" {
+		w.Header().Set("Access-Control-Allow-Methods", "GET")
+		return
+	}
+
+	sid := r.URL.Query().Get("id")
+	session := sessions[sid]
+	if session == nil {
+		http.NotFound(w, r)
+		return
+	}
+
+	session.alive.Reset(keepalive)
+
+	var i byte
+	for len(session.segment) == 0 {
+		if i++; i > 10 {
+			http.NotFound(w, r)
+			return
+		}
+		time.Sleep(time.Millisecond * 100)
+	}
+
+	session.mu.Lock()
+	data := session.segment
+	// important to start new segment with init
+	session.segment = session.init
+	session.seq++
+	session.mu.Unlock()
+
+	if _, err := w.Write(data); err != nil {
+		log.Error().Err(err).Caller().Send()
+	}
+}
+
+func handlerInit(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Access-Control-Allow-Origin", "*")
+	w.Header().Add("Content-Type", "video/mp4")
+
+	if r.Method == "OPTIONS" {
+		w.Header().Set("Access-Control-Allow-Methods", "GET")
+		return
+	}
+
+	sid := r.URL.Query().Get("id")
+	session := sessions[sid]
+	if session == nil {
+		http.NotFound(w, r)
+		return
+	}
+
+	if _, err := w.Write(session.init); err != nil {
+		log.Error().Err(err).Caller().Send()
+	}
+}
+
+func handlerSegmentMP4(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Access-Control-Allow-Origin", "*")
+	w.Header().Add("Content-Type", "video/iso.segment")
+
+	if r.Method == "OPTIONS" {
+		w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS")
+		return
+	}
+
+	sid := r.URL.Query().Get("id")
+	session := sessions[sid]
+	if session == nil {
+		http.NotFound(w, r)
+		return
+	}
+
+	session.alive.Reset(keepalive)
+
+	var i byte
+	for len(session.segment) == 0 {
+		if i++; i > 10 {
+			http.NotFound(w, r)
+			return
+		}
+		time.Sleep(time.Millisecond * 100)
+	}
+
+	session.mu.Lock()
+	data := session.segment
+	session.segment = nil
+	session.seq++
+	session.mu.Unlock()
+
+	if _, err := w.Write(data); err != nil {
+		log.Error().Err(err).Caller().Send()
+	}
+}

cmd/homekit/api.go

@@ -15,7 +15,7 @@ import (
 func apiHandler(w http.ResponseWriter, r *http.Request) {
 	switch r.Method {
 	case "GET":
-		items := make([]interface{}, 0)
+		items := make([]any, 0)
 
 		for name, src := range store.GetDict("streams") {
 			if src := src.(string); strings.HasPrefix(src, "homekit") {

cmd/homekit/homekit.go

@@ -5,8 +5,8 @@ import (
 	"github.com/AlexxIT/go2rtc/cmd/app"
 	"github.com/AlexxIT/go2rtc/cmd/srtp"
 	"github.com/AlexxIT/go2rtc/cmd/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/AlexxIT/go2rtc/pkg/homekit"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/rs/zerolog"
 )
 
@@ -20,12 +20,12 @@ func Init() {
 
 var log zerolog.Logger
 
-func streamHandler(url string) (streamer.Producer, error) {
+func streamHandler(url string) (core.Producer, error) {
 	conn, err := homekit.NewClient(url, srtp.Server)
 	if err != nil {
 		return nil, err
 	}
-	if err = conn.Dial();err!=nil{
+	if err = conn.Dial(); err != nil {
 		return nil, err
 	}
 	return conn, nil

cmd/http/http.go

@@ -4,9 +4,10 @@ import (
 	"errors"
 	"fmt"
 	"github.com/AlexxIT/go2rtc/cmd/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/AlexxIT/go2rtc/pkg/mjpeg"
+	"github.com/AlexxIT/go2rtc/pkg/mpegts"
 	"github.com/AlexxIT/go2rtc/pkg/rtmp"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/AlexxIT/go2rtc/pkg/tcp"
 	"net/http"
 	"strings"
@@ -17,7 +18,7 @@ func Init() {
 	streams.HandleFunc("https", handle)
 }
 
-func handle(url string) (streamer.Producer, error) {
+func handle(url string) (core.Producer, error) {
 	// first we get the Content-Type to define supported producer
 	req, err := http.NewRequest("GET", url, nil)
 	if err != nil {
@@ -41,6 +42,7 @@ func handle(url string) (streamer.Producer, error) {
 	switch ct {
 	case "image/jpeg", "multipart/x-mixed-replace":
 		return mjpeg.NewClient(res), nil
+
 	case "video/x-flv":
 		var conn *rtmp.Client
 		if conn, err = rtmp.Accept(res); err != nil {
@@ -50,6 +52,13 @@ func handle(url string) (streamer.Producer, error) {
 			return nil, err
 		}
 		return conn, nil
+
+	case "video/mpeg":
+		client := mpegts.NewClient(res)
+		if err = client.Handle(); err != nil {
+			return nil, err
+		}
+		return client, nil
 	}
 
 	return nil, fmt.Errorf("unsupported Content-Type: %s", ct)

cmd/isapi/init.go

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

cmd/ivideon/ivideon.go

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

cmd/mjpeg/mjpeg.go

@@ -6,6 +6,7 @@ import (
 	"github.com/AlexxIT/go2rtc/cmd/streams"
 	"github.com/AlexxIT/go2rtc/pkg/mjpeg"
 	"github.com/rs/zerolog/log"
+	"io"
 	"net/http"
 	"strconv"
 )
@@ -27,8 +28,11 @@ func handlerKeyframe(w http.ResponseWriter, r *http.Request) {
 
 	exit := make(chan []byte)
 
-	cons := &mjpeg.Consumer{}
-	cons.Listen(func(msg interface{}) {
+	cons := &mjpeg.Consumer{
+		RemoteAddr: r.RemoteAddr,
+		UserAgent:  r.UserAgent(),
+	}
+	cons.Listen(func(msg any) {
 		switch msg := msg.(type) {
 		case []byte:
 			exit <- msg
@@ -59,6 +63,14 @@ func handlerKeyframe(w http.ResponseWriter, r *http.Request) {
 const header = "--frame\r\nContent-Type: image/jpeg\r\nContent-Length: "
 
 func handlerStream(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		outputMjpeg(w, r)
+	} else {
+		inputMjpeg(w, r)
+	}
+}
+
+func outputMjpeg(w http.ResponseWriter, r *http.Request) {
 	src := r.URL.Query().Get("src")
 	stream := streams.GetOrNew(src)
 	if stream == nil {
@@ -68,8 +80,11 @@ func handlerStream(w http.ResponseWriter, r *http.Request) {
 
 	flusher := w.(http.Flusher)
 
-	cons := &mjpeg.Consumer{}
-	cons.Listen(func(msg interface{}) {
+	cons := &mjpeg.Consumer{
+		RemoteAddr: r.RemoteAddr,
+		UserAgent:  r.UserAgent(),
+	}
+	cons.Listen(func(msg any) {
 		switch msg := msg.(type) {
 		case []byte:
 			data := []byte(header + strconv.Itoa(len(msg)))
@@ -102,6 +117,27 @@ func handlerStream(w http.ResponseWriter, r *http.Request) {
 	//log.Trace().Msg("[api.mjpeg] close")
 }
 
+func inputMjpeg(w http.ResponseWriter, r *http.Request) {
+	dst := r.URL.Query().Get("dst")
+	stream := streams.Get(dst)
+	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
+		return
+	}
+
+	res := &http.Response{Body: r.Body, Header: r.Header, Request: r}
+	res.Header.Set("Content-Type", "multipart/mixed;boundary=")
+
+	client := mjpeg.NewClient(res)
+	stream.AddProducer(client)
+
+	if err := client.Start(); err != nil && err != io.EOF {
+		log.Warn().Err(err).Caller().Send()
+	}
+
+	stream.RemoveProducer(client)
+}
+
 func handlerWS(tr *api.Transport, _ *api.Message) error {
 	src := tr.Request.URL.Query().Get("src")
 	stream := streams.GetOrNew(src)
@@ -109,8 +145,11 @@ func handlerWS(tr *api.Transport, _ *api.Message) error {
 		return errors.New(api.StreamNotFound)
 	}
 
-	cons := &mjpeg.Consumer{}
-	cons.Listen(func(msg interface{}) {
+	cons := &mjpeg.Consumer{
+		RemoteAddr: tr.Request.RemoteAddr,
+		UserAgent:  tr.Request.UserAgent(),
+	}
+	cons.Listen(func(msg any) {
 		if data, ok := msg.([]byte); ok {
 			tr.Write(data)
 		}
@@ -121,6 +160,8 @@ func handlerWS(tr *api.Transport, _ *api.Message) error {
 		return err
 	}
 
+	tr.Write(&api.Message{Type: "mjpeg"})
+
 	tr.OnClose(func() {
 		stream.RemoveConsumer(cons)
 	})

cmd/mp4/mp4.go

@@ -4,6 +4,7 @@ import (
 	"github.com/AlexxIT/go2rtc/cmd/api"
 	"github.com/AlexxIT/go2rtc/cmd/app"
 	"github.com/AlexxIT/go2rtc/cmd/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/AlexxIT/go2rtc/pkg/mp4"
 	"github.com/rs/zerolog"
 	"net/http"
@@ -25,8 +26,14 @@ func Init() {
 var log zerolog.Logger
 
 func handlerKeyframe(w http.ResponseWriter, r *http.Request) {
-	if isChromeFirst(w, r) {
-		return
+	// Chrome 105 does two requests: without Range and with `Range: bytes=0-`
+	ua := r.UserAgent()
+	if strings.Contains(ua, " Chrome/") {
+		if r.Header.Values("Range") == nil {
+			w.Header().Set("Content-Type", "video/mp4")
+			w.WriteHeader(http.StatusOK)
+			return
+		}
 	}
 
 	src := r.URL.Query().Get("src")
@@ -39,7 +46,7 @@ func handlerKeyframe(w http.ResponseWriter, r *http.Request) {
 	exit := make(chan []byte)
 
 	cons := &mp4.Segment{OnlyKeyframe: true}
-	cons.Listen(func(msg interface{}) {
+	cons.Listen(func(msg any) {
 		if data, ok := msg.([]byte); ok && exit != nil {
 			exit <- data
 			exit = nil
@@ -67,7 +74,22 @@ func handlerKeyframe(w http.ResponseWriter, r *http.Request) {
 func handlerMP4(w http.ResponseWriter, r *http.Request) {
 	log.Trace().Msgf("[mp4] %s %+v", r.Method, r.Header)
 
-	if isChromeFirst(w, r) || isSafari(w, r) {
+	// Chrome has Safari in UA, so check first Chrome and later Safari
+	ua := r.UserAgent()
+	if strings.Contains(ua, " Chrome/") {
+		if r.Header.Values("Range") == nil {
+			w.Header().Set("Content-Type", "video/mp4")
+			w.WriteHeader(http.StatusOK)
+			return
+		}
+	} else if strings.Contains(ua, " Safari/") {
+		// auto redirect to HLS/fMP4 format, because Safari not support MP4 stream
+		url := "stream.m3u8?" + r.URL.RawQuery
+		if !r.URL.Query().Has("mp4") {
+			url += "&mp4"
+		}
+
+		http.Redirect(w, r, url, http.StatusMovedPermanently)
 		return
 	}
 
@@ -80,8 +102,13 @@ func handlerMP4(w http.ResponseWriter, r *http.Request) {
 
 	exit := make(chan error)
 
-	cons := &mp4.Consumer{}
-	cons.Listen(func(msg interface{}) {
+	cons := &mp4.Consumer{
+		RemoteAddr: r.RemoteAddr,
+		UserAgent:  r.UserAgent(),
+		Medias:     core.ParseQuery(r.URL.Query()),
+	}
+
+	cons.Listen(func(msg any) {
 		if data, ok := msg.([]byte); ok {
 			if _, err := w.Write(data); err != nil && exit != nil {
 				exit <- err
@@ -132,23 +159,3 @@ func handlerMP4(w http.ResponseWriter, r *http.Request) {
 		duration.Stop()
 	}
 }
-
-func isChromeFirst(w http.ResponseWriter, r *http.Request) bool {
-	// Chrome 105 does two requests: without Range and with `Range: bytes=0-`
-	if strings.Contains(r.UserAgent(), " Chrome/") {
-		if r.Header.Values("Range") == nil {
-			w.Header().Set("Content-Type", "video/mp4")
-			w.WriteHeader(http.StatusOK)
-			return true
-		}
-	}
-	return false
-}
-
-func isSafari(w http.ResponseWriter, r *http.Request) bool {
-	if r.Header.Get("Range") == "bytes=0-1" {
-		handlerKeyframe(w, r)
-		return true
-	}
-	return false
-}

cmd/mp4/ws.go

@@ -4,13 +4,11 @@ import (
 	"errors"
 	"github.com/AlexxIT/go2rtc/cmd/api"
 	"github.com/AlexxIT/go2rtc/cmd/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/AlexxIT/go2rtc/pkg/mp4"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"strings"
 )
 
-const packetSize = 8192
-
 func handlerWSMSE(tr *api.Transport, msg *api.Message) error {
 	src := tr.Request.URL.Query().Get("src")
 	stream := streams.GetOrNew(src)
@@ -18,27 +16,24 @@ func handlerWSMSE(tr *api.Transport, msg *api.Message) error {
 		return errors.New(api.StreamNotFound)
 	}
 
-	cons := &mp4.Consumer{}
-	cons.UserAgent = tr.Request.UserAgent()
-	cons.RemoteAddr = tr.Request.RemoteAddr
+	cons := &mp4.Consumer{
+		RemoteAddr: tr.Request.RemoteAddr,
+		UserAgent:  tr.Request.UserAgent(),
+	}
 
-	if codecs, ok := msg.Value.(string); ok {
+	if codecs := msg.String(); codecs != "" {
 		log.Trace().Str("codecs", codecs).Msgf("[mp4] new WS/MSE consumer")
 		cons.Medias = parseMedias(codecs, true)
 	}
 
-	cons.Listen(func(msg interface{}) {
+	cons.Listen(func(msg any) {
 		if data, ok := msg.([]byte); ok {
-			for len(data) > packetSize {
-				tr.Write(data[:packetSize])
-				data = data[packetSize:]
-			}
 			tr.Write(data)
 		}
 	})
 
 	if err := stream.AddConsumer(cons); err != nil {
-		log.Warn().Err(err).Caller().Send()
+		log.Debug().Err(err).Msg("[mp4] add consumer")
 		return err
 	}
 
@@ -68,14 +63,18 @@ func handlerWSMP4(tr *api.Transport, msg *api.Message) error {
 		return errors.New(api.StreamNotFound)
 	}
 
-	cons := &mp4.Segment{}
+	cons := &mp4.Segment{
+		RemoteAddr:   tr.Request.RemoteAddr,
+		UserAgent:    tr.Request.UserAgent(),
+		OnlyKeyframe: true,
+	}
 
-	if codecs, ok := msg.Value.(string); ok {
+	if codecs := msg.String(); codecs != "" {
 		log.Trace().Str("codecs", codecs).Msgf("[mp4] new WS/MP4 consumer")
 		cons.Medias = parseMedias(codecs, false)
 	}
 
-	cons.Listen(func(msg interface{}) {
+	cons.Listen(func(msg any) {
 		if data, ok := msg.([]byte); ok {
 			tr.Write(data)
 		}
@@ -86,6 +85,8 @@ func handlerWSMP4(tr *api.Transport, msg *api.Message) error {
 		return err
 	}
 
+	tr.Write(&api.Message{Type: "mp4", Value: cons.MimeType})
+
 	tr.OnClose(func() {
 		stream.RemoveConsumer(cons)
 	})
@@ -93,37 +94,40 @@ func handlerWSMP4(tr *api.Transport, msg *api.Message) error {
 	return nil
 }
 
-func parseMedias(codecs string, parseAudio bool) (medias []*streamer.Media) {
-	var videos []*streamer.Codec
-	var audios []*streamer.Codec
+func parseMedias(codecs string, parseAudio bool) (medias []*core.Media) {
+	var videos []*core.Codec
+	var audios []*core.Codec
 
 	for _, name := range strings.Split(codecs, ",") {
 		switch name {
-		case "avc1.640029":
-			codec := &streamer.Codec{Name: streamer.CodecH264}
+		case mp4.MimeH264:
+			codec := &core.Codec{Name: core.CodecH264}
 			videos = append(videos, codec)
-		case "hvc1.1.6.L153.B0":
-			codec := &streamer.Codec{Name: streamer.CodecH265}
+		case mp4.MimeH265:
+			codec := &core.Codec{Name: core.CodecH265}
 			videos = append(videos, codec)
-		case "mp4a.40.2":
-			codec := &streamer.Codec{Name: streamer.CodecAAC}
+		case mp4.MimeAAC:
+			codec := &core.Codec{Name: core.CodecAAC}
+			audios = append(audios, codec)
+		case mp4.MimeOpus:
+			codec := &core.Codec{Name: core.CodecOpus}
 			audios = append(audios, codec)
 		}
 	}
 
 	if videos != nil {
-		media := &streamer.Media{
-			Kind:      streamer.KindVideo,
-			Direction: streamer.DirectionRecvonly,
+		media := &core.Media{
+			Kind:      core.KindVideo,
+			Direction: core.DirectionSendonly,
 			Codecs:    videos,
 		}
 		medias = append(medias, media)
 	}
 
 	if audios != nil && parseAudio {
-		media := &streamer.Media{
-			Kind:      streamer.KindAudio,
-			Direction: streamer.DirectionRecvonly,
+		media := &core.Media{
+			Kind:      core.KindAudio,
+			Direction: core.DirectionSendonly,
 			Codecs:    audios,
 		}
 		medias = append(medias, media)

cmd/mpegts/mpegts.go

@@ -0,0 +1,43 @@
+package mpegts
+
+import (
+	"github.com/AlexxIT/go2rtc/cmd/api"
+	"github.com/AlexxIT/go2rtc/cmd/streams"
+	"github.com/AlexxIT/go2rtc/pkg/mpegts"
+	"net/http"
+)
+
+func Init() {
+	api.HandleFunc("api/stream.ts", apiHandle)
+}
+
+func apiHandle(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		http.Error(w, "", http.StatusMethodNotAllowed)
+		return
+	}
+
+	dst := r.URL.Query().Get("dst")
+	stream := streams.Get(dst)
+	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
+		return
+	}
+
+	res := &http.Response{Body: r.Body, Request: r}
+	client := mpegts.NewClient(res)
+
+	if err := client.Handle(); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	stream.AddProducer(client)
+
+	if err := client.Handle(); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	stream.RemoveProducer(client)
+}

cmd/ngrok/ngrok.go

@@ -30,7 +30,7 @@ func Init() {
 		log.Error().Err(err).Msg("[ngrok] start")
 	}
 
-	ngr.Listen(func(msg interface{}) {
+	ngr.Listen(func(msg any) {
 		if msg := msg.(*ngrok.Message); msg != nil {
 			if strings.HasPrefix(msg.Line, "ERROR:") {
 				log.Warn().Msg("[ngrok] " + msg.Line)

cmd/roborock/roborock.go

@@ -0,0 +1,100 @@
+package roborock
+
+import (
+	"fmt"
+	"github.com/AlexxIT/go2rtc/cmd/api"
+	"github.com/AlexxIT/go2rtc/cmd/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/roborock"
+	"net/http"
+)
+
+func Init() {
+	streams.HandleFunc("roborock", handle)
+
+	api.HandleFunc("api/roborock", apiHandle)
+}
+
+func handle(url string) (core.Producer, error) {
+	conn := roborock.NewClient(url)
+	if err := conn.Dial(); err != nil {
+		return nil, err
+	}
+	if err := conn.Connect(); err != nil {
+		return nil, err
+	}
+	return conn, nil
+}
+
+var Auth struct {
+	UserData *roborock.UserInfo `json:"user_data"`
+	BaseURL  string             `json:"base_url"`
+}
+
+func apiHandle(w http.ResponseWriter, r *http.Request) {
+	switch r.Method {
+	case "GET":
+		if Auth.UserData == nil {
+			http.Error(w, "no auth", http.StatusNotFound)
+			return
+		}
+
+	case "POST":
+		if err := r.ParseMultipartForm(1024); err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		username := r.Form.Get("username")
+		password := r.Form.Get("password")
+		if username == "" || password == "" {
+			http.Error(w, "empty username or password", http.StatusBadRequest)
+			return
+		}
+
+		base, err := roborock.GetBaseURL(username)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		ui, err := roborock.Login(base, username, password)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		Auth.BaseURL = base
+		Auth.UserData = ui
+
+	default:
+		http.Error(w, "", http.StatusMethodNotAllowed)
+		return
+	}
+
+	homeID, err := roborock.GetHomeID(Auth.BaseURL, Auth.UserData.Token)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	devices, err := roborock.GetDevices(Auth.UserData, homeID)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	var items []api.Stream
+
+	for _, device := range devices {
+		source := fmt.Sprintf(
+			"roborock://%s?u=%s&s=%s&k=%s&did=%s&key=%s&pin=",
+			Auth.UserData.IoT.URL.MQTT[6:],
+			Auth.UserData.IoT.User, Auth.UserData.IoT.Pass, Auth.UserData.IoT.Domain,
+			device.DID, device.Key,
+		)
+		items = append(items, api.Stream{Name: device.Name, URL: source})
+	}
+
+	api.ResponseStreams(w, items)
+}

cmd/rtmp/rtmp.go

@@ -1,16 +1,22 @@
 package rtmp
 
 import (
+	"github.com/AlexxIT/go2rtc/cmd/api"
 	"github.com/AlexxIT/go2rtc/cmd/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/AlexxIT/go2rtc/pkg/rtmp"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/rs/zerolog/log"
+	"io"
+	"net/http"
 )
 
 func Init() {
-	streams.HandleFunc("rtmp", handle)
+	streams.HandleFunc("rtmp", streamsHandle)
+
+	api.HandleFunc("api/stream.flv", apiHandle)
 }
 
-func handle(url string) (streamer.Producer, error) {
+func streamsHandle(url string) (core.Producer, error) {
 	conn := rtmp.NewClient(url)
 	if err := conn.Dial(); err != nil {
 		return nil, err
@@ -20,3 +26,37 @@ func handle(url string) (streamer.Producer, error) {
 	}
 	return conn, nil
 }
+
+func apiHandle(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		http.Error(w, "", http.StatusMethodNotAllowed)
+		return
+	}
+
+	dst := r.URL.Query().Get("dst")
+	stream := streams.Get(dst)
+	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
+		return
+	}
+
+	res := &http.Response{Body: r.Body, Request: r}
+	client, err := rtmp.Accept(res)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	if err = client.Describe(); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	stream.AddProducer(client)
+
+	if err = client.Start(); err != nil && err != io.EOF {
+		log.Warn().Err(err).Caller().Send()
+	}
+
+	stream.RemoveProducer(client)
+}

cmd/rtsp/rtsp.go

@@ -3,27 +3,32 @@ package rtsp
 import (
 	"github.com/AlexxIT/go2rtc/cmd/app"
 	"github.com/AlexxIT/go2rtc/cmd/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/mp4"
 	"github.com/AlexxIT/go2rtc/pkg/rtsp"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/AlexxIT/go2rtc/pkg/tcp"
 	"github.com/rs/zerolog"
 	"net"
+	"net/url"
 	"strings"
 )
 
 func Init() {
 	var conf struct {
 		Mod struct {
-			Listen   string `yaml:"listen"`
-			Username string `yaml:"username"`
-			Password string `yaml:"password"`
+			Listen       string `yaml:"listen" json:"listen"`
+			Username     string `yaml:"username" json:"-"`
+			Password     string `yaml:"password" json:"-"`
+			DefaultQuery string `yaml:"default_query" json:"default_query"`
 		} `yaml:"rtsp"`
 	}
 
 	// default config
 	conf.Mod.Listen = ":8554"
+	conf.Mod.DefaultQuery = "video&audio"
 
 	app.LoadConfig(&conf)
+	app.Info["rtsp"] = conf.Mod
 
 	log = app.GetLogger("rtsp")
 
@@ -48,6 +53,10 @@ func Init() {
 
 	log.Info().Str("addr", address).Msg("[rtsp] listen")
 
+	if query, err := url.ParseQuery(conf.Mod.DefaultQuery); err == nil {
+		defaultMedias = mp4.ParseQuery(query)
+	}
+
 	go func() {
 		for {
 			conn, err := ln.Accept()
@@ -77,8 +86,9 @@ var Port string
 
 var log zerolog.Logger
 var handlers []Handler
+var defaultMedias []*core.Media
 
-func rtspHandler(url string) (streamer.Producer, error) {
+func rtspHandler(url string) (core.Producer, error) {
 	backchannel := true
 
 	if i := strings.IndexByte(url, '#'); i > 0 {
@@ -88,30 +98,28 @@ func rtspHandler(url string) (streamer.Producer, error) {
 		url = url[:i]
 	}
 
-	conn, err := rtsp.NewClient(url)
-	if err != nil {
-		return nil, err
-	}
-
+	conn := rtsp.NewClient(url)
 	conn.UserAgent = app.UserAgent
 
 	if log.Trace().Enabled() {
-		conn.Listen(func(msg interface{}) {
+		conn.Listen(func(msg any) {
 			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)
+			case string:
+				log.Trace().Msgf("[rtsp] client msg: %s", msg)
 			}
 		})
 	}
 
-	if err = conn.Dial(); err != nil {
+	if err := conn.Dial(); err != nil {
 		return nil, err
 	}
 
 	conn.Backchannel = backchannel
-	if err = conn.Describe(); err != nil {
+	if err := conn.Describe(); err != nil {
 		if !backchannel {
 			return nil, err
 		}
@@ -135,7 +143,7 @@ func tcpHandler(conn *rtsp.Conn) {
 
 	trace := log.Trace().Enabled()
 
-	conn.Listen(func(msg interface{}) {
+	conn.Listen(func(msg any) {
 		if trace {
 			switch msg := msg.(type) {
 			case *tcp.Request:
@@ -161,7 +169,14 @@ func tcpHandler(conn *rtsp.Conn) {
 
 			log.Debug().Str("stream", name).Msg("[rtsp] new consumer")
 
-			initMedias(conn)
+			conn.SessionName = app.UserAgent
+
+			conn.Medias = mp4.ParseQuery(conn.URL.Query())
+			if conn.Medias == nil {
+				for _, media := range defaultMedias {
+					conn.Medias = append(conn.Medias, media.Clone())
+				}
+			}
 
 			if err := stream.AddConsumer(conn); err != nil {
 				log.Warn().Err(err).Str("stream", name).Msg("[rtsp]")
@@ -192,14 +207,14 @@ func tcpHandler(conn *rtsp.Conn) {
 			closer = func() {
 				stream.RemoveProducer(conn)
 			}
-
-		case streamer.StatePlaying:
-			log.Debug().Str("stream", name).Msg("[rtsp] start")
 		}
 	})
 
 	if err := conn.Accept(); err != nil {
 		log.Warn().Err(err).Caller().Send()
+		if closer != nil {
+			closer()
+		}
 		_ = conn.Close()
 		return
 	}
@@ -212,7 +227,7 @@ func tcpHandler(conn *rtsp.Conn) {
 
 	if closer != nil {
 		if err := conn.Handle(); err != nil {
-			log.Debug().Err(err).Caller().Send()
+			log.Debug().Msgf("[rtsp] handle=%s", err)
 		}
 
 		closer()
@@ -222,45 +237,3 @@ func tcpHandler(conn *rtsp.Conn) {
 
 	_ = conn.Close()
 }
-
-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 _, name := range value {
-				name = strings.ToUpper(name)
-
-				// check aliases
-				switch name {
-				case "COPY":
-					name = "" // pass empty codecs list
-				case "MJPEG":
-					name = streamer.CodecJPEG
-				case "AAC":
-					name = streamer.CodecAAC
-				}
-
-				media := &streamer.Media{
-					Kind: key, Direction: streamer.DirectionRecvonly,
-				}
-
-				// empty codecs match all codecs
-				if name != "" {
-					// empty clock rate and channels match any values
-					media.Codecs = []*streamer.Codec{{Name: name}}
-				}
-
-				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

@@ -2,12 +2,12 @@ package streams
 
 import (
 	"fmt"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	"strings"
 	"sync"
 )
 
-type Handler func(url string) (streamer.Producer, error)
+type Handler func(url string) (core.Producer, error)
 
 var handlers = map[string]Handler{}
 var handlersMu sync.Mutex
@@ -32,7 +32,7 @@ func HasProducer(url string) bool {
 	return getHandler(url) != nil
 }
 
-func GetProducer(url string) (streamer.Producer, error) {
+func GetProducer(url string) (core.Producer, error) {
 	handler := getHandler(url)
 	if handler == nil {
 		return nil, fmt.Errorf("unsupported scheme: %s", url)

cmd/streams/init.go

@@ -0,0 +1,116 @@
+package streams
+
+import (
+	"encoding/json"
+	"github.com/AlexxIT/go2rtc/cmd/api"
+	"github.com/AlexxIT/go2rtc/cmd/app"
+	"github.com/AlexxIT/go2rtc/cmd/app/store"
+	"github.com/rs/zerolog"
+	"net/http"
+)
+
+func Init() {
+	var cfg struct {
+		Mod map[string]any `yaml:"streams"`
+	}
+
+	app.LoadConfig(&cfg)
+
+	log = app.GetLogger("streams")
+
+	for name, item := range cfg.Mod {
+		streams[name] = NewStream(item)
+	}
+
+	for name, item := range store.GetDict("streams") {
+		streams[name] = NewStream(item)
+	}
+
+	api.HandleFunc("api/streams", streamsHandler)
+}
+
+func Get(name string) *Stream {
+	return streams[name]
+}
+
+func New(name string, source any) *Stream {
+	stream := NewStream(source)
+	streams[name] = stream
+	return stream
+}
+
+func GetOrNew(src string) *Stream {
+	if stream, ok := streams[src]; ok {
+		return stream
+	}
+
+	if !HasProducer(src) {
+		return nil
+	}
+
+	log.Info().Str("url", src).Msg("[streams] create new stream")
+
+	return New(src, src)
+}
+
+func streamsHandler(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+	src := query.Get("src")
+
+	// without source - return all streams list
+	if src == "" && r.Method != "POST" {
+		_ = json.NewEncoder(w).Encode(streams)
+		return
+	}
+
+	// Not sure about all this API. Should be rewrited...
+	switch r.Method {
+	case "GET":
+		e := json.NewEncoder(w)
+		e.SetIndent("", "  ")
+		_ = e.Encode(streams[src])
+
+	case "PUT":
+		name := query.Get("name")
+		if name == "" {
+			name = src
+		}
+
+		New(name, src)
+
+	case "PATCH":
+		name := query.Get("name")
+		if name == "" {
+			http.Error(w, "", http.StatusBadRequest)
+			return
+		}
+
+		if stream := Get(name); stream != nil {
+			stream.SetSource(src)
+		} else {
+			New(name, src)
+		}
+
+	case "POST":
+		// with dst - redirect source to dst
+		if dst := query.Get("dst"); dst != "" {
+			if stream := Get(dst); stream != nil {
+				if err := stream.Play(src); err != nil {
+					http.Error(w, err.Error(), http.StatusInternalServerError)
+				} else {
+					_ = json.NewEncoder(w).Encode(stream)
+				}
+			} else {
+				http.Error(w, "", http.StatusNotFound)
+			}
+		} else {
+			http.Error(w, "", http.StatusBadRequest)
+		}
+
+	case "DELETE":
+		delete(streams, src)
+	}
+}
+
+var log zerolog.Logger
+var streams = map[string]*Stream{}

cmd/streams/play.go

@@ -0,0 +1,151 @@
+package streams
+
+import (
+	"errors"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func (s *Stream) Play(source string) error {
+	s.mu.Lock()
+	for _, producer := range s.producers {
+		if producer.state == stateInternal && producer.conn != nil {
+			_ = producer.conn.Stop()
+		}
+	}
+	s.mu.Unlock()
+
+	if source == "" {
+		return nil
+	}
+
+	var src core.Producer
+
+	for _, producer := range s.producers {
+		if producer.conn == nil {
+			continue
+		}
+
+		cons, ok := producer.conn.(core.Consumer)
+		if !ok {
+			continue
+		}
+
+		if src == nil {
+			var err error
+			if src, err = GetProducer(source); err != nil {
+				return err
+			}
+		}
+
+		if !matchMedia(src, cons) {
+			continue
+		}
+
+		s.AddInternalProducer(src)
+
+		go func() {
+			_ = src.Start()
+			s.RemoveProducer(src)
+		}()
+
+		return nil
+	}
+
+	for _, producer := range s.producers {
+		// start new client
+		dst, err := GetProducer(producer.url)
+		if err != nil {
+			continue
+		}
+
+		// check if client support consumer interface
+		cons, ok := dst.(core.Consumer)
+		if !ok {
+			_ = dst.Stop()
+			continue
+		}
+
+		// start new producer
+		if src == nil {
+			if src, err = GetProducer(source); err != nil {
+				return err
+			}
+		}
+
+		if !matchMedia(src, cons) {
+			_ = dst.Stop()
+			continue
+		}
+
+		s.AddInternalProducer(src)
+		s.AddInternalConsumer(cons)
+
+		go func() {
+			_ = src.Start()
+			_ = dst.Stop()
+			s.RemoveProducer(src)
+		}()
+
+		go func() {
+			_ = dst.Start()
+			_ = src.Stop()
+			s.RemoveInternalConsumer(cons)
+		}()
+
+		return nil
+	}
+
+	return errors.New("can't find consumer")
+}
+
+func (s *Stream) AddInternalProducer(conn core.Producer) {
+	producer := &Producer{conn: conn, state: stateInternal}
+	s.mu.Lock()
+	s.producers = append(s.producers, producer)
+	s.mu.Unlock()
+}
+
+func (s *Stream) AddInternalConsumer(conn core.Consumer) {
+	s.mu.Lock()
+	s.consumers = append(s.consumers, conn)
+	s.mu.Unlock()
+}
+
+func (s *Stream) RemoveInternalConsumer(conn core.Consumer) {
+	s.mu.Lock()
+	for i, consumer := range s.consumers {
+		if consumer == conn {
+			s.consumers = append(s.consumers[:i], s.consumers[i+1:]...)
+			break
+		}
+	}
+	s.mu.Unlock()
+}
+
+func matchMedia(prod core.Producer, cons core.Consumer) bool {
+	for _, consMedia := range cons.GetMedias() {
+		for _, prodMedia := range prod.GetMedias() {
+			if prodMedia.Direction != core.DirectionRecvonly {
+				continue
+			}
+
+			prodCodec, consCodec := prodMedia.MatchMedia(consMedia)
+			if prodCodec == nil {
+				continue
+			}
+
+			track, err := prod.GetTrack(prodMedia, prodCodec)
+			if err != nil {
+				continue
+			}
+
+			if err = cons.AddTrack(consMedia, consCodec, track); err != nil {
+				continue
+			}
+
+			return true
+		}
+	}
+
+	return false
+}

cmd/streams/producer.go

@@ -1,7 +1,9 @@
 package streams
 
 import (
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"encoding/json"
+	"errors"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	"strings"
 	"sync"
 	"time"
@@ -15,20 +17,97 @@ const (
 	stateTracks
 	stateStart
 	stateExternal
+	stateInternal
 )
 
 type Producer struct {
-	streamer.Element
+	core.Listener
 
 	url      string
 	template string
 
-	element streamer.Producer
-	tracks  []*streamer.Track
+	conn      core.Producer
+	receivers []*core.Receiver
+	senders   []*core.Receiver
 
-	state   state
-	mu      sync.Mutex
-	restart *time.Timer
+	lastErr error
+
+	state    state
+	mu       sync.Mutex
+	workerID int
+}
+
+func (p *Producer) Dial() error {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if p.state == stateNone {
+		conn, err := GetProducer(p.url)
+		if err != nil {
+			return err
+		}
+
+		p.conn = conn
+		p.state = stateMedias
+	}
+
+	return nil
+}
+
+func (p *Producer) GetMedias() []*core.Media {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	return p.conn.GetMedias()
+}
+
+func (p *Producer) GetTrack(media *core.Media, codec *core.Codec) (*core.Receiver, error) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if p.state == stateNone {
+		return nil, errors.New("get track from none state")
+	}
+
+	for _, track := range p.receivers {
+		if track.Codec == codec {
+			return track, nil
+		}
+	}
+
+	track, err := p.conn.GetTrack(media, codec)
+	if err != nil {
+		return nil, err
+	}
+
+	p.receivers = append(p.receivers, track)
+
+	if p.state == stateMedias {
+		p.state = stateTracks
+	}
+
+	return track, nil
+}
+
+func (p *Producer) AddTrack(media *core.Media, codec *core.Codec, track *core.Receiver) error {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if p.state == stateNone {
+		return errors.New("add track from none state")
+	}
+
+	if err := p.conn.(core.Consumer).AddTrack(media, codec, track); err != nil {
+		return err
+	}
+
+	p.senders = append(p.senders, track)
+
+	if p.state == stateMedias {
+		p.state = stateTracks
+	}
+
+	return nil
 }
 
 func (p *Producer) SetSource(s string) {
@@ -38,52 +117,13 @@ func (p *Producer) SetSource(s string) {
 	p.url = strings.Replace(p.template, "{input}", s, 1)
 }
 
-func (p *Producer) GetMedias() []*streamer.Media {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-
-	if p.state == stateNone {
-		log.Debug().Msgf("[streams] probe producer url=%s", p.url)
-
-		var err error
-		p.element, err = GetProducer(p.url)
-		if err != nil || p.element == nil {
-			log.Error().Err(err).Caller().Send()
-			return nil
-		}
-
-		p.state = stateMedias
+func (p *Producer) MarshalJSON() ([]byte, error) {
+	if p.conn != nil {
+		return json.Marshal(p.conn)
 	}
 
-	return p.element.GetMedias()
-}
-
-func (p *Producer) GetTrack(media *streamer.Media, codec *streamer.Codec) *streamer.Track {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-
-	if p.state == stateNone {
-		return nil
-	}
-
-	for _, track := range p.tracks {
-		if track.Codec == codec {
-			return track
-		}
-	}
-
-	track := p.element.GetTrack(media, codec)
-	if track == nil {
-		return nil
-	}
-
-	p.tracks = append(p.tracks, track)
-
-	if p.state == stateMedias {
-		p.state = stateTracks
-	}
-
-	return track
+	info := core.Info{URL: p.url}
+	return json.Marshal(info)
 }
 
 // internals
@@ -99,61 +139,78 @@ func (p *Producer) start() {
 	log.Debug().Msgf("[streams] start producer url=%s", p.url)
 
 	p.state = stateStart
-	go func() {
-		// safe read element while mu locked
-		if err := p.element.Start(); err != nil {
-			log.Warn().Err(err).Caller().Send()
-		}
-		p.reconnect()
-	}()
+	p.workerID++
+
+	go p.worker(p.conn, p.workerID)
 }
 
-func (p *Producer) reconnect() {
+func (p *Producer) worker(conn core.Producer, workerID int) {
+	if err := conn.Start(); err != nil {
+		p.mu.Lock()
+		closed := p.workerID != workerID
+		p.mu.Unlock()
+
+		if closed {
+			return
+		}
+
+		log.Warn().Err(err).Str("url", p.url).Caller().Send()
+	}
+
+	p.reconnect(workerID)
+}
+
+func (p *Producer) reconnect(workerID int) {
 	p.mu.Lock()
 	defer p.mu.Unlock()
 
-	if p.state != stateStart {
+	if p.workerID != workerID {
 		log.Trace().Msgf("[streams] stop reconnect url=%s", p.url)
 		return
 	}
 
 	log.Debug().Msgf("[streams] reconnect to url=%s", p.url)
 
-	var err error
-	p.element, err = GetProducer(p.url)
-	if err != nil || p.element == nil {
-		log.Debug().Err(err).Caller().Send()
+	if err := p.Dial(); err != nil {
+		log.Debug().Msgf("[streams] producer=%s", err)
 		// TODO: dynamic timeout
-		p.restart = time.AfterFunc(30*time.Second, p.reconnect)
+		time.AfterFunc(30*time.Second, func() {
+			p.reconnect(workerID)
+		})
 		return
 	}
 
-	medias := p.element.GetMedias()
+	for _, media := range p.conn.GetMedias() {
+		switch media.Direction {
+		case core.DirectionRecvonly:
+			for _, receiver := range p.receivers {
+				codec := media.MatchCodec(receiver.Codec)
+				if codec == nil {
+					continue
+				}
 
-	// convert all old producer tracks to new tracks
-	for i, oldTrack := range p.tracks {
-		// match new element medias with old track codec
-		for _, media := range medias {
-			codec := media.MatchCodec(oldTrack.Codec)
-			if codec == nil {
-				continue
+				track, err := p.conn.GetTrack(media, codec)
+				if err != nil {
+					continue
+				}
+
+				receiver.Replace(track)
+				break
 			}
 
-			// move sink from old track to new track
-			newTrack := p.element.GetTrack(media, codec)
-			newTrack.GetSink(oldTrack)
-			p.tracks[i] = newTrack
+		case core.DirectionSendonly:
+			for _, sender := range p.senders {
+				codec := media.MatchCodec(sender.Codec)
+				if codec == nil {
+					continue
+				}
 
-			break
+				_ = p.conn.(core.Consumer).AddTrack(media, codec, sender)
+			}
 		}
 	}
 
-	go func() {
-		if err = p.element.Start(); err != nil {
-			log.Debug().Err(err).Caller().Send()
-		}
-		p.reconnect()
-	}()
+	go p.worker(p.conn, workerID)
 }
 
 func (p *Producer) stop() {
@@ -167,19 +224,18 @@ func (p *Producer) stop() {
 	case stateNone:
 		log.Debug().Msgf("[streams] can't stop none producer")
 		return
+	case stateStart:
+		p.workerID++
 	}
 
 	log.Debug().Msgf("[streams] stop producer url=%s", p.url)
 
-	if p.element != nil {
-		_ = p.element.Stop()
-		p.element = nil
-	}
-	if p.restart != nil {
-		p.restart.Stop()
-		p.restart = nil
+	if p.conn != nil {
+		_ = p.conn.Stop()
+		p.conn = nil
 	}
 
 	p.state = stateNone
-	p.tracks = nil
+	p.receivers = nil
+	p.senders = nil
 }

cmd/streams/stream.go

@@ -4,30 +4,27 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	"strings"
 	"sync"
+	"sync/atomic"
 )
 
-type Consumer struct {
-	element streamer.Consumer
-	tracks  []*streamer.Track
-}
-
 type Stream struct {
 	producers []*Producer
-	consumers []*Consumer
+	consumers []core.Consumer
 	mu        sync.Mutex
+	requests  int32
 }
 
-func NewStream(source interface{}) *Stream {
+func NewStream(source any) *Stream {
 	switch source := source.(type) {
 	case string:
 		s := new(Stream)
 		prod := &Producer{url: source}
 		s.producers = append(s.producers, prod)
 		return s
-	case []interface{}:
+	case []any:
 		s := new(Stream)
 		for _, source := range source {
 			prod := &Producer{url: source.(string)}
@@ -36,12 +33,12 @@ func NewStream(source interface{}) *Stream {
 		return s
 	case *Stream:
 		return source
-	case map[string]interface{}:
+	case map[string]any:
 		return NewStream(source["url"])
 	case nil:
 		return new(Stream)
 	default:
-		panic("wrong source type")
+		panic(core.Caller())
 	}
 }
 
@@ -51,63 +48,91 @@ func (s *Stream) SetSource(source string) {
 	}
 }
 
-func (s *Stream) AddConsumer(cons streamer.Consumer) (err error) {
-	ic := len(s.consumers)
+func (s *Stream) AddConsumer(cons core.Consumer) (err error) {
+	// support for multiple simultaneous requests from different consumers
+	atomic.AddInt32(&s.requests, 1)
 
-	consumer := &Consumer{element: cons}
 	var producers []*Producer // matched producers for consumer
 
 	var codecs string
 
 	// Step 1. Get consumer medias
-	for icc, consMedia := range cons.GetMedias() {
-		log.Trace().Stringer("media", consMedia).
-			Msgf("[streams] consumer=%d candidate=%d", ic, icc)
+	for _, consMedia := range cons.GetMedias() {
 
 	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 candidate=%d", ip, ipc)
+		for _, prod := range s.producers {
+			if err = prod.Dial(); err != nil {
+				continue
+			}
 
+			// Step 2. Get producer medias (not tracks yet)
+			for _, prodMedia := range prod.GetMedias() {
 				collectCodecs(prodMedia, &codecs)
 
 				// 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)
+				prodCodec, consCodec := prodMedia.MatchMedia(consMedia)
+				if prodCodec == nil {
+					continue
+				}
 
-					// Step 4. Get producer track
-					prodTrack := prod.GetTrack(prodMedia, prodCodec)
-					if prodTrack == nil {
-						log.Warn().Msg("[stream] can't get track")
+				var track *core.Receiver
+
+				switch prodMedia.Direction {
+				case core.DirectionRecvonly:
+					// Step 4. Get recvonly track from producer
+					if track, err = prod.GetTrack(prodMedia, prodCodec); err != nil {
+						log.Info().Err(err).Msg("[streams] can't get track")
+						continue
+					}
+					// Step 5. Add track to consumer
+					if err = cons.AddTrack(consMedia, consCodec, track); err != nil {
+						log.Info().Err(err).Msg("[streams] can't add track")
 						continue
 					}
 
-					// Step 5. Add track to consumer and get new track
-					consTrack := consumer.element.AddTrack(consMedia, prodTrack)
+				case core.DirectionSendonly:
+					// Step 4. Get recvonly track from consumer (backchannel)
+					if track, err = cons.(core.Producer).GetTrack(consMedia, consCodec); err != nil {
+						log.Info().Err(err).Msg("[streams] can't get track")
+						continue
+					}
+					// Step 5. Add track to producer
+					if err = prod.AddTrack(prodMedia, prodCodec, track); err != nil {
+						log.Info().Err(err).Msg("[streams] can't add track")
+						continue
+					}
+				}
 
-					consumer.tracks = append(consumer.tracks, consTrack)
-					producers = append(producers, prod)
+				producers = append(producers, prod)
+
+				if !consMedia.MatchAll() {
 					break producers
 				}
 			}
 		}
 	}
 
-	if len(producers) == 0 {
+	// stop producers if they don't have readers
+	if atomic.AddInt32(&s.requests, -1) == 0 {
 		s.stopProducers()
+	}
+
+	if len(producers) == 0 {
 		if len(codecs) > 0 {
 			return errors.New("codecs not match: " + codecs)
-		} else {
-			return fmt.Errorf("sources unavailable: %d", len(s.producers))
 		}
+
+		for i, producer := range s.producers {
+			if producer.lastErr != nil {
+				return fmt.Errorf("source %d error: %w", i, producer.lastErr)
+			}
+		}
+
+		return fmt.Errorf("sources unavailable: %d", len(s.producers))
 	}
 
 	s.mu.Lock()
-	s.consumers = append(s.consumers, consumer)
+	s.consumers = append(s.consumers, cons)
 	s.mu.Unlock()
 
 	// there may be duplicates, but that's not a problem
@@ -118,16 +143,13 @@ func (s *Stream) AddConsumer(cons streamer.Consumer) (err error) {
 	return nil
 }
 
-func (s *Stream) RemoveConsumer(cons streamer.Consumer) {
+func (s *Stream) RemoveConsumer(cons core.Consumer) {
+	_ = cons.Stop()
+
 	s.mu.Lock()
 	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)
+		if consumer == cons {
+			s.consumers = append(s.consumers[:i], s.consumers[i+1:]...)
 			break
 		}
 	}
@@ -136,18 +158,18 @@ func (s *Stream) RemoveConsumer(cons streamer.Consumer) {
 	s.stopProducers()
 }
 
-func (s *Stream) AddProducer(prod streamer.Producer) {
-	producer := &Producer{element: prod, state: stateExternal}
+func (s *Stream) AddProducer(prod core.Producer) {
+	producer := &Producer{conn: prod, state: stateExternal}
 	s.mu.Lock()
 	s.producers = append(s.producers, producer)
 	s.mu.Unlock()
 }
 
-func (s *Stream) RemoveProducer(prod streamer.Producer) {
+func (s *Stream) RemoveProducer(prod core.Producer) {
 	s.mu.Lock()
 	for i, producer := range s.producers {
-		if producer.element == prod {
-			s.removeProducer(i)
+		if producer.conn == prod {
+			s.producers = append(s.producers[:i], s.producers[i+1:]...)
 			break
 		}
 	}
@@ -158,8 +180,8 @@ func (s *Stream) stopProducers() {
 	s.mu.Lock()
 producers:
 	for _, producer := range s.producers {
-		for _, track := range producer.tracks {
-			if track.HasSink() {
+		for _, track := range producer.receivers {
+			if len(track.Senders()) > 0 {
 				continue producers
 			}
 		}
@@ -168,69 +190,32 @@ producers:
 	s.mu.Unlock()
 }
 
-//func (s *Stream) Active() bool {
-//	if len(s.consumers) > 0 {
-//		return true
-//	}
-//
-//	for _, prod := range s.producers {
-//		if prod.element != nil {
-//			return true
-//		}
-//	}
-//
-//	return false
-//}
-
 func (s *Stream) MarshalJSON() ([]byte, error) {
-	var v []interface{}
-	s.mu.Lock()
-	for _, prod := range s.producers {
-		if prod.element != nil {
-			v = append(v, prod.element)
-		}
+	if !s.mu.TryLock() {
+		log.Warn().Msgf("[streams] json locked")
+		return json.Marshal(nil)
 	}
-	for _, cons := range s.consumers {
-		// cons.element always not nil
-		v = append(v, cons.element)
+
+	var info struct {
+		Producers []*Producer     `json:"producers"`
+		Consumers []core.Consumer `json:"consumers"`
 	}
+	info.Producers = s.producers
+	info.Consumers = s.consumers
+
 	s.mu.Unlock()
-	if len(v) == 0 {
-		v = nil
-	}
-	return json.Marshal(v)
+
+	return json.Marshal(info)
 }
 
-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 collectCodecs(media *core.Media, codecs *string) {
+	if media.Direction == core.DirectionRecvonly {
+		return
 	}
-}
 
-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:]...)
-	}
-}
-
-func collectCodecs(media *streamer.Media, codecs *string) {
 	for _, codec := range media.Codecs {
 		name := codec.Name
-		if name == streamer.CodecAAC {
+		if name == core.CodecAAC {
 			name = "AAC"
 		}
 		if strings.Contains(*codecs, name) {

cmd/streams/stream_test.go

@@ -1,135 +0,0 @@
-package streams
-
-import (
-	"github.com/AlexxIT/go2rtc/pkg/fake"
-	"github.com/AlexxIT/go2rtc/pkg/rtsp"
-	"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, _ = rtsp.UnmarshalSDP([]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,67 +0,0 @@
-package streams
-
-import (
-	"github.com/AlexxIT/go2rtc/cmd/app"
-	"github.com/AlexxIT/go2rtc/cmd/app/store"
-	"github.com/rs/zerolog"
-)
-
-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)
-	}
-
-	for name, item := range store.GetDict("streams") {
-		streams[name] = NewStream(item)
-	}
-}
-
-func Get(name string) *Stream {
-	return streams[name]
-}
-
-func New(name string, source interface{}) *Stream {
-	stream := NewStream(source)
-	streams[name] = stream
-	return stream
-}
-
-func GetOrNew(src string) *Stream {
-	if stream, ok := streams[src]; ok {
-		return stream
-	}
-
-	if !HasProducer(src) {
-		return nil
-	}
-
-	log.Info().Str("url", src).Msg("[streams] create new stream")
-
-	return New(src, src)
-}
-
-func Delete(name string) {
-	delete(streams, name)
-}
-
-func All() map[string]interface{} {
-	all := map[string]interface{}{}
-	for name, stream := range streams {
-		all[name] = stream
-		//if stream.Active() {
-		//	all[name] = stream
-		//}
-	}
-	return all
-}
-
-var log zerolog.Logger
-var streams = map[string]*Stream{}

cmd/tapo/tapo.go

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

cmd/webrtc/README.md

@@ -0,0 +1,8 @@
+## Userful links
+
+- https://www.ietf.org/archive/id/draft-ietf-wish-whip-01.html
+- https://www.ietf.org/id/draft-murillo-whep-01.html
+- https://github.com/Glimesh/broadcast-box/
+- https://github.com/obsproject/obs-studio/pull/7926
+- https://misi.github.io/webrtc-c0d3l4b/
+- https://github.com/webtorrent/webtorrent/blob/master/docs/faq.md

cmd/webrtc/candidates.go

@@ -4,36 +4,82 @@ import (
 	"github.com/AlexxIT/go2rtc/cmd/api"
 	"github.com/AlexxIT/go2rtc/pkg/webrtc"
 	"github.com/pion/sdp/v3"
+	"strconv"
+	"strings"
 )
 
-var candidates []string
-
-func AddCandidate(address string) {
-	candidates = append(candidates, address)
+type Address struct {
+	Host string
+	Port int
 }
 
-func asyncCandidates(tr *api.Transport) {
-	for _, address := range candidates {
-		address, err := webrtc.LookupIP(address)
-		if err != nil {
-			log.Warn().Err(err).Caller().Send()
-			continue
+var addresses []Address
+
+func AddCandidate(address string) {
+	var port int
+
+	// try to get port from address string
+	if i := strings.LastIndexByte(address, ':'); i > 0 {
+		if v, _ := strconv.Atoi(address[i+1:]); v != 0 {
+			address = address[:i]
+			port = v
+		}
+	}
+
+	// use default WebRTC port
+	if port == 0 {
+		port, _ = strconv.Atoi(Port)
+	}
+
+	addresses = append(addresses, Address{Host: address, Port: port})
+}
+
+func GetCandidates() (candidates []string) {
+	for _, address := range addresses {
+		// using stun server for receive public IP-address
+		if address.Host == "stun" {
+			ip, err := webrtc.GetCachedPublicIP()
+			if err != nil {
+				continue
+			}
+			// this is a copy, original host unchanged
+			address.Host = ip.String()
 		}
 
-		cand, err := webrtc.NewCandidate(address)
-		if err != nil {
-			log.Warn().Err(err).Caller().Send()
-			continue
+		candidates = append(
+			candidates,
+			webrtc.CandidateManualHostUDP(address.Host, address.Port),
+			webrtc.CandidateManualHostTCPPassive(address.Host, address.Port),
+		)
+	}
+
+	return
+}
+
+func asyncCandidates(tr *api.Transport, cons *webrtc.Conn) {
+	tr.WithContext(func(ctx map[any]any) {
+		if candidates, ok := ctx["candidate"].([]string); ok {
+			// process candidates that receive before this moment
+			for _, candidate := range candidates {
+				_ = cons.AddCandidate(candidate)
+			}
+
+			// remove already processed candidates
+			delete(ctx, "candidate")
 		}
 
-		log.Trace().Str("candidate", cand).Msg("[webrtc] config")
+		// set variable for process candidates after this moment
+		ctx["webrtc"] = cons
+	})
 
-		tr.Write(&api.Message{Type: "webrtc/candidate", Value: cand})
+	for _, candidate := range GetCandidates() {
+		log.Trace().Str("candidate", candidate).Msg("[webrtc] config")
+		tr.Write(&api.Message{Type: "webrtc/candidate", Value: candidate})
 	}
 }
 
 func syncCanditates(answer string) (string, error) {
-	if len(candidates) == 0 {
+	if len(addresses) == 0 {
 		return answer, nil
 	}
 
@@ -44,30 +90,8 @@ func syncCanditates(answer string) (string, error) {
 
 	md := sd.MediaDescriptions[0]
 
-	_, end := md.Attribute("end-of-candidates")
-	if end {
-		md.Attributes = md.Attributes[:len(md.Attributes)-1]
-	}
-
-	for _, address := range candidates {
-		var err error
-		address, err = webrtc.LookupIP(address)
-		if err != nil {
-			log.Warn().Err(err).Msg("[webrtc] candidate")
-			continue
-		}
-
-		cand, err := webrtc.NewCandidate(address)
-		if err != nil {
-			log.Warn().Err(err).Msg("[webrtc] candidate")
-			continue
-		}
-
-		md.WithPropertyAttribute(cand)
-	}
-
-	if end {
-		md.WithPropertyAttribute("end-of-candidates")
+	for _, candidate := range GetCandidates() {
+		md.WithPropertyAttribute(candidate)
 	}
 
 	data, err := sd.Marshal()
@@ -79,13 +103,20 @@ func syncCanditates(answer string) (string, error) {
 }
 
 func candidateHandler(tr *api.Transport, msg *api.Message) error {
-	if tr.Consumer == nil {
-		return nil
-	}
-	if conn := tr.Consumer.(*webrtc.Conn); conn != nil {
-		s := msg.Value.(string)
-		log.Trace().Str("candidate", s).Msg("[webrtc] remote")
-		conn.AddCandidate(s)
-	}
+	// process incoming candidate in sync function
+	tr.WithContext(func(ctx map[any]any) {
+		candidate := msg.String()
+		log.Trace().Str("candidate", candidate).Msg("[webrtc] remote")
+
+		if cons, ok := ctx["webrtc"].(*webrtc.Conn); ok {
+			// if webrtc.Server already initialized - process candidate
+			_ = cons.AddCandidate(candidate)
+		} else {
+			// or collect candidate and process it later
+			list, _ := ctx["candidate"].([]string)
+			ctx["candidate"] = append(list, candidate)
+		}
+	})
+
 	return nil
 }

cmd/webrtc/client.go

@@ -0,0 +1,178 @@
+package webrtc
+
+import (
+	"errors"
+	"github.com/AlexxIT/go2rtc/cmd/api"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/webrtc"
+	"github.com/gorilla/websocket"
+	pion "github.com/pion/webrtc/v3"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+)
+
+func streamsHandler(url string) (core.Producer, error) {
+	url = url[7:]
+	if i := strings.Index(url, "://"); i > 0 {
+		switch url[:i] {
+		case "ws", "wss":
+			return asyncClient(url)
+		case "http", "https":
+			return syncClient(url)
+		}
+	}
+	return nil, errors.New("unsupported url: " + url)
+}
+
+// asyncClient can connect only to go2rtc server
+// ex: ws://localhost:1984/api/ws?src=camera1
+func asyncClient(url string) (core.Producer, error) {
+	// 1. Connect to signalign server
+	ws, _, err := websocket.DefaultDialer.Dial(url, nil)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		if err != nil {
+			_ = ws.Close()
+		}
+	}()
+
+	// 2. Create PeerConnection
+	pc, err := PeerConnection(true)
+	if err != nil {
+		log.Error().Err(err).Caller().Send()
+		return nil, err
+	}
+
+	var sendOffer core.Waiter
+
+	prod := webrtc.NewConn(pc)
+	prod.Desc = "WebRTC/WebSocket async"
+	prod.Mode = core.ModeActiveProducer
+	prod.Listen(func(msg any) {
+		switch msg := msg.(type) {
+		case pion.PeerConnectionState:
+			_ = ws.Close()
+
+		case *pion.ICECandidate:
+			sendOffer.Wait()
+
+			s := msg.ToJSON().Candidate
+			log.Trace().Str("candidate", s).Msg("[webrtc] local")
+			_ = ws.WriteJSON(&api.Message{Type: "webrtc/candidate", Value: s})
+		}
+	})
+
+	medias := []*core.Media{
+		{Kind: core.KindVideo, Direction: core.DirectionRecvonly},
+		{Kind: core.KindAudio, Direction: core.DirectionRecvonly},
+		{Kind: core.KindAudio, Direction: core.DirectionSendonly},
+	}
+
+	// 3. Create offer
+	offer, err := prod.CreateOffer(medias)
+	if err != nil {
+		return nil, err
+	}
+
+	// 4. Send offer
+	msg := &api.Message{Type: "webrtc/offer", Value: offer}
+	if err = ws.WriteJSON(msg); err != nil {
+		return nil, err
+	}
+
+	sendOffer.Done()
+
+	// 5. Get answer
+	if err = ws.ReadJSON(msg); err != nil {
+		return nil, err
+	}
+
+	if msg.Type != "webrtc/answer" {
+		return nil, errors.New("wrong answer: " + msg.Type)
+	}
+
+	answer := msg.String()
+	if err = prod.SetAnswer(answer); err != nil {
+		return nil, err
+	}
+
+	// 6. Continue to receiving candidates
+	go func() {
+		for {
+			// receive data from remote
+			msg := new(api.Message)
+			if err = ws.ReadJSON(msg); err != nil {
+				if cerr, ok := err.(*websocket.CloseError); ok {
+					log.Trace().Err(err).Caller().Msgf("[webrtc] ws code=%d", cerr)
+				}
+				break
+			}
+
+			switch msg.Type {
+			case "webrtc/candidate":
+				if msg.Value != nil {
+					_ = prod.AddCandidate(msg.String())
+				}
+			}
+		}
+
+		_ = ws.Close()
+	}()
+
+	return prod, nil
+}
+
+// syncClient - support WebRTC-HTTP Egress Protocol (WHEP)
+// ex: http://localhost:1984/api/webrtc?src=camera1
+func syncClient(url string) (core.Producer, error) {
+	// 2. Create PeerConnection
+	pc, err := PeerConnection(true)
+	if err != nil {
+		log.Error().Err(err).Caller().Send()
+		return nil, err
+	}
+
+	prod := webrtc.NewConn(pc)
+	prod.Desc = "WebRTC/WHEP sync"
+	prod.Mode = core.ModeActiveProducer
+
+	medias := []*core.Media{
+		{Kind: core.KindVideo, Direction: core.DirectionRecvonly},
+		{Kind: core.KindAudio, Direction: core.DirectionRecvonly},
+	}
+
+	// 3. Create offer
+	offer, err := prod.CreateCompleteOffer(medias)
+	if err != nil {
+		return nil, err
+	}
+
+	req, err := http.NewRequest("POST", url, strings.NewReader(offer))
+	req.Header.Set("Content-Type", MimeSDP)
+	if err != nil {
+		return nil, err
+	}
+
+	client := http.Client{Timeout: time.Second * 5000}
+	defer client.CloseIdleConnections()
+
+	res, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	answer, err := io.ReadAll(res.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	if err = prod.SetAnswer(string(answer)); err != nil {
+		return nil, err
+	}
+
+	return prod, nil
+}

cmd/webrtc/init.go

@@ -0,0 +1,241 @@
+package webrtc
+
+import (
+	"errors"
+	"github.com/AlexxIT/go2rtc/cmd/api"
+	"github.com/AlexxIT/go2rtc/cmd/app"
+	"github.com/AlexxIT/go2rtc/cmd/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/webrtc"
+	pion "github.com/pion/webrtc/v3"
+	"github.com/rs/zerolog"
+	"net"
+)
+
+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.Listen = ":8555/tcp"
+	cfg.Mod.IceServers = []pion.ICEServer{
+		{URLs: []string{"stun:stun.l.google.com:19302"}},
+	}
+
+	app.LoadConfig(&cfg)
+
+	log = app.GetLogger("webrtc")
+
+	address := cfg.Mod.Listen
+
+	// create pionAPI with custom codecs list and custom network settings
+	serverAPI, err := webrtc.NewAPI(address)
+	if err != nil {
+		log.Error().Err(err).Caller().Send()
+		return
+	}
+
+	// use same API for WebRTC server and client if no address
+	clientAPI := serverAPI
+
+	if address != "" {
+		log.Info().Str("addr", address).Msg("[webrtc] listen")
+		_, Port, _ = net.SplitHostPort(address)
+
+		clientAPI, _ = webrtc.NewAPI("")
+	}
+
+	pionConf := pion.Configuration{
+		ICEServers:   cfg.Mod.IceServers,
+		SDPSemantics: pion.SDPSemanticsUnifiedPlanWithFallback,
+	}
+
+	PeerConnection = func(active bool) (*pion.PeerConnection, error) {
+		// active - client, passive - server
+		if active {
+			return clientAPI.NewPeerConnection(pionConf)
+		} else {
+			return serverAPI.NewPeerConnection(pionConf)
+		}
+	}
+
+	for _, candidate := range cfg.Mod.Candidates {
+		AddCandidate(candidate)
+	}
+
+	// async WebRTC server (two API versions)
+	api.HandleWS("webrtc", asyncHandler)
+	api.HandleWS("webrtc/offer", asyncHandler)
+	api.HandleWS("webrtc/candidate", candidateHandler)
+
+	// sync WebRTC server (two API versions)
+	api.HandleFunc("api/webrtc", syncHandler)
+
+	// WebRTC client
+	streams.HandleFunc("webrtc", streamsHandler)
+}
+
+var Port string
+var log zerolog.Logger
+
+var PeerConnection func(active bool) (*pion.PeerConnection, error)
+
+func asyncHandler(tr *api.Transport, msg *api.Message) error {
+	var stream *streams.Stream
+	var mode core.Mode
+
+	query := tr.Request.URL.Query()
+	if name := query.Get("src"); name != "" {
+		stream = streams.GetOrNew(name)
+		mode = core.ModePassiveConsumer
+		log.Debug().Str("src", name).Msg("[webrtc] new consumer")
+	} else if name = query.Get("dst"); name != "" {
+		stream = streams.Get(name)
+		mode = core.ModePassiveProducer
+		log.Debug().Str("src", name).Msg("[webrtc] new producer")
+	}
+
+	if stream == nil {
+		return errors.New(api.StreamNotFound)
+	}
+
+	// create new PeerConnection instance
+	pc, err := PeerConnection(false)
+	if err != nil {
+		log.Error().Err(err).Caller().Send()
+		return err
+	}
+
+	var sendAnswer core.Waiter
+
+	conn := webrtc.NewConn(pc)
+	conn.Desc = "WebRTC/WebSocket async"
+	conn.Mode = mode
+	conn.UserAgent = tr.Request.UserAgent()
+	conn.Listen(func(msg any) {
+		switch msg := msg.(type) {
+		case pion.PeerConnectionState:
+			if msg != pion.PeerConnectionStateClosed {
+				return
+			}
+			switch mode {
+			case core.ModePassiveConsumer:
+				stream.RemoveConsumer(conn)
+			case core.ModePassiveProducer:
+				stream.RemoveProducer(conn)
+			}
+
+		case *pion.ICECandidate:
+			sendAnswer.Wait()
+
+			s := msg.ToJSON().Candidate
+			log.Trace().Str("candidate", s).Msg("[webrtc] local")
+			tr.Write(&api.Message{Type: "webrtc/candidate", Value: s})
+		}
+	})
+
+	// V2 - json/object exchange, V1 - raw SDP exchange
+	apiV2 := msg.Type == "webrtc"
+
+	// 1. SetOffer, so we can get remote client codecs
+	var offer string
+	if apiV2 {
+		offer = msg.GetString("sdp")
+	} else {
+		offer = msg.String()
+	}
+
+	log.Trace().Msgf("[webrtc] offer:\n%s", offer)
+
+	if err = conn.SetOffer(offer); err != nil {
+		log.Warn().Err(err).Caller().Send()
+		return err
+	}
+
+	switch mode {
+	case core.ModePassiveConsumer:
+		// 2. AddConsumer, so we get new tracks
+		if err = stream.AddConsumer(conn); err != nil {
+			log.Debug().Err(err).Msg("[webrtc] add consumer")
+			_ = conn.Close()
+			return err
+		}
+	case core.ModePassiveProducer:
+		stream.AddProducer(conn)
+	}
+
+	// 3. Exchange SDP without waiting all candidates
+	answer, err := conn.GetAnswer()
+	log.Trace().Msgf("[webrtc] answer\n%s", answer)
+
+	if err != nil {
+		log.Error().Err(err).Caller().Send()
+		return err
+	}
+
+	if apiV2 {
+		desc := pion.SessionDescription{Type: pion.SDPTypeAnswer, SDP: answer}
+		tr.Write(&api.Message{Type: "webrtc", Value: desc})
+	} else {
+		tr.Write(&api.Message{Type: "webrtc/answer", Value: answer})
+	}
+
+	sendAnswer.Done()
+
+	asyncCandidates(tr, conn)
+
+	return nil
+}
+
+func ExchangeSDP(stream *streams.Stream, offer, desc, userAgent string) (answer string, err error) {
+	pc, err := PeerConnection(false)
+	if err != nil {
+		log.Error().Err(err).Caller().Send()
+		return
+	}
+
+	// create new webrtc instance
+	conn := webrtc.NewConn(pc)
+	conn.Desc = desc
+	conn.Mode = core.ModePassiveConsumer
+	conn.UserAgent = userAgent
+	conn.Listen(func(msg any) {
+		switch msg := msg.(type) {
+		case pion.PeerConnectionState:
+			if msg == pion.PeerConnectionStateClosed {
+				stream.RemoveConsumer(conn)
+			}
+		}
+	})
+
+	// 1. SetOffer, so we can get remote client codecs
+	log.Trace().Msgf("[webrtc] offer:\n%s", offer)
+
+	if err = conn.SetOffer(offer); err != nil {
+		log.Warn().Err(err).Caller().Send()
+		return
+	}
+
+	// 2. AddConsumer, so we get new tracks
+	if err = stream.AddConsumer(conn); err != nil {
+		log.Warn().Err(err).Caller().Send()
+		_ = conn.Close()
+		return
+	}
+
+	answer, err = conn.GetCompleteAnswer()
+	if err == nil {
+		answer, err = syncCanditates(answer)
+	}
+	log.Trace().Msgf("[webrtc] answer\n%s", answer)
+
+	if err != nil {
+		log.Error().Err(err).Caller().Send()
+	}
+
+	return
+}

cmd/webrtc/server.go

@@ -0,0 +1,210 @@
+package webrtc
+
+import (
+	"encoding/json"
+	"github.com/AlexxIT/go2rtc/cmd/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/webrtc"
+	pion "github.com/pion/webrtc/v3"
+	"io"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+)
+
+const MimeSDP = "application/sdp"
+
+var sessions = map[string]*webrtc.Conn{}
+
+func syncHandler(w http.ResponseWriter, r *http.Request) {
+	switch r.Method {
+	case "POST":
+		query := r.URL.Query()
+		if query.Get("src") != "" {
+			// WHEP or JSON SDP or raw SDP exchange
+			outputWebRTC(w, r)
+		} else if query.Get("dst") != "" {
+			// WHIP SDP exchange
+			inputWebRTC(w, r)
+		} else {
+			http.Error(w, "", http.StatusBadRequest)
+		}
+
+	case "PATCH":
+		// TODO: WHEP/WHIP
+		http.Error(w, "", http.StatusMethodNotAllowed)
+
+	case "DELETE":
+		if id := r.URL.Query().Get("id"); id != "" {
+			if conn, ok := sessions[id]; ok {
+				delete(sessions, id)
+				_ = conn.Close()
+			} else {
+				http.Error(w, "", http.StatusNotFound)
+			}
+		} else {
+			http.Error(w, "", http.StatusBadRequest)
+		}
+
+	default:
+		http.Error(w, "", http.StatusMethodNotAllowed)
+	}
+}
+
+// outputWebRTC support API depending on Content-Type:
+// 1. application/json - receive {"type":"offer","sdp":"v=0\r\n..."} and response {"type":"answer","sdp":"v=0\r\n..."}
+// 2. application/sdp - receive/response SDP via WebRTC-HTTP Egress Protocol (WHEP)
+// 3. other - receive/response raw SDP
+func outputWebRTC(w http.ResponseWriter, r *http.Request) {
+	url := r.URL.Query().Get("src")
+	stream := streams.Get(url)
+	if stream == nil {
+		return
+	}
+
+	mediaType := r.Header.Get("Content-Type")
+	if mediaType != "" {
+		mediaType, _, _ = strings.Cut(mediaType, ";")
+		mediaType = strings.ToLower(strings.TrimSpace(mediaType))
+	}
+
+	var offer string
+
+	switch mediaType {
+	case "application/json":
+		var desc pion.SessionDescription
+		if err := json.NewDecoder(r.Body).Decode(&desc); err != nil {
+			log.Error().Err(err).Caller().Send()
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+		offer = desc.SDP
+
+	default:
+		body, err := io.ReadAll(r.Body)
+		if err != nil {
+			log.Error().Err(err).Caller().Send()
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		offer = string(body)
+	}
+
+	var desc string
+
+	switch mediaType {
+	case "application/json":
+		desc = "WebRTC/JSON sync"
+	case MimeSDP:
+		desc = "WebRTC/WHEP sync"
+	default:
+		desc = "WebRTC/HTTP sync"
+	}
+
+	answer, err := ExchangeSDP(stream, offer, desc, r.UserAgent())
+	if err != nil {
+		log.Error().Err(err).Caller().Send()
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	switch mediaType {
+	case "application/json":
+		w.Header().Set("Content-Type", mediaType)
+
+		v := pion.SessionDescription{
+			Type: pion.SDPTypeAnswer, SDP: answer,
+		}
+		err = json.NewEncoder(w).Encode(v)
+
+	case MimeSDP:
+		w.Header().Set("Content-Type", mediaType)
+		w.WriteHeader(http.StatusCreated)
+
+		_, err = w.Write([]byte(answer))
+
+	default:
+		_, err = w.Write([]byte(answer))
+	}
+
+	if err != nil {
+		log.Error().Err(err).Caller().Send()
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+func inputWebRTC(w http.ResponseWriter, r *http.Request) {
+	dst := r.URL.Query().Get("dst")
+	stream := streams.Get(dst)
+	if stream == nil {
+		stream = streams.New(dst, nil)
+	}
+
+	// 1. Get offer
+	offer, err := io.ReadAll(r.Body)
+	if err != nil {
+		log.Error().Err(err).Caller().Send()
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	log.Trace().Msgf("[webrtc] WHIP offer\n%s", offer)
+
+	pc, err := PeerConnection(false)
+	if err != nil {
+		log.Error().Err(err).Caller().Send()
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// create new webrtc instance
+	prod := webrtc.NewConn(pc)
+	prod.Desc = "WebRTC/WHIP sync"
+	prod.Mode = core.ModePassiveProducer
+	prod.UserAgent = r.UserAgent()
+
+	if err = prod.SetOffer(string(offer)); err != nil {
+		log.Warn().Err(err).Caller().Send()
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	answer, err := prod.GetCompleteAnswer()
+	if err == nil {
+		answer, err = syncCanditates(answer)
+	}
+	if err != nil {
+		log.Warn().Err(err).Caller().Send()
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	log.Trace().Msgf("[webrtc] WHIP answer\n%s", answer)
+
+	id := strconv.FormatInt(time.Now().UnixNano(), 36)
+	sessions[id] = prod
+
+	prod.Listen(func(msg any) {
+		switch msg := msg.(type) {
+		case pion.PeerConnectionState:
+			if msg == pion.PeerConnectionStateClosed {
+				stream.RemoveProducer(prod)
+				if _, ok := sessions[id]; ok {
+					delete(sessions, id)
+				}
+			}
+		}
+	})
+
+	stream.AddProducer(prod)
+
+	w.Header().Set("Content-Type", MimeSDP)
+	w.Header().Set("Location", "webrtc?id="+id)
+	w.WriteHeader(http.StatusCreated)
+
+	if _, err = w.Write([]byte(answer)); err != nil {
+		log.Warn().Err(err).Caller().Send()
+		return
+	}
+}

cmd/webrtc/webrtc.go

@@ -1,217 +0,0 @@
-package webrtc
-
-import (
-	"errors"
-	"github.com/AlexxIT/go2rtc/cmd/api"
-	"github.com/AlexxIT/go2rtc/cmd/app"
-	"github.com/AlexxIT/go2rtc/cmd/streams"
-	"github.com/AlexxIT/go2rtc/pkg/webrtc"
-	pion "github.com/pion/webrtc/v3"
-	"github.com/rs/zerolog"
-	"io"
-	"net"
-	"net/http"
-)
-
-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).Caller().Msg("webrtc.NewAPI")
-		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.HandleWS("webrtc/offer", asyncHandler)
-	api.HandleWS("webrtc/candidate", candidateHandler)
-
-	api.HandleFunc("api/webrtc", syncHandler)
-}
-
-var Port string
-var log zerolog.Logger
-
-var NewPConn func() (*pion.PeerConnection, error)
-
-func asyncHandler(tr *api.Transport, msg *api.Message) error {
-	src := tr.Request.URL.Query().Get("src")
-	stream := streams.Get(src)
-	if stream == nil {
-		return errors.New(api.StreamNotFound)
-	}
-
-	log.Debug().Str("url", src).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).Caller().Send()
-		return err
-	}
-
-	conn.UserAgent = tr.Request.UserAgent()
-	conn.Listen(func(msg interface{}) {
-		switch msg := msg.(type) {
-		case pion.PeerConnectionState:
-			if msg == pion.PeerConnectionStateClosed {
-				stream.RemoveConsumer(conn)
-			}
-		case *pion.ICECandidate:
-			if msg != nil {
-				s := msg.ToJSON().Candidate
-				log.Trace().Str("candidate", s).Msg("[webrtc] local")
-				tr.Write(&api.Message{Type: "webrtc/candidate", Value: s})
-			}
-		}
-	})
-
-	// 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).Caller().Send()
-		return err
-	}
-
-	// 2. AddConsumer, so we get new tracks
-	if err = stream.AddConsumer(conn); err != nil {
-		log.Warn().Err(err).Caller().Send()
-		_ = conn.Conn.Close()
-		return err
-	}
-
-	conn.Init()
-
-	// 3. Exchange SDP without waiting all candidates
-	answer, err := conn.GetAnswer()
-	log.Trace().Msgf("[webrtc] answer\n%s", answer)
-
-	if err != nil {
-		log.Error().Err(err).Caller().Send()
-		return err
-	}
-
-	tr.Consumer = conn
-
-	tr.Write(&api.Message{Type: "webrtc/answer", Value: answer})
-
-	asyncCandidates(tr)
-
-	return nil
-}
-
-func syncHandler(w http.ResponseWriter, r *http.Request) {
-	url := r.URL.Query().Get("src")
-	stream := streams.Get(url)
-	if stream == nil {
-		return
-	}
-
-	// get offer
-	offer, err := io.ReadAll(r.Body)
-	if err != nil {
-		log.Error().Err(err).Caller().Msg("ioutil.ReadAll")
-		return
-	}
-
-	answer, err := ExchangeSDP(stream, string(offer), r.UserAgent())
-	if err != nil {
-		log.Error().Err(err).Caller().Msg("ExchangeSDP")
-		return
-	}
-
-	// send SDP to client
-	if _, err = w.Write([]byte(answer)); err != nil {
-		log.Error().Err(err).Caller().Msg("w.Write")
-	}
-}
-
-func ExchangeSDP(
-	stream *streams.Stream, offer string, userAgent string,
-) (answer string, err error) {
-	// create new webrtc instance
-	conn := new(webrtc.Conn)
-	conn.Conn, err = NewPConn()
-	if err != nil {
-		log.Error().Err(err).Caller().Msg("NewPConn")
-		return
-	}
-
-	conn.UserAgent = userAgent
-	conn.Listen(func(msg interface{}) {
-		switch msg := msg.(type) {
-		case pion.PeerConnectionState:
-			if msg == pion.PeerConnectionStateClosed {
-				stream.RemoveConsumer(conn)
-			}
-		}
-	})
-
-	// 1. SetOffer, so we can get remote client codecs
-	log.Trace().Msgf("[webrtc] offer:\n%s", offer)
-
-	if err = conn.SetOffer(offer); err != nil {
-		log.Warn().Err(err).Caller().Msg("conn.SetOffer")
-		return
-	}
-
-	// 2. AddConsumer, so we get new tracks
-	if err = stream.AddConsumer(conn); err != nil {
-		log.Warn().Err(err).Caller().Msg("stream.AddConsumer")
-		_ = conn.Conn.Close()
-		return
-	}
-
-	conn.Init()
-
-	// exchange sdp without waiting all candidates
-	//answer, err := conn.ExchangeSDP(offer, false)
-	answer, err = conn.GetCompleteAnswer()
-	if err == nil {
-		answer, err = syncCanditates(answer)
-	}
-	log.Trace().Msgf("[webrtc] answer\n%s", answer)
-
-	if err != nil {
-		log.Error().Err(err).Caller().Msg("conn.GetCompleteAnswer")
-	}
-
-	return
-}

cmd/webtorrent/init.go

@@ -0,0 +1,175 @@
+package webtorrent
+
+import (
+	"errors"
+	"fmt"
+	"github.com/AlexxIT/go2rtc/cmd/api"
+	"github.com/AlexxIT/go2rtc/cmd/app"
+	"github.com/AlexxIT/go2rtc/cmd/streams"
+	"github.com/AlexxIT/go2rtc/cmd/webrtc"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/webtorrent"
+	"github.com/rs/zerolog"
+	"net/http"
+	"net/url"
+)
+
+func Init() {
+	var cfg struct {
+		Mod struct {
+			Trackers []string `yaml:"trackers"`
+			Shares   map[string]struct {
+				Pwd string `yaml:"pwd"`
+				Src string `yaml:"src"`
+			} `yaml:"shares"`
+		} `yaml:"webtorrent"`
+	}
+
+	cfg.Mod.Trackers = []string{"wss://tracker.openwebtorrent.com"}
+
+	app.LoadConfig(&cfg)
+
+	if len(cfg.Mod.Trackers) == 0 {
+		return
+	}
+
+	log = app.GetLogger("webtorrent")
+
+	streams.HandleFunc("webtorrent", streamHandle)
+
+	api.HandleFunc("api/webtorrent", apiHandle)
+
+	srv = &webtorrent.Server{
+		URL: cfg.Mod.Trackers[0],
+		Exchange: func(src, offer string) (answer string, err error) {
+			stream := streams.Get(src)
+			if stream == nil {
+				return "", errors.New(api.StreamNotFound)
+			}
+			return webrtc.ExchangeSDP(stream, offer, "WebRTC/WebTorrent sync", "")
+		},
+	}
+
+	if log.Debug().Enabled() {
+		srv.Listen(func(msg any) {
+			switch msg.(type) {
+			case string, error:
+				log.Debug().Msgf("[webtorrent] %s", msg)
+			case *webtorrent.Message:
+				log.Trace().Any("msg", msg).Msgf("[webtorrent]")
+			}
+		})
+	}
+
+	for name, share := range cfg.Mod.Shares {
+		if len(name) < 8 {
+			log.Warn().Str("name", name).Msgf("min share name len - 8 symbols")
+			continue
+		}
+		if len(share.Pwd) < 4 {
+			log.Warn().Str("name", name).Str("pwd", share.Pwd).Msgf("min share pwd len - 4 symbols")
+			continue
+		}
+		if streams.Get(share.Src) == nil {
+			log.Warn().Str("stream", share.Src).Msgf("stream not exists")
+			continue
+		}
+
+		srv.AddShare(name, share.Pwd, share.Src)
+
+		// adds to GET /api/webtorrent
+		shares[name] = name
+	}
+}
+
+var log zerolog.Logger
+
+var shares = map[string]string{}
+var srv *webtorrent.Server
+
+func apiHandle(w http.ResponseWriter, r *http.Request) {
+	src := r.URL.Query().Get("src")
+	share, ok := shares[src]
+
+	switch r.Method {
+	case "GET":
+		// support act as WebTorrent tracker (for testing purposes)
+		if r.Header.Get("Connection") == "Upgrade" {
+			tracker(w, r)
+			return
+		}
+
+		if src != "" {
+			// response one share
+			if ok {
+				pwd := srv.GetSharePwd(share)
+				data := fmt.Sprintf(`{"share":%q,"pwd":%q}`, share, pwd)
+				_, _ = w.Write([]byte(data))
+			} else {
+				http.Error(w, "", http.StatusNotFound)
+			}
+		} else {
+			// response all shares
+			var items []api.Stream
+			for src, share := range shares {
+				pwd := srv.GetSharePwd(share)
+				source := fmt.Sprintf("webtorrent:?share=%s&pwd=%s", share, pwd)
+				items = append(items, api.Stream{Name: src, URL: source})
+			}
+			api.ResponseStreams(w, items)
+		}
+
+	case "POST":
+		// check if share already exist
+		if ok {
+			http.Error(w, "", http.StatusBadRequest)
+			return
+		}
+
+		// check if stream exists
+		if stream := streams.Get(src); stream == nil {
+			http.Error(w, "", http.StatusNotFound)
+			return
+		}
+
+		// create new random share
+		share = core.RandString(10, 62)
+		pwd := core.RandString(10, 62)
+		srv.AddShare(share, pwd, src)
+
+		shares[src] = share
+
+		w.WriteHeader(http.StatusCreated)
+		data := fmt.Sprintf(`{"share":%q,"pwd":%q}`, share, pwd)
+		_, _ = w.Write([]byte(data))
+
+	case "DELETE":
+		if ok {
+			srv.RemoveShare(share)
+			delete(shares, src)
+		} else {
+			http.Error(w, "", http.StatusNotFound)
+		}
+	}
+}
+
+func streamHandle(rawURL string) (core.Producer, error) {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	query := u.Query()
+	share := query.Get("share")
+	pwd := query.Get("pwd")
+	if len(share) < 8 || len(pwd) < 4 {
+		return nil, errors.New("wrong URL: " + rawURL)
+	}
+
+	pc, err := webrtc.PeerConnection(true)
+	if err != nil {
+		return nil, err
+	}
+
+	return webtorrent.NewClient(srv.URL, share, pwd, pc)
+}

cmd/webtorrent/tracker.go

@@ -0,0 +1,107 @@
+package webtorrent
+
+import (
+	"fmt"
+	"github.com/AlexxIT/go2rtc/pkg/webtorrent"
+	"github.com/gorilla/websocket"
+	"net/http"
+)
+
+var upgrader *websocket.Upgrader
+var hashes map[string]map[string]*websocket.Conn
+
+func tracker(w http.ResponseWriter, r *http.Request) {
+	if upgrader == nil {
+		upgrader = &websocket.Upgrader{
+			ReadBufferSize:  1024,
+			WriteBufferSize: 2028,
+		}
+		upgrader.CheckOrigin = func(r *http.Request) bool {
+			return true
+		}
+	}
+
+	ws, err := upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		log.Warn().Err(err).Send()
+		return
+	}
+
+	defer ws.Close()
+
+	for {
+		var msg webtorrent.Message
+		if err = ws.ReadJSON(&msg); err != nil {
+			return
+		}
+
+		//log.Trace().Msgf("[webtorrent] message=%v", msg)
+
+		if msg.InfoHash == "" || msg.PeerId == "" {
+			continue
+		}
+
+		if hashes == nil {
+			hashes = map[string]map[string]*websocket.Conn{}
+		}
+
+		// new or old client with offers
+		clients := hashes[msg.InfoHash]
+		if clients == nil {
+			clients = map[string]*websocket.Conn{
+				msg.PeerId: ws,
+			}
+			hashes[msg.InfoHash] = clients
+		} else {
+			clients[msg.PeerId] = ws
+		}
+
+		switch {
+		case msg.Offers != nil:
+			// ask for ping
+			raw := fmt.Sprintf(
+				`{"action":"announce","interval":120,"info_hash":"%s","complete":0,"incomplete":1}`,
+				msg.InfoHash,
+			)
+			if err = ws.WriteMessage(websocket.TextMessage, []byte(raw)); err != nil {
+				log.Warn().Err(err).Send()
+				return
+			}
+
+			// skip if no offers (server)
+			if len(msg.Offers) == 0 {
+				continue
+			}
+
+			// get and check only first offer
+			offer := msg.Offers[0]
+			if offer.OfferId == "" || offer.Offer.Type != "offer" || offer.Offer.SDP == "" {
+				continue
+			}
+
+			// send offer to all clients (one of them - server)
+			raw = fmt.Sprintf(
+				`{"action":"announce","info_hash":"%s","peer_id":"%s","offer_id":"%s","offer":{"type":"offer","sdp":"%s"}}`,
+				msg.InfoHash, msg.PeerId, offer.OfferId, offer.Offer.SDP,
+			)
+
+			for _, server := range clients {
+				if server != ws {
+					_ = server.WriteMessage(websocket.TextMessage, []byte(raw))
+				}
+			}
+
+		case msg.OfferId != "" && msg.ToPeerId != "" && msg.Answer != nil:
+			ws1, ok := clients[msg.ToPeerId]
+			if !ok {
+				continue
+			}
+
+			raw := fmt.Sprintf(
+				`{"action":"announce","info_hash":"%s","peer_id":"%s","offer_id":"%s","answer":{"type":"answer","sdp":"%s"}}`,
+				msg.InfoHash, msg.PeerId, msg.OfferId, msg.Answer.SDP,
+			)
+			_ = ws1.WriteMessage(websocket.TextMessage, []byte(raw))
+		}
+	}
+}

go.mod

@@ -1,52 +1,52 @@
 module github.com/AlexxIT/go2rtc
 
-go 1.19
+go 1.20
 
 require (
 	github.com/brutella/hap v0.0.17
 	github.com/deepch/vdk v0.0.19
 	github.com/gorilla/websocket v1.5.0
 	github.com/hashicorp/mdns v1.0.5
-	github.com/pion/ice/v2 v2.2.6
-	github.com/pion/interceptor v0.1.11
-	github.com/pion/rtcp v1.2.9
+	github.com/pion/ice/v2 v2.3.1
+	github.com/pion/interceptor v0.1.12
+	github.com/pion/rtcp v1.2.10
 	github.com/pion/rtp v1.7.13
-	github.com/pion/sdp/v3 v3.0.5
-	github.com/pion/srtp/v2 v2.0.10
-	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/pion/sdp/v3 v3.0.6
+	github.com/pion/srtp/v2 v2.0.12
+	github.com/pion/stun v0.4.0
+	github.com/pion/webrtc/v3 v3.1.58
+	github.com/rs/zerolog v1.29.0
+	github.com/stretchr/testify v1.8.2
 	github.com/tadglines/go-pkgs v0.0.0-20210623144937-b983b20f54f9
 	gopkg.in/yaml.v3 v3.0.1
 )
 
 require (
-	github.com/brutella/dnssd v1.2.3 // indirect
+	github.com/brutella/dnssd v1.2.5 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/go-chi/chi v1.5.4 // indirect
 	github.com/google/uuid v1.3.0 // indirect
 	github.com/kr/pretty v0.2.1 // indirect
-	github.com/mattn/go-colorable v0.1.12 // indirect
-	github.com/mattn/go-isatty v0.0.14 // indirect
-	github.com/miekg/dns v1.1.50 // indirect
-	github.com/pion/datachannel v1.5.2 // indirect
-	github.com/pion/dtls/v2 v2.1.5 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.17 // indirect
+	github.com/miekg/dns v1.1.52 // indirect
+	github.com/pion/datachannel v1.5.5 // indirect
+	github.com/pion/dtls/v2 v2.2.6 // indirect
 	github.com/pion/logging v0.2.2 // indirect
-	github.com/pion/mdns v0.0.5 // indirect
+	github.com/pion/mdns v0.0.7 // indirect
 	github.com/pion/randutil v0.1.0 // indirect
-	github.com/pion/sctp v1.8.2 // 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.8.6 // indirect
+	github.com/pion/transport/v2 v2.0.2 // indirect
+	github.com/pion/turn/v2 v2.1.0 // indirect
+	github.com/pion/udp/v2 v2.0.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/xiam/to v0.0.0-20200126224905-d60d31e03561 // indirect
-	golang.org/x/crypto v0.0.0-20220516162934-403b01795ae8 // indirect
-	golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 // indirect
-	golang.org/x/net v0.0.0-20220630215102-69896b714898 // indirect
-	golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab // indirect
-	golang.org/x/text v0.3.7 // indirect
-	golang.org/x/tools v0.1.11 // indirect
+	golang.org/x/crypto v0.7.0 // indirect
+	golang.org/x/mod v0.9.0 // indirect
+	golang.org/x/net v0.8.0 // indirect
+	golang.org/x/sys v0.6.0 // indirect
+	golang.org/x/text v0.8.0 // indirect
+	golang.org/x/tools v0.7.0 // indirect
 )
 
 replace (

go.sum

@@ -2,8 +2,9 @@ github.com/AlexxIT/hap v0.0.15-0.20221108133010-d8a45b7a7045 h1:xJf3FxQJReJSDyYX
 github.com/AlexxIT/hap v0.0.15-0.20221108133010-d8a45b7a7045/go.mod h1:QNA3sm16zE5uUyC8+E/gNkMvQWjqQLuxQKkU5PMi8N4=
 github.com/AlexxIT/vdk v0.0.18-0.20221108193131-6168555b4f92 h1:cIeYMGaAirSZnrKRDTb5VgZDDYqPLhYiczElMg4sQW0=
 github.com/AlexxIT/vdk v0.0.18-0.20221108193131-6168555b4f92/go.mod h1:7ydHfSkflMZxBXfWR79dMjrT54xzvLxnPaByOa9Jpzg=
-github.com/brutella/dnssd v1.2.3 h1:4fBLjZjPH7SbcHhEcIJhZcC9nOhIDZ0m3rn9bjl1/i0=
 github.com/brutella/dnssd v1.2.3/go.mod h1:JoW2sJUrmVIef25G6lrLj7HS6Xdwh6q8WUIvMkkBYXs=
+github.com/brutella/dnssd v1.2.5 h1:b8syhho41/5ikw3X2X4baR9NWEBSlpZnfQgujsv7bk4=
+github.com/brutella/dnssd v1.2.5/go.mod h1:JoW2sJUrmVIef25G6lrLj7HS6Xdwh6q8WUIvMkkBYXs=
 github.com/coreos/go-systemd/v22 v22.3.3-0.20220203105225-a9a7ef127534/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
@@ -40,13 +41,17 @@ github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfn
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/mattn/go-colorable v0.1.12 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-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
 github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.17 h1:BTarxUcIeDqL27Mc+vyvdWYSL28zpIhv3RoTdsLMPng=
+github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/miekg/dns v1.1.41/go.mod h1:p6aan82bvRIyn+zDIv9xYNUpwa73JcSh9BKwknJysuI=
-github.com/miekg/dns v1.1.50 h1:DQUfb9uc6smULcREF09Uc+/Gd46YWqJd5DbpPE9xkcA=
 github.com/miekg/dns v1.1.50/go.mod h1:e3IlAVfNqAllflbibAZEWOXOQ+Ynzk/dDozDxY7XnME=
+github.com/miekg/dns v1.1.52 h1:Bmlc/qsNNULOe6bpXcUTsuOajd0DzRHwup6D9k1An0c=
+github.com/miekg/dns v1.1.52/go.mod h1:uInx36IzPl7FYnDcMeVWxj9byh7DutNykX4G9Sj60FY=
 github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
 github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
@@ -56,101 +61,106 @@ github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042
 github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
 github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
 github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY=
-github.com/pion/datachannel v1.5.2 h1:piB93s8LGmbECrpO84DnkIVWasRMk3IimbcXkTQLE6E=
-github.com/pion/datachannel v1.5.2/go.mod h1:FTGQWaHrdCwIJ1rw6xBIfZVkslikjShim5yr05XFuCQ=
-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/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/datachannel v1.5.5 h1:10ef4kwdjije+M9d7Xm9im2Y3O6A6ccQb0zcqZcJew8=
+github.com/pion/datachannel v1.5.5/go.mod h1:iMz+lECmfdCMqFRhXhcA/219B0SQlbpoR2V118yimL0=
+github.com/pion/dtls/v2 v2.2.6 h1:yXMxKr0Skd+Ub6A8UqXTRLSywskx93ooMRHsQUtd+Z4=
+github.com/pion/dtls/v2 v2.2.6/go.mod h1:t8fWJCIquY5rlQZwA2yWxUS1+OCrAdXrhVKXB5oD/wY=
+github.com/pion/ice/v2 v2.3.1 h1:FQCmUfZe2Jpe7LYStVBOP6z1DiSzbIateih3TztgTjc=
+github.com/pion/ice/v2 v2.3.1/go.mod h1:aq2kc6MtYNcn4XmMhobAv6hTNJiHzvD0yXRz80+bnP8=
+github.com/pion/interceptor v0.1.12 h1:CslaNriCFUItiXS5o+hh5lpL0t0ytQkFnUcbbCs2Zq8=
+github.com/pion/interceptor v0.1.12/go.mod h1:bDtgAD9dRkBZpWHGKaoKb42FhDHTG2rX8Ii9LRALLVA=
 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.5 h1:Q2oj/JB3NqfzY9xGZ1fPzZzK7sDSD8rZPOvcIQ10BCw=
-github.com/pion/mdns v0.0.5/go.mod h1:UgssrvdD3mxpi8tMxAXbsppL3vJ4Jipw1mTCW+al01g=
+github.com/pion/mdns v0.0.7 h1:P0UB4Sr6xDWEox0kTVxF0LmQihtCbSAdW0H2nEgkA3U=
+github.com/pion/mdns v0.0.7/go.mod h1:4iP2UbeFhLI/vWju/bw6ZfwjJzk0z8DNValjGxR/dD8=
 github.com/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.9 h1:1ujStwg++IOLIEoOiIQ2s+qBuJ1VN81KW+9pMPsif+U=
-github.com/pion/rtcp v1.2.9/go.mod h1:qVPhiCzAm4D/rxb6XzKeyZiQK69yJpbUDJSF7TgrqNo=
+github.com/pion/rtcp v1.2.10 h1:nkr3uj+8Sp97zyItdN60tE/S6vk4al5CPRR6Gejsdjc=
+github.com/pion/rtcp v1.2.10/go.mod h1:ztfEwXZNLGyF1oQDttz/ZKIBaeeg/oWbRYqzBM9TL1I=
 github.com/pion/rtp v1.7.13 h1:qcHwlmtiI50t1XivvoawdCGTP4Uiypzfrsap+bijcoA=
 github.com/pion/rtp v1.7.13/go.mod h1:bDb5n+BFZxXx0Ea7E5qe+klMuqiBrP+w8XSjiWtCUko=
-github.com/pion/sctp v1.8.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/v3 v3.0.5 h1:ouvI7IgGl+V4CrqskVtr3AaTrPvPisEOxwgpdktctkU=
-github.com/pion/sdp/v3 v3.0.5/go.mod h1:iiFWFpQO8Fy3S5ldclBkpXqmWy02ns78NOKoLLL0YQw=
-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.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.8 h1:KEstL92OUN3k5k8qxsXHpr7WWfrdp7iJZHx99ud8muw=
-github.com/pion/turn/v2 v2.0.8/go.mod h1:+y7xl719J8bAEVpSXBXvTxStjJv3hbz9YFflvkpcGPw=
-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/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/sctp v1.8.5/go.mod h1:SUFFfDpViyKejTAdwD1d/HQsCu+V/40cCs2nZIvC3s0=
+github.com/pion/sctp v1.8.6 h1:CUex11Vkt9YS++VhLf8b55O3VqKrWL6W3SDwX4jAqsI=
+github.com/pion/sctp v1.8.6/go.mod h1:SUFFfDpViyKejTAdwD1d/HQsCu+V/40cCs2nZIvC3s0=
+github.com/pion/sdp/v3 v3.0.6 h1:WuDLhtuFUUVpTfus9ILC4HRyHsW6TdugjEX/QY9OiUw=
+github.com/pion/sdp/v3 v3.0.6/go.mod h1:iiFWFpQO8Fy3S5ldclBkpXqmWy02ns78NOKoLLL0YQw=
+github.com/pion/srtp/v2 v2.0.12 h1:WrmiVCubGMOAObBU1vwWjG0H3VSyQHawKeer2PVA5rY=
+github.com/pion/srtp/v2 v2.0.12/go.mod h1:C3Ep44hlOo2qEYaq4ddsmK5dL63eLehXFbHaZ9F5V9Y=
+github.com/pion/stun v0.4.0 h1:vgRrbBE2htWHy7l3Zsxckk7rkjnjOsSM7PHZnBwo8rk=
+github.com/pion/stun v0.4.0/go.mod h1:QPsh1/SbXASntw3zkkrIk3ZJVKz4saBY2G7S10P3wCw=
+github.com/pion/transport v0.14.1 h1:XSM6olwW+o8J4SCmOBb/BpwZypkHeyM0PGFCxNQBr40=
+github.com/pion/transport v0.14.1/go.mod h1:4tGmbk00NeYA3rUa9+n+dzCCoKkcy3YlYb99Jn2fNnI=
+github.com/pion/transport/v2 v2.0.0/go.mod h1:HS2MEBJTwD+1ZI2eSXSvHJx/HnzQqRy2/LXxt6eVMHc=
+github.com/pion/transport/v2 v2.0.2 h1:St+8o+1PEzPT51O9bv+tH/KYYLMNR5Vwm5Z3Qkjsywg=
+github.com/pion/transport/v2 v2.0.2/go.mod h1:vrz6bUbFr/cjdwbnxq8OdDDzHf7JJfGsIRkxfpZoTA0=
+github.com/pion/turn/v2 v2.1.0 h1:5wGHSgGhJhP/RpabkUb/T9PdsAjkGLS6toYz5HNzoSI=
+github.com/pion/turn/v2 v2.1.0/go.mod h1:yrT5XbXSGX1VFSF31A3c1kCNB5bBZgk/uu5LET162qs=
+github.com/pion/udp/v2 v2.0.1 h1:xP0z6WNux1zWEjhC7onRA3EwwSliXqu1ElUZAQhUP54=
+github.com/pion/udp/v2 v2.0.1/go.mod h1:B7uvTMP00lzWdyMr/1PVZXtV3wpPIxBRd4Wl6AksXn8=
+github.com/pion/webrtc/v3 v3.1.58 h1:husXqiKQuk6gbOqJlPHs185OskAyxUW6iAEgHghgCrc=
+github.com/pion/webrtc/v3 v3.1.58/go.mod h1:jJdqoqGBlZiE3y8Z1tg1fjSkyEDCZLL+foypUBn0Lhk=
 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/rs/xid v1.4.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
+github.com/rs/zerolog v1.29.0 h1:Zes4hju04hjbvkVkOhdl2HpZa+0PmVwigmo8XoORE5w=
+github.com/rs/zerolog v1.29.0/go.mod h1:NILgTygv/Uej1ra5XxGf82ZFSLk58MFGAUS2o6usyD0=
 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/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
-github.com/stretchr/testify v1.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/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8=
+github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/tadglines/go-pkgs v0.0.0-20210623144937-b983b20f54f9 h1:aeN+ghOV0b2VCmKKO3gqnDQ8mLbpABZgRR2FVYx4ouI=
 github.com/tadglines/go-pkgs v0.0.0-20210623144937-b983b20f54f9/go.mod h1:roo6cZ/uqpwKMuvPG0YmzI5+AmUiMWfjCBZpGXqbTxE=
 github.com/xiam/to v0.0.0-20200126224905-d60d31e03561 h1:SVoNK97S6JlaYlHcaC+79tg3JUlQABcc0dH2VQ4Y+9s=
 github.com/xiam/to v0.0.0-20200126224905-d60d31e03561/go.mod h1:cqbG7phSzrbdg3aj+Kn63bpVruzwDZi58CpxlZkjwzw=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20220131195533-30dcbda58838/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/crypto v0.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/crypto v0.5.0/go.mod h1:NK/OQwhpMQP3MwtdjgLlYHnH9ebylxKWv3e0fK+mkQU=
+golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58=
+golang.org/x/crypto v0.7.0 h1:AvwMYaRytfdeVt3u6mLaxYtErKYjxA2OXjJ1HHq6t3A=
+golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 h1:6zppjxzCulZykYSLyVDYbneBfbaBIQPYMevg0bEwv2s=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.9.0 h1:KENHtAZL2y3NLMYZeHY9DW8HW8V+kQyJsY/V9JlKvCs=
+golang.org/x/mod v0.9.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-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-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
 golang.org/x/net v0.0.0-20210410081132-afb366fc7cd1/go.mod h1:9tjilg8BloeKEkVJvy7fQ90B1CfIiPueXVOjqfkSzI8=
 golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
 golang.org/x/net v0.0.0-20210726213435-c6fcb2dbf985/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-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/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco=
+golang.org/x/net v0.5.0/go.mod h1:DivGGAXEgPSlEBzxGzZI+ZLohi+xUj054jfeKui00ws=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.8.0 h1:Zrh2ngAOFYneWTAIAPethzeaQLuHwhuBkuV6ZiRnUaQ=
+golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -168,25 +178,36 @@ golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBc
 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/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab h1:2QkjZIsXupsJbJIdSjjUOgWK3aEtzyuh2mPt3l/CkeU=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0 h1:MVltZSvRTcU2ljQOhs94SXPftV6DCNnZViHeQps87pQ=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.4.0/go.mod h1:9P2UbLfCdcvo3p/nzKvsmas4TnlujnuoV9hGgYzW1lQ=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
 golang.org/x/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 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.6.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.8.0 h1:57P1ETyNKtuIjB4SRd15iJxuhj8Gc416Y78H3qgMh68=
+golang.org/x/text v0.8.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.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.1.6-0.20210726203631-07bc1bf47fb2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/tools v0.1.11 h1:loJ25fNOEhSXfHrpoGj91eCUThwdNX6u24rO1xnNteY=
-golang.org/x/tools v0.1.11/go.mod h1:SgwaegtQh8clINPpECJMqnxLv9I09HLqnW3RMqW0CA4=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.7.0 h1:W4OVu8VVOaIO0yzWMNdepAulS7YfoS3Zabrm8DOXXU4=
+golang.org/x/tools v0.7.0/go.mod h1:4pg6aUX35JBAogB10C9AtvVL+qowtN4pT3CGSQex14s=
 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=

hardware.Dockerfile

@@ -0,0 +1,52 @@
+# 0. Prepare images
+# only debian 12 (bookworm) has latest ffmpeg
+ARG DEBIAN_VERSION="bookworm-slim"
+ARG GO_VERSION="1.19-buster"
+ARG NGROK_VERSION="3"
+
+FROM debian:${DEBIAN_VERSION} AS base
+FROM golang:${GO_VERSION} AS go
+FROM ngrok/ngrok:${NGROK_VERSION} AS ngrok
+
+
+# 1. Build go2rtc binary
+FROM go AS build
+
+WORKDIR /build
+
+# Cache dependencies
+COPY go.mod go.sum ./
+RUN go mod download
+
+COPY . .
+RUN CGO_ENABLED=0 go build -ldflags "-s -w" -trimpath
+
+
+# 2. Collect all files
+FROM scratch AS rootfs
+
+COPY --from=build /build/go2rtc /usr/local/bin/
+COPY --from=ngrok /bin/ngrok /usr/local/bin/
+COPY ./build/docker/run.sh /
+
+
+# 3. Final image
+FROM base
+
+# Install ffmpeg, bash (for run.sh), 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)
+RUN echo 'deb http://deb.debian.org/debian bookworm non-free' > /etc/apt/sources.list.d/debian-non-free.list && \
+    apt-get -y update && apt-get -y install tini ffmpeg python3 curl jq intel-media-va-driver-non-free
+
+COPY --from=rootfs / /
+
+RUN chmod a+x /run.sh && mkdir -p /config
+
+ENTRYPOINT ["/usr/bin/tini", "--"]
+
+# https://github.com/NVIDIA/nvidia-docker/wiki/Installation-(Native-GPU-Support)
+ENV NVIDIA_VISIBLE_DEVICES all
+ENV NVIDIA_DRIVER_CAPABILITIES compute,video,utility
+
+CMD ["/run.sh"]

main.go

@@ -4,21 +4,28 @@ import (
 	"github.com/AlexxIT/go2rtc/cmd/api"
 	"github.com/AlexxIT/go2rtc/cmd/app"
 	"github.com/AlexxIT/go2rtc/cmd/debug"
+	"github.com/AlexxIT/go2rtc/cmd/dvrip"
 	"github.com/AlexxIT/go2rtc/cmd/echo"
 	"github.com/AlexxIT/go2rtc/cmd/exec"
 	"github.com/AlexxIT/go2rtc/cmd/ffmpeg"
 	"github.com/AlexxIT/go2rtc/cmd/hass"
+	"github.com/AlexxIT/go2rtc/cmd/hls"
 	"github.com/AlexxIT/go2rtc/cmd/homekit"
 	"github.com/AlexxIT/go2rtc/cmd/http"
+	"github.com/AlexxIT/go2rtc/cmd/isapi"
 	"github.com/AlexxIT/go2rtc/cmd/ivideon"
 	"github.com/AlexxIT/go2rtc/cmd/mjpeg"
 	"github.com/AlexxIT/go2rtc/cmd/mp4"
+	"github.com/AlexxIT/go2rtc/cmd/mpegts"
 	"github.com/AlexxIT/go2rtc/cmd/ngrok"
+	"github.com/AlexxIT/go2rtc/cmd/roborock"
 	"github.com/AlexxIT/go2rtc/cmd/rtmp"
 	"github.com/AlexxIT/go2rtc/cmd/rtsp"
 	"github.com/AlexxIT/go2rtc/cmd/srtp"
 	"github.com/AlexxIT/go2rtc/cmd/streams"
+	"github.com/AlexxIT/go2rtc/cmd/tapo"
 	"github.com/AlexxIT/go2rtc/cmd/webrtc"
+	"github.com/AlexxIT/go2rtc/cmd/webtorrent"
 	"os"
 	"os/signal"
 	"syscall"
@@ -26,28 +33,32 @@ import (
 
 func main() {
 	app.Init()     // init config and logs
+	api.Init()     // init HTTP API server
 	streams.Init() // load streams list
 
-	api.Init() // init HTTP API server
-
-	echo.Init()
-
 	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
-
-	webrtc.Init()
-	mp4.Init()
-	mjpeg.Init()
+	echo.Init()
+	ivideon.Init()
 	http.Init()
+	dvrip.Init()
+	tapo.Init()
+	isapi.Init()
+	mpegts.Init()
+	roborock.Init()
 
 	srtp.Init()
 	homekit.Init()
 
-	ivideon.Init()
+	webrtc.Init()
+	mp4.Init()
+	hls.Init()
+	mjpeg.Init()
 
+	webtorrent.Init()
 	ngrok.Init()
 	debug.Init()
 

pkg/aac/rtp.go

@@ -2,56 +2,62 @@ package aac
 
 import (
 	"encoding/binary"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/pion/rtp"
 )
 
 const RTPPacketVersionAAC = 0
 
-func RTPDepay(track *streamer.Track) streamer.WrapperFunc {
-	return func(push streamer.WriterFunc) streamer.WriterFunc {
-		return func(packet *rtp.Packet) error {
-			// support ONLY 2 bytes header size!
-			// streamtype=5;profile-level-id=1;mode=AAC-hbr;sizelength=13;indexlength=3;indexdeltalength=3;config=1408
-			headersSize := binary.BigEndian.Uint16(packet.Payload) >> 3
+func RTPDepay(handler core.HandlerFunc) core.HandlerFunc {
+	return func(packet *rtp.Packet) {
+		// support ONLY 2 bytes header size!
+		// streamtype=5;profile-level-id=1;mode=AAC-hbr;sizelength=13;indexlength=3;indexdeltalength=3;config=1408
+		headersSize := binary.BigEndian.Uint16(packet.Payload) >> 3
 
-			//log.Printf("[RTP/AAC] units: %d, size: %4d, ts: %10d, %t", headersSize/2, len(packet.Payload), packet.Timestamp, packet.Marker)
+		//log.Printf("[RTP/AAC] units: %d, size: %4d, ts: %10d, %t", headersSize/2, len(packet.Payload), packet.Timestamp, packet.Marker)
 
-			clone := *packet
-			clone.Version = RTPPacketVersionAAC
-			clone.Payload = packet.Payload[2+headersSize:]
-			return push(&clone)
+		data := packet.Payload[2+headersSize:]
+		if IsADTS(data) {
+			data = data[7:]
 		}
+
+		clone := *packet
+		clone.Version = RTPPacketVersionAAC
+		clone.Payload = data
+		handler(&clone)
 	}
 }
 
-func RTPPay(mtu uint16) streamer.WrapperFunc {
+func RTPPay(handler core.HandlerFunc) core.HandlerFunc {
 	sequencer := rtp.NewRandomSequencer()
 
-	return func(push streamer.WriterFunc) streamer.WriterFunc {
-		return func(packet *rtp.Packet) error {
-			if packet.Version != RTPPacketVersionAAC {
-				return push(packet)
-			}
-
-			// support ONLY one unit in payload
-			size := uint16(len(packet.Payload))
-			// 2 bytes header size + 2 bytes first payload size
-			payload := make([]byte, 2+2+size)
-			payload[1] = 16 // header size in bits
-			binary.BigEndian.PutUint16(payload[2:], size<<3)
-			copy(payload[4:], packet.Payload)
-
-			clone := rtp.Packet{
-				Header: rtp.Header{
-					Version:        2,
-					Marker:         true,
-					SequenceNumber: sequencer.NextSequenceNumber(),
-					Timestamp:      packet.Timestamp,
-				},
-				Payload: payload,
-			}
-			return push(&clone)
+	return func(packet *rtp.Packet) {
+		if packet.Version != RTPPacketVersionAAC {
+			handler(packet)
+			return
 		}
+
+		// support ONLY one unit in payload
+		size := uint16(len(packet.Payload))
+		// 2 bytes header size + 2 bytes first payload size
+		payload := make([]byte, 2+2+size)
+		payload[1] = 16 // header size in bits
+		binary.BigEndian.PutUint16(payload[2:], size<<3)
+		copy(payload[4:], packet.Payload)
+
+		clone := rtp.Packet{
+			Header: rtp.Header{
+				Version:        2,
+				Marker:         true,
+				SequenceNumber: sequencer.NextSequenceNumber(),
+				Timestamp:      packet.Timestamp,
+			},
+			Payload: payload,
+		}
+		handler(&clone)
 	}
 }
+
+func IsADTS(b []byte) bool {
+	return len(b) > 7 && b[0] == 0xFF && b[1]&0xF0 == 0xF0
+}

pkg/core/codec.go

@@ -0,0 +1,142 @@
+package core
+
+import (
+	"encoding/base64"
+	"fmt"
+	"github.com/pion/sdp/v3"
+	"strconv"
+	"strings"
+	"unicode"
+)
+
+type Codec struct {
+	Name        string // H264, PCMU, PCMA, opus...
+	ClockRate   uint32 // 90000, 8000, 16000...
+	Channels    uint16 // 0, 1, 2
+	FmtpLine    string
+	PayloadType uint8
+}
+
+func (c *Codec) String() string {
+	s := fmt.Sprintf("%d %s", c.PayloadType, c.Name)
+	if c.ClockRate != 0 && c.ClockRate != 90000 {
+		s = fmt.Sprintf("%s/%d", s, c.ClockRate)
+	}
+	if c.Channels > 0 {
+		s = fmt.Sprintf("%s/%d", s, c.Channels)
+	}
+	return s
+}
+
+func (c *Codec) Text() string {
+	switch c.Name {
+	case CodecH264:
+		if profile := DecodeH264(c.FmtpLine); profile != "" {
+			return "H.264 " + profile
+		}
+		return c.Name
+	}
+
+	s := c.Name
+	if c.ClockRate != 0 && c.ClockRate != 90000 {
+		s += "/" + strconv.Itoa(int(c.ClockRate))
+	}
+	if c.Channels > 0 {
+		s += "/" + strconv.Itoa(int(c.Channels))
+	}
+	return s
+}
+
+func (c *Codec) IsRTP() bool {
+	return c.PayloadType != PayloadTypeRAW
+}
+
+func (c *Codec) Clone() *Codec {
+	clone := *c
+	return &clone
+}
+
+func (c *Codec) Match(remote *Codec) bool {
+	switch remote.Name {
+	case CodecAll, CodecAny:
+		return true
+	}
+
+	return c.Name == remote.Name &&
+		(c.ClockRate == remote.ClockRate || remote.ClockRate == 0) &&
+		(c.Channels == remote.Channels || remote.Channels == 0)
+}
+
+func UnmarshalCodec(md *sdp.MediaDescription, payloadType string) *Codec {
+	c := &Codec{PayloadType: byte(atoi(payloadType))}
+
+	for _, attr := range md.Attributes {
+		switch {
+		case c.Name == "" && attr.Key == "rtpmap" && strings.HasPrefix(attr.Value, payloadType):
+			i := strings.IndexByte(attr.Value, ' ')
+			ss := strings.Split(attr.Value[i+1:], "/")
+
+			c.Name = strings.ToUpper(ss[0])
+			// fix tailing space: `a=rtpmap:96 H264/90000 `
+			c.ClockRate = uint32(atoi(strings.TrimRightFunc(ss[1], unicode.IsSpace)))
+
+			if len(ss) == 3 && ss[2] == "2" {
+				c.Channels = 2
+			}
+		case c.FmtpLine == "" && attr.Key == "fmtp" && strings.HasPrefix(attr.Value, payloadType):
+			if i := strings.IndexByte(attr.Value, ' '); i > 0 {
+				c.FmtpLine = attr.Value[i+1:]
+			}
+		}
+	}
+
+	if c.Name == "" {
+		// https://en.wikipedia.org/wiki/RTP_payload_formats
+		switch payloadType {
+		case "0":
+			c.Name = CodecPCMU
+			c.ClockRate = 8000
+		case "8":
+			c.Name = CodecPCMA
+			c.ClockRate = 8000
+		case "14":
+			c.Name = CodecMP3
+			c.ClockRate = 44100
+		case "26":
+			c.Name = CodecJPEG
+			c.ClockRate = 90000
+		default:
+			c.Name = payloadType
+		}
+	}
+
+	return c
+}
+
+func atoi(s string) (i int) {
+	i, _ = strconv.Atoi(s)
+	return
+}
+
+func DecodeH264(fmtp string) string {
+	if ps := Between(fmtp, "sprop-parameter-sets=", ","); ps != "" {
+		if sps, _ := base64.StdEncoding.DecodeString(ps); len(sps) >= 4 {
+			var profile string
+			switch sps[1] {
+			case 0x42:
+				profile = "Baseline"
+			case 0x4D:
+				profile = "Main"
+			case 0x58:
+				profile = "Extended"
+			case 0x64:
+				profile = "High"
+			default:
+				profile = fmt.Sprintf("0x%02X", sps[1])
+			}
+
+			return fmt.Sprintf("%s %d.%d", profile, sps[3]/10, sps[3]%10)
+		}
+	}
+	return ""
+}

pkg/core/core.go

@@ -0,0 +1,100 @@
+package core
+
+const (
+	DirectionRecvonly = "recvonly"
+	DirectionSendonly = "sendonly"
+	DirectionSendRecv = "sendrecv"
+)
+
+const (
+	KindVideo = "video"
+	KindAudio = "audio"
+)
+
+const (
+	CodecH264 = "H264" // payloadType: 96
+	CodecH265 = "H265"
+	CodecVP8  = "VP8"
+	CodecVP9  = "VP9"
+	CodecAV1  = "AV1"
+	CodecJPEG = "JPEG" // payloadType: 26
+
+	CodecPCMU = "PCMU" // payloadType: 0
+	CodecPCMA = "PCMA" // payloadType: 8
+	CodecAAC  = "MPEG4-GENERIC"
+	CodecOpus = "OPUS" // payloadType: 111
+	CodecG722 = "G722"
+	CodecMP3  = "MPA" // payload: 14, aka MPEG-1 Layer III
+	CodecPCM  = "L16" // Linear PCM
+
+	CodecELD = "ELD" // AAC-ELD
+
+	CodecAll = "ALL"
+	CodecAny = "ANY"
+)
+
+const PayloadTypeRAW byte = 255
+
+type Producer interface {
+	// GetMedias - return Media(s) with local Media.Direction:
+	// - recvonly for Producer Video/Audio
+	// - sendonly for Producer backchannel
+	GetMedias() []*Media
+
+	// GetTrack - return Receiver, that can only produce rtp.Packet(s)
+	GetTrack(media *Media, codec *Codec) (*Receiver, error)
+
+	Start() error
+	Stop() error
+}
+
+type Consumer interface {
+	// GetMedias - return Media(s) with local Media.Direction:
+	// - sendonly for Consumer Video/Audio
+	// - recvonly for Consumer backchannel
+	GetMedias() []*Media
+
+	AddTrack(media *Media, codec *Codec, track *Receiver) error
+
+	Stop() error
+}
+
+type Mode byte
+
+const (
+	ModeActiveProducer Mode = iota + 1 // typical source (client)
+	ModePassiveConsumer
+	ModePassiveProducer
+	ModeActiveConsumer
+)
+
+func (m Mode) String() string {
+	switch m {
+	case ModeActiveProducer:
+		return "active producer"
+	case ModePassiveConsumer:
+		return "passive consumer"
+	case ModePassiveProducer:
+		return "passive producer"
+	case ModeActiveConsumer:
+		return "active consumer"
+	}
+	return "unknown"
+}
+
+type Info struct {
+	Type       string      `json:"type,omitempty"`
+	URL        string      `json:"url,omitempty"`
+	RemoteAddr string      `json:"remote_addr,omitempty"`
+	UserAgent  string      `json:"user_agent,omitempty"`
+	Medias     []*Media    `json:"medias,omitempty"`
+	Receivers  []*Receiver `json:"receivers,omitempty"`
+	Senders    []*Sender   `json:"senders,omitempty"`
+	Recv       int         `json:"recv,omitempty"`
+	Send       int         `json:"send,omitempty"`
+}
+
+const (
+	UnsupportedCodec    = "unsupported codec"
+	WrongMediaDirection = "wrong media direction"
+)

pkg/core/helpers.go

@@ -0,0 +1,55 @@
+package core
+
+import (
+	cryptorand "crypto/rand"
+	"github.com/rs/zerolog/log"
+	"runtime"
+	"strconv"
+	"strings"
+)
+
+const symbols = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_"
+
+// RandString base10 - numbers, base16 - hex, base36 - digits+letters, base64 - URL safe symbols
+func RandString(size, base byte) string {
+	b := make([]byte, size)
+	if _, err := cryptorand.Read(b); err != nil {
+		panic(err)
+	}
+	for i := byte(0); i < size; i++ {
+		b[i] = symbols[b[i]%base]
+	}
+	return string(b)
+}
+
+func Between(s, sub1, sub2 string) string {
+	i := strings.Index(s, sub1)
+	if i < 0 {
+		return ""
+	}
+	s = s[i+len(sub1):]
+
+	if len(sub2) == 1 {
+		i = strings.IndexByte(s, sub2[0])
+	} else {
+		i = strings.Index(s, sub2)
+	}
+	if i >= 0 {
+		return s[:i]
+	}
+
+	return s
+}
+
+func Assert(ok bool) {
+	if !ok {
+		_, file, line, _ := runtime.Caller(1)
+		panic(file + ":" + strconv.Itoa(line))
+	}
+}
+
+func Caller() string {
+	log.Error().Caller(0).Send()
+	_, file, line, _ := runtime.Caller(1)
+	return file + ":" + strconv.Itoa(line)
+}

pkg/core/listener.go

@@ -0,0 +1,18 @@
+package core
+
+type EventFunc func(msg any)
+
+// Listener base struct for all classes with support feedback
+type Listener struct {
+	events []EventFunc
+}
+
+func (l *Listener) Listen(f EventFunc) {
+	l.events = append(l.events, f)
+}
+
+func (l *Listener) Fire(msg any) {
+	for _, f := range l.events {
+		f(msg)
+	}
+}

pkg/core/media.go

@@ -0,0 +1,191 @@
+package core
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/pion/sdp/v3"
+	"strings"
+)
+
+// Media take best from:
+// - deepch/vdk/format/rtsp/sdp.Media
+// - pion/sdp.MediaDescription
+type Media struct {
+	Kind      string   `json:"kind,omitempty"`      // video or audio
+	Direction string   `json:"direction,omitempty"` // sendonly, recvonly
+	Codecs    []*Codec `json:"codecs,omitempty"`
+
+	ID string `json:"id,omitempty"` // MID for WebRTC, Control for RTSP
+}
+
+func (m *Media) String() string {
+	s := fmt.Sprintf("%s, %s", m.Kind, m.Direction)
+	for _, codec := range m.Codecs {
+		name := codec.Text()
+
+		if strings.Contains(s, name) {
+			continue
+		}
+
+		s += ", " + name
+	}
+	return s
+}
+
+func (m *Media) MarshalJSON() ([]byte, error) {
+	return json.Marshal(m.String())
+}
+
+func (m *Media) Clone() *Media {
+	clone := *m
+	clone.Codecs = make([]*Codec, len(m.Codecs))
+	for i, codec := range m.Codecs {
+		clone.Codecs[i] = codec.Clone()
+	}
+	return &clone
+}
+
+func (m *Media) MatchMedia(remote *Media) (codec, remoteCodec *Codec) {
+	// check same kind and opposite dirrection
+	if m.Kind != remote.Kind ||
+		m.Direction == DirectionSendonly && remote.Direction != DirectionRecvonly ||
+		m.Direction == DirectionRecvonly && remote.Direction != DirectionSendonly {
+		return nil, nil
+	}
+
+	for _, codec = range m.Codecs {
+		for _, remoteCodec = range remote.Codecs {
+			if codec.Match(remoteCodec) {
+				return
+			}
+		}
+	}
+
+	return nil, nil
+}
+
+func (m *Media) MatchCodec(remote *Codec) *Codec {
+	for _, codec := range m.Codecs {
+		if codec.Match(remote) {
+			return codec
+		}
+	}
+	return nil
+}
+
+func (m *Media) MatchAll() bool {
+	for _, codec := range m.Codecs {
+		if codec.Name == CodecAll {
+			return true
+		}
+	}
+	return false
+}
+
+func GetKind(name string) string {
+	switch name {
+	case CodecH264, CodecH265, CodecVP8, CodecVP9, CodecAV1, CodecJPEG:
+		return KindVideo
+	case CodecPCMU, CodecPCMA, CodecAAC, CodecOpus, CodecG722, CodecMP3, CodecELD:
+		return KindAudio
+	}
+	return ""
+}
+
+func MarshalSDP(name string, medias []*Media) ([]byte, error) {
+	sd := &sdp.SessionDescription{
+		Origin: sdp.Origin{
+			Username: "-", SessionID: 1, SessionVersion: 1,
+			NetworkType: "IN", AddressType: "IP4", UnicastAddress: "0.0.0.0",
+		},
+		SessionName: sdp.SessionName(name),
+		ConnectionInformation: &sdp.ConnectionInformation{
+			NetworkType: "IN", AddressType: "IP4", Address: &sdp.Address{
+				Address: "0.0.0.0",
+			},
+		},
+		TimeDescriptions: []sdp.TimeDescription{
+			{Timing: sdp.Timing{}},
+		},
+	}
+
+	for _, media := range medias {
+		if media.Codecs == nil {
+			continue
+		}
+
+		codec := media.Codecs[0]
+
+		name := codec.Name
+		if name == CodecELD {
+			name = CodecAAC
+		}
+
+		md := &sdp.MediaDescription{
+			MediaName: sdp.MediaName{
+				Media:  media.Kind,
+				Protos: []string{"RTP", "AVP"},
+			},
+		}
+		md.WithCodec(codec.PayloadType, name, codec.ClockRate, codec.Channels, codec.FmtpLine)
+
+		sd.MediaDescriptions = append(sd.MediaDescriptions, md)
+	}
+
+	return sd.Marshal()
+}
+
+func UnmarshalMedia(md *sdp.MediaDescription) *Media {
+	m := &Media{
+		Kind: md.MediaName.Media,
+	}
+
+	for _, attr := range md.Attributes {
+		switch attr.Key {
+		case DirectionSendonly, DirectionRecvonly, DirectionSendRecv:
+			m.Direction = attr.Key
+		case "control", "mid":
+			m.ID = attr.Value
+		}
+	}
+
+	for _, format := range md.MediaName.Formats {
+		m.Codecs = append(m.Codecs, UnmarshalCodec(md, format))
+	}
+
+	return m
+}
+
+func ParseQuery(query map[string][]string) (medias []*Media) {
+	// set media candidates from query list
+	for key, values := range query {
+		switch key {
+		case KindVideo, KindAudio:
+			for _, value := range values {
+				media := &Media{Kind: key, Direction: DirectionSendonly}
+
+				for _, name := range strings.Split(value, ",") {
+					name = strings.ToUpper(name)
+
+					// check aliases
+					switch name {
+					case "", "COPY":
+						name = CodecAny
+					case "MJPEG":
+						name = CodecJPEG
+					case "AAC":
+						name = CodecAAC
+					case "MP3":
+						name = CodecMP3
+					}
+
+					media.Codecs = append(media.Codecs, &Codec{Name: name})
+				}
+
+				medias = append(medias, media)
+			}
+		}
+	}
+
+	return
+}

pkg/core/media_test.go

@@ -0,0 +1,63 @@
+package core
+
+import (
+	"fmt"
+	"github.com/pion/sdp/v3"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"net/url"
+	"testing"
+)
+
+func TestSDP(t *testing.T) {
+	medias := []*Media{{
+		Kind: KindAudio, Direction: DirectionSendonly,
+		Codecs: []*Codec{
+			{Name: CodecPCMU, ClockRate: 8000},
+		},
+	}}
+
+	data, err := MarshalSDP("go2rtc/1.0.0", medias)
+	assert.Empty(t, err)
+
+	sd := &sdp.SessionDescription{}
+	err = sd.Unmarshal(data)
+	assert.Empty(t, err)
+}
+
+func TestParseQuery(t *testing.T) {
+	u, _ := url.Parse("rtsp://localhost:8554/camera1")
+	medias := ParseQuery(u.Query())
+	assert.Nil(t, medias)
+
+	for _, rawULR := range []string{
+		"rtsp://localhost:8554/camera1?video",
+		"rtsp://localhost:8554/camera1?video=copy",
+		"rtsp://localhost:8554/camera1?video=any",
+	} {
+		u, _ = url.Parse(rawULR)
+		medias = ParseQuery(u.Query())
+		assert.Equal(t, []*Media{
+			{Kind: KindVideo, Direction: DirectionRecvonly, Codecs: []*Codec{{Name: CodecAny}}},
+		}, medias)
+	}
+}
+
+func TestClone(t *testing.T) {
+	media1 := &Media{
+		Kind:      KindVideo,
+		Direction: DirectionRecvonly,
+		Codecs: []*Codec{
+			{Name: CodecPCMU, ClockRate: 8000},
+		},
+	}
+	media2 := media1.Clone()
+
+	p1 := fmt.Sprintf("%p", media1)
+	p2 := fmt.Sprintf("%p", media2)
+	require.NotEqualValues(t, p1, p2)
+
+	p3 := fmt.Sprintf("%p", media1.Codecs[0])
+	p4 := fmt.Sprintf("%p", media2.Codecs[0])
+	require.NotEqualValues(t, p3, p4)
+}

pkg/core/probe.go

@@ -0,0 +1,31 @@
+package core
+
+import "time"
+
+type Probe struct {
+	deadline time.Time
+	items    map[any]struct{}
+}
+
+func NewProbe(enable bool) *Probe {
+	if enable {
+		return &Probe{
+			deadline: time.Now().Add(time.Second * 3),
+			items:    map[any]struct{}{},
+		}
+	} else {
+		return nil
+	}
+}
+
+// Active return true if probe enabled and not finish
+func (p *Probe) Active() bool {
+	return len(p.items) < 2 && time.Now().Before(p.deadline)
+}
+
+// Append safe to run if Probe is nil
+func (p *Probe) Append(v any) {
+	if p != nil {
+		p.items[v] = struct{}{}
+	}
+}

pkg/core/track.go

@@ -0,0 +1,188 @@
+package core
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"github.com/pion/rtp"
+	"strconv"
+	"sync"
+)
+
+var ErrCantGetTrack = errors.New("can't get track")
+
+type Receiver struct {
+	Codec *Codec
+	Media *Media
+
+	ID byte // Channel for RTSP, PayloadType for MPEG-TS
+
+	senders map[*Sender]chan *rtp.Packet
+	mu      sync.Mutex
+	bytes   int
+}
+
+func NewReceiver(media *Media, codec *Codec) *Receiver {
+	Assert(codec != nil)
+	return &Receiver{Codec: codec, Media: media}
+}
+
+// WriteRTP - fast and non blocking write to all readers buffers
+func (t *Receiver) WriteRTP(packet *rtp.Packet) {
+	t.mu.Lock()
+	t.bytes += len(packet.Payload)
+	for sender, buffer := range t.senders {
+		if len(buffer) < cap(buffer) {
+			buffer <- packet
+		} else {
+			sender.overflow++
+		}
+	}
+	t.mu.Unlock()
+}
+
+func (t *Receiver) Senders() (senders []*Sender) {
+	t.mu.Lock()
+	for sender := range t.senders {
+		senders = append(senders, sender)
+	}
+	t.mu.Unlock()
+	return
+}
+
+func (t *Receiver) Close() {
+	t.mu.Lock()
+	// close all sender channel buffers and erase senders list
+	for _, buffer := range t.senders {
+		close(buffer)
+	}
+	t.senders = nil
+	t.mu.Unlock()
+}
+
+func (t *Receiver) Replace(target *Receiver) {
+	// move this receiver senders to new receiver
+	t.mu.Lock()
+	senders := t.senders
+	t.mu.Unlock()
+
+	target.mu.Lock()
+	target.senders = senders
+	target.mu.Unlock()
+}
+
+func (t *Receiver) String() string {
+	s := t.Codec.String() + ", bytes=" + strconv.Itoa(t.bytes)
+	if t.mu.TryLock() {
+		s += fmt.Sprintf(", senders=%d", len(t.senders))
+		t.mu.Unlock()
+	} else {
+		s += fmt.Sprintf(", senders=?")
+	}
+	return s
+}
+
+func (t *Receiver) MarshalJSON() ([]byte, error) {
+	return json.Marshal(t.String())
+}
+
+type Sender struct {
+	Codec *Codec
+	Media *Media
+
+	Handler HandlerFunc
+
+	receivers []*Receiver
+	mu        sync.Mutex
+	bytes     int
+
+	overflow int
+}
+
+func NewSender(media *Media, codec *Codec) *Sender {
+	return &Sender{Codec: codec, Media: media}
+}
+
+// HandlerFunc like http.HandlerFunc
+type HandlerFunc func(packet *rtp.Packet)
+
+func (s *Sender) HandleRTP(track *Receiver) {
+	bufferSize := 100
+
+	if GetKind(track.Codec.Name) == KindVideo {
+		if track.Codec.IsRTP() {
+			// H.264 2560x1440 4096kbs can have 700+ packets between 25 frames
+			// H.265 5120x1440 can have 700+ packets between two keyframes
+			bufferSize = 1000
+		} else {
+			bufferSize = 50
+		}
+	}
+
+	buffer := make(chan *rtp.Packet, bufferSize)
+
+	track.mu.Lock()
+	if track.senders == nil {
+		track.senders = map[*Sender]chan *rtp.Packet{}
+	}
+	track.senders[s] = buffer
+	track.mu.Unlock()
+
+	s.mu.Lock()
+	s.receivers = append(s.receivers, track)
+	s.mu.Unlock()
+
+	go func() {
+		// read packets from buffer channel until it will be closed
+		for packet := range buffer {
+			s.bytes += len(packet.Payload)
+			s.Handler(packet)
+		}
+
+		// remove current receiver from list
+		// it can only happen when receiver close buffer channel
+		s.mu.Lock()
+		for i, receiver := range s.receivers {
+			if receiver == track {
+				s.receivers = append(s.receivers[:i], s.receivers[i+1:]...)
+				break
+			}
+		}
+		s.mu.Unlock()
+	}()
+}
+
+func (s *Sender) Close() {
+	s.mu.Lock()
+	// remove this sender from all receivers list
+	for _, receiver := range s.receivers {
+		receiver.mu.Lock()
+		if buffer := receiver.senders[s]; buffer != nil {
+			// remove channel from list
+			delete(receiver.senders, s)
+			// close channel
+			close(buffer)
+		}
+		receiver.mu.Unlock()
+	}
+	s.receivers = nil
+	s.mu.Unlock()
+}
+
+func (s *Sender) String() string {
+	info := s.Codec.String() + ", bytes=" + strconv.Itoa(s.bytes)
+	if s.mu.TryLock() {
+		info += ", receivers=" + strconv.Itoa(len(s.receivers))
+		s.mu.Unlock()
+	} else {
+		info += ", receivers=?"
+	}
+	if s.overflow > 0 {
+		info += ", overflow=" + strconv.Itoa(s.overflow)
+	}
+	return info
+}
+
+func (s *Sender) MarshalJSON() ([]byte, error) {
+	return json.Marshal(s.String())
+}

pkg/core/waiter.go

@@ -0,0 +1,71 @@
+package core
+
+import (
+	"sync"
+)
+
+// Waiter support:
+// - autotart on first Wait
+// - block new waiters after last Done
+// - safe Done after finish
+type Waiter struct {
+	sync.WaitGroup
+	mu    sync.Mutex
+	state int // state < 0 means finish
+}
+
+func (w *Waiter) Add(delta int) {
+	w.mu.Lock()
+	if w.state >= 0 {
+		w.state += delta
+		w.WaitGroup.Add(delta)
+	}
+	w.mu.Unlock()
+}
+
+func (w *Waiter) Wait() {
+	w.mu.Lock()
+	// first wait auto start waiter
+	if w.state == 0 {
+		w.state++
+		w.WaitGroup.Add(1)
+	}
+	w.mu.Unlock()
+
+	w.WaitGroup.Wait()
+}
+
+func (w *Waiter) Done() {
+	w.mu.Lock()
+
+	// safe run Done only when have tasks
+	if w.state > 0 {
+		w.state--
+		w.WaitGroup.Done()
+	}
+
+	// block waiter for any operations after last done
+	if w.state == 0 {
+		w.state = -1
+	}
+
+	w.mu.Unlock()
+}
+
+func (w *Waiter) WaitChan() <-chan struct{} {
+	var ch chan struct{}
+
+	w.mu.Lock()
+
+	if w.state >= 0 {
+		ch = make(chan struct{})
+		go func() {
+			w.Wait()
+			ch <- struct{}{}
+		}()
+	}
+
+	w.mu.Unlock()
+
+	return ch
+}

pkg/core/worker.go

@@ -0,0 +1,52 @@
+package core
+
+import (
+	"time"
+)
+
+type Worker struct {
+	timer *time.Timer
+	done  chan struct{}
+}
+
+// NewWorker run f after d
+func NewWorker(d time.Duration, f func() time.Duration) *Worker {
+	timer := time.NewTimer(d)
+	done := make(chan struct{})
+
+	go func() {
+		for {
+			select {
+			case <-timer.C:
+				if d = f(); d > 0 {
+					timer.Reset(d)
+					continue
+				}
+			case <-done:
+				timer.Stop()
+			}
+			break
+		}
+	}()
+
+	return &Worker{timer: timer, done: done}
+}
+
+// Do - instant timer run
+func (w *Worker) Do() {
+	if w == nil {
+		return
+	}
+	w.timer.Reset(0)
+}
+
+func (w *Worker) Stop() {
+	if w == nil {
+		return
+	}
+
+	select {
+	case w.done <- struct{}{}:
+	default:
+	}
+}

pkg/dvrip/client.go

@@ -0,0 +1,436 @@
+package dvrip
+
+import (
+	"bufio"
+	"crypto/md5"
+	"encoding/base64"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/h265"
+	"github.com/pion/rtp"
+	"io"
+	"net"
+	"net/url"
+	"time"
+)
+
+type Client struct {
+	core.Listener
+
+	uri     string
+	conn    net.Conn
+	reader  *bufio.Reader
+	session uint32
+	seq     uint32
+	stream  string
+
+	medias     []*core.Media
+	receivers  []*core.Receiver
+	videoTrack *core.Receiver
+	audioTrack *core.Receiver
+
+	videoTS  uint32
+	videoDT  uint32
+	audioTS  uint32
+	audioSeq uint16
+
+	recv uint32
+}
+
+type Response map[string]any
+
+const Login = uint16(1000)
+const OPMonitorClaim = uint16(1413)
+const OPMonitorStart = uint16(1410)
+
+func NewClient(url string) *Client {
+	return &Client{uri: url}
+}
+
+func (c *Client) Dial() (err error) {
+	u, err := url.Parse(c.uri)
+	if err != nil {
+		return
+	}
+
+	if u.Port() == "" {
+		// add default TCP port
+		u.Host += ":34567"
+	}
+
+	c.conn, err = net.DialTimeout("tcp", u.Host, time.Second*3)
+	if err != nil {
+		return
+	}
+
+	c.reader = bufio.NewReader(c.conn)
+
+	query := u.Query()
+	channel := query.Get("channel")
+	if channel == "" {
+		channel = "0"
+	}
+
+	subtype := query.Get("subtype")
+	switch subtype {
+	case "", "0":
+		subtype = "Main"
+	case "1":
+		subtype = "Extra1"
+	}
+
+	c.stream = fmt.Sprintf(
+		`{"Channel":%s,"CombinMode":"NONE","StreamType":"%s","TransMode":"TCP"}`,
+		channel, subtype,
+	)
+
+	if u.User != nil {
+		pass, _ := u.User.Password()
+		return c.Login(u.User.Username(), pass)
+	} else {
+		return c.Login("admin", "admin")
+	}
+}
+
+func (c *Client) Login(user, pass string) (err error) {
+	data := fmt.Sprintf(
+		`{"EncryptType":"MD5","LoginType":"DVRIP-Web","PassWord":"%s","UserName":"%s"}`,
+		SofiaHash(pass), user,
+	)
+
+	if err = c.Request(Login, data); err != nil {
+		return
+	}
+
+	_, err = c.ResponseJSON()
+	return
+}
+
+func (c *Client) Play() (err error) {
+	format := `{"Name":"OPMonitor","SessionID":"0x%08X","OPMonitor":{"Action":"%s","Parameter":%s}}`
+
+	data := fmt.Sprintf(format, c.session, "Claim", c.stream)
+	if err = c.Request(OPMonitorClaim, data); err != nil {
+		return
+	}
+	if _, err = c.ResponseJSON(); err != nil {
+		return
+	}
+
+	data = fmt.Sprintf(format, c.session, "Start", c.stream)
+	return c.Request(OPMonitorStart, data)
+}
+
+func (c *Client) Handle() error {
+	var buf []byte
+	var size int
+
+	var probe byte
+	if c.medias == nil {
+		probe = 1
+	}
+
+	for {
+		b, err := c.Response()
+		if err != nil {
+			return err
+		}
+
+		// collect data from multiple packets
+		if size > 0 {
+			buf = append(buf, b...)
+			if len(buf) < size {
+				continue
+			}
+			if len(buf) > size {
+				return errors.New("wrong size")
+			}
+			b = buf
+		}
+
+		dataType := binary.BigEndian.Uint32(b)
+		switch dataType {
+		case 0x1FC, 0x1FE:
+			size = int(binary.LittleEndian.Uint32(b[12:])) + 16
+		case 0x1FD: // PFrame
+			size = int(binary.LittleEndian.Uint32(b[4:])) + 8
+		case 0x1FA, 0x1F9:
+			size = int(binary.LittleEndian.Uint16(b[6:])) + 8
+		default:
+			return fmt.Errorf("unknown type: %X", dataType)
+		}
+
+		if len(b) < size {
+			buf = b
+			continue // need to collect data from next packets
+		}
+
+		//log.Printf("[DVR] type: %d, len: %d", dataType, len(b))
+
+		switch dataType {
+		case 0x1FC, 0x1FE: // video IFrame
+			payload := h264.AnnexB2AVC(b[16:])
+
+			if c.videoTrack == nil {
+				fps := b[5]
+				//width := uint16(b[6]) * 8
+				//height := uint16(b[7]) * 8
+				//println(width, height)
+				ts := b[8:]
+
+				// the exact value of the start TS does not matter
+				c.videoTS = binary.LittleEndian.Uint32(ts)
+				c.videoDT = 90000 / uint32(fps)
+
+				c.AddVideoTrack(b[4], payload)
+			}
+
+			if c.videoTrack != nil {
+				c.videoTS += c.videoDT
+
+				packet := &rtp.Packet{
+					Header:  rtp.Header{Timestamp: c.videoTS},
+					Payload: payload,
+				}
+
+				//log.Printf("[AVC] %v, len: %d, ts: %10d", h265.Types(payload), len(payload), packet.Timestamp)
+
+				c.videoTrack.WriteRTP(packet)
+			}
+
+		case 0x1FD: // PFrame
+			if c.videoTrack != nil {
+				c.videoTS += c.videoDT
+
+				packet := &rtp.Packet{
+					Header:  rtp.Header{Timestamp: c.videoTS},
+					Payload: h264.AnnexB2AVC(b[8:]),
+				}
+
+				//log.Printf("[DVR] %v, len: %d, ts: %10d", h265.Types(packet.Payload), len(packet.Payload), packet.Timestamp)
+
+				c.videoTrack.WriteRTP(packet)
+			}
+
+		case 0x1FA, 0x1F9: // audio
+			if c.audioTrack == nil {
+				// the exact value of the start TS does not matter
+				c.audioTS = c.videoTS
+
+				c.AddAudioTrack(b[4], b[5])
+			}
+
+			if c.audioTrack != nil {
+				for b != nil {
+					payload := b[8:size]
+					if len(b) > size {
+						b = b[size:]
+					} else {
+						b = nil
+					}
+
+					c.audioTS += uint32(len(payload))
+					c.audioSeq++
+
+					packet := &rtp.Packet{
+						Header: rtp.Header{
+							Version:        2,
+							Marker:         true,
+							SequenceNumber: c.audioSeq,
+							Timestamp:      c.audioTS,
+						},
+						Payload: payload,
+					}
+
+					//log.Printf("[DVR] len: %d, ts: %10d", len(packet.Payload), packet.Timestamp)
+
+					c.audioTrack.WriteRTP(packet)
+				}
+			}
+		}
+
+		if probe != 0 {
+			probe++
+			if (c.videoTS > 0 && c.audioTS > 0) || probe == 20 {
+				return nil
+			}
+		}
+
+		size = 0
+	}
+}
+
+func (c *Client) Close() error {
+	return c.conn.Close()
+}
+
+func (c *Client) Request(cmd uint16, data string) (err error) {
+	b := make([]byte, 20, 128)
+	b[0] = 255
+	binary.LittleEndian.PutUint32(b[4:], c.session)
+	binary.LittleEndian.PutUint32(b[8:], c.seq)
+	binary.LittleEndian.PutUint16(b[14:], cmd)
+	binary.LittleEndian.PutUint32(b[16:], uint32(len(data))+2)
+	b = append(b, data...)
+	b = append(b, 0x0A, 0x00)
+
+	c.seq++
+
+	if err = c.conn.SetWriteDeadline(time.Now().Add(time.Second * 5)); err != nil {
+		return
+	}
+
+	_, err = c.conn.Write(b)
+	return
+}
+
+func (c *Client) Response() (b []byte, err error) {
+	if err = c.conn.SetReadDeadline(time.Now().Add(time.Second * 5)); err != nil {
+		return
+	}
+
+	b = make([]byte, 20)
+	if _, err = io.ReadFull(c.reader, b); err != nil {
+		return
+	}
+
+	c.recv += 20
+
+	if b[0] != 255 {
+		return nil, errors.New("read error")
+	}
+
+	c.session = binary.LittleEndian.Uint32(b[4:])
+	size := binary.LittleEndian.Uint32(b[16:])
+
+	b = make([]byte, size)
+	if _, err = io.ReadFull(c.reader, b); err != nil {
+		return
+	}
+
+	c.recv += size
+
+	return
+}
+
+func (c *Client) ResponseJSON() (res Response, err error) {
+	b, err := c.Response()
+	if err != nil {
+		return
+	}
+
+	res = Response{}
+	if err = json.Unmarshal(b[:len(b)-2], &res); err != nil {
+		return
+	}
+
+	if v, ok := res["Ret"].(float64); !ok || (v != 100 && v != 515) {
+		err = fmt.Errorf("wrong response: %s", b)
+	}
+	return
+}
+
+func (c *Client) AddVideoTrack(mediaCode byte, payload []byte) {
+	var codec *core.Codec
+	switch mediaCode {
+	case 2:
+		codec = &core.Codec{
+			Name:        core.CodecH264,
+			ClockRate:   90000,
+			PayloadType: core.PayloadTypeRAW,
+			FmtpLine:    h264.GetFmtpLine(payload),
+		}
+
+	case 0x03, 0x13:
+		codec = &core.Codec{
+			Name:        core.CodecH265,
+			ClockRate:   90000,
+			PayloadType: core.PayloadTypeRAW,
+			FmtpLine:    "profile-id=1",
+		}
+
+		for {
+			size := 4 + int(binary.BigEndian.Uint32(payload))
+
+			switch h265.NALUType(payload) {
+			case h265.NALUTypeVPS:
+				codec.FmtpLine += ";sprop-vps=" + base64.StdEncoding.EncodeToString(payload[4:size])
+			case h265.NALUTypeSPS:
+				codec.FmtpLine += ";sprop-sps=" + base64.StdEncoding.EncodeToString(payload[4:size])
+			case h265.NALUTypePPS:
+				codec.FmtpLine += ";sprop-pps=" + base64.StdEncoding.EncodeToString(payload[4:size])
+			}
+
+			if size < len(payload) {
+				payload = payload[size:]
+			} else {
+				break
+			}
+		}
+	default:
+		println("[DVRIP] unsupported video codec:", mediaCode)
+		return
+	}
+
+	media := &core.Media{
+		Kind:      core.KindVideo,
+		Direction: core.DirectionRecvonly,
+		Codecs:    []*core.Codec{codec},
+	}
+	c.medias = append(c.medias, media)
+
+	c.videoTrack = core.NewReceiver(media, codec)
+	c.receivers = append(c.receivers, c.videoTrack)
+}
+
+var sampleRates = []uint32{4000, 8000, 11025, 16000, 20000, 22050, 32000, 44100, 48000}
+
+func (c *Client) AddAudioTrack(mediaCode byte, sampleRate byte) {
+	// https://github.com/vigoss30611/buildroot-ltc/blob/master/system/qm/ipc/ProtocolService/src/ZhiNuo/inc/zn_dh_base_type.h
+	// PCM8 = 7, G729, IMA_ADPCM, G711U, G721, PCM8_VWIS, MS_ADPCM, G711A, PCM16
+	var codec *core.Codec
+	switch mediaCode {
+	case 10: // G711U
+		codec = &core.Codec{
+			Name: core.CodecPCMU,
+		}
+	case 14: // G711A
+		codec = &core.Codec{
+			Name: core.CodecPCMA,
+		}
+	default:
+		println("[DVRIP] unsupported audio codec:", mediaCode)
+		return
+	}
+
+	if sampleRate <= byte(len(sampleRates)) {
+		codec.ClockRate = sampleRates[sampleRate-1]
+	}
+
+	media := &core.Media{
+		Kind:      core.KindAudio,
+		Direction: core.DirectionRecvonly,
+		Codecs:    []*core.Codec{codec},
+	}
+	c.medias = append(c.medias, media)
+
+	c.audioTrack = core.NewReceiver(media, codec)
+	c.receivers = append(c.receivers, c.audioTrack)
+}
+
+func SofiaHash(password string) string {
+	const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+
+	sofia := make([]byte, 0, 8)
+	hash := md5.Sum([]byte(password))
+	for i := 0; i < md5.Size; i += 2 {
+		j := uint16(hash[i]) + uint16(hash[i+1])
+		sofia = append(sofia, chars[j%62])
+	}
+
+	return string(sofia)
+}

pkg/dvrip/producer.go

@@ -0,0 +1,41 @@
+package dvrip
+
+import (
+	"encoding/json"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func (c *Client) GetMedias() []*core.Media {
+	return c.medias
+}
+
+func (c *Client) GetTrack(media *core.Media, codec *core.Codec) (*core.Receiver, error) {
+	for _, track := range c.receivers {
+		if track.Codec == codec {
+			return track, nil
+		}
+	}
+	return nil, core.ErrCantGetTrack
+}
+
+func (c *Client) Start() error {
+	return c.Handle()
+}
+
+func (c *Client) Stop() error {
+	for _, receiver := range c.receivers {
+		receiver.Close()
+	}
+	return c.Close()
+}
+
+func (c *Client) MarshalJSON() ([]byte, error) {
+	info := &core.Info{
+		Type:       "DVRIP active producer",
+		RemoteAddr: c.conn.RemoteAddr().String(),
+		Medias:     c.medias,
+		Receivers:  c.receivers,
+		Recv:       int(c.recv),
+	}
+	return json.Marshal(info)
+}

pkg/h264/README.md

@@ -1,38 +1,6 @@
 # H264
 
-Access Unit (AU) can contain one or multiple NAL Unit:
-
-1. [SEI,] SPS, PPS, IFrame, [IFrame...]
-2. BFrame, [BFrame...]
-3. IFrame, [IFrame...]
-
-## RTP H264
-
-Camera | NALu
--------|-----
-EZVIZ C3S          | 7f, 8f, 28:28:28 -> 5t, 28:28:28 -> 1t, 1t, 1t, 1t
-Sonoff GK-200MP2-B | 28:28:28 -> 5t, 1t, 1t, 1t
-Dahua IPC-K42      | 7f, 8f, 28:28:28 -> 5t, 28:28:28 -> 1t, 28:28:28 -> 1t
-FFmpeg copy        | 5t, 1t, 1t, 28:28:28 -> 1t, 28:28:28 -> 1t
-FFmpeg h264        | 24 -> 6:5:5:5:5t, 24 -> 1:1:1:1t, 28:28:28 -> 5f, 28:28:28 -> 5f, 28:28:28 -> 5t
-FFmpeg resize      | 6f, 28:28:28 -> 5f, 28... -> 5t, 24 -> 1:1f, 24 -> 1:1t
-
-## WebRTC
-
-Video codec	    | Media string | Device
-----------------|--------------|-------
-H.264/baseline! | avc1.42E0xx  | Chromecast
-H.264/baseline! | avc1.42E0xx  | Chrome/Safari WebRTC
-H.264/baseline! | avc1.42C0xx  | FFmpeg ultrafast
-H.264/baseline! | avc1.4240xx  | Dahua H264B
-H.264/baseline  | avc1.4200xx  | Chrome WebRTC
-H.264/main!     | avc1.4D40xx  | Chromecast
-H.264/main!     | avc1.4D40xx  | FFmpeg superfast main
-H.264/main!     | avc1.4D40xx  | Dahua H264
-H.264/main      | avc1.4D00xx  | Chrome WebRTC
-H.264/high!     | avc1.640Cxx  | Safari WebRTC
-H.264/high      | avc1.6400xx  | Chromecast
-H.264/high      | avc1.6400xx  | FFmpeg superfast
+Payloader code taken from [pion](https://github.com/pion/rtp) library. And changed to AVC packets support.
 
 ## Useful Links
 

pkg/h264/avc.go

@@ -1,11 +1,147 @@
 package h264
 
 import (
+	"bytes"
 	"encoding/binary"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/pion/rtp"
 )
 
+func AnnexB2AVC(b []byte) []byte {
+	for i := 0; i < len(b); {
+		if i+4 >= len(b) {
+			break
+		}
+
+		size := bytes.Index(b[i+4:], []byte{0, 0, 0, 1})
+		if size < 0 {
+			size = len(b) - (i + 4)
+		}
+
+		binary.BigEndian.PutUint32(b[i:], uint32(size))
+
+		i += size + 4
+	}
+
+	return b
+}
+
+const forbiddenZeroBit = 0x80
+const nalUnitType = 0x1F
+
+// DecodeStream - find and return first AU in AVC format
+// useful for processing live streams with unknown separator size
+func DecodeStream(annexb []byte) ([]byte, int) {
+	startPos := -1
+
+	i := 0
+	for {
+		// search next separator
+		if i = IndexFrom(annexb, []byte{0, 0, 1}, i); i < 0 {
+			break
+		}
+
+		// move i to next AU
+		if i += 3; i >= len(annexb) {
+			break
+		}
+
+		// check if AU type valid
+		octet := annexb[i]
+		if octet&forbiddenZeroBit != 0 {
+			continue
+		}
+
+		// 0 => AUD => SPS/IF/PF => AUD
+		// 0 => SPS/PF => SPS/PF
+		nalType := octet & nalUnitType
+		if startPos >= 0 {
+			switch nalType {
+			case NALUTypeAUD, NALUTypeSPS, NALUTypePFrame:
+				if annexb[i-4] == 0 {
+					return DecodeAnnexB(annexb[startPos : i-4]), i - 4
+				} else {
+					return DecodeAnnexB(annexb[startPos : i-3]), i - 3
+				}
+			}
+		} else {
+			switch nalType {
+			case NALUTypeSPS, NALUTypePFrame:
+				if i >= 4 && annexb[i-4] == 0 {
+					startPos = i - 4
+				} else {
+					startPos = i - 3
+				}
+			}
+		}
+	}
+
+	return nil, 0
+}
+
+// DecodeAnnexB - convert AnnexB to AVC format
+// support unknown separator size
+func DecodeAnnexB(b []byte) []byte {
+	if b[2] == 1 {
+		// convert: 0 0 1 => 0 0 0 1
+		b = append([]byte{0}, b...)
+	}
+
+	startPos := 0
+
+	i := 4
+	for {
+		// search next separato
+		if i = IndexFrom(b, []byte{0, 0, 1}, i); i < 0 {
+			break
+		}
+
+		// move i to next AU
+		if i += 3; i >= len(b) {
+			break
+		}
+
+		// check if AU type valid
+		octet := b[i]
+		if octet&forbiddenZeroBit != 0 {
+			continue
+		}
+
+		switch octet & nalUnitType {
+		case NALUTypePFrame, NALUTypeIFrame, NALUTypeSPS, NALUTypePPS:
+			if b[i-4] != 0 {
+				// prefix: 0 0 1
+				binary.BigEndian.PutUint32(b[startPos:], uint32(i-startPos-7))
+				tmp := make([]byte, 0, len(b)+1)
+				tmp = append(tmp, b[:i]...)
+				tmp = append(tmp, 0)
+				b = append(tmp, b[i:]...)
+				startPos = i - 3
+			} else {
+				// prefix: 0 0 0 1
+				binary.BigEndian.PutUint32(b[startPos:], uint32(i-startPos-8))
+				startPos = i - 4
+			}
+		}
+	}
+
+	binary.BigEndian.PutUint32(b[startPos:], uint32(len(b)-startPos-4))
+	return b
+}
+
+func IndexFrom(b []byte, sep []byte, from int) int {
+	if from > 0 {
+		if from < len(b) {
+			if i := bytes.Index(b[from:], sep); i >= 0 {
+				return from + i
+			}
+		}
+		return -1
+	}
+
+	return bytes.Index(b, sep)
+}
+
 func EncodeAVC(nals ...[]byte) (avc []byte) {
 	var i, n int
 
@@ -28,17 +164,15 @@ func EncodeAVC(nals ...[]byte) (avc []byte) {
 	return
 }
 
-func RepairAVC(track *streamer.Track) streamer.WrapperFunc {
-	sps, pps := GetParameterSet(track.Codec.FmtpLine)
+func RepairAVC(codec *core.Codec, handler core.HandlerFunc) core.HandlerFunc {
+	sps, pps := GetParameterSet(codec.FmtpLine)
 	ps := EncodeAVC(sps, pps)
 
-	return func(push streamer.WriterFunc) streamer.WriterFunc {
-		return func(packet *rtp.Packet) (err error) {
-			if NALUType(packet.Payload) == NALUTypeIFrame {
-				packet.Payload = Join(ps, packet.Payload)
-			}
-			return push(packet)
+	return func(packet *rtp.Packet) {
+		if NALUType(packet.Payload) == NALUTypeIFrame {
+			packet.Payload = Join(ps, packet.Payload)
 		}
+		handler(packet)
 	}
 }
 

pkg/h264/helper.go

@@ -3,7 +3,9 @@ package h264
 import (
 	"encoding/base64"
 	"encoding/binary"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"encoding/hex"
+	"fmt"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	"strings"
 )
 
@@ -47,11 +49,39 @@ func Join(ps, iframe []byte) []byte {
 	return b
 }
 
+// GetProfileLevelID - get profile from fmtp line
+// Some devices won't play video with high level, so limit max profile and max level.
+// And return some profile even if fmtp line is empty.
 func GetProfileLevelID(fmtp string) string {
-	if fmtp == "" {
-		return ""
+	// avc1.640029 - H.264 high 4.1 (Chromecast 1st and 2nd Gen)
+	profile := byte(0x64)
+	capab := byte(0)
+	level := byte(0x29)
+
+	if fmtp != "" {
+		var conf []byte
+		// some cameras has wrong profile-level-id
+		// https://github.com/AlexxIT/go2rtc/issues/155
+		if s := core.Between(fmtp, "sprop-parameter-sets=", ","); s != "" {
+			if sps, _ := base64.StdEncoding.DecodeString(s); len(sps) >= 4 {
+				conf = sps[1:4]
+			}
+		} else if s = core.Between(fmtp, "profile-level-id=", ";"); s != "" {
+			conf, _ = hex.DecodeString(s)
+		}
+
+		if conf != nil {
+			if conf[0] < profile {
+				profile = conf[0]
+				capab = conf[1]
+			}
+			if conf[2] < level {
+				level = conf[2]
+			}
+		}
 	}
-	return streamer.Between(fmtp, "profile-level-id=", ";")
+
+	return fmt.Sprintf("%02X%02X%02X", profile, capab, level)
 }
 
 func GetParameterSet(fmtp string) (sps, pps []byte) {
@@ -59,7 +89,7 @@ func GetParameterSet(fmtp string) (sps, pps []byte) {
 		return
 	}
 
-	s := streamer.Between(fmtp, "sprop-parameter-sets=", ";")
+	s := core.Between(fmtp, "sprop-parameter-sets=", ";")
 	if s == "" {
 		return
 	}
@@ -74,3 +104,26 @@ func GetParameterSet(fmtp string) (sps, pps []byte) {
 
 	return
 }
+
+// GetFmtpLine from SPS+PPS+IFrame in AVC format
+func GetFmtpLine(avc []byte) string {
+	s := "packetization-mode=1"
+
+	for {
+		size := 4 + int(binary.BigEndian.Uint32(avc))
+
+		switch NALUType(avc) {
+		case NALUTypeSPS:
+			s += ";profile-level-id=" + hex.EncodeToString(avc[5:8])
+			s += ";sprop-parameter-sets=" + base64.StdEncoding.EncodeToString(avc[4:size])
+		case NALUTypePPS:
+			s += "," + base64.StdEncoding.EncodeToString(avc[4:size])
+		}
+
+		if size < len(avc) {
+			avc = avc[size:]
+		} else {
+			return s
+		}
+	}
+}

pkg/h264/payloader.go

@@ -4,8 +4,8 @@ import "encoding/binary"
 
 // Payloader payloads H264 packets
 type Payloader struct {
-	IsAVC            bool
-	spsNalu, ppsNalu []byte
+	IsAVC     bool
+	stapANalu []byte
 }
 
 const (
@@ -31,7 +31,7 @@ const (
 
 //func annexbNALUStartCode() []byte { return []byte{0x00, 0x00, 0x00, 0x01} }
 
-func emitNalus(nals []byte, isAVC bool, emit func([]byte)) {
+func EmitNalus(nals []byte, isAVC bool, emit func([]byte)) {
 	if !isAVC {
 		nextInd := func(nalu []byte, start int) (indStart int, indLen int) {
 			zeroCount := 0
@@ -84,7 +84,7 @@ func (p *Payloader) Payload(mtu uint16, payload []byte) [][]byte {
 		return payloads
 	}
 
-	emitNalus(payload, p.IsAVC, func(nalu []byte) {
+	EmitNalus(payload, p.IsAVC, func(nalu []byte) {
 		if len(nalu) == 0 {
 			return
 		}
@@ -92,36 +92,25 @@ func (p *Payloader) Payload(mtu uint16, payload []byte) [][]byte {
 		naluType := nalu[0] & naluTypeBitmask
 		naluRefIdc := nalu[0] & naluRefIdcBitmask
 
-		switch {
-		case naluType == audNALUType || naluType == fillerNALUType:
+		switch naluType {
+		case audNALUType, fillerNALUType:
 			return
-		case naluType == spsNALUType:
-			p.spsNalu = nalu
-			return
-		case naluType == ppsNALUType:
-			p.ppsNalu = nalu
-			return
-		case p.spsNalu != nil && p.ppsNalu != nil:
-			// Pack current NALU with SPS and PPS as STAP-A
-			spsLen := make([]byte, 2)
-			binary.BigEndian.PutUint16(spsLen, uint16(len(p.spsNalu)))
-
-			ppsLen := make([]byte, 2)
-			binary.BigEndian.PutUint16(ppsLen, uint16(len(p.ppsNalu)))
-
-			stapANalu := []byte{outputStapAHeader}
-			stapANalu = append(stapANalu, spsLen...)
-			stapANalu = append(stapANalu, p.spsNalu...)
-			stapANalu = append(stapANalu, ppsLen...)
-			stapANalu = append(stapANalu, p.ppsNalu...)
-			if len(stapANalu) <= int(mtu) {
-				out := make([]byte, len(stapANalu))
-				copy(out, stapANalu)
-				payloads = append(payloads, out)
+		case spsNALUType, ppsNALUType:
+			if p.stapANalu == nil {
+				p.stapANalu = []byte{outputStapAHeader}
 			}
+			p.stapANalu = append(p.stapANalu, byte(len(nalu)>>8), byte(len(nalu)))
+			p.stapANalu = append(p.stapANalu, nalu...)
+			return
+		}
 
-			p.spsNalu = nil
-			p.ppsNalu = nil
+		if p.stapANalu != nil {
+			// Pack current NALU with SPS and PPS as STAP-A
+			// Supports multiple PPS in a row
+			if len(p.stapANalu) <= int(mtu) {
+				payloads = append(payloads, p.stapANalu)
+			}
+			p.stapANalu = nil
 		}
 
 		// Single NALU

pkg/h264/rtp.go

@@ -2,40 +2,47 @@ package h264
 
 import (
 	"encoding/binary"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/pion/rtp"
 	"github.com/pion/rtp/codecs"
 )
 
 const RTPPacketVersionAVC = 0
 
-func RTPDepay(track *streamer.Track) streamer.WrapperFunc {
+const PSMaxSize = 128 // the biggest SPS I've seen is 48 (EZVIZ CS-CV210)
+
+func RTPDepay(codec *core.Codec, handler core.HandlerFunc) core.HandlerFunc {
 	depack := &codecs.H264Packet{IsAVC: true}
 
-	sps, pps := GetParameterSet(track.Codec.FmtpLine)
+	sps, pps := GetParameterSet(codec.FmtpLine)
 	ps := EncodeAVC(sps, pps)
 
 	buf := make([]byte, 0, 512*1024) // 512K
 
-	return func(push streamer.WriterFunc) streamer.WriterFunc {
-		return func(packet *rtp.Packet) error {
-			//log.Printf("[RTP] codec: %s, nalu: %2d, size: %6d, ts: %10d, pt: %2d, ssrc: %d, seq: %d, %v", track.Codec.Name, packet.Payload[0]&0x1F, len(packet.Payload), packet.Timestamp, packet.PayloadType, packet.SSRC, packet.SequenceNumber, packet.Marker)
+	return func(packet *rtp.Packet) {
+		//log.Printf("[RTP] codec: %s, nalu: %2d, size: %6d, ts: %10d, pt: %2d, ssrc: %d, seq: %d, %v", track.Codec.Name, packet.Payload[0]&0x1F, len(packet.Payload), packet.Timestamp, packet.PayloadType, packet.SSRC, packet.SequenceNumber, packet.Marker)
 
-			payload, err := depack.Unmarshal(packet.Payload)
-			if len(payload) == 0 || err != nil {
-				return nil
+		payload, err := depack.Unmarshal(packet.Payload)
+		if len(payload) == 0 || err != nil {
+			return
+		}
+
+		// Fix TP-Link Tapo TC70: sends SPS and PPS with packet.Marker = true
+		// Reolink Duo 2: sends SPS with Marker and PPS without
+		if packet.Marker && len(payload) < PSMaxSize {
+			switch NALUType(payload) {
+			case NALUTypeSPS, NALUTypePPS:
+				buf = append(buf, payload...)
+				return
+			case NALUTypeSEI:
+				// RtspServer https://github.com/AlexxIT/go2rtc/issues/244
+				// sends, marked SPS, marked PPS, marked SEI, marked IFrame
+				return
 			}
+		}
 
-			// Fix TP-Link Tapo TC70: sends SPS and PPS with packet.Marker = true
-			if packet.Marker {
-				switch NALUType(payload) {
-				case NALUTypeSPS, NALUTypePPS:
-					buf = append(buf, payload...)
-					return nil
-				}
-			}
-
-			if len(buf) == 0 {
+		if len(buf) == 0 {
+			for {
 				// Amcrest IP4M-1051: 9, 7, 8, 6, 28...
 				// Amcrest IP4M-1051: 9, 6, 1
 				switch NALUType(payload) {
@@ -48,67 +55,68 @@ func RTPDepay(track *streamer.Track) streamer.WrapperFunc {
 
 					// check if only one NAL (fix ffmpeg transcoding for Reolink RLC-510A)
 					if i == len(payload) {
-						return nil
+						return
 					}
 
 					payload = payload[i:]
-
-					if NALUType(payload) == NALUTypeIFrame {
-						buf = append(buf, ps...)
-					}
+					continue
 				}
+				break
 			}
-
-			// collect all NALs for Access Unit
-			if !packet.Marker {
-				buf = append(buf, payload...)
-				return nil
-			}
-
-			if len(buf) > 0 {
-				payload = append(buf, payload...)
-				buf = buf[:0]
-			}
-
-			//log.Printf("[AVC] %v, len: %d", Types(payload), len(payload))
-
-			clone := *packet
-			clone.Version = RTPPacketVersionAVC
-			clone.Payload = payload
-			return push(&clone)
 		}
+
+		// collect all NALs for Access Unit
+		if !packet.Marker {
+			buf = append(buf, payload...)
+			return
+		}
+
+		if len(buf) > 0 {
+			payload = append(buf, payload...)
+			buf = buf[:0]
+		}
+
+		// should not be that huge SPS
+		if NALUType(payload) == NALUTypeSPS && binary.BigEndian.Uint32(payload) >= PSMaxSize {
+			// some Chinese buggy cameras has single packet with SPS+PPS+IFrame separated by 00 00 00 01
+			// https://github.com/AlexxIT/WebRTC/issues/391
+			// https://github.com/AlexxIT/WebRTC/issues/392
+			AnnexB2AVC(payload)
+		}
+
+		//log.Printf("[AVC] %v, len: %d, ts: %10d, seq: %d", Types(payload), len(payload), packet.Timestamp, packet.SequenceNumber)
+
+		clone := *packet
+		clone.Version = RTPPacketVersionAVC
+		clone.Payload = payload
+		handler(&clone)
 	}
 }
 
-func RTPPay(mtu uint16) streamer.WrapperFunc {
+func RTPPay(mtu uint16, handler core.HandlerFunc) core.HandlerFunc {
 	payloader := &Payloader{IsAVC: true}
 	sequencer := rtp.NewRandomSequencer()
 	mtu -= 12 // rtp.Header size
 
-	return func(push streamer.WriterFunc) streamer.WriterFunc {
-		return func(packet *rtp.Packet) error {
-			if packet.Version != RTPPacketVersionAVC {
-				return push(packet)
-			}
+	return func(packet *rtp.Packet) {
+		if packet.Version != RTPPacketVersionAVC {
+			handler(packet)
+			return
+		}
 
-			payloads := payloader.Payload(mtu, packet.Payload)
-			last := len(payloads) - 1
-			for i, payload := range payloads {
-				clone := rtp.Packet{
-					Header: rtp.Header{
-						Version:        2,
-						Marker:         i == last,
-						SequenceNumber: sequencer.NextSequenceNumber(),
-						Timestamp:      packet.Timestamp,
-					},
-					Payload: payload,
-				}
-				if err := push(&clone); err != nil {
-					return err
-				}
+		payloads := payloader.Payload(mtu, packet.Payload)
+		last := len(payloads) - 1
+		for i, payload := range payloads {
+			clone := rtp.Packet{
+				Header: rtp.Header{
+					Version:        2,
+					Marker:         i == last,
+					SequenceNumber: sequencer.NextSequenceNumber(),
+					Timestamp:      packet.Timestamp,
+				},
+				Payload: payload,
 			}
-
-			return nil
+			handler(&clone)
 		}
 	}
 }

pkg/h265/README.md

@@ -1,3 +1,7 @@
+# H265
+
+Payloader code taken from [pion](https://github.com/pion/rtp) library branch [h265](https://github.com/pion/rtp/tree/h265). Because it's still not in release. Thanks to [@kevmo314](https://github.com/kevmo314).
+
 ## Useful links
 
 - https://datatracker.ietf.org/doc/html/rfc7798

pkg/h265/helper.go

@@ -3,18 +3,20 @@ package h265
 import (
 	"encoding/base64"
 	"encoding/binary"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 )
 
 const (
-	NALUTypePFrame  = 1
-	NALUTypeIFrame  = 19
-	NALUTypeIFrame2 = 20
-	NALUTypeIFrame3 = 21
-	NALUTypeVPS     = 32
-	NALUTypeSPS     = 33
-	NALUTypePPS     = 34
-	NALUTypeFU      = 49
+	NALUTypePFrame    = 1
+	NALUTypeIFrame    = 19
+	NALUTypeIFrame2   = 20
+	NALUTypeIFrame3   = 21
+	NALUTypeVPS       = 32
+	NALUTypeSPS       = 33
+	NALUTypePPS       = 34
+	NALUTypePrefixSEI = 39
+	NALUTypeSuffixSEI = 40
+	NALUTypeFU        = 49
 )
 
 func NALUType(b []byte) byte {
@@ -60,13 +62,13 @@ func GetParameterSet(fmtp string) (vps, sps, pps []byte) {
 		return
 	}
 
-	s := streamer.Between(fmtp, "sprop-vps=", ";")
+	s := core.Between(fmtp, "sprop-vps=", ";")
 	vps, _ = base64.StdEncoding.DecodeString(s)
 
-	s = streamer.Between(fmtp, "sprop-sps=", ";")
+	s = core.Between(fmtp, "sprop-sps=", ";")
 	sps, _ = base64.StdEncoding.DecodeString(s)
 
-	s = streamer.Between(fmtp, "sprop-pps=", ";")
+	s = core.Between(fmtp, "sprop-pps=", ";")
 	pps, _ = base64.StdEncoding.DecodeString(s)
 
 	return

pkg/h265/payloader.go

@@ -0,0 +1,300 @@
+package h265
+
+import (
+	"encoding/binary"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"math"
+)
+
+//
+// Network Abstraction Unit Header implementation
+//
+
+const (
+	// sizeof(uint16)
+	h265NaluHeaderSize = 2
+	// https://datatracker.ietf.org/doc/html/rfc7798#section-4.4.2
+	h265NaluAggregationPacketType = 48
+	// https://datatracker.ietf.org/doc/html/rfc7798#section-4.4.3
+	h265NaluFragmentationUnitType = 49
+	// https://datatracker.ietf.org/doc/html/rfc7798#section-4.4.4
+	h265NaluPACIPacketType = 50
+)
+
+// H265NALUHeader is a H265 NAL Unit Header
+// https://datatracker.ietf.org/doc/html/rfc7798#section-1.1.4
+// +---------------+---------------+
+//
+//	|0|1|2|3|4|5|6|7|0|1|2|3|4|5|6|7|
+//	+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//	|F|   Type    |  LayerID  | TID |
+//	+-------------+-----------------+
+type H265NALUHeader uint16
+
+func newH265NALUHeader(highByte, lowByte uint8) H265NALUHeader {
+	return H265NALUHeader((uint16(highByte) << 8) | uint16(lowByte))
+}
+
+// F is the forbidden bit, should always be 0.
+func (h H265NALUHeader) F() bool {
+	return (uint16(h) >> 15) != 0
+}
+
+// Type of NAL Unit.
+func (h H265NALUHeader) Type() uint8 {
+	// 01111110 00000000
+	const mask = 0b01111110 << 8
+	return uint8((uint16(h) & mask) >> (8 + 1))
+}
+
+// IsTypeVCLUnit returns whether or not the NAL Unit type is a VCL NAL unit.
+func (h H265NALUHeader) IsTypeVCLUnit() bool {
+	// Type is coded on 6 bits
+	const msbMask = 0b00100000
+	return (h.Type() & msbMask) == 0
+}
+
+// LayerID should always be 0 in non-3D HEVC context.
+func (h H265NALUHeader) LayerID() uint8 {
+	// 00000001 11111000
+	const mask = (0b00000001 << 8) | 0b11111000
+	return uint8((uint16(h) & mask) >> 3)
+}
+
+// TID is the temporal identifier of the NAL unit +1.
+func (h H265NALUHeader) TID() uint8 {
+	const mask = 0b00000111
+	return uint8(uint16(h) & mask)
+}
+
+// IsAggregationPacket returns whether or not the packet is an Aggregation packet.
+func (h H265NALUHeader) IsAggregationPacket() bool {
+	return h.Type() == h265NaluAggregationPacketType
+}
+
+// IsFragmentationUnit returns whether or not the packet is a Fragmentation Unit packet.
+func (h H265NALUHeader) IsFragmentationUnit() bool {
+	return h.Type() == h265NaluFragmentationUnitType
+}
+
+// IsPACIPacket returns whether or not the packet is a PACI packet.
+func (h H265NALUHeader) IsPACIPacket() bool {
+	return h.Type() == h265NaluPACIPacketType
+}
+
+//
+// Fragmentation Unit implementation
+//
+
+const (
+	// sizeof(uint8)
+	h265FragmentationUnitHeaderSize = 1
+)
+
+// H265FragmentationUnitHeader is a H265 FU Header
+// +---------------+
+// |0|1|2|3|4|5|6|7|
+// +-+-+-+-+-+-+-+-+
+// |S|E|  FuType   |
+// +---------------+
+type H265FragmentationUnitHeader uint8
+
+// S represents the start of a fragmented NAL unit.
+func (h H265FragmentationUnitHeader) S() bool {
+	const mask = 0b10000000
+	return ((h & mask) >> 7) != 0
+}
+
+// E represents the end of a fragmented NAL unit.
+func (h H265FragmentationUnitHeader) E() bool {
+	const mask = 0b01000000
+	return ((h & mask) >> 6) != 0
+}
+
+// FuType MUST be equal to the field Type of the fragmented NAL unit.
+func (h H265FragmentationUnitHeader) FuType() uint8 {
+	const mask = 0b00111111
+	return uint8(h) & mask
+}
+
+// Payloader payloads H265 packets
+type Payloader struct {
+	AddDONL         bool
+	SkipAggregation bool
+	donl            uint16
+}
+
+// Payload fragments a H265 packet across one or more byte arrays
+func (p *Payloader) Payload(mtu uint16, payload []byte) [][]byte {
+	var payloads [][]byte
+	if len(payload) == 0 {
+		return payloads
+	}
+
+	bufferedNALUs := make([][]byte, 0)
+	aggregationBufferSize := 0
+
+	flushBufferedNals := func() {
+		if len(bufferedNALUs) == 0 {
+			return
+		}
+		if len(bufferedNALUs) == 1 {
+			// emit this as a single NALU packet
+			nalu := bufferedNALUs[0]
+
+			if p.AddDONL {
+				buf := make([]byte, len(nalu)+2)
+
+				// copy the NALU header to the payload header
+				copy(buf[0:h265NaluHeaderSize], nalu[0:h265NaluHeaderSize])
+
+				// copy the DONL into the header
+				binary.BigEndian.PutUint16(buf[h265NaluHeaderSize:h265NaluHeaderSize+2], p.donl)
+
+				// write the payload
+				copy(buf[h265NaluHeaderSize+2:], nalu[h265NaluHeaderSize:])
+
+				p.donl++
+
+				payloads = append(payloads, buf)
+			} else {
+				// write the nalu directly to the payload
+				payloads = append(payloads, nalu)
+			}
+		} else {
+			// construct an aggregation packet
+			aggregationPacketSize := aggregationBufferSize + 2
+			buf := make([]byte, aggregationPacketSize)
+
+			layerID := uint8(math.MaxUint8)
+			tid := uint8(math.MaxUint8)
+			for _, nalu := range bufferedNALUs {
+				header := newH265NALUHeader(nalu[0], nalu[1])
+				headerLayerID := header.LayerID()
+				headerTID := header.TID()
+				if headerLayerID < layerID {
+					layerID = headerLayerID
+				}
+				if headerTID < tid {
+					tid = headerTID
+				}
+			}
+
+			binary.BigEndian.PutUint16(buf[0:2], (uint16(h265NaluAggregationPacketType)<<9)|(uint16(layerID)<<3)|uint16(tid))
+
+			index := 2
+			for i, nalu := range bufferedNALUs {
+				if p.AddDONL {
+					if i == 0 {
+						binary.BigEndian.PutUint16(buf[index:index+2], p.donl)
+						index += 2
+					} else {
+						buf[index] = byte(i - 1)
+						index++
+					}
+				}
+				binary.BigEndian.PutUint16(buf[index:index+2], uint16(len(nalu)))
+				index += 2
+				index += copy(buf[index:], nalu)
+			}
+			payloads = append(payloads, buf)
+		}
+		// clear the buffered NALUs
+		bufferedNALUs = make([][]byte, 0)
+		aggregationBufferSize = 0
+	}
+
+	h264.EmitNalus(payload, true, func(nalu []byte) {
+		if len(nalu) == 0 {
+			return
+		}
+
+		if len(nalu) <= int(mtu) {
+			// this nalu fits into a single packet, either it can be emitted as
+			// a single nalu or appended to the previous aggregation packet
+
+			marginalAggregationSize := len(nalu) + 2
+			if p.AddDONL {
+				marginalAggregationSize += 1
+			}
+
+			if aggregationBufferSize+marginalAggregationSize > int(mtu) {
+				flushBufferedNals()
+			}
+			bufferedNALUs = append(bufferedNALUs, nalu)
+			aggregationBufferSize += marginalAggregationSize
+			if p.SkipAggregation {
+				// emit this immediately.
+				flushBufferedNals()
+			}
+		} else {
+			// if this nalu doesn't fit in the current mtu, it needs to be fragmented
+			fuPacketHeaderSize := h265FragmentationUnitHeaderSize + 2 /* payload header size */
+			if p.AddDONL {
+				fuPacketHeaderSize += 2
+			}
+
+			// then, fragment the nalu
+			maxFUPayloadSize := int(mtu) - fuPacketHeaderSize
+
+			naluHeader := newH265NALUHeader(nalu[0], nalu[1])
+
+			// the nalu header is omitted from the fragmentation packet payload
+			nalu = nalu[h265NaluHeaderSize:]
+
+			if maxFUPayloadSize == 0 || len(nalu) == 0 {
+				return
+			}
+
+			// flush any buffered aggregation packets.
+			flushBufferedNals()
+
+			fullNALUSize := len(nalu)
+			for len(nalu) > 0 {
+				curentFUPayloadSize := len(nalu)
+				if curentFUPayloadSize > maxFUPayloadSize {
+					curentFUPayloadSize = maxFUPayloadSize
+				}
+
+				out := make([]byte, fuPacketHeaderSize+curentFUPayloadSize)
+
+				// write the payload header
+				binary.BigEndian.PutUint16(out[0:2], uint16(naluHeader))
+				out[0] = (out[0] & 0b10000001) | h265NaluFragmentationUnitType<<1
+
+				// write the fragment header
+				out[2] = byte(H265FragmentationUnitHeader(naluHeader.Type()))
+				if len(nalu) == fullNALUSize {
+					// Set start bit
+					out[2] |= 1 << 7
+				} else if len(nalu)-curentFUPayloadSize == 0 {
+					// Set end bit
+					out[2] |= 1 << 6
+				}
+
+				if p.AddDONL {
+					// write the DONL header
+					binary.BigEndian.PutUint16(out[3:5], p.donl)
+
+					p.donl++
+
+					// copy the fragment payload
+					copy(out[5:], nalu[0:curentFUPayloadSize])
+				} else {
+					// copy the fragment payload
+					copy(out[3:], nalu[0:curentFUPayloadSize])
+				}
+
+				// append the fragment to the payload
+				payloads = append(payloads, out)
+
+				// advance the nalu data pointer
+				nalu = nalu[curentFUPayloadSize:]
+			}
+		}
+	})
+
+	flushBufferedNals()
+
+	return payloads
+}

pkg/h265/rtp.go

@@ -2,146 +2,177 @@ package h265
 
 import (
 	"encoding/binary"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/AlexxIT/go2rtc/pkg/h264"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/pion/rtp"
 )
 
-func RTPDepay(track *streamer.Track) streamer.WrapperFunc {
-	//vps, sps, pps := GetParameterSet(track.Codec.FmtpLine)
+func RTPDepay(codec *core.Codec, handler core.HandlerFunc) core.HandlerFunc {
+	//vps, sps, pps := GetParameterSet(codec.FmtpLine)
 	//ps := h264.EncodeAVC(vps, sps, pps)
 
 	buf := make([]byte, 0, 512*1024) // 512K
 	var nuStart int
 
-	return func(push streamer.WriterFunc) streamer.WriterFunc {
-		return func(packet *rtp.Packet) error {
-			data := packet.Payload
-			nuType := (data[0] >> 1) & 0x3F
-			//log.Printf("[RTP] codec: %s, nalu: %2d, size: %6d, ts: %10d, pt: %2d, ssrc: %d, seq: %d, %v", track.Codec.Name, nuType, len(packet.Payload), packet.Timestamp, packet.PayloadType, packet.SSRC, packet.SequenceNumber, packet.Marker)
+	return func(packet *rtp.Packet) {
+		data := packet.Payload
+		nuType := (data[0] >> 1) & 0x3F
+		//log.Printf("[RTP] codec: %s, nalu: %2d, size: %6d, ts: %10d, pt: %2d, ssrc: %d, seq: %d, %v", track.Codec.Name, nuType, len(packet.Payload), packet.Timestamp, packet.PayloadType, packet.SSRC, packet.SequenceNumber, packet.Marker)
 
-			if nuType == NALUTypeFU {
-				switch data[2] >> 6 {
-				case 2: // begin
-					nuType = data[2] & 0x3F
+		// Fix for RtspServer https://github.com/AlexxIT/go2rtc/issues/244
+		if packet.Marker && len(data) < h264.PSMaxSize {
+			switch nuType {
+			case NALUTypeVPS, NALUTypeSPS, NALUTypePPS:
+				packet.Marker = false
+			case NALUTypePrefixSEI, NALUTypeSuffixSEI:
+				return
+			}
+		}
 
-					// push PS data before keyframe
-					//if len(buf) == 0 && nuType >= 19 && nuType <= 21 {
-					//	buf = append(buf, ps...)
-					//}
+		if nuType == NALUTypeFU {
+			switch data[2] >> 6 {
+			case 2: // begin
+				nuType = data[2] & 0x3F
+
+				// push PS data before keyframe
+				//if len(buf) == 0 && nuType >= 19 && nuType <= 21 {
+				//	buf = append(buf, ps...)
+				//}
 
-					nuStart = len(buf)
-					buf = append(buf, 0, 0, 0, 0) // NAL unit size
-					buf = append(buf, (data[0]&0x81)|(nuType<<1), data[1])
-					buf = append(buf, data[3:]...)
-					return nil
-				case 0: // continue
-					buf = append(buf, data[3:]...)
-					return nil
-				case 1: // end
-					buf = append(buf, data[3:]...)
-					binary.BigEndian.PutUint32(buf[nuStart:], uint32(len(buf)-nuStart-4))
-				}
-			} else {
 				nuStart = len(buf)
 				buf = append(buf, 0, 0, 0, 0) // NAL unit size
-				buf = append(buf, data...)
-				binary.BigEndian.PutUint32(buf[nuStart:], uint32(len(data)))
+				buf = append(buf, (data[0]&0x81)|(nuType<<1), data[1])
+				buf = append(buf, data[3:]...)
+				return
+			case 0: // continue
+				buf = append(buf, data[3:]...)
+				return
+			case 1: // end
+				buf = append(buf, data[3:]...)
+				binary.BigEndian.PutUint32(buf[nuStart:], uint32(len(buf)-nuStart-4))
 			}
+		} else {
+			nuStart = len(buf)
+			buf = append(buf, 0, 0, 0, 0) // NAL unit size
+			buf = append(buf, data...)
+			binary.BigEndian.PutUint32(buf[nuStart:], uint32(len(data)))
+		}
 
-			// collect all NAL Units for Access Unit
-			if !packet.Marker {
-				return nil
+		// collect all NAL Units for Access Unit
+		if !packet.Marker {
+			return
+		}
+
+		//log.Printf("[HEVC] %v, len: %d", Types(buf), len(buf))
+
+		clone := *packet
+		clone.Version = h264.RTPPacketVersionAVC
+		clone.Payload = buf
+
+		buf = buf[:0]
+
+		handler(&clone)
+	}
+}
+
+func RTPPay(mtu uint16, handler core.HandlerFunc) core.HandlerFunc {
+	payloader := &Payloader{}
+	sequencer := rtp.NewRandomSequencer()
+	mtu -= 12 // rtp.Header size
+
+	return func(packet *rtp.Packet) {
+		if packet.Version != h264.RTPPacketVersionAVC {
+			handler(packet)
+			return
+		}
+
+		payloads := payloader.Payload(mtu, packet.Payload)
+		last := len(payloads) - 1
+		for i, payload := range payloads {
+			clone := rtp.Packet{
+				Header: rtp.Header{
+					Version:        2,
+					Marker:         i == last,
+					SequenceNumber: sequencer.NextSequenceNumber(),
+					Timestamp:      packet.Timestamp,
+				},
+				Payload: payload,
 			}
-
-			//log.Printf("[HEVC] %v, len: %d", Types(buf), len(buf))
-
-			clone := *packet
-			clone.Version = h264.RTPPacketVersionAVC
-			clone.Payload = buf
-
-			buf = buf[:0]
-
-			return push(&clone)
+			handler(&clone)
 		}
 	}
 }
 
 // SafariPay - generate Safari friendly payload for H265
 // https://github.com/AlexxIT/Blog/issues/5
-func SafariPay(mtu uint16) streamer.WrapperFunc {
+func SafariPay(mtu uint16, handler core.HandlerFunc) core.HandlerFunc {
 	sequencer := rtp.NewRandomSequencer()
 	size := int(mtu - 12) // rtp.Header size
 
-	return func(push streamer.WriterFunc) streamer.WriterFunc {
-		return func(packet *rtp.Packet) error {
-			if packet.Version != h264.RTPPacketVersionAVC {
-				return push(packet)
+	return func(packet *rtp.Packet) {
+		if packet.Version != h264.RTPPacketVersionAVC {
+			handler(packet)
+			return
+		}
+
+		// protect original packets from modification
+		au := make([]byte, len(packet.Payload))
+		copy(au, packet.Payload)
+
+		var start byte
+
+		for i := 0; i < len(au); {
+			size := int(binary.BigEndian.Uint32(au[i:])) + 4
+
+			// convert AVC to Annex-B
+			au[i] = 0
+			au[i+1] = 0
+			au[i+2] = 0
+			au[i+3] = 1
+
+			switch NALUType(au[i:]) {
+			case NALUTypeIFrame, NALUTypeIFrame2, NALUTypeIFrame3:
+				start = 3
+			default:
+				if start == 0 {
+					start = 2
+				}
 			}
 
-			// protect original packets from modification
-			au := make([]byte, len(packet.Payload))
-			copy(au, packet.Payload)
+			i += size
+		}
 
-			var start byte
+		// rtp.Packet payload
+		b := make([]byte, 1, size)
+		size-- // minus header byte
 
-			for i := 0; i < len(au); {
-				size := int(binary.BigEndian.Uint32(au[i:])) + 4
+		for au != nil {
+			b[0] = start
 
-				// convert AVC to Annex-B
-				au[i] = 0
-				au[i+1] = 0
-				au[i+2] = 0
-				au[i+3] = 1
-
-				switch NALUType(au[i:]) {
-				case NALUTypeIFrame, NALUTypeIFrame2, NALUTypeIFrame3:
-					start = 3
-				default:
-					if start == 0 {
-						start = 2
-					}
-				}
-
-				i += size
+			if start > 1 {
+				start -= 2
 			}
 
-			// rtp.Packet payload
-			b := make([]byte, 1, size)
-			size-- // minus header byte
-
-			for au != nil {
-				b[0] = start
-
-				if start > 1 {
-					start -= 2
-				}
-
-				if len(au) > size {
-					b = append(b, au[:size]...)
-					au = au[size:]
-				} else {
-					b = append(b, au...)
-					au = nil
-				}
-
-				clone := rtp.Packet{
-					Header: rtp.Header{
-						Version:        2,
-						Marker:         au == nil,
-						SequenceNumber: sequencer.NextSequenceNumber(),
-						Timestamp:      packet.Timestamp,
-					},
-					Payload: b,
-				}
-				if err := push(&clone); err != nil {
-					return err
-				}
-
-				b = b[:1] // clear buffer
+			if len(au) > size {
+				b = append(b, au[:size]...)
+				au = au[size:]
+			} else {
+				b = append(b, au...)
+				au = nil
 			}
 
-			return nil
+			clone := rtp.Packet{
+				Header: rtp.Header{
+					Version:        2,
+					Marker:         au == nil,
+					SequenceNumber: sequencer.NextSequenceNumber(),
+					Timestamp:      packet.Timestamp,
+				},
+				Payload: b,
+			}
+			handler(&clone)
+
+			b = b[:1] // clear buffer
 		}
 	}
 }

pkg/hap/character.go

@@ -11,14 +11,14 @@ import (
 )
 
 type Character struct {
-	AID         int         `json:"aid,omitempty"`
-	IID         int         `json:"iid"`
-	Type        string      `json:"type,omitempty"`
-	Format      string      `json:"format,omitempty"`
-	Value       interface{} `json:"value,omitempty"`
-	Event       interface{} `json:"ev,omitempty"`
-	Perms       []string    `json:"perms,omitempty"`
-	Description string      `json:"description,omitempty"`
+	AID         int      `json:"aid,omitempty"`
+	IID         int      `json:"iid"`
+	Type        string   `json:"type,omitempty"`
+	Format      string   `json:"format,omitempty"`
+	Value       any      `json:"value,omitempty"`
+	Event       any      `json:"ev,omitempty"`
+	Perms       []string `json:"perms,omitempty"`
+	Description string   `json:"description,omitempty"`
 	//MaxDataLen int      `json:"maxDataLen"`
 
 	listeners map[io.Writer]bool
@@ -91,7 +91,7 @@ func (c *Character) GenerateEvent() (data []byte, err error) {
 }
 
 // Set new value and NotifyListeners
-func (c *Character) Set(v interface{}) (err error) {
+func (c *Character) Set(v any) (err error) {
 	if err = c.Write(v); err != nil {
 		return
 	}
@@ -99,7 +99,7 @@ func (c *Character) Set(v interface{}) (err error) {
 }
 
 // Write new value with right format
-func (c *Character) Write(v interface{}) (err error) {
+func (c *Character) Write(v any) (err error) {
 	switch c.Format {
 	case characteristic.FormatTLV8:
 		var data []byte
@@ -120,7 +120,7 @@ func (c *Character) Write(v interface{}) (err error) {
 }
 
 // ReadTLV8 value to right struct
-func (c *Character) ReadTLV8(v interface{}) (err error) {
+func (c *Character) ReadTLV8(v any) (err error) {
 	var data []byte
 	if data, err = base64.StdEncoding.DecodeString(c.Value.(string)); err != nil {
 		return

pkg/hap/conn.go

@@ -7,8 +7,8 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/AlexxIT/go2rtc/pkg/hap/mdns"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/brutella/hap"
 	"github.com/brutella/hap/chacha20poly1305"
 	"github.com/brutella/hap/curve25519"
@@ -26,7 +26,7 @@ import (
 
 // Conn for HomeKit. DevicePublic can be null.
 type Conn struct {
-	streamer.Element
+	core.Listener
 
 	DeviceAddress string // including port
 	DeviceID      string
@@ -35,7 +35,7 @@ type Conn struct {
 	ClientPrivate []byte
 
 	OnEvent func(res *http.Response)
-	Output  func(msg interface{})
+	Output  func(msg any)
 
 	conn         net.Conn
 	secure       *Secure

pkg/hap/helpers.go

@@ -38,7 +38,7 @@ type PairVerifyPayload struct {
 	Signature     []byte `tlv8:"10,optional"`
 }
 
-//func (c *Character) Unmarshal(value interface{}) error {
+//func (c *Character) Unmarshal(value any) error {
 //	switch c.Format {
 //	case characteristic.FormatTLV8:
 //		data, err := base64.StdEncoding.DecodeString(c.Value.(string))
@@ -50,7 +50,7 @@ type PairVerifyPayload struct {
 //	return nil
 //}
 
-//func (c *Character) Marshal(value interface{}) error {
+//func (c *Character) Marshal(value any) error {
 //	switch c.Format {
 //	case characteristic.FormatTLV8:
 //		data, err := tlv8.Marshal(value)

pkg/homekit/client.go

@@ -1,28 +1,30 @@
 package homekit
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
+	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/AlexxIT/go2rtc/pkg/hap"
 	"github.com/AlexxIT/go2rtc/pkg/hap/camera"
 	"github.com/AlexxIT/go2rtc/pkg/srtp"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/brutella/hap/characteristic"
 	"github.com/brutella/hap/rtp"
 	"net"
 	"net/url"
+	"sync/atomic"
 )
 
 type Client struct {
-	streamer.Element
+	core.Listener
 
 	conn   *hap.Conn
 	exit   chan error
 	server *srtp.Server
 	url    string
 
-	medias []*streamer.Media
-	tracks []*streamer.Track
+	medias    []*core.Media
+	receivers []*core.Receiver
 
 	sessions []*srtp.Session
 }
@@ -60,7 +62,7 @@ func (c *Client) Dial() error {
 	return nil
 }
 
-func (c *Client) GetMedias() []*streamer.Media {
+func (c *Client) GetMedias() []*core.Media {
 	if c.medias == nil {
 		c.medias = c.getMedias()
 	}
@@ -68,20 +70,20 @@ func (c *Client) GetMedias() []*streamer.Media {
 	return c.medias
 }
 
-func (c *Client) GetTrack(media *streamer.Media, codec *streamer.Codec) *streamer.Track {
-	for _, track := range c.tracks {
+func (c *Client) GetTrack(media *core.Media, codec *core.Codec) (*core.Receiver, error) {
+	for _, track := range c.receivers {
 		if track.Codec == codec {
-			return track
+			return track, nil
 		}
 	}
 
-	track := streamer.NewTrack(codec, media.Direction)
-	c.tracks = append(c.tracks, track)
-	return track
+	track := core.NewReceiver(media, codec)
+	c.receivers = append(c.receivers, track)
+	return track, nil
 }
 
 func (c *Client) Start() error {
-	if c.tracks == nil {
+	if c.receivers == nil {
 		return errors.New("producer without tracks")
 	}
 
@@ -159,11 +161,11 @@ func (c *Client) Start() error {
 		return err
 	}
 
-	for _, track := range c.tracks {
+	for _, track := range c.receivers {
 		switch track.Codec.Name {
-		case streamer.CodecH264:
+		case core.CodecH264:
 			vs.Track = track
-		case streamer.CodecELD:
+		case core.CodecELD:
 			as.Track = track
 		}
 	}
@@ -186,8 +188,8 @@ func (c *Client) Stop() error {
 	return err
 }
 
-func (c *Client) getMedias() []*streamer.Media {
-	var medias []*streamer.Media
+func (c *Client) getMedias() []*core.Media {
+	var medias []*core.Media
 
 	accs, err := c.conn.GetAccessories()
 	if err != nil {
@@ -204,20 +206,20 @@ func (c *Client) getMedias() []*streamer.Media {
 	}
 
 	for _, hkCodec := range v1.Codecs {
-		codec := &streamer.Codec{ClockRate: 90000}
+		codec := &core.Codec{ClockRate: 90000}
 
 		switch hkCodec.Type {
 		case rtp.VideoCodecType_H264:
-			codec.Name = streamer.CodecH264
+			codec.Name = core.CodecH264
 			codec.FmtpLine = "profile-level-id=420029"
 		default:
 			fmt.Printf("unknown codec: %d", hkCodec.Type)
 			continue
 		}
 
-		media := &streamer.Media{
-			Kind: streamer.KindVideo, Direction: streamer.DirectionSendonly,
-			Codecs: []*streamer.Codec{codec},
+		media := &core.Media{
+			Kind: core.KindVideo, Direction: core.DirectionRecvonly,
+			Codecs: []*core.Codec{codec},
 		}
 		medias = append(medias, media)
 	}
@@ -229,7 +231,7 @@ func (c *Client) getMedias() []*streamer.Media {
 	}
 
 	for _, hkCodec := range v2.Codecs {
-		codec := &streamer.Codec{
+		codec := &core.Codec{
 			Channels: uint16(hkCodec.Parameters.Channels),
 		}
 
@@ -246,7 +248,7 @@ func (c *Client) getMedias() []*streamer.Media {
 
 		switch hkCodec.Type {
 		case rtp.AudioCodecType_AAC_ELD:
-			codec.Name = streamer.CodecELD
+			codec.Name = core.CodecELD
 			// only this value supported by FFmpeg
 			codec.FmtpLine = "profile-level-id=1;mode=AAC-hbr;sizelength=13;indexlength=3;indexdeltalength=3;config=F8EC3000"
 		default:
@@ -254,12 +256,28 @@ func (c *Client) getMedias() []*streamer.Media {
 			continue
 		}
 
-		media := &streamer.Media{
-			Kind: streamer.KindAudio, Direction: streamer.DirectionSendonly,
-			Codecs: []*streamer.Codec{codec},
+		media := &core.Media{
+			Kind: core.KindAudio, Direction: core.DirectionRecvonly,
+			Codecs: []*core.Codec{codec},
 		}
 		medias = append(medias, media)
 	}
 
 	return medias
 }
+
+func (c *Client) MarshalJSON() ([]byte, error) {
+	var recv uint32
+	for _, session := range c.sessions {
+		recv += atomic.LoadUint32(&session.Recv)
+	}
+
+	info := &core.Info{
+		Type:      "HomeKit active producer",
+		URL:       c.conn.URL(),
+		Medias:    c.medias,
+		Receivers: c.receivers,
+		Recv:      int(recv),
+	}
+	return json.Marshal(info)
+}

pkg/httpflv/amf0.go

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

pkg/httpflv/flvio.go

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

pkg/httpflv/httpflv.go

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

pkg/isapi/client.go

@@ -0,0 +1,151 @@
+package isapi
+
+import (
+	"errors"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/tcp"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+)
+
+type Client struct {
+	core.Listener
+
+	url     string
+	channel string
+	conn    net.Conn
+
+	medias []*core.Media
+	sender *core.Sender
+	send   int
+}
+
+func NewClient(rawURL string) (*Client, error) {
+	// check if url is valid url
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	u.Scheme = "http"
+	u.Path = ""
+
+	return &Client{url: u.String()}, nil
+}
+
+func (c *Client) Dial() (err error) {
+	link := c.url + "/ISAPI/System/TwoWayAudio/channels"
+	req, err := http.NewRequest("GET", link, nil)
+	if err != nil {
+		return err
+	}
+
+	res, err := tcp.Do(req)
+	if err != nil {
+		return
+	}
+
+	if res.StatusCode != http.StatusOK {
+		tcp.Close(res)
+		return errors.New(res.Status)
+	}
+
+	b, err := io.ReadAll(res.Body)
+	if err != nil {
+		return err
+	}
+
+	xml := string(b)
+
+	codec := core.Between(xml, `<audioCompressionType>`, `<`)
+	switch codec {
+	case "G.711ulaw":
+		codec = core.CodecPCMU
+	case "G.711alaw":
+		codec = core.CodecPCMA
+	default:
+		return nil
+	}
+
+	c.channel = core.Between(xml, `<id>`, `<`)
+
+	media := &core.Media{
+		Kind:      core.KindAudio,
+		Direction: core.DirectionSendonly,
+		Codecs: []*core.Codec{
+			{Name: codec, ClockRate: 8000},
+		},
+	}
+	c.medias = append(c.medias, media)
+
+	return nil
+}
+
+func (c *Client) Open() (err error) {
+	link := c.url + "/ISAPI/System/TwoWayAudio/channels/" + c.channel
+
+	req, err := http.NewRequest("PUT", link+"/open", nil)
+	if err != nil {
+		return err
+	}
+
+	res, err := tcp.Do(req)
+	if err != nil {
+		return
+	}
+
+	tcp.Close(res)
+
+	ctx, pconn := tcp.WithConn()
+	req, err = http.NewRequestWithContext(ctx, "PUT", link+"/audioData", nil)
+	if err != nil {
+		return err
+	}
+
+	req.Header.Set("Content-Type", "application/octet-stream")
+	req.Header.Set("Content-Length", "0")
+
+	res, err = tcp.Do(req)
+	if err != nil {
+		return err
+	}
+
+	c.conn = *pconn
+
+	// just block until c.conn closed
+	b := make([]byte, 1)
+	_, _ = c.conn.Read(b)
+
+	tcp.Close(res)
+
+	return nil
+}
+
+func (c *Client) Close() (err error) {
+	link := c.url + "/ISAPI/System/TwoWayAudio/channels/" + c.channel + "/close"
+	req, err := http.NewRequest("PUT", link+"/open", nil)
+	if err != nil {
+		return err
+	}
+
+	res, err := tcp.Do(req)
+	if err != nil {
+		return err
+	}
+
+	tcp.Close(res)
+
+	return nil
+}
+
+//type XMLChannels struct {
+//	Channels []Channel `xml:"TwoWayAudioChannel"`
+//}
+
+//type Channel struct {
+//	ID      string `xml:"id"`
+//	Enabled string `xml:"enabled"`
+//	Codec   string `xml:"audioCompressionType"`
+//}

pkg/isapi/consumer.go

@@ -0,0 +1,63 @@
+package isapi
+
+import (
+	"encoding/json"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+)
+
+func (c *Client) GetMedias() []*core.Media {
+	return c.medias
+}
+
+func (c *Client) GetTrack(media *core.Media, codec *core.Codec) (*core.Receiver, error) {
+	return nil, core.ErrCantGetTrack
+}
+
+func (c *Client) AddTrack(media *core.Media, _ *core.Codec, track *core.Receiver) error {
+	if c.sender == nil {
+		c.sender = core.NewSender(media, track.Codec)
+		c.sender.Handler = func(packet *rtp.Packet) {
+			if c.conn == nil {
+				return
+			}
+			c.send += len(packet.Payload)
+			_, _ = c.conn.Write(packet.Payload)
+		}
+	}
+
+	c.sender.HandleRTP(track)
+	return nil
+}
+
+func (c *Client) Start() (err error) {
+	if err = c.Open(); err != nil {
+		return
+	}
+	return
+}
+
+func (c *Client) Stop() (err error) {
+	if c.sender != nil {
+		c.sender.Close()
+	}
+
+	if c.conn != nil {
+		_ = c.Close()
+		return c.conn.Close()
+	}
+
+	return nil
+}
+
+func (c *Client) MarshalJSON() ([]byte, error) {
+	info := &core.Info{
+		Type:   "ISAPI active consumer",
+		Medias: c.medias,
+		Send:   c.send,
+	}
+	if c.sender != nil {
+		info.Senders = []*core.Sender{c.sender}
+	}
+	return json.Marshal(info)
+}

pkg/iso/atoms.go

@@ -0,0 +1,318 @@
+package iso
+
+const (
+	Ftyp                        = "ftyp"
+	Moov                        = "moov"
+	MoovMvhd                    = "mvhd"
+	MoovTrak                    = "trak"
+	MoovTrakTkhd                = "tkhd"
+	MoovTrakMdia                = "mdia"
+	MoovTrakMdiaMdhd            = "mdhd"
+	MoovTrakMdiaHdlr            = "hdlr"
+	MoovTrakMdiaMinf            = "minf"
+	MoovTrakMdiaMinfVmhd        = "vmhd"
+	MoovTrakMdiaMinfSmhd        = "smhd"
+	MoovTrakMdiaMinfDinf        = "dinf"
+	MoovTrakMdiaMinfDinfDref    = "dref"
+	MoovTrakMdiaMinfDinfDrefUrl = "url "
+	MoovTrakMdiaMinfStbl        = "stbl"
+	MoovTrakMdiaMinfStblStsd    = "stsd"
+	MoovTrakMdiaMinfStblStts    = "stts"
+	MoovTrakMdiaMinfStblStsc    = "stsc"
+	MoovTrakMdiaMinfStblStsz    = "stsz"
+	MoovTrakMdiaMinfStblStco    = "stco"
+	MoovMvex                    = "mvex"
+	MoovMvexTrex                = "trex"
+	Moof                        = "moof"
+	MoofMfhd                    = "mfhd"
+	MoofTraf                    = "traf"
+	MoofTrafTfhd                = "tfhd"
+	MoofTrafTfdt                = "tfdt"
+	MoofTrafTrun                = "trun"
+	Mdat                        = "mdat"
+)
+
+func (m *Movie) WriteFileType() {
+	m.StartAtom(Ftyp)
+	m.WriteString("iso5")
+	m.WriteUint32(512)
+	m.WriteString("iso5")
+	m.WriteString("iso6")
+	m.WriteString("mp41")
+	m.EndAtom()
+}
+
+func (m *Movie) WriteMovieHeader() {
+	m.StartAtom(MoovMvhd)
+	m.Skip(1)           // version
+	m.Skip(3)           // flags
+	m.Skip(4)           // create time
+	m.Skip(4)           // modify time
+	m.WriteUint32(1000) // time scale
+	m.Skip(4)           // duration
+	m.WriteFloat32(1)   // preferred rate
+	m.WriteFloat16(1)   // preferred volume
+	m.Skip(10)          // reserved
+	m.WriteMatrix()
+	m.Skip(6 * 4)             // predefined?
+	m.WriteUint32(0xFFFFFFFF) // next track ID
+	m.EndAtom()
+}
+
+func (m *Movie) WriteTrackHeader(id uint32, width, height uint16) {
+	const (
+		TkhdTrackEnabled   = 0x0001
+		TkhdTrackInMovie   = 0x0002
+		TkhdTrackInPreview = 0x0004
+		TkhdTrackInPoster  = 0x0008
+	)
+
+	// https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/QTFFChap2/qtff2.html#//apple_ref/doc/uid/TP40000939-CH204-32963
+	m.StartAtom(MoovTrakTkhd)
+	m.Skip(1) // version
+	m.WriteUint24(TkhdTrackEnabled | TkhdTrackInMovie)
+	m.Skip(4)         // create time
+	m.Skip(4)         // modify time
+	m.WriteUint32(id) // trackID
+	m.Skip(4)         // reserved
+	m.Skip(4)         // duration
+	m.Skip(8)         // reserved
+	m.Skip(2)         // layer
+	if width > 0 {
+		m.Skip(2)
+		m.Skip(2)
+	} else {
+		m.WriteUint16(1)  // alternate group
+		m.WriteFloat16(1) // volume
+	}
+	m.Skip(2) // reserved
+	m.WriteMatrix()
+	if width > 0 {
+		m.WriteFloat32(float64(width))
+		m.WriteFloat32(float64(height))
+	} else {
+		m.Skip(4)
+		m.Skip(4)
+	}
+	m.EndAtom()
+}
+
+func (m *Movie) WriteMediaHeader(timescale uint32) {
+	// https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/QTFFChap2/qtff2.html#//apple_ref/doc/uid/TP40000939-CH204-32999
+	m.StartAtom(MoovTrakMdiaMdhd)
+	m.Skip(1)                // version
+	m.Skip(3)                // flags
+	m.Skip(4)                // creation time
+	m.Skip(4)                // modification time
+	m.WriteUint32(timescale) // timescale
+	m.Skip(4)                // duration
+	m.WriteUint16(0x55C4)    // language (Unspecified)
+	m.Skip(2)                // quality
+	m.EndAtom()
+}
+
+func (m *Movie) WriteMediaHandler(s, name string) {
+	// https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/QTFFChap2/qtff2.html#//apple_ref/doc/uid/TP40000939-CH204-33004
+	m.StartAtom(MoovTrakMdiaHdlr)
+	m.Skip(1) // version
+	m.Skip(3) // flags
+	m.Skip(4)
+	m.WriteString(s)    // handler type (4 byte!)
+	m.Skip(3 * 4)       // reserved
+	m.WriteString(name) // handler name (any len)
+	m.Skip(1)           // end string
+	m.EndAtom()
+}
+
+func (m *Movie) WriteVideoMediaInfo() {
+	// https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/QTFFChap2/qtff2.html#//apple_ref/doc/uid/TP40000939-CH204-33012
+	m.StartAtom(MoovTrakMdiaMinfVmhd)
+	m.Skip(1)        // version
+	m.WriteUint24(1) // flags (You should always set this flag to 1)
+	m.Skip(2)        // graphics mode
+	m.Skip(3 * 2)    // op color
+	m.EndAtom()
+}
+
+func (m *Movie) WriteAudioMediaInfo() {
+	m.StartAtom(MoovTrakMdiaMinfSmhd)
+	m.Skip(1) // version
+	m.Skip(3) // flags
+	m.Skip(4) // balance
+	m.EndAtom()
+}
+
+func (m *Movie) WriteDataInfo() {
+	// https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/QTFFChap2/qtff2.html#//apple_ref/doc/uid/TP40000939-CH204-25680
+	m.StartAtom(MoovTrakMdiaMinfDinf)
+	m.StartAtom(MoovTrakMdiaMinfDinfDref)
+	m.Skip(1)        // version
+	m.Skip(3)        // flags
+	m.WriteUint32(1) // childrens
+
+	m.StartAtom(MoovTrakMdiaMinfDinfDrefUrl)
+	m.Skip(1)        // version
+	m.WriteUint24(1) // flags (self reference)
+	m.EndAtom()
+
+	m.EndAtom() // DREF
+	m.EndAtom() // DINF
+}
+
+func (m *Movie) WriteSampleTable(writeSampleDesc func()) {
+	// https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/QTFFChap2/qtff2.html#//apple_ref/doc/uid/TP40000939-CH204-33040
+	m.StartAtom(MoovTrakMdiaMinfStbl)
+
+	m.StartAtom(MoovTrakMdiaMinfStblStsd)
+	m.Skip(1)        // version
+	m.Skip(3)        // flags
+	m.WriteUint32(1) // entry count
+	writeSampleDesc()
+	m.EndAtom()
+
+	m.StartAtom(MoovTrakMdiaMinfStblStts)
+	m.Skip(1) // version
+	m.Skip(3) // flags
+	m.Skip(4) // entry count
+	m.EndAtom()
+
+	m.StartAtom(MoovTrakMdiaMinfStblStsc)
+	m.Skip(1) // version
+	m.Skip(3) // flags
+	m.Skip(4) // entry count
+	m.EndAtom()
+
+	m.StartAtom(MoovTrakMdiaMinfStblStsz)
+	m.Skip(1) // version
+	m.Skip(3) // flags
+	m.Skip(4) // sample size
+	m.Skip(4) // entry count
+	m.EndAtom()
+
+	m.StartAtom(MoovTrakMdiaMinfStblStco)
+	m.Skip(1) // version
+	m.Skip(3) // flags
+	m.Skip(4) // entry count
+	m.EndAtom()
+
+	m.EndAtom()
+}
+
+func (m *Movie) WriteTrackExtend(id uint32) {
+	m.StartAtom(MoovMvexTrex)
+	m.Skip(1)         // version
+	m.Skip(3)         // flags
+	m.WriteUint32(id) // trackID
+	m.WriteUint32(1)  // default sample description index
+	m.Skip(4)         // default sample duration
+	m.Skip(4)         // default sample size
+	m.Skip(4)         // default sample flags
+	m.EndAtom()
+}
+
+func (m *Movie) WriteVideoTrack(id uint32, codec string, timescale uint32, width, height uint16, conf []byte) {
+	m.StartAtom(MoovTrak)
+	m.WriteTrackHeader(id, width, height)
+
+	m.StartAtom(MoovTrakMdia)
+	m.WriteMediaHeader(timescale)
+	m.WriteMediaHandler("vide", "VideoHandler")
+
+	m.StartAtom(MoovTrakMdiaMinf)
+	m.WriteVideoMediaInfo()
+	m.WriteDataInfo()
+	m.WriteSampleTable(func() {
+		m.WriteVideo(codec, width, height, conf)
+	})
+	m.EndAtom() // MINF
+
+	m.EndAtom() // MDIA
+	m.EndAtom() // TRAK
+}
+
+func (m *Movie) WriteAudioTrack(id uint32, codec string, timescale uint32, channels uint16, conf []byte) {
+	m.StartAtom(MoovTrak)
+	m.WriteTrackHeader(id, 0, 0)
+
+	m.StartAtom(MoovTrakMdia)
+	m.WriteMediaHeader(timescale)
+	m.WriteMediaHandler("soun", "SoundHandler")
+
+	m.StartAtom(MoovTrakMdiaMinf)
+	m.WriteAudioMediaInfo()
+	m.WriteDataInfo()
+	m.WriteSampleTable(func() {
+		m.WriteAudio(codec, channels, timescale, conf)
+	})
+	m.EndAtom() // MINF
+
+	m.EndAtom() // MDIA
+	m.EndAtom() // TRAK
+}
+
+func (m *Movie) WriteMovieFragment(seq, tid, duration, size uint32, time uint64) {
+	m.StartAtom(Moof)
+
+	m.StartAtom(MoofMfhd)
+	m.Skip(1)          // version
+	m.Skip(3)          // flags
+	m.WriteUint32(seq) // sequence number
+	m.EndAtom()
+
+	m.StartAtom(MoofTraf)
+
+	const (
+		TfhdDefaultSampleDuration = 0x000008
+		TfhdDefaultSampleSize     = 0x000010
+		TfhdDefaultSampleFlags    = 0x000020
+		TfhdDefaultBaseIsMoof     = 0x020000
+	)
+
+	m.StartAtom(MoofTrafTfhd)
+	m.Skip(1) // version
+	m.WriteUint24(
+		TfhdDefaultSampleDuration |
+			TfhdDefaultSampleSize |
+			TfhdDefaultSampleFlags |
+			TfhdDefaultBaseIsMoof,
+	)
+	m.WriteUint32(tid)       // track id
+	m.WriteUint32(duration)  // default sample duration
+	m.WriteUint32(size)      // default sample size
+	m.WriteUint32(0x2000000) // default sample flags
+	m.EndAtom()
+
+	m.StartAtom(MoofTrafTfdt)
+	m.WriteBytes(1)     // version
+	m.Skip(3)           // flags
+	m.WriteUint64(time) // base media decode time
+	m.EndAtom()
+
+	const (
+		TrunDataOffset       = 0x000001
+		TrunFirstSampleFlags = 0x000004
+		TrunSampleDuration   = 0x0000100
+		TrunSampleSize       = 0x0000200
+		TrunSampleFlags      = 0x0000400
+		TrunSampleCTS        = 0x0000800
+	)
+
+	m.StartAtom(MoofTrafTrun)
+	m.Skip(1)                     // version
+	m.WriteUint24(TrunDataOffset) // flags
+	m.WriteUint32(1)              // sample count
+	// data offset: current pos + uint32 len + MDAT header len
+	m.WriteUint32(uint32(len(m.b)) + 4 + 8)
+	m.EndAtom() // TRUN
+
+	m.EndAtom() // TRAF
+
+	m.EndAtom() // MOOF
+}
+
+func (m *Movie) WriteData(b []byte) {
+	m.StartAtom(Mdat)
+	m.Write(b)
+	m.EndAtom()
+
+}

pkg/iso/codecs.go

@@ -0,0 +1,153 @@
+package iso
+
+import (
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func (m *Movie) WriteVideo(codec string, width, height uint16, conf []byte) {
+	// https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/QTFFChap3/qtff3.html
+	switch codec {
+	case core.CodecH264:
+		m.StartAtom("avc1")
+	case core.CodecH265:
+		m.StartAtom("hev1")
+	default:
+		panic("unsupported iso video: " + codec)
+	}
+	m.Skip(6)
+	m.WriteUint16(1)      // data_reference_index
+	m.Skip(2)             // version
+	m.Skip(2)             // revision
+	m.Skip(4)             // vendor
+	m.Skip(4)             // temporal quality
+	m.Skip(4)             // spatial quality
+	m.WriteUint16(width)  // width
+	m.WriteUint16(height) // height
+	m.WriteFloat32(72)    // horizontal resolution
+	m.WriteFloat32(72)    // vertical resolution
+	m.Skip(4)             // reserved
+	m.WriteUint16(1)      // frame count
+	m.Skip(32)            // compressor name
+	m.WriteUint16(24)     // depth
+	m.WriteUint16(0xFFFF) // color table id (-1)
+
+	switch codec {
+	case core.CodecH264:
+		m.StartAtom("avcC")
+	case core.CodecH265:
+		m.StartAtom("hvcC")
+	}
+	m.Write(conf)
+	m.EndAtom() // AVCC
+
+	m.EndAtom() // AVC1
+}
+
+func (m *Movie) WriteAudio(codec string, channels uint16, sampleRate uint32, conf []byte) {
+	switch codec {
+	case core.CodecAAC, core.CodecMP3:
+		m.StartAtom("mp4a")
+	case core.CodecOpus:
+		m.StartAtom("Opus")
+	case core.CodecPCMU:
+		m.StartAtom("ulaw")
+	case core.CodecPCMA:
+		m.StartAtom("alaw")
+	default:
+		panic("unsupported iso audio: " + codec)
+	}
+	m.Skip(6)
+	m.WriteUint16(1)                    // data_reference_index
+	m.Skip(2)                           // version
+	m.Skip(2)                           // revision
+	m.Skip(4)                           // vendor
+	m.WriteUint16(channels)             // channel_count
+	m.WriteUint16(16)                   // sample_size
+	m.Skip(2)                           // compression id
+	m.Skip(2)                           // reserved
+	m.WriteFloat32(float64(sampleRate)) // sample_rate
+
+	switch codec {
+	case core.CodecAAC:
+		m.WriteEsdsAAC(conf)
+	case core.CodecMP3:
+		m.WriteEsdsMP3()
+	case core.CodecOpus:
+		// don't know what means this magic
+		m.StartAtom("dOps")
+		m.WriteBytes(0, 0x02, 0x01, 0x38, 0, 0, 0xBB, 0x80, 0, 0, 0)
+		m.EndAtom()
+	case core.CodecPCMU, core.CodecPCMA:
+		// don't know what means this magic
+		m.StartAtom("chan")
+		m.WriteBytes(0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0)
+		m.EndAtom()
+	}
+
+	m.EndAtom() // MP4A/OPUS
+}
+
+func (m *Movie) WriteEsdsAAC(conf []byte) {
+	m.StartAtom("esds")
+	m.Skip(1) // version
+	m.Skip(3) // flags
+
+	// MP4ESDescrTag[3]:
+	// - MP4DecConfigDescrTag[4]:
+	//   - MP4DecSpecificDescrTag[5]: conf
+	// - Other[6]
+	const header = 5
+	const size3 = 3
+	const size4 = 13
+	size5 := byte(len(conf))
+	const size6 = 1
+
+	m.WriteBytes(3, 0x80, 0x80, 0x80, size3+header+size4+header+size5+header+size6)
+	m.Skip(2) // es id
+	m.Skip(1) // es flags
+
+	m.WriteBytes(4, 0x80, 0x80, 0x80, size4+header+size5)
+	m.WriteBytes(0x40) // object id
+	m.WriteBytes(0x15) // stream type
+	m.Skip(3)          // buffer size db
+	m.Skip(4)          // max bitraga
+	m.Skip(4)          // avg bitraga
+
+	m.WriteBytes(5, 0x80, 0x80, 0x80, size5)
+	m.Write(conf)
+
+	m.WriteBytes(6, 0x80, 0x80, 0x80, 1)
+	m.WriteBytes(2) // ?
+
+	m.EndAtom() // ESDS
+}
+
+func (m *Movie) WriteEsdsMP3() {
+	m.StartAtom("esds")
+	m.Skip(1) // version
+	m.Skip(3) // flags
+
+	// MP4ESDescrTag[3]:
+	// - MP4DecConfigDescrTag[4]:
+	// - Other[6]
+	const header = 5
+	const size3 = 3
+	const size4 = 13
+	const size6 = 1
+
+	m.WriteBytes(3, 0x80, 0x80, 0x80, size3+header+size4+header+size6)
+	m.Skip(2) // es id
+	m.Skip(1) // es flags
+
+	m.WriteBytes(4, 0x80, 0x80, 0x80, size4)
+	m.WriteBytes(0x6B) // object id
+	m.WriteBytes(0x15) // stream type
+	m.Skip(3)          // buffer size db
+	m.Skip(4)          // max bitraga
+	m.Skip(4)          // avg bitraga
+
+	m.WriteBytes(6, 0x80, 0x80, 0x80, 1)
+	m.WriteBytes(2) // ?
+
+	m.EndAtom() // ESDS
+}