diff --git a/installs_on_host/go2rtc/.gitignore b/installs_on_host/go2rtc/.gitignore
new file mode 100644
index 0000000..5d53907
--- /dev/null
+++ b/installs_on_host/go2rtc/.gitignore
@@ -0,0 +1,24 @@
+.idea/
+.tmp/
+
+go2rtc.yaml
+go2rtc.json
+
+go2rtc_freebsd*
+go2rtc_linux*
+go2rtc_mac*
+go2rtc_win*
+
+/go2rtc
+/go2rtc.exe
+
+0_test.go
+
+.DS_Store
+
+website/.vitepress/cache
+website/.vitepress/dist
+
+node_modules
+package-lock.json
+CLAUDE.md
\ No newline at end of file
diff --git a/installs_on_host/go2rtc/LICENSE b/installs_on_host/go2rtc/LICENSE
new file mode 100644
index 0000000..beb8fca
--- /dev/null
+++ b/installs_on_host/go2rtc/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Alexey Khit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/installs_on_host/go2rtc/README.md b/installs_on_host/go2rtc/README.md
new file mode 100644
index 0000000..b15d57a
--- /dev/null
+++ b/installs_on_host/go2rtc/README.md
@@ -0,0 +1,538 @@
+<h1 align="center">
+  <a href="https://github.com/AlexxIT/go2rtc">
+    <img src="./website/images/logo.gif" alt="go2rtc - GitHub">
+  </a>
+</h1>
+<p align="center">
+  <a href="https://github.com/AlexxIT/go2rtc/stargazers" target="_blank">
+    <img style="display: inline" src="https://img.shields.io/github/stars/AlexxIT/go2rtc?style=flat-square&logo=github" alt="go2rtc - GitHub Stars">
+  </a>
+  <a href="https://hub.docker.com/r/alexxit/go2rtc" target="_blank">
+    <img style="display: inline" src="https://img.shields.io/docker/pulls/alexxit/go2rtc?style=flat-square&logo=docker&logoColor=white&label=pulls" alt="go2rtc - Docker Pulls">
+  </a>
+  <a href="https://github.com/AlexxIT/go2rtc/releases" target="_blank">
+    <img style="display: inline" src="https://img.shields.io/github/downloads/AlexxIT/go2rtc/total?color=blue&style=flat-square&logo=github" alt="go2rtc - GitHub Downloads">
+  </a>
+</p>
+<p align="center">
+  <a href="https://trendshift.io/repositories/4628" target="_blank">
+    <img src="https://trendshift.io/api/badge/repositories/4628" alt="go2rtc - Trendshift"/>
+  </a>
+</p>
+
+Ultimate camera streaming application with support for dozens formats and protocols.
+
+- zero-dependency [small app](#go2rtc-binary) for all OS (Windows, macOS, Linux, FreeBSD)
+- zero-delay for many [supported protocols](#codecs-madness) (lowest possible streaming latency)
+- [streaming input](#streaming-input) from dozens formats and protocols
+- [streaming output](#streaming-output) in all popular formats
+- [streaming ingest](#streaming-ingest) in a number of popular formats
+- [publish](#publish-stream) any source to popular streaming services (YouTube, Telegram)
+- on-the-fly transcoding only if necessary via [FFmpeg](internal/ffmpeg/README.md)
+- [two-way audio](#two-way-audio) support for many formats
+- [streaming audio](#stream-to-camera) to all cameras with [two-way audio](#two-way-audio) support
+- mixing tracks from different sources to single stream
+- [auto-match](www/README.md#javascript-api) client-supported streaming formats and codecs
+- [streaming stats](#streaming-stats) for all active connections
+- can be [integrated to any project](#projects-using-go2rtc) or be used as [standalone app](#go2rtc-binary)
+
+#### Inspired by
+
+- series of streaming projects from [@deepch](https://github.com/deepch)
+- [webrtc](https://github.com/pion/webrtc) go library and whole [@pion](https://github.com/pion) team
+- [rtsp-simple-server](https://github.com/aler9/rtsp-simple-server) idea from [@aler9](https://github.com/aler9)
+- [GStreamer](https://gstreamer.freedesktop.org/) framework pipeline idea
+- [MediaSoup](https://mediasoup.org/) framework routing idea
+- HomeKit Accessory Protocol from [@brutella](https://github.com/brutella/hap)
+- creator of the project's logo [@v_novoseltsev](https://www.instagram.com/v_novoseltsev)
+
+<br>
+<details>
+<summary><b>Table of Contents</b></summary>
+
+- [Installation](#installation)
+  - [go2rtc: Binary](#go2rtc-binary)
+  - [go2rtc: Docker](#go2rtc-docker)
+  - [go2rtc: Home Assistant add-on](#go2rtc-home-assistant-add-on)
+  - [go2rtc: Home Assistant Integration](#go2rtc-home-assistant-integration)
+  - [go2rtc: Master version](#go2rtc-master-version)
+- [Configuration](#configuration)
+- [Features](#features)
+  - [Streaming input](#streaming-input)
+  - [Streaming output](#streaming-output)
+  - [Streaming ingest](#streaming-ingest)
+  - [Two-way audio](#two-way-audio)
+  - [Stream to camera](#stream-to-camera)
+  - [Publish stream](#publish-stream)
+  - [Preload stream](#preload-stream)
+  - [Streaming stats](#streaming-stats)
+- [Codecs](#codecs)
+  - [Codecs filters](#codecs-filters)
+  - [Codecs madness](#codecs-madness)
+  - [Built-in transcoding](#built-in-transcoding)
+  - [Codecs negotiation](#codecs-negotiation)
+- [Security](#security)
+- [Projects using go2rtc](#projects-using-go2rtc)
+- [Camera experience](#camera-experience)
+- [Tips](#tips)
+
+</details>
+
+## Installation
+
+1. Download [binary](#go2rtc-binary) or use [Docker](#go2rtc-docker) or Home Assistant [add-on](#go2rtc-home-assistant-add-on) or [integration](#go2rtc-home-assistant-integration)
+2. Open web interface: `http://localhost:1984/`
+3. Add [streams](#streaming-input) to [config](#configuration)
+
+**Developers:** integrate [HTTP API](internal/api/README.md) into your smart home platform.
+
+### go2rtc: Binary
+
+Download binary for your OS from [latest release](https://github.com/AlexxIT/go2rtc/releases/):
+
+| name                                                                                                            | description                                                                                                                               |
+|-----------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------|
+| [go2rtc_win64.zip](https://github.com/AlexxIT/go2rtc/releases/latest/download/go2rtc_win64.zip)                 | Windows 10+ 64-bit                                                                                                                        |
+| [go2rtc_win32.zip](https://github.com/AlexxIT/go2rtc/releases/latest/download/go2rtc_win32.zip)                 | Windows 10+ 32-bit                                                                                                                        |
+| [go2rtc_win_arm64.zip](https://github.com/AlexxIT/go2rtc/releases/latest/download/go2rtc_win_arm64.zip)         | Windows ARM 64-bit                                                                                                                        |
+| [go2rtc_linux_amd64](https://github.com/AlexxIT/go2rtc/releases/latest/download/go2rtc_linux_amd64)             | Linux 64-bit                                                                                                                              |
+| [go2rtc_linux_i386](https://github.com/AlexxIT/go2rtc/releases/latest/download/go2rtc_linux_i386)               | Linux 32-bit                                                                                                                              |
+| [go2rtc_linux_arm64](https://github.com/AlexxIT/go2rtc/releases/latest/download/go2rtc_linux_arm64)             | Linux ARM 64-bit (ex. Raspberry 64-bit OS)                                                                                                |
+| [go2rtc_linux_arm](https://github.com/AlexxIT/go2rtc/releases/latest/download/go2rtc_linux_arm)                 | Linux ARM 32-bit (ex. Raspberry 32-bit OS)                                                                                                |
+| [go2rtc_linux_armv6](https://github.com/AlexxIT/go2rtc/releases/latest/download/go2rtc_linux_armv6)             | Linux ARMv6 (for old Raspberry 1 and Zero)                                                                                                |
+| [go2rtc_linux_mipsel](https://github.com/AlexxIT/go2rtc/releases/latest/download/go2rtc_linux_mipsel)           | Linux MIPS (ex. [Xiaomi Gateway 3](https://github.com/AlexxIT/XiaomiGateway3), [Wyze cameras](https://github.com/gtxaspec/wz_mini_hacks)) |
+| [go2rtc_mac_amd64.zip](https://github.com/AlexxIT/go2rtc/releases/latest/download/go2rtc_mac_amd64.zip)         | macOS 11+ Intel 64-bit                                                                                                                    |
+| [go2rtc_mac_arm64.zip](https://github.com/AlexxIT/go2rtc/releases/latest/download/go2rtc_mac_arm64.zip)         | macOS ARM 64-bit                                                                                                                          |
+| [go2rtc_freebsd_amd64.zip](https://github.com/AlexxIT/go2rtc/releases/latest/download/go2rtc_freebsd_amd64.zip) | FreeBSD 64-bit                                                                                                                            |
+| [go2rtc_freebsd_arm64.zip](https://github.com/AlexxIT/go2rtc/releases/latest/download/go2rtc_freebsd_arm64.zip) | FreeBSD ARM 64-bit                                                                                                                        |
+
+Don't forget to fix the rights `chmod +x go2rtc_xxx_xxx` on Linux and Mac.
+
+PS. The application is compiled with the latest versions of the Go language for maximum speed and security. Therefore, the [minimum OS versions](https://go.dev/wiki/MinimumRequirements) depend on the Go language.
+
+### go2rtc: Docker
+
+The Docker containers [`alexxit/go2rtc`](https://hub.docker.com/r/alexxit/go2rtc) and [`ghcr.io/alexxit/go2rtc`](https://github.com/AlexxIT/go2rtc/pkgs/container/go2rtc) support multiple architectures including `386`, `amd64`, `arm/v6`, `arm/v7` and `arm64`.
+These containers offer the same functionality as the Home Assistant [add-on](#go2rtc-home-assistant-add-on) but are designed to operate independently of Home Assistant.
+It comes preinstalled with [FFmpeg](internal/ffmpeg/README.md) and [Python](internal/echo/README.md).
+
+### go2rtc: Home Assistant add-on
+
+[![Open your Home Assistant instance and show the add add-on repository dialog with a specific repository URL pre-filled.](https://my.home-assistant.io/badges/supervisor_add_addon_repository.svg)](https://my.home-assistant.io/redirect/supervisor_add_addon_repository/?repository_url=https%3A%2F%2Fgithub.com%2FAlexxIT%2Fhassio-addons)
+
+1. Settings > Add-ons > Plus > Repositories > Add
+   ```
+   https://github.com/AlexxIT/hassio-addons
+   ```
+2. go2rtc > Install > Start
+
+### go2rtc: Home Assistant Integration
+
+[WebRTC Camera](https://github.com/AlexxIT/WebRTC) custom component can be used on any Home Assistant [installation](https://www.home-assistant.io/installation/), including [HassWP](https://github.com/AlexxIT/HassWP) on Windows. It can automatically download and use the latest version of go2rtc. Or it can connect to an existing version of go2rtc. Addon installation in this case is optional.
+
+### go2rtc: Master version
+
+Latest, but maybe unstable version:
+
+- Binary: [latest master build](https://nightly.link/AlexxIT/go2rtc/workflows/build/master)
+- Docker: `alexxit/go2rtc:master` or `alexxit/go2rtc:master-hardware` versions
+- Home Assistant add-on: `go2rtc master` or `go2rtc master hardware` versions
+
+## Configuration
+
+This is the `go2rtc.yaml` file in [YAML-format](https://en.wikipedia.org/wiki/YAML).
+The configuration can be changed in the [WebUI](www/README.md) at `http://localhost:1984`.
+The editor provides syntax highlighting and checking.
+
+![go2rtc webui config](website/images/webui-config.png)
+
+The simplest config looks like this:
+
+```yaml
+streams:
+  hall-camera: rtsp://admin:password@192.168.1.123/cam/realmonitor?channel=1&subtype=0
+```
+
+- by default go2rtc will search `go2rtc.yaml` in the current work directory
+- `api` server will start on default **1984 port** (TCP)
+- `rtsp` server will start on default **8554 port** (TCP)
+- `webrtc` will use port **8555** (TCP/UDP) for connections
+
+More information can be [found here](internal/app/README.md).
+
+## Features
+
+A summary table of all modules and features can be found [here](internal/README.md).
+
+**Core modules**
+
+- [`app`](internal/app/README.md) - Reading [configs](internal/app/README.md) and setting up [logs](internal/app/README.md#log).
+- [`api`](internal/api/README.md) - Handle [HTTP](internal/api/README.md) and [WebSocket](internal/api/ws/README.md) API.
+- [`streams`](internal/streams/README.md) - Handle a list of streams.
+
+### Streaming input
+
+#### public protocols
+
+- [`mpjpeg`](internal/mjpeg/README.md#mjpeg-client) - The legacy but still used [MJPEG](https://en.wikipedia.org/wiki/Motion_JPEG) protocol for real-time media transmission.
+- [`onvif`](internal/onvif/README.md#onvif-client) - A popular [ONVIF](https://en.wikipedia.org/wiki/ONVIF) protocol for receiving media in RTSP format.
+- [`rtmp`](internal/rtmp/README.md#rtmp-client) - The legacy but still used [RTMP](https://en.wikipedia.org/wiki/Real-Time_Messaging_Protocol) protocol for real-time media transmission.
+- [`rtsp`](internal/rtsp/README.md#rtsp-client) - The most common [RTSP](https://en.wikipedia.org/wiki/Real-Time_Streaming_Protocol) protocol for real-time media transmission.
+- [`webrtc`](internal/webrtc/README.md#webrtc-client) - [WebRTC](https://en.wikipedia.org/wiki/WebRTC) web-compatible protocol for real-time media transmission.
+- [`yuv4mpegpipe`](internal/http/README.md#tcp) - Raw [YUV](https://en.wikipedia.org/wiki/Y%E2%80%B2UV) frame stream with [YUV4MPEG](https://manned.org/yuv4mpeg) header.
+
+#### private protocols
+
+- [`bubble`](internal/bubble/README.md) - Some NVR from [dvr163.com](http://help.dvr163.com/) and [eseecloud.com](http://www.eseecloud.com/).
+- [`doorbird`](internal/doorbird/README.md) - [Doorbird](https://www.doorbird.com/) devices with two-way audio.
+- [`dvrip`](internal/dvrip/README.md) - DVR-IP NVR, NetSurveillance, Sofia protocol (XMeye SDK).
+- [`eseecloud`](internal/eseecloud/README.md) - Some NVR from [dvr163.com](http://help.dvr163.com/) and [eseecloud.com](http://www.eseecloud.com/).
+- [`gopro`](internal/gopro/README.md) - [GoPro](https://gopro.com/) cameras, connected via USB or Wi-Fi.
+- [`hass`](internal/hass/README.md) - Import cameras from [Home Assistant](https://www.home-assistant.io/) config files.
+- [`homekit`](internal/homekit/README.md) - Cameras with [Apple HomeKit](https://www.apple.com/home-app/accessories/) protocol.
+- [`isapi`](internal/isapi/README.md) - Two-way audio for [Hikvision ISAPI](https://tpp.hikvision.com/download/ISAPI_OTAP) protocol.
+- [`kasa`](internal/kasa/README.md) - [TP-Link Kasa](https://www.kasasmart.com/) cameras.
+- [`multitrans`](internal/multitrans/README.md) - Two-way audio for Chinese version of [TP-Link](https://www.tp-link.com.cn/) cameras.
+- [`nest`](internal/nest/README.md) - [Google Nest](https://developers.google.com/nest/device-access/supported-devices) cameras through user-unfriendly and paid APIs.
+- [`ring`](internal/ring/README.md) - Ring cameras with two-way audio support.
+- [`roborock`](internal/roborock/README.md) - [Roborock](https://roborock.com/) vacuums with cameras with two-way audio support. 
+- [`tapo`](internal/tapo/README.md) - [TP-Link Tapo](https://www.tapo.com/) cameras with two-way audio support.
+- [`vigi`](internal/tapo/README.md#tp-link-vigi) - TP-Link Vigi cameras.
+- [`tuya`](internal/tuya/README.md) - [Tuya](https://www.tuya.com/) ecosystem cameras with two-way audio support.
+- [`webtorrent`](internal/webtorrent/README.md) - Stream from another go2rtc via [WebTorrent](https://en.wikipedia.org/wiki/WebTorrent) protocol.
+- [`wyze`](internal/wyze/README.md) - [Wyze](https://wyze.com/) cameras using native P2P protocol
+- [`xiaomi`](internal/xiaomi/README.md) - [Xiaomi Mi Home](https://home.mi.com/) ecosystem cameras with two-way audio support.
+
+#### devices
+
+- [`alsa`](internal/alsa/README.md) - A [framework](https://en.wikipedia.org/wiki/Advanced_Linux_Sound_Architecture) for receiving audio from devices on Linux OS.
+- [`v4l2`](internal/v4l2/README.md) - A [framework](https://en.wikipedia.org/wiki/Video4Linux) for receiving video from devices on Linux OS.
+
+#### files
+
+- [`adts`](internal/http/README.md#tcp) - Audio stream in [AAC](https://en.wikipedia.org/wiki/Advanced_Audio_Coding) codec with Audio Data Transport Stream headers.
+- [`flv`](internal/http/README.md#tcp) - The legacy but still used [Flash Video](https://en.wikipedia.org/wiki/Flash_Video) format.
+- [`h264`](internal/http/README.md#tcp) - AVC/H.264 bitstream.
+- [`hevc`](internal/http/README.md#tcp) - HEVC/H.265 bitstream.
+- [`hls`](internal/http/README.md) - A popular [HTTP Live Streaming](https://en.wikipedia.org/wiki/HTTP_Live_Streaming) format.
+- [`mjpeg`](internal/http/README.md#tcp) - A continuous sequence of JPEG frames (without HTTP headers).
+- [`mpegts`](internal/http/README.md#tcp) - The legacy [MPEG transport stream](https://en.wikipedia.org/wiki/MPEG_transport_stream) format.
+- [`wav`](internal/http/README.md#tcp) - Audio stream in [Waveform Audio File](https://en.wikipedia.org/wiki/WAV) format.
+
+#### scripts
+
+- [`echo`](internal/echo/README.md) - If the source has a dynamic link, you can use a bash or python script to get it.
+- [`exec`](internal/exec/README.md) - You can run an external application (`ffmpeg`, `gstreamer`, `rpicam`, etc.) and receive a media stream from it.
+- [`expr`](internal/expr/README.md) - If the source has a dynamic link, you can use [Expr](https://github.com/expr-lang/expr) language to get it.
+- [`ffmpeg`](internal/ffmpeg/README.md) - Use [FFmpeg](https://ffmpeg.org/) as a stream source. Hardware-accelerated transcoding and streaming from USB devices are supported.
+
+#### webrtc
+
+- [`creality`](internal/webrtc/README.md#creality) - [Creality](https://www.creality.com/) 3D printer cameras.
+- [`kinesis`](internal/webrtc/README.md#kinesis) - [Amazon Kinesis](https://aws.amazon.com/kinesis/video-streams/) video streams.
+- [`openipc`](internal/webrtc/README.md#openipc) - Cameras on open-source [OpenIPC](https://openipc.org/) firmware.
+- [`switchbot`](internal/webrtc/README.md#switchbot) - [SwitchBot](https://us.switch-bot.com/) cameras.
+- [`whep`](internal/webrtc/README.md#whep) - [WebRTC/WHEP](https://datatracker.ietf.org/doc/draft-murillo-whep/) is replaced by [WebRTC/WISH](https://datatracker.ietf.org/doc/charter-ietf-wish/02/) standard for WebRTC video/audio viewers.
+- [`wyze`](internal/webrtc/README.md#wyze) - Legacy method to connect to [Wyze](https://www.wyze.com/) cameras via [docker-wyze-bridge](https://github.com/mrlt8/docker-wyze-bridge).
+
+### Streaming output
+
+- [`adts`](internal/mpeg/README.md) - Output stream in ADTS format with [AAC](https://en.wikipedia.org/wiki/Advanced_Audio_Coding) audio.
+- [`ascii`](internal/mjpeg/README.md#ascii) - Just for fun stream as [ASCII to Terminal](https://www.youtube.com/watch?v=sHj_3h_sX7M).
+- [`flv`](internal/rtmp/README.md) - Output stream in [Flash Video](https://en.wikipedia.org/wiki/Flash_Video) format.
+- [`hls`](internal/hls/README.md) - Output stream in [HTTP Live Streaming](https://en.wikipedia.org/wiki/HTTP_Live_Streaming) format.
+- [`homekit`](internal/homekit/README.md#homekit-server) - Output stream to [Apple Home](https://www.apple.com/home-app/) using [HomeKit](https://en.wikipedia.org/wiki/Apple_Home) protocol.
+- [`jpeg`](internal/mjpeg/README.md#jpeg) - Output snapshots in [JPEG](https://en.wikipedia.org/wiki/JPEG) format.
+- [`mpjpeg`](internal/mjpeg/README.md#mpjpeg) - Output a stream in [MJPEG](https://en.wikipedia.org/wiki/Motion_JPEG) format.
+- [`mp4`](internal/mp4/README.md) - Output as [MP4 stream](https://en.wikipedia.org/wiki/Progressive_download) or [Media Source Extensions](https://developer.mozilla.org/en-US/docs/Web/API/Media_Source_Extensions_API) (MSE) compatible format.
+- [`mpegts`](internal/mpeg/README.md) - Output stream in [MPEG transport stream](https://en.wikipedia.org/wiki/MPEG_transport_stream) format.
+- [`onvif`](internal/onvif/README.md#onvif-server) - Output stream using [ONVIF](https://en.wikipedia.org/wiki/ONVIF) protocol.
+- [`rtmp`](internal/rtmp/README.md#rtmp-server) - Output stream using [Real-Time Messaging](https://en.wikipedia.org/wiki/Real-Time_Messaging_Protocol) protocol.
+- [`rtsp`](internal/rtsp/README.md#rtsp-server) - Output stream using [Real-Time Streaming](https://en.wikipedia.org/wiki/Real-Time_Streaming_Protocol) protocol.
+- [`webrtc`](internal/webrtc/README.md#webrtc-server) - Output stream using [Web Real-Time Communication](https://developer.mozilla.org/en-US/docs/Web/API/WebRTC_API) API.
+- [`webtorrent`](internal/webtorrent/README.md#webtorrent-server) - Output stream using [WebTorrent](https://en.wikipedia.org/wiki/WebTorrent) protocol.
+- [`yuv4mpegpipe`](internal/mjpeg/README.md#yuv4mpegpipe) - Output in raw [YUV](https://en.wikipedia.org/wiki/Y%E2%80%B2UV) frame stream with [YUV4MPEG](https://manned.org/yuv4mpeg) header.
+
+### Streaming ingest
+
+Supported for: 
+[`flv`](internal/rtmp/README.md#flv-server), 
+[`mjpeg`](internal/mjpeg/README.md#streaming-ingest), 
+[`mpegts`](internal/mpeg/README.md#streaming-ingest), 
+[`rtmp`](internal/rtmp/README.md#rtmp-server), 
+[`rtsp`](internal/rtsp/README.md#streaming-ingest), 
+[`webrtc`](internal/webrtc/README.md#streaming-ingest).
+
+This is a feature when go2rtc expects to receive an incoming stream from an external application. The stream transmission is started and stopped by an external application.
+
+- You can push data only to an existing stream (create a stream with empty source in config).
+- You can push multiple incoming sources to the same stream.
+- You can push data to a non-empty stream, so it will have additional codecs inside.
+
+### Two-way audio
+
+Supported for:
+[`doorbird`](internal/doorbird/README.md), 
+[`dvrip`](internal/dvrip/README.md), 
+[`exec`](internal/exec/README.md), 
+[`isapi`](internal/isapi/README.md), 
+[`multitrans`](internal/multitrans/README.md), 
+[`ring`](internal/ring/README.md), 
+[`roborock`](internal/roborock/README.md), 
+[`rtsp`](internal/rtsp/README.md#two-way-audio), 
+[`tapo`](internal/tapo/README.md), 
+[`tuya`](internal/tuya/README.md), 
+[`webrtc`](internal/webrtc/README.md), 
+[`wyze`](internal/wyze/README.md), 
+[`xiaomi`](internal/xiaomi/README.md).
+
+Two-way audio can be used in browser with [WebRTC](internal/webrtc/README.md) technology. The browser will give access to the microphone only for HTTPS sites ([read more](https://stackoverflow.com/questions/52759992/how-to-access-camera-and-microphone-in-chrome-without-https)).
+
+### Stream to camera
+
+You can play audio files or live streams on any camera with [two-way audio](#two-way-audio) support.
+
+[read more](internal/streams/README.md#stream-to-camera)
+
+### Publish stream
+
+You can publish any stream to streaming services (YouTube, Telegram, etc.) via RTMP/RTMPS.
+
+[read more](internal/streams/README.md#publish-stream)
+
+### Preload stream
+
+You can preload any stream on go2rtc start. This is useful for cameras that take a long time to start up.
+
+[read more](internal/streams/README.md#preload-stream)
+
+### Streaming stats
+
+[WebUI](www/README.md) provides detailed information about all active connections, including IP-addresses, formats, protocols, number of packets and bytes transferred. 
+Via the [HTTP API](internal/api/README.md) in [`json`](https://en.wikipedia.org/wiki/JSON) or [`dot`](https://en.wikipedia.org/wiki/DOT_(graph_description_language)) format on an interactive connection map.
+
+![go2rtc webui net](website/images/webui-net.png)
+
+## Codecs
+
+If you have questions about why video or audio is not displayed, you need to read the following sections.
+
+| Name                         | FFmpeg   | RTSP          | Aliases     |
+|------------------------------|----------|---------------|-------------|
+| Advanced Audio Coding        | `aac`    | MPEG4-GENERIC |             |
+| Advanced Video Coding        | `h264`   | H264          | AVC, H.264  |
+| G.711 PCM (A-law)            | `alaw`   | PCMA          | G711A       |
+| G.711 PCM (µ-law)            | `mulaw`  | PCMU          | G711u       |
+| High Efficiency Video Coding | `hevc`   | H265          | HEVC, H.265 |
+| Motion JPEG                  | `mpjpeg` | JPEG          |             |
+| MPEG-1 Audio Layer III       | `mp3`    | MPA           |             |
+| Opus Codec                   | `opus`   | OPUS          |             |
+| PCM signed 16-bit big-endian | `s16be`  | L16           |             |
+
+### Codecs filters
+
+go2rtc can automatically detect which codecs your device supports for [WebRTC](internal/webrtc/README.md) and [MSE](internal/mp4/README.md) technologies.
+
+But it cannot be done for [RTSP](internal/rtsp/README.md), [HTTP progressive streaming](internal/mp4/README.md), [HLS](internal/hls/README.md) technologies. 
+You can manually add a codec filter when you create a link to a stream. 
+The filters work the same for all three technologies. 
+Filters do not create a new codec, they only select the suitable codec from existing sources. 
+You can add new codecs to the stream using the [FFmpeg transcoding](internal/ffmpeg/README.md).
+
+Without filters:
+
+- RTSP will provide only the first video and only the first audio (any codec)
+- MP4 will include only compatible codecs (H264, H265, AAC)
+- HLS will output in the legacy TS format (H264 without audio)
+
+Some examples:
+
+- `rtsp://192.168.1.123:8554/camera1?mp4` - useful for recording as MP4 files (e.g. Home Assistant or Frigate)
+- `rtsp://192.168.1.123:8554/camera1?video=h264,h265&audio=aac` - full version of the filter above
+- `rtsp://192.168.1.123:8554/camera1?video=h264&audio=aac&audio=opus` - H264 video codec and two separate audio tracks
+- `rtsp://192.168.1.123:8554/camera1?video&audio=all` - any video codec and all audio codecs as separate tracks
+- `http://192.168.1.123:1984/api/stream.m3u8?src=camera1&mp4` - HLS stream with MP4 compatible codecs (HLS/fMP4)
+- `http://192.168.1.123:1984/api/stream.m3u8?src=camera1&mp4=flac` - HLS stream with PCMA/PCMU/PCM audio support (HLS/fMP4), won't work on old devices
+- `http://192.168.1.123:1984/api/stream.mp4?src=camera1&mp4=flac` - MP4 file with PCMA/PCMU/PCM audio support, won't work on old devices (ex. iOS 12)
+- `http://192.168.1.123:1984/api/stream.mp4?src=camera1&mp4=all` - MP4 file with non-standard audio codecs, won't work on some players
+
+### Codecs madness
+
+`AVC/H.264` video can be played almost anywhere. But `HEVC/H.265` has many limitations in supporting different devices and browsers.
+
+| Device                                                             | WebRTC                                  | MSE                                     | HTTP*                                        | HLS                         |
+|--------------------------------------------------------------------|-----------------------------------------|-----------------------------------------|----------------------------------------------|-----------------------------|
+| *latency*                                                          | best                                    | medium                                  | bad                                          | bad                         |
+| Desktop Chrome 136+ <br/> Desktop Edge <br/> Android Chrome 136+   | H264, H265* <br/> PCMU, PCMA <br/> OPUS | H264, H265* <br/> AAC, FLAC* <br/> OPUS | H264, H265* <br/> AAC, FLAC* <br/> OPUS, MP3 | no                          |
+| Desktop Firefox                                                    | H264 <br/> PCMU, PCMA <br/> OPUS        | H264 <br/> AAC, FLAC* <br/> OPUS        | H264 <br/> AAC, FLAC* <br/> OPUS             | no                          |
+| Desktop Safari 14+ <br/> iPad Safari 14+ <br/> iPhone Safari 17.1+ | H264, H265* <br/> PCMU, PCMA <br/> OPUS | H264, H265 <br/> AAC, FLAC*             | **no!**                                      | H264, H265 <br/> AAC, FLAC* |
+| iPhone Safari 14+                                                  | H264, H265* <br/> PCMU, PCMA <br/> OPUS | **no!**                                 | **no!**                                      | H264, H265 <br/> AAC, FLAC* |
+| macOS [Hass App][1]                                                | no                                      | no                                      | no                                           | H264, H265 <br/> AAC, FLAC* |
+
+[1]: https://apps.apple.com/app/home-assistant/id1099568401
+
+- `HTTP*` - HTTP Progressive Streaming, not related to [progressive download](https://en.wikipedia.org/wiki/Progressive_download), because the file has no size and no end
+- `WebRTC H265` - supported in [Chrome 136+](https://developer.chrome.com/release-notes/136), supported in [Safari 18+](https://developer.apple.com/documentation/safari-release-notes/safari-18-release-notes)
+- `MSE iPhone` - supported in [iOS 17.1+](https://webkit.org/blog/14735/webkit-features-in-safari-17-1/)
+
+**Audio**
+
+- go2rtc supports [automatic repackaging](#built-in-transcoding) of `PCMA/PCMU/PCM` codecs into `FLAC` for MSE/MP4/HLS so they'll work almost anywhere
+- **WebRTC** audio codecs: `PCMU/8000`, `PCMA/8000`, `OPUS/48000/2`
+- `OPUS` and `MP3` inside **MP4** are part of the standard, but some players do not support them anyway (especially Apple)
+
+**Apple devices**
+
+- all Apple devices don't support HTTP progressive streaming
+- old iPhone firmwares don't support MSE technology because it competes with the HTTP Live Streaming (HLS) technology, invented by Apple
+- HLS is the worst technology for **live** streaming, it still exists only because of iPhones
+
+### Built-in transcoding
+
+There are no plans to embed complex transcoding algorithms inside go2rtc. 
+[FFmpeg source](internal/ffmpeg/README.md) does a great job with this. 
+Including [hardware acceleration](https://github.com/AlexxIT/go2rtc/wiki/Hardware-acceleration) support.
+
+But go2rtc has some simple algorithms. They are turned on automatically; you do not need to set them up additionally.
+
+**PCM for MSE/MP4/HLS**
+
+Go2rtc can pack `PCMA`, `PCMU` and `PCM` codecs into an MP4 container so that they work in all browsers and all built-in players on modern devices. Including Apple QuickTime:
+
+```text
+PCMA/PCMU => PCM => FLAC => MSE/MP4/HLS
+```
+
+**Resample PCMA/PCMU for WebRTC**
+
+By default WebRTC supports only `PCMA/8000` and `PCMU/8000`. But go2rtc can automatically resample PCMA and PCMU codecs with a different sample rate. Also, go2rtc can transcode `PCM` codec to `PCMA/8000`, so WebRTC can play it:
+
+```text
+PCM/xxx => PCMA/8000 => WebRTC
+PCMA/xxx => PCMA/8000 => WebRTC
+PCMU/xxx => PCMU/8000 => WebRTC
+```
+
+**Important**
+
+- FLAC codec not supported in an RTSP stream. If you are using Frigate or Home Assistant for recording MP4 files with PCMA/PCMU/PCM audio, you should set up transcoding to the AAC codec.
+- PCMA and PCMU are VERY low-quality codecs. They support only 256! different sounds. Use them only when you have no other options.
+
+### Codecs negotiation
+
+For example, you want to watch an RTSP stream from a [Dahua IPC-K42](https://www.dahuasecurity.com/fr/products/All-Products/Network-Cameras/Wireless-Series/Wi-Fi-Series/4MP/IPC-K42) camera in your Chrome browser.
+
+- this camera supports two-way audio standard **ONVIF Profile T**
+- this camera supports codecs **H264, H265** for sending video, and you select `H264` in camera settings
+- this camera supports codecs **AAC, PCMU, PCMA** for sending audio (from mic), and you select `AAC/16000` in camera settings
+- this camera supports codecs **AAC, PCMU, PCMA** for receiving audio (to speaker), you don't need to select them
+- your browser supports codecs **H264, VP8, VP9, AV1** for receiving video, you don't need to select them
+- your browser supports codecs **OPUS, PCMU, PCMA** for sending and receiving audio, you don't need to select them
+- you can't get the camera audio directly because its audio codecs don't match your browser's codecs
+    - so you decide to use transcoding via FFmpeg and add this setting to the config YAML file
+    - you have chosen `OPUS/48000/2` codec, because it is higher quality than the `PCMU/8000` or `PCMA/8000`
+
+Now you have a stream with two sources - **RTSP and FFmpeg**:
+
+```yaml
+streams:
+  dahua:
+    - rtsp://admin:password@192.168.1.123/cam/realmonitor?channel=1&subtype=0&unicast=true&proto=Onvif
+    - ffmpeg:rtsp://admin:password@192.168.1.123/cam/realmonitor?channel=1&subtype=0#audio=opus
+```
+
+**go2rtc** automatically matches codecs for your browser across all of your stream sources. This is called **multi-source two-way codec negotiation**, and it's one of the main features of this app.
+
+**PS.** You can select `PCMU` or `PCMA` codec in camera settings and not use transcoding at all. Or you can select `AAC` codec for main stream and `PCMU` codec for second stream and add both RTSP to YAML config, this also will work fine.
+
+## Security
+
+> [!IMPORTANT]
+> If an attacker gains access to the API, you are in danger. Through the API, an attacker can use insecure sources such as echo and exec. And get full access to your server.
+
+For maximum (paranoid) security, go2rtc has special settings:
+
+```yaml
+app:
+  # use only allowed modules
+  modules: [api, rtsp, webrtc, exec, ffmpeg, mjpeg]
+
+api:
+  # use only allowed API paths
+  allow_paths: [/api, /api/streams, /api/webrtc, /api/frame.jpeg]
+  # enable auth for localhost (used together with username and password)
+  local_auth: true
+
+exec:
+  # use only allowed exec paths
+  allow_paths: [ffmpeg]
+```
+
+By default, `go2rtc` starts the Web interface on port `1984` and RTSP on port `8554`, as well as uses port `8555` for WebRTC connections. The three ports are accessible from your local network. So anyone on your local network can watch video from your cameras without authorization. The same rule applies to the Home Assistant add-on.
+
+This is not a problem if you trust your local network as much as I do. But you can change this behaviour with a `go2rtc.yaml` config:
+
+```yaml
+api:
+  listen: "127.0.0.1:1984" # localhost
+
+rtsp:
+  listen: "127.0.0.1:8554" # localhost
+
+webrtc:
+  listen: ":8555" # external TCP/UDP port
+```
+
+- local access to RTSP is not a problem for [FFmpeg](internal/ffmpeg/README.md) integration, because it runs locally on your server
+- local access to API is not a problem for the [Home Assistant add-on](#go2rtc-home-assistant-add-on), because Home Assistant runs locally on the same server, and the add-on web UI is protected with Home Assistant authorization ([Ingress feature](https://www.home-assistant.io/blog/2019/04/15/hassio-ingress/))
+- external access to WebRTC TCP port is not a problem, because it is used only for transmitting encrypted media data
+    - anyway you need to open this port to your local network and to the Internet for WebRTC to work
+
+If you need web interface protection without the Home Assistant add-on, you need to use a reverse proxy, like [Nginx](https://nginx.org/), [Caddy](https://caddyserver.com/), etc.
+
+PS. Additionally, WebRTC will try to use the 8555 UDP port to transmit encrypted media. It works without problems on the local network, and sometimes also works for external access, even if you haven't opened this port on your router ([read more](https://en.wikipedia.org/wiki/UDP_hole_punching)). But for stable external WebRTC access, you need to open the 8555 port on your router for both TCP and UDP.
+
+## Projects using go2rtc
+
+- [Home Assistant](https://www.home-assistant.io/) [2024.11+](https://www.home-assistant.io/integrations/go2rtc/) - top open-source smart home project
+- [Frigate](https://frigate.video/) [0.12+](https://docs.frigate.video/guides/configuring_go2rtc/) - open-source NVR built around real-time AI object detection
+- [Advanced Camera Card](https://github.com/dermotduffy/advanced-camera-card) - custom card for Home Assistant
+- [OpenIPC](https://github.com/OpenIPC/firmware/tree/master/general/package/go2rtc) - alternative IP camera firmware from an open community
+- [wz_mini_hacks](https://github.com/gtxaspec/wz_mini_hacks) - custom firmware for Wyze cameras
+- [EufyP2PStream](https://github.com/oischinger/eufyp2pstream) - a small project that provides a video/audio stream from Eufy cameras that don't directly support RTSP
+- [ioBroker.euSec](https://github.com/bropat/ioBroker.eusec) - [ioBroker](https://www.iobroker.net/) adapter for controlling Eufy security devices
+- [MMM-go2rtc](https://github.com/Anonym-tsk/MMM-go2rtc) - MagicMirror² module
+- [ring-mqtt](https://github.com/tsightler/ring-mqtt) - Ring-to-MQTT bridge
+- [lightNVR](https://github.com/opensensor/lightNVR)
+
+**Distributions**
+
+- [Alpine Linux](https://pkgs.alpinelinux.org/packages?name=go2rtc)
+- [Arch User Repository](https://linux-packages.com/aur/package/go2rtc)
+- [Gentoo](https://github.com/inode64/inode64-overlay/tree/main/media-video/go2rtc)
+- [NixOS](https://search.nixos.org/packages?query=go2rtc)
+- [Proxmox Helper Scripts](https://github.com/community-scripts/ProxmoxVE/)
+- [QNAP](https://www.myqnap.org/product/go2rtc/)
+- [Synology NAS](https://synocommunity.com/package/go2rtc)
+- [Unraid](https://unraid.net/community/apps?q=go2rtc)
+
+## Camera experience
+
+- [Dahua](https://www.dahuasecurity.com/) - reference implementation streaming protocols, a lot of settings, high stream quality, multiple streaming clients
+- [EZVIZ](https://www.ezviz.com/) - awful RTSP protocol implementation, many bugs in SDP
+- [Hikvision](https://www.hikvision.com/) - a lot of proprietary streaming technologies
+- [Reolink](https://reolink.com/) - some models have an awful, unusable RTSP implementation and not the best RTMP alternative (I recommend that you contact Reolink support for new firmware), few settings
+- [Sonoff](https://sonoff.tech/) - very low stream quality, no settings, not the best protocol implementation
+- [TP-Link](https://www.tp-link.com/) - few streaming clients, packet loss?
+- Cheap noname cameras, Wyze Cams, Xiaomi cameras with hacks (usually have `/live/ch00_1` in RTSP URL) - awful but usable RTSP protocol implementation, low stream quality, few settings, packet loss?
+
+## Tips
+
+**Using apps for low RTSP delay**
+
+- `ffplay -fflags nobuffer -flags low_delay "rtsp://192.168.1.123:8554/camera1"`
+- VLC > Preferences > Input / Codecs > Default Caching Level: Lowest Latency
+
+**Snapshots to Telegram**
+
+[read more](https://github.com/AlexxIT/go2rtc/wiki/Snapshot-to-Telegram)
diff --git a/installs_on_host/go2rtc/docker/Dockerfile b/installs_on_host/go2rtc/docker/Dockerfile
new file mode 100644
index 0000000..9efded4
--- /dev/null
+++ b/installs_on_host/go2rtc/docker/Dockerfile
@@ -0,0 +1,55 @@
+# syntax=docker/dockerfile:labs
+
+# 0. Prepare images
+ARG PYTHON_VERSION="3.13"
+ARG GO_VERSION="1.25"
+
+
+# 1. Build go2rtc binary
+FROM --platform=$BUILDPLATFORM golang:${GO_VERSION}-alpine AS build
+ARG TARGETPLATFORM
+ARG TARGETOS
+ARG TARGETARCH
+
+ENV GOOS=${TARGETOS}
+ENV GOARCH=${TARGETARCH}
+
+WORKDIR /build
+
+RUN apk add git
+
+# Cache dependencies
+COPY go.mod go.sum ./
+RUN --mount=type=cache,target=/root/.cache/go-build go mod download
+
+COPY . .
+RUN --mount=type=cache,target=/root/.cache/go-build CGO_ENABLED=0 go build -ldflags "-s -w" -trimpath
+
+
+# 2. Final image
+FROM python:${PYTHON_VERSION}-alpine AS base
+
+# Install ffmpeg, tini (for signal handling),
+# and other common tools for the echo source.
+# alsa-plugins-pulse for ALSA support (+0MB)
+# font-droid for FFmpeg drawtext filter (+2MB)
+RUN apk add --no-cache tini ffmpeg ffplay bash curl jq alsa-plugins-pulse font-droid
+
+# Hardware Acceleration for Intel CPU (+50MB)
+ARG TARGETARCH
+
+RUN if [ "${TARGETARCH}" = "amd64" ]; then apk add --no-cache libva-intel-driver intel-media-driver; fi
+
+# Hardware: AMD and NVidia VAAPI (not sure about this)
+# RUN libva-glx mesa-va-gallium
+# Hardware: AMD and NVidia VDPAU (not sure about this)
+# RUN libva-vdpau-driver mesa-vdpau-gallium (+150MB total)
+
+COPY --from=build /build/go2rtc /usr/local/bin/
+
+EXPOSE 1984 8554 8555 8555/udp
+ENTRYPOINT ["/sbin/tini", "--"]
+VOLUME /config
+WORKDIR /config
+
+CMD ["go2rtc", "-config", "/config/go2rtc.yaml"]
diff --git a/installs_on_host/go2rtc/docker/README.md b/installs_on_host/go2rtc/docker/README.md
new file mode 100644
index 0000000..41069ba
--- /dev/null
+++ b/installs_on_host/go2rtc/docker/README.md
@@ -0,0 +1,54 @@
+# Docker
+
+Images are built automatically via [GitHub actions](https://github.com/AlexxIT/go2rtc/actions) and published on [Docker Hub](https://hub.docker.com/r/alexxit/go2rtc) and [GitHub](https://github.com/AlexxIT/go2rtc/pkgs/container/go2rtc).
+
+## Versions
+
+- `alexxit/go2rtc:latest` - latest release based on `alpine` (`amd64`, `386`, `arm/v6`, `arm/v7`, `arm64`) with support for hardware transcoding for Intel iGPU and Raspberry
+- `alexxit/go2rtc:latest-hardware` - latest release based on `debian 13` (`amd64`) with support for hardware transcoding for Intel iGPU, AMD GPU and NVidia GPU
+- `alexxit/go2rtc:latest-rockchip` - latest release based on `debian 12` (`arm64`) with support for hardware transcoding for Rockchip RK35xx
+- `alexxit/go2rtc:master` - latest unstable version based on `alpine`
+- `alexxit/go2rtc:master-hardware` - latest unstable version based on `debian 13` (`amd64`)
+- `alexxit/go2rtc:master-rockchip` - latest unstable version based on `debian 12` (`arm64`)
+
+## Docker compose
+
+```yaml
+services:
+  go2rtc:
+    image: alexxit/go2rtc
+    network_mode: host       # important for WebRTC, HomeKit, UDP cameras
+    privileged: true         # only for FFmpeg hardware transcoding
+    restart: unless-stopped  # autorestart on fail or config change from WebUI
+    environment:
+      - TZ=Atlantic/Bermuda  # timezone in logs
+    volumes:
+      - "~/go2rtc:/config"   # folder for go2rtc.yaml file (edit from WebUI)
+```
+
+## Basic Deployment
+
+```bash
+docker run -d \
+  --name go2rtc \
+  --network host \
+  --privileged \
+  --restart unless-stopped \
+  -e TZ=Atlantic/Bermuda \
+  -v ~/go2rtc:/config \
+  alexxit/go2rtc
+```
+
+## Deployment with GPU Acceleration
+
+```bash
+docker run -d \
+  --name go2rtc \
+  --network host \
+  --privileged \
+  --restart unless-stopped \
+  -e TZ=Atlantic/Bermuda \
+  --gpus all \
+  -v ~/go2rtc:/config \
+  alexxit/go2rtc:latest-hardware
+```
diff --git a/installs_on_host/go2rtc/docker/hardware.Dockerfile b/installs_on_host/go2rtc/docker/hardware.Dockerfile
new file mode 100644
index 0000000..563843b
--- /dev/null
+++ b/installs_on_host/go2rtc/docker/hardware.Dockerfile
@@ -0,0 +1,60 @@
+# syntax=docker/dockerfile:labs
+
+# 0. Prepare images
+# only debian 13 (trixie) has latest ffmpeg
+# https://packages.debian.org/trixie/ffmpeg
+ARG DEBIAN_VERSION="trixie-slim"
+ARG GO_VERSION="1.25-bookworm"
+
+
+# 1. Build go2rtc binary
+FROM --platform=$BUILDPLATFORM golang:${GO_VERSION} AS build
+ARG TARGETPLATFORM
+ARG TARGETOS
+ARG TARGETARCH
+
+ENV GOOS=${TARGETOS}
+ENV GOARCH=${TARGETARCH}
+
+WORKDIR /build
+
+# Cache dependencies
+COPY go.mod go.sum ./
+RUN --mount=type=cache,target=/root/.cache/go-build go mod download
+
+COPY . .
+RUN --mount=type=cache,target=/root/.cache/go-build CGO_ENABLED=0 go build -ldflags "-s -w" -trimpath
+
+
+# 2. Final image
+FROM debian:${DEBIAN_VERSION}
+
+# Prepare apt for buildkit cache
+RUN rm -f /etc/apt/apt.conf.d/docker-clean \
+  && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' >/etc/apt/apt.conf.d/keep-cache
+
+# Install ffmpeg, tini (for signal handling),
+# and other common tools for the echo source.
+# non-free for Intel QSV support (not used by go2rtc, just for tests)
+# mesa-va-drivers for AMD APU
+# libasound2-plugins for ALSA support
+RUN --mount=type=cache,target=/var/cache/apt,sharing=locked --mount=type=cache,target=/var/lib/apt,sharing=locked \
+    echo 'deb http://deb.debian.org/debian trixie non-free' > /etc/apt/sources.list.d/debian-non-free.list && \
+    apt-get -y update && apt-get -y install ffmpeg tini \
+        python3 curl jq \
+        intel-media-va-driver-non-free \
+        mesa-va-drivers \
+        libasound2-plugins && \
+    apt-get clean && rm -rf /var/lib/apt/lists/*
+
+COPY --from=build /build/go2rtc /usr/local/bin/
+
+EXPOSE 1984 8554 8555 8555/udp
+ENTRYPOINT ["/usr/bin/tini", "--"]
+VOLUME /config
+WORKDIR /config
+# https://github.com/NVIDIA/nvidia-docker/wiki/Installation-(Native-GPU-Support)
+ENV NVIDIA_VISIBLE_DEVICES all
+ENV NVIDIA_DRIVER_CAPABILITIES compute,video,utility
+
+CMD ["go2rtc", "-config", "/config/go2rtc.yaml"]
diff --git a/installs_on_host/go2rtc/docker/rockchip.Dockerfile b/installs_on_host/go2rtc/docker/rockchip.Dockerfile
new file mode 100644
index 0000000..6ab924e
--- /dev/null
+++ b/installs_on_host/go2rtc/docker/rockchip.Dockerfile
@@ -0,0 +1,51 @@
+# syntax=docker/dockerfile:labs
+
+# 0. Prepare images
+ARG PYTHON_VERSION="3.13-slim-bookworm"
+ARG GO_VERSION="1.25-bookworm"
+
+
+# 1. Build go2rtc binary
+FROM --platform=$BUILDPLATFORM golang:${GO_VERSION} AS build
+ARG TARGETPLATFORM
+ARG TARGETOS
+ARG TARGETARCH
+
+ENV GOOS=${TARGETOS}
+ENV GOARCH=${TARGETARCH}
+
+WORKDIR /build
+
+# Cache dependencies
+COPY go.mod go.sum ./
+RUN --mount=type=cache,target=/root/.cache/go-build go mod download
+
+COPY . .
+RUN --mount=type=cache,target=/root/.cache/go-build CGO_ENABLED=0 go build -ldflags "-s -w" -trimpath
+
+
+# 2. Final image
+FROM python:${PYTHON_VERSION}
+
+# Prepare apt for buildkit cache
+RUN rm -f /etc/apt/apt.conf.d/docker-clean \
+  && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' >/etc/apt/apt.conf.d/keep-cache
+
+# Install ffmpeg, tini (for signal handling),
+# and other common tools for the echo source.
+# libasound2-plugins for ALSA support
+RUN --mount=type=cache,target=/var/cache/apt,sharing=locked --mount=type=cache,target=/var/lib/apt,sharing=locked \
+    apt-get -y update && apt-get -y install tini \
+        curl jq \
+        libasound2-plugins && \
+    apt-get clean && rm -rf /var/lib/apt/lists/*
+
+COPY --from=build /build/go2rtc /usr/local/bin/
+ADD --chmod=755 https://github.com/MarcA711/Rockchip-FFmpeg-Builds/releases/download/6.1-8-no_extra_dump/ffmpeg /usr/local/bin
+
+EXPOSE 1984 8554 8555 8555/udp
+ENTRYPOINT ["/usr/bin/tini", "--"]
+VOLUME /config
+WORKDIR /config
+
+CMD ["go2rtc", "-config", "/config/go2rtc.yaml"]
diff --git a/installs_on_host/go2rtc/examples/go2rtc_hass/main.go b/installs_on_host/go2rtc/examples/go2rtc_hass/main.go
new file mode 100644
index 0000000..42c2d15
--- /dev/null
+++ b/installs_on_host/go2rtc/examples/go2rtc_hass/main.go
@@ -0,0 +1,20 @@
+package main
+
+import (
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/hass"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/shell"
+)
+
+func main() {
+	app.Init()
+	streams.Init()
+
+	api.Init()
+
+	hass.Init()
+
+	shell.RunUntilSignal()
+}
diff --git a/installs_on_host/go2rtc/examples/go2rtc_mjpeg/main.go b/installs_on_host/go2rtc/examples/go2rtc_mjpeg/main.go
new file mode 100644
index 0000000..3c915b3
--- /dev/null
+++ b/installs_on_host/go2rtc/examples/go2rtc_mjpeg/main.go
@@ -0,0 +1,26 @@
+package main
+
+import (
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/api/ws"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/ffmpeg"
+	"github.com/AlexxIT/go2rtc/internal/mjpeg"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/internal/v4l2"
+	"github.com/AlexxIT/go2rtc/pkg/shell"
+)
+
+func main() {
+	app.Init()
+	streams.Init()
+
+	api.Init()
+	ws.Init()
+
+	ffmpeg.Init()
+	mjpeg.Init()
+	v4l2.Init()
+
+	shell.RunUntilSignal()
+}
diff --git a/installs_on_host/go2rtc/examples/go2rtc_rtsp/main.go b/installs_on_host/go2rtc/examples/go2rtc_rtsp/main.go
new file mode 100644
index 0000000..07d3256
--- /dev/null
+++ b/installs_on_host/go2rtc/examples/go2rtc_rtsp/main.go
@@ -0,0 +1,17 @@
+package main
+
+import (
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/rtsp"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/shell"
+)
+
+func main() {
+	app.Init()
+	streams.Init()
+
+	rtsp.Init()
+
+	shell.RunUntilSignal()
+}
diff --git a/installs_on_host/go2rtc/examples/homekit_info/main.go b/installs_on_host/go2rtc/examples/homekit_info/main.go
new file mode 100644
index 0000000..8527042
--- /dev/null
+++ b/installs_on_host/go2rtc/examples/homekit_info/main.go
@@ -0,0 +1,123 @@
+package main
+
+import (
+	"encoding/json"
+	"os"
+
+	"github.com/AlexxIT/go2rtc/pkg/hap"
+)
+
+var servs = map[string]string{
+	"3E":  "Accessory Information",
+	"7E":  "Security System",
+	"85":  "Motion Sensor",
+	"96":  "Battery",
+	"A2":  "Protocol Information",
+	"110": "Camera RTP Stream Management",
+	"112": "Microphone",
+	"113": "Speaker",
+	"121": "Doorbell",
+	"129": "Data Stream Transport Management",
+	"204": "Camera Recording Management",
+	"21A": "Camera Operating Mode",
+	"22A": "Wi-Fi Transport",
+	"239": "Accessory Runtime Information",
+}
+
+var chars = map[string]string{
+	"14":  "Identify",
+	"20":  "Manufacturer",
+	"21":  "Model",
+	"23":  "Name",
+	"30":  "Serial Number",
+	"52":  "Firmware Revision",
+	"53":  "Hardware Revision",
+	"220": "Product Data",
+	"A6":  "Accessory Flags",
+
+	"22": "Motion Detected",
+	"75": "Status Active",
+
+	"11A": "Mute",
+	"119": "Volume",
+
+	"B0":  "Active",
+	"209": "Selected Camera Recording Configuration",
+	"207": "Supported Audio Recording Configuration",
+	"205": "Supported Camera Recording Configuration",
+	"206": "Supported Video Recording Configuration",
+	"226": "Recording Audio Active",
+
+	"223": "Event Snapshots Active",
+	"225": "Periodic Snapshots Active",
+	"21B": "HomeKit Camera Active",
+	"21C": "Third Party Camera Active",
+	"21D": "Camera Operating Mode Indicator",
+	"11B": "Night Vision",
+	//"129": "Supported Data Stream Transport Configuration",
+	"37":  "Version",
+	"131": "Setup Data Stream Transport",
+	"130": "Supported Data Stream Transport Configuration",
+
+	"120": "Streaming Status",
+	"115": "Supported Audio Stream Configuration",
+	"116": "Supported RTP Configuration",
+	"114": "Supported Video Stream Configuration",
+	"117": "Selected RTP Stream Configuration",
+	"118": "Setup Endpoints",
+
+	"22B": "Current Transport",
+	"22C": "Wi-Fi Capabilities",
+	"22D": "Wi-Fi Configuration Control",
+
+	"23C": "Ping",
+
+	"68": "Battery Level",
+	"79": "Status Low Battery",
+	"8F": "Charging State",
+
+	"73":  "Programmable Switch Event",
+	"232": "Operating State Response",
+
+	"66": "Security System Current State",
+	"67": "Security System Target State",
+}
+
+func main() {
+	src := os.Args[1]
+	dst := os.Args[2]
+
+	f, err := os.Open(src)
+	if err != nil {
+		panic(err)
+	}
+
+	var v hap.JSONAccessories
+	if err = json.NewDecoder(f).Decode(&v); err != nil {
+		panic(err)
+	}
+
+	for _, acc := range v.Value {
+		for _, srv := range acc.Services {
+			if srv.Desc == "" {
+				srv.Desc = servs[srv.Type]
+			}
+			for _, chr := range srv.Characters {
+				if chr.Desc == "" {
+					chr.Desc = chars[chr.Type]
+				}
+			}
+		}
+	}
+
+	f, err = os.Create(dst)
+	if err != nil {
+		panic(err)
+	}
+
+	enc := json.NewEncoder(f)
+	enc.SetIndent("", "  ")
+	if err = enc.Encode(v); err != nil {
+		panic(err)
+	}
+}
diff --git a/installs_on_host/go2rtc/examples/mdns/main.go b/installs_on_host/go2rtc/examples/mdns/main.go
new file mode 100644
index 0000000..52f065a
--- /dev/null
+++ b/installs_on_host/go2rtc/examples/mdns/main.go
@@ -0,0 +1,39 @@
+package main
+
+import (
+	"log"
+	"os"
+
+	"github.com/AlexxIT/go2rtc/pkg/mdns"
+)
+
+func main() {
+	var service = mdns.ServiceHAP
+
+	if len(os.Args) >= 2 {
+		service = os.Args[1]
+	}
+
+	onentry := func(entry *mdns.ServiceEntry) bool {
+		log.Printf("name=%s, addr=%s, info=%s\n", entry.Name, entry.Addr(), entry.Info)
+		return false
+	}
+
+	var err error
+
+	if len(os.Args) >= 3 {
+		host := os.Args[2]
+
+		log.Printf("run discovery service=%s host=%s\n", service, host)
+
+		err = mdns.QueryOrDiscovery(host, service, onentry)
+	} else {
+		log.Printf("run discovery service=%s\n", service)
+
+		err = mdns.Discovery(service, onentry)
+	}
+
+	if err != nil {
+		log.Println(err)
+	}
+}
diff --git a/installs_on_host/go2rtc/examples/mod_pinggy/go.mod b/installs_on_host/go2rtc/examples/mod_pinggy/go.mod
new file mode 100644
index 0000000..893e601
--- /dev/null
+++ b/installs_on_host/go2rtc/examples/mod_pinggy/go.mod
@@ -0,0 +1,9 @@
+module pinggy
+
+go 1.25
+
+require (
+	github.com/Pinggy-io/pinggy-go/pinggy v0.6.9 // indirect
+	golang.org/x/crypto v0.8.0 // indirect
+	golang.org/x/sys v0.7.0 // indirect
+)
diff --git a/installs_on_host/go2rtc/examples/mod_pinggy/go.sum b/installs_on_host/go2rtc/examples/mod_pinggy/go.sum
new file mode 100644
index 0000000..05298fb
--- /dev/null
+++ b/installs_on_host/go2rtc/examples/mod_pinggy/go.sum
@@ -0,0 +1,39 @@
+github.com/Pinggy-io/pinggy-go/pinggy v0.6.9 h1:lzZ00JK6BUGQXnpkJZ+cVj8kIkXsmiVBUci9uEkSwEY=
+github.com/Pinggy-io/pinggy-go/pinggy v0.6.9/go.mod h1:V1Sxb+4zyr36o9atZiqtT4XhsKtW1RSb2GvsbTbTJYw=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.8.0 h1:pd9TJtTueMTVQXzk8E2XESSMQDj/U7OUu0PqJqPXQjQ=
+golang.org/x/crypto v0.8.0/go.mod h1:mRqEX+O9/h5TFCrQhkgjo2yKi0yYA+9ecGkdQoHrywE=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU=
+golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
diff --git a/installs_on_host/go2rtc/examples/mod_pinggy/main.go b/installs_on_host/go2rtc/examples/mod_pinggy/main.go
new file mode 100644
index 0000000..f494263
--- /dev/null
+++ b/installs_on_host/go2rtc/examples/mod_pinggy/main.go
@@ -0,0 +1,41 @@
+package main
+
+import (
+	"log"
+	"os"
+
+	"github.com/Pinggy-io/pinggy-go/pinggy"
+)
+
+func main() {
+	tunType := os.Args[1]
+	address := os.Args[2]
+
+	log.SetFlags(log.Llongfile | log.LstdFlags)
+
+	config := pinggy.Config{
+		Type:              pinggy.TunnelType(tunType),
+		TcpForwardingAddr: address,
+
+		//SshOverSsl: true,
+		//Stdout:     os.Stderr,
+		//Stderr:     os.Stderr,
+	}
+
+	if tunType == "http" {
+		hman := pinggy.CreateHeaderManipulationAndAuthConfig()
+		//hman.SetReverseProxy(address)
+		//hman.SetPassPreflight(true)
+		//hman.SetNoReverseProxy()
+		config.HeaderManipulationAndAuth = hman
+	}
+
+	pl, err := pinggy.ConnectWithConfig(config)
+	if err != nil {
+		log.Panicln(err)
+	}
+	log.Println("Addrs: ", pl.RemoteUrls())
+	//err = pl.InitiateWebDebug("localhost:3424")
+	//log.Println(err)
+	pl.StartForwarding()
+}
diff --git a/installs_on_host/go2rtc/examples/onvif_client/README.md b/installs_on_host/go2rtc/examples/onvif_client/README.md
new file mode 100644
index 0000000..1fda07f
--- /dev/null
+++ b/installs_on_host/go2rtc/examples/onvif_client/README.md
@@ -0,0 +1,5 @@
+## ONVIF Client
+
+```shell
+go run examples/onvif_client/main.go http://admin:password@192.168.10.90 GetAudioEncoderConfigurations
+```
\ No newline at end of file
diff --git a/installs_on_host/go2rtc/examples/onvif_client/main.go b/installs_on_host/go2rtc/examples/onvif_client/main.go
new file mode 100644
index 0000000..724d325
--- /dev/null
+++ b/installs_on_host/go2rtc/examples/onvif_client/main.go
@@ -0,0 +1,75 @@
+package main
+
+import (
+	"log"
+	"net/url"
+	"os"
+
+	"github.com/AlexxIT/go2rtc/pkg/onvif"
+)
+
+func main() {
+	var rawURL = os.Args[1]
+	var operation = os.Args[2]
+	var token string
+	if len(os.Args) > 3 {
+		token = os.Args[3]
+	}
+
+	client, err := onvif.NewClient(rawURL)
+	if err != nil {
+		log.Panic(err)
+	}
+
+	var b []byte
+
+	switch operation {
+	case onvif.ServiceGetServiceCapabilities:
+		b, err = client.MediaRequest(operation)
+	case onvif.DeviceGetCapabilities,
+		onvif.DeviceGetDeviceInformation,
+		onvif.DeviceGetDiscoveryMode,
+		onvif.DeviceGetDNS,
+		onvif.DeviceGetHostname,
+		onvif.DeviceGetNetworkDefaultGateway,
+		onvif.DeviceGetNetworkInterfaces,
+		onvif.DeviceGetNetworkProtocols,
+		onvif.DeviceGetNTP,
+		onvif.DeviceGetScopes,
+		onvif.DeviceGetServices,
+		onvif.DeviceGetSystemDateAndTime,
+		onvif.DeviceSystemReboot:
+		b, err = client.DeviceRequest(operation)
+	case onvif.MediaGetProfiles,
+		onvif.MediaGetVideoEncoderConfigurations,
+		onvif.MediaGetVideoSources,
+		onvif.MediaGetVideoSourceConfigurations,
+		onvif.MediaGetAudioEncoderConfigurations,
+		onvif.MediaGetAudioSources,
+		onvif.MediaGetAudioSourceConfigurations:
+		b, err = client.MediaRequest(operation)
+	case onvif.MediaGetProfile:
+		b, err = client.GetProfile(token)
+	case onvif.MediaGetVideoSourceConfiguration:
+		b, err = client.GetVideoSourceConfiguration(token)
+	case onvif.MediaGetStreamUri:
+		b, err = client.GetStreamUri(token)
+	case onvif.MediaGetSnapshotUri:
+		b, err = client.GetSnapshotUri(token)
+	default:
+		log.Printf("unknown action\n")
+	}
+
+	if err != nil {
+		log.Printf("%s\n", err)
+	}
+
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if err = os.WriteFile(u.Hostname()+"_"+operation+".xml", b, 0644); err != nil {
+		log.Printf("%s\n", err)
+	}
+}
diff --git a/installs_on_host/go2rtc/examples/rtsp_client/main.go b/installs_on_host/go2rtc/examples/rtsp_client/main.go
new file mode 100644
index 0000000..9c2112d
--- /dev/null
+++ b/installs_on_host/go2rtc/examples/rtsp_client/main.go
@@ -0,0 +1,39 @@
+package main
+
+import (
+	"log"
+	"os"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/rtsp"
+	"github.com/AlexxIT/go2rtc/pkg/shell"
+)
+
+func main() {
+	client := rtsp.NewClient(os.Args[1])
+	if err := client.Dial(); err != nil {
+		log.Panic(err)
+	}
+
+	client.Medias = []*core.Media{
+		{
+			Kind:      core.KindAudio,
+			Direction: core.DirectionRecvonly,
+			Codecs: []*core.Codec{
+				{Name: core.CodecPCMU, ClockRate: 8000},
+			},
+			ID: "streamid=0",
+		},
+	}
+	if err := client.Announce(); err != nil {
+		log.Panic(err)
+	}
+	if _, err := client.SetupMedia(client.Medias[0]); err != nil {
+		log.Panic(err)
+	}
+	if err := client.Record(); err != nil {
+		log.Panic(err)
+	}
+
+	shell.RunUntilSignal()
+}
diff --git a/installs_on_host/go2rtc/examples/tutk_decoder/README.md b/installs_on_host/go2rtc/examples/tutk_decoder/README.md
new file mode 100644
index 0000000..197bd82
--- /dev/null
+++ b/installs_on_host/go2rtc/examples/tutk_decoder/README.md
@@ -0,0 +1,5 @@
+# tutk_decoder
+
+1. Wireshark > Select any packet > Follow > UDP Stream
+2. Wireshark > File > Export Packet Dissections > As JSON > Displayed, Values
+3. `tutk_decoder wireshark.json decoded.txt`
diff --git a/installs_on_host/go2rtc/examples/tutk_decoder/main.go b/installs_on_host/go2rtc/examples/tutk_decoder/main.go
new file mode 100644
index 0000000..0b6d90a
--- /dev/null
+++ b/installs_on_host/go2rtc/examples/tutk_decoder/main.go
@@ -0,0 +1,82 @@
+package main
+
+import (
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"log"
+	"os"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/pkg/tutk"
+)
+
+func main() {
+	if len(os.Args) != 3 {
+		fmt.Println("Usage: tutk_decoder wireshark.json decoded.txt")
+		return
+	}
+
+	src, err := os.Open(os.Args[1])
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer src.Close()
+
+	dst, err := os.Create(os.Args[2])
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer dst.Close()
+
+	var items []item
+	if err = json.NewDecoder(src).Decode(&items); err != nil {
+		log.Fatal(err)
+	}
+
+	var b []byte
+
+	for _, v := range items {
+		if v.Source.Layers.Data.DataData == "" {
+			continue
+		}
+
+		s := strings.ReplaceAll(v.Source.Layers.Data.DataData, ":", "")
+		b, err = hex.DecodeString(s)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		tutk.ReverseTransCodePartial(b, b)
+
+		ts := v.Source.Layers.Frame.FrameTimeRelative
+
+		_, _ = fmt.Fprintf(dst, "%8s: %s -> %s [%4d] %x\n",
+			ts[:len(ts)-6],
+			v.Source.Layers.Ip.IpSrc, v.Source.Layers.Ip.IpDst,
+			len(b), b)
+	}
+}
+
+type item struct {
+	Source struct {
+		Layers struct {
+			Frame struct {
+				FrameTimeRelative string `json:"frame.time_relative"`
+				FrameNumber       string `json:"frame.number"`
+			} `json:"frame"`
+			Ip struct {
+				IpSrc string `json:"ip.src"`
+				IpDst string `json:"ip.dst"`
+			} `json:"ip"`
+			Udp struct {
+				UdpSrcport string `json:"udp.srcport"`
+				UdpDstport string `json:"udp.dstport"`
+			} `json:"udp"`
+			Data struct {
+				DataData string `json:"data.data"`
+				DataLen  string `json:"data.len"`
+			} `json:"data"`
+		} `json:"layers"`
+	} `json:"_source"`
+}
diff --git a/installs_on_host/go2rtc/go.mod b/installs_on_host/go2rtc/go.mod
new file mode 100644
index 0000000..485509e
--- /dev/null
+++ b/installs_on_host/go2rtc/go.mod
@@ -0,0 +1,52 @@
+module github.com/AlexxIT/go2rtc
+
+go 1.24.0
+
+require (
+	github.com/asticode/go-astits v1.14.0
+	github.com/eclipse/paho.mqtt.golang v1.5.1
+	github.com/expr-lang/expr v1.17.7
+	github.com/google/uuid v1.6.0
+	github.com/gorilla/websocket v1.5.3
+	github.com/mattn/go-isatty v0.0.20
+	github.com/miekg/dns v1.1.70
+	github.com/pion/dtls/v3 v3.0.10
+	github.com/pion/ice/v4 v4.2.0
+	github.com/pion/interceptor v0.1.43
+	github.com/pion/rtcp v1.2.16
+	github.com/pion/rtp v1.10.0
+	github.com/pion/sdp/v3 v3.0.17
+	github.com/pion/srtp/v3 v3.0.10
+	github.com/pion/stun/v3 v3.1.1
+	github.com/pion/webrtc/v4 v4.2.3
+	github.com/rs/zerolog v1.34.0
+	github.com/sigurn/crc16 v0.0.0-20240131213347-83fcde1e29d1
+	github.com/sigurn/crc8 v0.0.0-20220107193325-2243fe600f9f
+	github.com/stretchr/testify v1.11.1
+	github.com/tadglines/go-pkgs v0.0.0-20210623144937-b983b20f54f9
+	golang.org/x/crypto v0.47.0
+	golang.org/x/net v0.49.0
+	gopkg.in/yaml.v3 v3.0.1
+)
+
+require (
+	github.com/asticode/go-astikit v0.57.1 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/kr/pretty v0.3.1 // indirect
+	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/pion/datachannel v1.6.0 // indirect
+	github.com/pion/logging v0.2.4 // indirect
+	github.com/pion/mdns/v2 v2.1.0 // indirect
+	github.com/pion/randutil v0.1.0 // indirect
+	github.com/pion/sctp v1.9.2 // indirect
+	github.com/pion/transport/v3 v3.1.1 // indirect
+	github.com/pion/transport/v4 v4.0.1 // indirect
+	github.com/pion/turn/v4 v4.1.4 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/wlynxg/anet v0.0.5 // indirect
+	golang.org/x/mod v0.32.0 // indirect
+	golang.org/x/sync v0.19.0 // indirect
+	golang.org/x/sys v0.40.0 // indirect
+	golang.org/x/time v0.14.0 // indirect
+	golang.org/x/tools v0.41.0 // indirect
+)
diff --git a/installs_on_host/go2rtc/go.sum b/installs_on_host/go2rtc/go.sum
new file mode 100644
index 0000000..897bb8a
--- /dev/null
+++ b/installs_on_host/go2rtc/go.sum
@@ -0,0 +1,152 @@
+github.com/asticode/go-astikit v0.30.0/go.mod h1:h4ly7idim1tNhaVkdVBeXQZEE3L0xblP7fCWbgwipF0=
+github.com/asticode/go-astikit v0.57.1 h1:fEykwH98Nny08kcRbk4uer+S8h0rKveCIpG9F6NVLuA=
+github.com/asticode/go-astikit v0.57.1/go.mod h1:fV43j20UZYfXzP9oBn33udkvCvDvCDhzjVqoLFuuYZE=
+github.com/asticode/go-astits v1.14.0 h1:zkgnZzipx2XX5mWycqsSBeEyDH58+i4HtyF4j2ROb00=
+github.com/asticode/go-astits v1.14.0/go.mod h1:QSHmknZ51pf6KJdHKZHJTLlMegIrhega3LPWz3ND/iI=
+github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/eclipse/paho.mqtt.golang v1.5.1 h1:/VSOv3oDLlpqR2Epjn1Q7b2bSTplJIeV2ISgCl2W7nE=
+github.com/eclipse/paho.mqtt.golang v1.5.1/go.mod h1:1/yJCneuyOoCOzKSsOTUc0AJfpsItBGWvYpBLimhArU=
+github.com/expr-lang/expr v1.17.6 h1:1h6i8ONk9cexhDmowO/A64VPxHScu7qfSl2k8OlINec=
+github.com/expr-lang/expr v1.17.6/go.mod h1:8/vRC7+7HBzESEqt5kKpYXxrxkr31SaO8r40VO/1IT4=
+github.com/expr-lang/expr v1.17.7 h1:Q0xY/e/2aCIp8g9s/LGvMDCC5PxYlvHgDZRQ4y16JX8=
+github.com/expr-lang/expr v1.17.7/go.mod h1:8/vRC7+7HBzESEqt5kKpYXxrxkr31SaO8r40VO/1IT4=
+github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
+github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/miekg/dns v1.1.69 h1:Kb7Y/1Jo+SG+a2GtfoFUfDkG//csdRPwRLkCsxDG9Sc=
+github.com/miekg/dns v1.1.69/go.mod h1:7OyjD9nEba5OkqQ/hB4fy3PIoxafSZJtducccIelz3g=
+github.com/miekg/dns v1.1.70 h1:DZ4u2AV35VJxdD9Fo9fIWm119BsQL5cZU1cQ9s0LkqA=
+github.com/miekg/dns v1.1.70/go.mod h1:+EuEPhdHOsfk6Wk5TT2CzssZdqkmFhf8r+aVyDEToIs=
+github.com/pion/datachannel v1.5.10 h1:ly0Q26K1i6ZkGf42W7D4hQYR90pZwzFOjTq5AuCKk4o=
+github.com/pion/datachannel v1.5.10/go.mod h1:p/jJfC9arb29W7WrxyKbepTU20CFgyx5oLo8Rs4Py/M=
+github.com/pion/datachannel v1.6.0 h1:XecBlj+cvsxhAMZWFfFcPyUaDZtd7IJvrXqlXD/53i0=
+github.com/pion/datachannel v1.6.0/go.mod h1:ur+wzYF8mWdC+Mkis5Thosk+u/VOL287apDNEbFpsIk=
+github.com/pion/dtls/v3 v3.0.9 h1:4AijfFRm8mAjd1gfdlB1wzJF3fjjR/VPIpJgkEtvYmM=
+github.com/pion/dtls/v3 v3.0.9/go.mod h1:abApPjgadS/ra1wvUzHLc3o2HvoxppAh+NZkyApL4Os=
+github.com/pion/dtls/v3 v3.0.10 h1:k9ekkq1kaZoxnNEbyLKI8DI37j/Nbk1HWmMuywpQJgg=
+github.com/pion/dtls/v3 v3.0.10/go.mod h1:YEmmBYIoBsY3jmG56dsziTv/Lca9y4Om83370CXfqJ8=
+github.com/pion/ice/v4 v4.1.0 h1:YlxIii2bTPWyC08/4hdmtYq4srbrY0T9xcTsTjldGqU=
+github.com/pion/ice/v4 v4.1.0/go.mod h1:5gPbzYxqenvn05k7zKPIZFuSAufolygiy6P1U9HzvZ4=
+github.com/pion/ice/v4 v4.2.0 h1:jJC8S+CvXCCvIQUgx+oNZnoUpt6zwc34FhjWwCU4nlw=
+github.com/pion/ice/v4 v4.2.0/go.mod h1:EgjBGxDgmd8xB0OkYEVFlzQuEI7kWSCFu+mULqaisy4=
+github.com/pion/interceptor v0.1.42 h1:0/4tvNtruXflBxLfApMVoMubUMik57VZ+94U0J7cmkQ=
+github.com/pion/interceptor v0.1.42/go.mod h1:g6XYTChs9XyolIQFhRHOOUS+bGVGLRfgTCUzH29EfVU=
+github.com/pion/interceptor v0.1.43 h1:6hmRfnmjogSs300xfkR0JxYFZ9k5blTEvCD7wxEDuNQ=
+github.com/pion/interceptor v0.1.43/go.mod h1:BSiC1qKIJt1XVr3l3xQ2GEmCFStk9tx8fwtCZxxgR7M=
+github.com/pion/logging v0.2.4 h1:tTew+7cmQ+Mc1pTBLKH2puKsOvhm32dROumOZ655zB8=
+github.com/pion/logging v0.2.4/go.mod h1:DffhXTKYdNZU+KtJ5pyQDjvOAh/GsNSyv1lbkFbe3so=
+github.com/pion/mdns/v2 v2.1.0 h1:3IJ9+Xio6tWYjhN6WwuY142P/1jA0D5ERaIqawg/fOY=
+github.com/pion/mdns/v2 v2.1.0/go.mod h1:pcez23GdynwcfRU1977qKU0mDxSeucttSHbCSfFOd9A=
+github.com/pion/randutil v0.1.0 h1:CFG1UdESneORglEsnimhUjf33Rwjubwj6xfiOXBa3mA=
+github.com/pion/randutil v0.1.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8=
+github.com/pion/rtcp v1.2.16 h1:fk1B1dNW4hsI78XUCljZJlC4kZOPk67mNRuQ0fcEkSo=
+github.com/pion/rtcp v1.2.16/go.mod h1:/as7VKfYbs5NIb4h6muQ35kQF/J0ZVNz2Z3xKoCBYOo=
+github.com/pion/rtp v1.8.26 h1:VB+ESQFQhBXFytD+Gk8cxB6dXeVf2WQzg4aORvAvAAc=
+github.com/pion/rtp v1.8.26/go.mod h1:rF5nS1GqbR7H/TCpKwylzeq6yDM+MM6k+On5EgeThEM=
+github.com/pion/rtp v1.10.0 h1:XN/xca4ho6ZEcijpdF2VGFbwuHUfiIMf3ew8eAAE43w=
+github.com/pion/rtp v1.10.0/go.mod h1:rF5nS1GqbR7H/TCpKwylzeq6yDM+MM6k+On5EgeThEM=
+github.com/pion/sctp v1.8.41 h1:20R4OHAno4Vky3/iE4xccInAScAa83X6nWUfyc65MIs=
+github.com/pion/sctp v1.8.41/go.mod h1:2wO6HBycUH7iCssuGyc2e9+0giXVW0pyCv3ZuL8LiyY=
+github.com/pion/sctp v1.9.2 h1:HxsOzEV9pWoeggv7T5kewVkstFNcGvhMPx0GvUOUQXo=
+github.com/pion/sctp v1.9.2/go.mod h1:OTOlsQ5EDQ6mQ0z4MUGXt2CgQmKyafBEXhUVqLRB6G8=
+github.com/pion/sdp/v3 v3.0.16 h1:0dKzYO6gTAvuLaAKQkC02eCPjMIi4NuAr/ibAwrGDCo=
+github.com/pion/sdp/v3 v3.0.16/go.mod h1:9tyKzznud3qiweZcD86kS0ff1pGYB3VX+Bcsmkx6IXo=
+github.com/pion/sdp/v3 v3.0.17 h1:9SfLAW/fF1XC8yRqQ3iWGzxkySxup4k4V7yN8Fs8nuo=
+github.com/pion/sdp/v3 v3.0.17/go.mod h1:9tyKzznud3qiweZcD86kS0ff1pGYB3VX+Bcsmkx6IXo=
+github.com/pion/srtp/v3 v3.0.9 h1:lRGF4G61xxj+m/YluB3ZnBpiALSri2lTzba0kGZMrQY=
+github.com/pion/srtp/v3 v3.0.9/go.mod h1:E+AuWd7Ug2Fp5u38MKnhduvpVkveXJX6J4Lq4rxUYt8=
+github.com/pion/srtp/v3 v3.0.10 h1:tFirkpBb3XccP5VEXLi50GqXhv5SKPxqrdlhDCJlZrQ=
+github.com/pion/srtp/v3 v3.0.10/go.mod h1:3mOTIB0cq9qlbn59V4ozvv9ClW/BSEbRp4cY0VtaR7M=
+github.com/pion/stun/v3 v3.0.2 h1:BJuGEN2oLrJisiNEJtUTJC4BGbzbfp37LizfqswblFU=
+github.com/pion/stun/v3 v3.0.2/go.mod h1:JFJKfIWvt178MCF5H/YIgZ4VX3LYE77vca4b9HP60SA=
+github.com/pion/stun/v3 v3.1.1 h1:CkQxveJ4xGQjulGSROXbXq94TAWu8gIX2dT+ePhUkqw=
+github.com/pion/stun/v3 v3.1.1/go.mod h1:qC1DfmcCTQjl9PBaMa5wSn3x9IPmKxSdcCsxBcDBndM=
+github.com/pion/transport/v3 v3.1.1 h1:Tr684+fnnKlhPceU+ICdrw6KKkTms+5qHMgw6bIkYOM=
+github.com/pion/transport/v3 v3.1.1/go.mod h1:+c2eewC5WJQHiAA46fkMMzoYZSuGzA/7E2FPrOYHctQ=
+github.com/pion/transport/v4 v4.0.1 h1:sdROELU6BZ63Ab7FrOLn13M6YdJLY20wldXW2Cu2k8o=
+github.com/pion/transport/v4 v4.0.1/go.mod h1:nEuEA4AD5lPdcIegQDpVLgNoDGreqM/YqmEx3ovP4jM=
+github.com/pion/turn/v4 v4.1.3 h1:jVNW0iR05AS94ysEtvzsrk3gKs9Zqxf6HmnsLfRvlzA=
+github.com/pion/turn/v4 v4.1.3/go.mod h1:TD/eiBUf5f5LwXbCJa35T7dPtTpCHRJ9oJWmyPLVT3A=
+github.com/pion/turn/v4 v4.1.4 h1:EU11yMXKIsK43FhcUnjLlrhE4nboHZq+TXBIi3QpcxQ=
+github.com/pion/turn/v4 v4.1.4/go.mod h1:ES1DXVFKnOhuDkqn9hn5VJlSWmZPaRJLyBXoOeO/BmQ=
+github.com/pion/webrtc/v4 v4.1.8 h1:ynkjfiURDQ1+8EcJsoa60yumHAmyeYjz08AaOuor+sk=
+github.com/pion/webrtc/v4 v4.1.8/go.mod h1:KVaARG2RN0lZx0jc7AWTe38JpPv+1/KicOZ9jN52J/s=
+github.com/pion/webrtc/v4 v4.2.3 h1:RtdWDnkenNQGxUrZqWa5gSkTm5ncsLg5d+zu0M4cXt4=
+github.com/pion/webrtc/v4 v4.2.3/go.mod h1:7vsyFzRzaKP5IELUnj8zLcglPyIT6wWwqTppBZ1k6Kc=
+github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/profile v1.4.0/go.mod h1:NWz/XGvpEW1FyYQ7fCx4dqYBLlfTcE+A9FLAkNKqjFE=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
+github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
+github.com/rs/zerolog v1.34.0 h1:k43nTLIwcTVQAncfCw4KZ2VY6ukYoZaBPNOE8txlOeY=
+github.com/rs/zerolog v1.34.0/go.mod h1:bJsvje4Z08ROH4Nhs5iH600c3IkWhwp44iRc54W6wYQ=
+github.com/sigurn/crc16 v0.0.0-20240131213347-83fcde1e29d1 h1:NVK+OqnavpyFmUiKfUMHrpvbCi2VFoWTrcpI7aDaJ2I=
+github.com/sigurn/crc16 v0.0.0-20240131213347-83fcde1e29d1/go.mod h1:9/etS5gpQq9BJsJMWg1wpLbfuSnkm8dPF6FdW2JXVhA=
+github.com/sigurn/crc8 v0.0.0-20220107193325-2243fe600f9f h1:1R9KdKjCNSd7F8iGTxIpoID9prlYH8nuNYKt0XvweHA=
+github.com/sigurn/crc8 v0.0.0-20220107193325-2243fe600f9f/go.mod h1:vQhwQ4meQEDfahT5kd61wLAF5AAeh5ZPLVI4JJ/tYo8=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/tadglines/go-pkgs v0.0.0-20210623144937-b983b20f54f9 h1:aeN+ghOV0b2VCmKKO3gqnDQ8mLbpABZgRR2FVYx4ouI=
+github.com/tadglines/go-pkgs v0.0.0-20210623144937-b983b20f54f9/go.mod h1:roo6cZ/uqpwKMuvPG0YmzI5+AmUiMWfjCBZpGXqbTxE=
+github.com/wlynxg/anet v0.0.5 h1:J3VJGi1gvo0JwZ/P1/Yc/8p63SoW98B5dHkYDmpgvvU=
+github.com/wlynxg/anet v0.0.5/go.mod h1:eay5PRQr7fIVAMbTbchTnO9gG65Hg/uYGdc7mguHxoA=
+golang.org/x/crypto v0.46.0 h1:cKRW/pmt1pKAfetfu+RCEvjvZkA9RimPbh7bhFjGVBU=
+golang.org/x/crypto v0.46.0/go.mod h1:Evb/oLKmMraqjZ2iQTwDwvCtJkczlDuTmdJXoZVzqU0=
+golang.org/x/crypto v0.47.0 h1:V6e3FRj+n4dbpw86FJ8Fv7XVOql7TEwpHapKoMJ/GO8=
+golang.org/x/crypto v0.47.0/go.mod h1:ff3Y9VzzKbwSSEzWqJsJVBnWmRwRSHt/6Op5n9bQc4A=
+golang.org/x/mod v0.31.0 h1:HaW9xtz0+kOcWKwli0ZXy79Ix+UW/vOfmWI5QVd2tgI=
+golang.org/x/mod v0.31.0/go.mod h1:43JraMp9cGx1Rx3AqioxrbrhNsLl2l/iNAvuBkrezpg=
+golang.org/x/mod v0.32.0 h1:9F4d3PHLljb6x//jOyokMv3eX+YDeepZSEo3mFJy93c=
+golang.org/x/mod v0.32.0/go.mod h1:SgipZ/3h2Ci89DlEtEXWUk/HteuRin+HHhN+WbNhguU=
+golang.org/x/net v0.48.0 h1:zyQRTTrjc33Lhh0fBgT/H3oZq9WuvRR5gPC70xpDiQU=
+golang.org/x/net v0.48.0/go.mod h1:+ndRgGjkh8FGtu1w1FGbEC31if4VrNVMuKTgcAAnQRY=
+golang.org/x/net v0.49.0 h1:eeHFmOGUTtaaPSGNmjBKpbng9MulQsJURQUAfUwY++o=
+golang.org/x/net v0.49.0/go.mod h1:/ysNB2EvaqvesRkuLAyjI1ycPZlQHM3q01F02UY/MV8=
+golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
+golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.39.0 h1:CvCKL8MeisomCi6qNZ+wbb0DN9E5AATixKsvNtMoMFk=
+golang.org/x/sys v0.39.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/sys v0.40.0 h1:DBZZqJ2Rkml6QMQsZywtnjnnGvHza6BTfYFWY9kjEWQ=
+golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/term v0.38.0 h1:PQ5pkm/rLO6HnxFR7N2lJHOZX6Kez5Y1gDSJla6jo7Q=
+golang.org/x/term v0.38.0/go.mod h1:bSEAKrOT1W+VSu9TSCMtoGEOUcKxOKgl3LE5QEF/xVg=
+golang.org/x/term v0.39.0 h1:RclSuaJf32jOqZz74CkPA9qFuVTX7vhLlpfj/IGWlqY=
+golang.org/x/time v0.14.0 h1:MRx4UaLrDotUKUdCIqzPC48t1Y9hANFKIRpNx+Te8PI=
+golang.org/x/time v0.14.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4=
+golang.org/x/tools v0.40.0 h1:yLkxfA+Qnul4cs9QA3KnlFu0lVmd8JJfoq+E41uSutA=
+golang.org/x/tools v0.40.0/go.mod h1:Ik/tzLRlbscWpqqMRjyWYDisX8bG13FrdXp3o4Sr9lc=
+golang.org/x/tools v0.41.0 h1:a9b8iMweWG+S0OBnlU36rzLp20z1Rp10w+IY2czHTQc=
+golang.org/x/tools v0.41.0/go.mod h1:XSY6eDqxVNiYgezAVqqCeihT4j1U2CCsqvH3WhQpnlg=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/installs_on_host/go2rtc/internal/README.md b/installs_on_host/go2rtc/internal/README.md
new file mode 100644
index 0000000..f3e9f3b
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/README.md
@@ -0,0 +1,113 @@
+# Modules
+
+go2rtc tries to name formats, protocols and codecs the same way they are named in FFmpeg.
+Some formats and protocols go2rtc supports exclusively. They have no equivalent in FFmpeg.
+
+- The [`echo`], [`expr`], [`hass`] and [`onvif`] modules receive a link to a stream. They don't know the protocol in advance.
+- The [`exec`] and [`ffmpeg`] modules support many formats. They are identical to the [`http`] module.
+- The [`api`], [`app`], [`debug`], [`ngrok`], [`pinggy`], [`srtp`], [`streams`] are supporting modules.
+
+**Modules** implement communication APIs: authorization, encryption, command set, structure of media packets.
+
+**Formats** describe the structure of the data being transmitted.
+
+**Protocols** implement transport for data transmission.
+
+| module         | formats         | protocols        | input | output | ingest | two-way |
+|----------------|-----------------|------------------|-------|--------|--------|---------|
+| [`alsa`]       | `pcm`           | `ioctl`          | yes   |        |        |         |
+| [`bubble`]     | -               | `http`           | yes   |        |        |         |
+| [`doorbird`]   | `mulaw`         | `http`           | yes   |        |        | yes     |
+| [`dvrip`]      | -               | `tcp`            | yes   |        |        | yes     |
+| [`echo`]       | *               | *                | yes   |        |        |         |
+| [`eseecloud`]  | `rtp`           | `http`           | yes   |        |        |         |
+| [`exec`]       | *               | `pipe`, `rtsp`   | yes   |        |        | yes     |
+| [`expr`]       | *               | *                | yes   |        |        |         |
+| [`ffmpeg`]     | *               | `pipe`, `rtsp`   | yes   |        |        |         |
+| [`flussonic`]  | `mp4`           | `ws`             | yes   |        |        |         |
+| [`gopro`]      | `mpegts`        | `udp`            | yes   |        |        |         |
+| [`hass`]       | *               | *                | yes   |        |        |         |
+| [`hls`]        | `mpegts`, `mp4` | `http`           |       | yes    |        |         |
+| [`homekit`]    | `srtp`          | `hap`            | yes   | yes    |        | no      |
+| [`http`]       | `adts`          | `http`, `tcp`    | yes   |        |        |         |
+| [`http`]       | `flv`           | `http`, `tcp`    | yes   |        |        |         |
+| [`http`]       | `h264`          | `http`, `tcp`    | yes   |        |        |         |
+| [`http`]       | `hevc`          | `http`, `tcp`    | yes   |        |        |         |
+| [`http`]       | `hls`           | `http`, `tcp`    | yes   |        |        |         |
+| [`http`]       | `mjpeg`         | `http`, `tcp`    | yes   |        |        |         |
+| [`http`]       | `mpjpeg`        | `http`           | yes   |        |        |         |
+| [`http`]       | `mpegts`        | `http`, `tcp`    | yes   |        |        |         |
+| [`http`]       | `wav`           | `http`, `tcp`    | yes   |        |        |         |
+| [`http`]       | `yuv4mpegpipe`  | `http`, `tcp`    | yes   |        |        |         |
+| [`isapi`]      | `alaw`, `mulaw` | `http`           |       |        |        | yes     |
+| [`ivideon`]    | `mp4`           | `ws`             | yes   |        |        |         |
+| [`kasa`]       | `h264`, `mulaw` | `http`           | yes   |        |        |         |
+| [`mjpeg`]      | `ascii`         | `http`           |       | yes    |        |         |
+| [`mjpeg`]      | `jpeg`          | `http`           |       | yes    |        |         |
+| [`mjpeg`]      | `mpjpeg`        | `http`           |       | yes    | yes    |         |
+| [`mjpeg`]      | `yuv4mpegpipe`  | `http`           |       | yes    |        |         |
+| [`mp4`]        | `mp4`           | `http`, `ws`     |       | yes    |        |         |
+| [`mpeg`]       | `adts`          | `http`           |       | yes    |        |         |
+| [`mpeg`]       | `mpegts`        | `http`           |       | yes    | yes    |         |
+| [`multitrans`] | `rtp`           | `tcp`            |       |        |        | yes     |
+| [`nest`]       | `srtp`          | `rtsp`, `webrtc` | yes   |        |        | no      |
+| [`onvif`]      | `rtp`           | *                | yes   | yes    |        |         |
+| [`ring`]       | `srtp`          | `webrtc`         | yes   |        |        | yes     |
+| [`roborock`]   | `srtp`          | `webrtc`         | yes   |        |        | yes     |
+| [`rtmp`]       | `flv`           | `rtmp`           | yes   | yes    | yes    |         |
+| [`rtmp`]       | `flv`           | `http`           |       | yes    | yes    |         |
+| [`rtsp`]       | `rtsp`          | `rtsp`           | yes   | yes    | yes    | yes     |
+| [`tapo`]       | `mpegts`        | `http`           | yes   |        |        | yes     |
+| [`tuya`]       | `srtp`          | `webrtc`         | yes   |        |        | yes     |
+| [`v4l2`]       | `rawvideo`      | `ioctl`          | yes   |        |        |         |
+| [`webrtc`]     | `srtp`          | `webrtc`         | yes   | yes    | yes    | yes     |
+| [`webtorrent`] | `srtp`          | `webrtc`         | yes   | yes    |        |         |
+| [`wyoming`]    | `pcm`           | `tcp`            |       | yes    |        |         |
+| [`wyze`]       | -               | `tutk`           | yes   |        |        | yes     |
+| [`xiaomi`]     | -               | `cs2`, `tutk`    | yes   |        |        | yes     |
+| [`yandex`]     | `srtp`          | `webrtc`         | yes   |        |        |         |
+
+[`alsa`]: alsa/README.md
+[`api`]: api/README.md
+[`app`]: app/README.md
+[`bubble`]: bubble/README.md
+[`debug`]: debug/README.md
+[`doorbird`]: doorbird/README.md
+[`dvrip`]: dvrip/README.md
+[`echo`]: echo/README.md
+[`eseecloud`]: eseecloud/README.md
+[`exec`]: exec/README.md
+[`expr`]: expr/README.md
+[`ffmpeg`]: ffmpeg/README.md
+[`flussonic`]: flussonic/README.md
+[`gopro`]: gopro/README.md
+[`hass`]: hass/README.md
+[`hls`]: hls/README.md
+[`homekit`]: homekit/README.md
+[`http`]: http/README.md
+[`isapi`]: isapi/README.md
+[`ivideon`]: ivideon/README.md
+[`kasa`]: kasa/README.md
+[`mjpeg`]: mjpeg/README.md
+[`mp4`]: mp4/README.md
+[`mpeg`]: mpeg/README.md
+[`multitrans`]: multitrans/README.md
+[`nest`]: nest/README.md
+[`ngrok`]: ngrok/README.md
+[`onvif`]: onvif/README.md
+[`pinggy`]: pinggy/README.md
+[`ring`]: ring/README.md
+[`roborock`]: roborock/README.md
+[`rtmp`]: rtmp/README.md
+[`rtsp`]: rtsp/README.md
+[`srtp`]: srtp/README.md
+[`streams`]: streams/README.md
+[`tapo`]: tapo/README.md
+[`tuya`]: tuya/README.md
+[`v4l2`]: v4l2/README.md
+[`webrtc`]: webrtc/README.md
+[`webtorrent`]: webtorrent/README.md
+[`wyoming`]: wyze/README.md
+[`wyze`]: wyze/README.md
+[`xiaomi`]: xiaomi/README.md
+[`yandex`]: yandex/README.md
diff --git a/installs_on_host/go2rtc/internal/alsa/README.md b/installs_on_host/go2rtc/internal/alsa/README.md
new file mode 100644
index 0000000..3e0b853
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/alsa/README.md
@@ -0,0 +1,12 @@
+# ALSA
+
+[`new in v1.9.10`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.9.10)
+
+> [!WARNING]
+> This source is under development and does not always work well.
+
+[Advanced Linux Sound Architecture](https://en.wikipedia.org/wiki/Advanced_Linux_Sound_Architecture) - a framework for receiving audio from devices on Linux OS.
+
+Easy to add via **WebUI > add > ALSA**.
+
+Alternatively, you can use FFmpeg source.
diff --git a/installs_on_host/go2rtc/internal/alsa/alsa.go b/installs_on_host/go2rtc/internal/alsa/alsa.go
new file mode 100644
index 0000000..7886c74
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/alsa/alsa.go
@@ -0,0 +1,7 @@
+//go:build !(linux && (386 || amd64 || arm || arm64 || mipsle))
+
+package alsa
+
+func Init() {
+	// not supported
+}
diff --git a/installs_on_host/go2rtc/internal/alsa/alsa_linux.go b/installs_on_host/go2rtc/internal/alsa/alsa_linux.go
new file mode 100644
index 0000000..316a759
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/alsa/alsa_linux.go
@@ -0,0 +1,83 @@
+//go:build linux && (386 || amd64 || arm || arm64 || mipsle)
+
+package alsa
+
+import (
+	"fmt"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/alsa"
+	"github.com/AlexxIT/go2rtc/pkg/alsa/device"
+)
+
+func Init() {
+	streams.HandleFunc("alsa", alsa.Open)
+
+	api.HandleFunc("api/alsa", apiAlsa)
+}
+
+func apiAlsa(w http.ResponseWriter, r *http.Request) {
+	files, err := os.ReadDir("/dev/snd/")
+	if err != nil {
+		return
+	}
+
+	var sources []*api.Source
+
+	for _, file := range files {
+		if !strings.HasPrefix(file.Name(), "pcm") {
+			continue
+		}
+
+		path := "/dev/snd/" + file.Name()
+
+		dev, err := device.Open(path)
+		if err != nil {
+			continue
+		}
+
+		info, err := dev.Info()
+		if err == nil {
+			formats := formatsToString(dev.ListFormats())
+			r1, r2 := dev.RangeRates()
+			c1, c2 := dev.RangeChannels()
+			source := &api.Source{
+				Name: info.ID,
+				Info: fmt.Sprintf("Formats: %s, Rates: %d-%d, Channels: %d-%d", formats, r1, r2, c1, c2),
+				URL:  "alsa:device?audio=" + path,
+			}
+			if !strings.Contains(source.Name, info.Name) {
+				source.Name += ", " + info.Name
+			}
+			sources = append(sources, source)
+		}
+
+		_ = dev.Close()
+	}
+
+	api.ResponseSources(w, sources)
+}
+
+func formatsToString(formats []byte) string {
+	var s string
+	for i, format := range formats {
+		if i > 0 {
+			s += " "
+		}
+		switch format {
+		case 2:
+			s += "s16le"
+		case 10:
+			s += "s32le"
+		default:
+			s += strconv.Itoa(int(format))
+		}
+
+	}
+	return s
+}
diff --git a/installs_on_host/go2rtc/internal/api/README.md b/installs_on_host/go2rtc/internal/api/README.md
new file mode 100644
index 0000000..ca01fb6
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/api/README.md
@@ -0,0 +1,45 @@
+# HTTP API
+
+The HTTP API is the main part for interacting with the application. Default address: `http://localhost:1984/`.
+
+The HTTP API is described in [OpenAPI](../../website/api/openapi.yaml) format. It can be explored in [interactive viewer](https://go2rtc.org/api/). WebSocket API described [here](ws/README.md).
+
+The project's static HTML and JS files are located in the [www](../../www/README.md) folder. An external developer can use them as a basis for integrating go2rtc into their project or for developing a custom web interface for go2rtc.
+
+The contents of `www` folder are built into go2rtc when building, but you can use configuration to specify an external folder as the source of static files.
+
+## Configuration
+
+**Important!** go2rtc passes requests from localhost and Unix sockets without HTTP authorization, even if you have it configured. It is your responsibility to set up secure external access to the API. If not properly configured, an attacker can gain access to your cameras and even your server.
+
+- you can disable HTTP API with `listen: ""` and use, for example, only RTSP client/server protocol
+- you can enable HTTP API only on localhost with `listen: "127.0.0.1:1984"` setting
+- you can change the API `base_path` and host go2rtc on your main app webserver suburl
+- all files from `static_dir` hosted on root path: `/`
+- you can use raw TLS cert/key content or path to files
+
+```yaml
+api:
+  listen: ":1984"    # default ":1984", HTTP API port ("" - disabled)
+  username: "admin"  # default "", Basic auth for WebUI
+  password: "pass"   # default "", Basic auth for WebUI
+  local_auth: true   # default false, Enable auth check for localhost requests
+  base_path: "/rtc"  # default "", API prefix for serving on suburl (/api => /rtc/api)
+  static_dir: "www"  # default "", folder for static files (custom web interface)
+  origin: "*"        # default "", allow CORS requests (only * supported)
+  tls_listen: ":443" # default "", enable HTTPS server
+  tls_cert: |        # default "", PEM-encoded fullchain certificate for HTTPS
+    -----BEGIN CERTIFICATE-----
+    ...
+    -----END CERTIFICATE-----
+  tls_key: |         # default "", PEM-encoded private key for HTTPS
+    -----BEGIN PRIVATE KEY-----
+    ...
+    -----END PRIVATE KEY-----
+  unix_listen: "/tmp/go2rtc.sock"  # default "", unix socket listener for API
+```
+
+**PS:**
+
+- MJPEG over WebSocket plays better than native MJPEG because Chrome [bug](https://bugs.chromium.org/p/chromium/issues/detail?id=527446)
+- MP4 over WebSocket was created only for Apple iOS because it doesn't support file streaming
diff --git a/installs_on_host/go2rtc/internal/api/api.go b/installs_on_host/go2rtc/internal/api/api.go
new file mode 100644
index 0000000..dfb6511
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/api/api.go
@@ -0,0 +1,321 @@
+package api
+
+import (
+	"crypto/tls"
+	"encoding/json"
+	"fmt"
+	"net"
+	"net/http"
+	"os"
+	"slices"
+	"strconv"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/rs/zerolog"
+)
+
+func Init() {
+	var cfg struct {
+		Mod struct {
+			Listen     string `yaml:"listen"`
+			Username   string `yaml:"username"`
+			Password   string `yaml:"password"`
+			LocalAuth  bool   `yaml:"local_auth"`
+			BasePath   string `yaml:"base_path"`
+			StaticDir  string `yaml:"static_dir"`
+			Origin     string `yaml:"origin"`
+			TLSListen  string `yaml:"tls_listen"`
+			TLSCert    string `yaml:"tls_cert"`
+			TLSKey     string `yaml:"tls_key"`
+			UnixListen string `yaml:"unix_listen"`
+
+			AllowPaths []string `yaml:"allow_paths"`
+		} `yaml:"api"`
+	}
+
+	// default config
+	cfg.Mod.Listen = ":1984"
+
+	// load config from YAML
+	app.LoadConfig(&cfg)
+
+	if cfg.Mod.Listen == "" && cfg.Mod.UnixListen == "" && cfg.Mod.TLSListen == "" {
+		return
+	}
+
+	allowPaths = cfg.Mod.AllowPaths
+	basePath = cfg.Mod.BasePath
+	log = app.GetLogger("api")
+
+	initStatic(cfg.Mod.StaticDir)
+
+	HandleFunc("api", apiHandler)
+	HandleFunc("api/config", configHandler)
+	HandleFunc("api/exit", exitHandler)
+	HandleFunc("api/restart", restartHandler)
+	HandleFunc("api/log", logHandler)
+
+	Handler = http.DefaultServeMux // 4th
+
+	if cfg.Mod.Origin == "*" {
+		Handler = middlewareCORS(Handler) // 3rd
+	}
+
+	if cfg.Mod.Username != "" {
+		Handler = middlewareAuth(cfg.Mod.Username, cfg.Mod.Password, cfg.Mod.LocalAuth, Handler) // 2nd
+	}
+
+	if log.Trace().Enabled() {
+		Handler = middlewareLog(Handler) // 1st
+	}
+
+	if cfg.Mod.Listen != "" {
+		_, port, _ := net.SplitHostPort(cfg.Mod.Listen)
+		Port, _ = strconv.Atoi(port)
+		go listen("tcp", cfg.Mod.Listen)
+	}
+
+	if cfg.Mod.UnixListen != "" {
+		_ = syscall.Unlink(cfg.Mod.UnixListen)
+		go listen("unix", cfg.Mod.UnixListen)
+	}
+
+	// Initialize the HTTPS server
+	if cfg.Mod.TLSListen != "" && cfg.Mod.TLSCert != "" && cfg.Mod.TLSKey != "" {
+		go tlsListen("tcp", cfg.Mod.TLSListen, cfg.Mod.TLSCert, cfg.Mod.TLSKey)
+	}
+}
+
+func listen(network, address string) {
+	ln, err := net.Listen(network, address)
+	if err != nil {
+		log.Error().Err(err).Msg("[api] listen")
+		return
+	}
+
+	log.Info().Str("addr", address).Msg("[api] listen")
+
+	server := http.Server{
+		Handler:           Handler,
+		ReadHeaderTimeout: 5 * time.Second, // Example: Set to 5 seconds
+	}
+	if err = server.Serve(ln); err != nil {
+		log.Fatal().Err(err).Msg("[api] serve")
+	}
+}
+
+func tlsListen(network, address, certFile, keyFile string) {
+	var cert tls.Certificate
+	var err error
+	if strings.IndexByte(certFile, '\n') < 0 && strings.IndexByte(keyFile, '\n') < 0 {
+		// check if file path
+		cert, err = tls.LoadX509KeyPair(certFile, keyFile)
+	} else {
+		// if text file content
+		cert, err = tls.X509KeyPair([]byte(certFile), []byte(keyFile))
+	}
+	if err != nil {
+		log.Error().Err(err).Caller().Send()
+		return
+	}
+
+	ln, err := net.Listen(network, address)
+	if err != nil {
+		log.Error().Err(err).Msg("[api] tls listen")
+		return
+	}
+
+	log.Info().Str("addr", address).Msg("[api] tls listen")
+
+	server := &http.Server{
+		Handler:           Handler,
+		TLSConfig:         &tls.Config{Certificates: []tls.Certificate{cert}},
+		ReadHeaderTimeout: 5 * time.Second,
+	}
+	if err = server.ServeTLS(ln, "", ""); err != nil {
+		log.Fatal().Err(err).Msg("[api] tls serve")
+	}
+}
+
+var Port int
+
+const (
+	MimeJSON = "application/json"
+	MimeText = "text/plain"
+)
+
+var Handler http.Handler
+
+// HandleFunc handle pattern with relative path:
+// - "api/streams" => "{basepath}/api/streams"
+// - "/streams"    => "/streams"
+func HandleFunc(pattern string, handler http.HandlerFunc) {
+	if len(pattern) == 0 || pattern[0] != '/' {
+		pattern = basePath + "/" + pattern
+	}
+	if allowPaths != nil && !slices.Contains(allowPaths, pattern) {
+		log.Trace().Str("path", pattern).Msg("[api] ignore path not in allow_paths")
+		return
+	}
+	log.Trace().Str("path", pattern).Msg("[api] register path")
+	http.HandleFunc(pattern, handler)
+}
+
+// ResponseJSON important always add Content-Type
+// so go won't need to call http.DetectContentType
+func ResponseJSON(w http.ResponseWriter, v any) {
+	w.Header().Set("Content-Type", MimeJSON)
+	_ = json.NewEncoder(w).Encode(v)
+}
+
+func ResponsePrettyJSON(w http.ResponseWriter, v any) {
+	w.Header().Set("Content-Type", MimeJSON)
+	enc := json.NewEncoder(w)
+	enc.SetIndent("", "  ")
+	_ = enc.Encode(v)
+}
+
+func Response(w http.ResponseWriter, body any, contentType string) {
+	w.Header().Set("Content-Type", contentType)
+
+	switch v := body.(type) {
+	case []byte:
+		_, _ = w.Write(v)
+	case string:
+		_, _ = w.Write([]byte(v))
+	default:
+		_, _ = fmt.Fprint(w, body)
+	}
+}
+
+const StreamNotFound = "stream not found"
+
+var allowPaths []string
+var basePath string
+var log zerolog.Logger
+
+func middlewareLog(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		log.Trace().Msgf("[api] %s %s %s", r.Method, r.URL, r.RemoteAddr)
+		next.ServeHTTP(w, r)
+	})
+}
+
+func isLoopback(remoteAddr string) bool {
+	return strings.HasPrefix(remoteAddr, "127.") || strings.HasPrefix(remoteAddr, "[::1]") || remoteAddr == "@"
+}
+
+func middlewareAuth(username, password string, localAuth bool, next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if localAuth || !isLoopback(r.RemoteAddr) {
+			user, pass, ok := r.BasicAuth()
+			if !ok || user != username || pass != password {
+				w.Header().Set("Www-Authenticate", `Basic realm="go2rtc"`)
+				http.Error(w, "Unauthorized", http.StatusUnauthorized)
+				return
+			}
+		}
+
+		next.ServeHTTP(w, r)
+	})
+}
+
+func middlewareCORS(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
+		w.Header().Set("Access-Control-Allow-Headers", "Authorization, Content-Type")
+		next.ServeHTTP(w, r)
+	})
+}
+
+var mu sync.Mutex
+
+func apiHandler(w http.ResponseWriter, r *http.Request) {
+	mu.Lock()
+	app.Info["host"] = r.Host
+	mu.Unlock()
+
+	ResponseJSON(w, app.Info)
+}
+
+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, err := strconv.Atoi(s)
+
+	// https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_08_02
+	if err != nil || code < 0 || code > 125 {
+		http.Error(w, "Code must be in the range [0, 125]", http.StatusBadRequest)
+		return
+	}
+
+	os.Exit(code)
+}
+
+func restartHandler(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		http.Error(w, "", http.StatusBadRequest)
+		return
+	}
+
+	path, err := os.Executable()
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	log.Debug().Msgf("[api] restart %s", path)
+
+	go syscall.Exec(path, os.Args, os.Environ())
+}
+
+func logHandler(w http.ResponseWriter, r *http.Request) {
+	switch r.Method {
+	case "GET":
+		// Send current state of the log file immediately
+		w.Header().Set("Content-Type", "application/jsonlines")
+		_, _ = app.MemoryLog.WriteTo(w)
+	case "DELETE":
+		app.MemoryLog.Reset()
+		Response(w, "OK", "text/plain")
+	default:
+		http.Error(w, "Method not allowed", http.StatusBadRequest)
+	}
+}
+
+type Source struct {
+	ID       string `json:"id,omitempty"`
+	Name     string `json:"name,omitempty"`
+	Info     string `json:"info,omitempty"`
+	URL      string `json:"url,omitempty"`
+	Location string `json:"location,omitempty"`
+}
+
+func ResponseSources(w http.ResponseWriter, sources []*Source) {
+	if len(sources) == 0 {
+		http.Error(w, "no sources", http.StatusNotFound)
+		return
+	}
+
+	var response = struct {
+		Sources []*Source `json:"sources"`
+	}{
+		Sources: sources,
+	}
+	ResponseJSON(w, response)
+}
+
+func Error(w http.ResponseWriter, err error) {
+	log.Error().Err(err).Caller(1).Send()
+
+	http.Error(w, err.Error(), http.StatusInsufficientStorage)
+}
diff --git a/installs_on_host/go2rtc/internal/api/config.go b/installs_on_host/go2rtc/internal/api/config.go
new file mode 100644
index 0000000..9072e8d
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/api/config.go
@@ -0,0 +1,101 @@
+package api
+
+import (
+	"io"
+	"net/http"
+	"os"
+
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"gopkg.in/yaml.v3"
+)
+
+func configHandler(w http.ResponseWriter, r *http.Request) {
+	if app.ConfigPath == "" {
+		http.Error(w, "", http.StatusGone)
+		return
+	}
+
+	switch r.Method {
+	case "GET":
+		data, err := os.ReadFile(app.ConfigPath)
+		if err != nil {
+			http.Error(w, "", http.StatusNotFound)
+			return
+		}
+		// https://www.ietf.org/archive/id/draft-ietf-httpapi-yaml-mediatypes-00.html
+		Response(w, data, "application/yaml")
+
+	case "POST", "PATCH":
+		data, err := io.ReadAll(r.Body)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		if r.Method == "PATCH" {
+			// no need to validate after merge
+			data, err = mergeYAML(app.ConfigPath, data)
+			if err != nil {
+				http.Error(w, err.Error(), http.StatusBadRequest)
+				return
+			}
+		} else {
+			// validate config
+			if err = yaml.Unmarshal(data, map[string]any{}); err != nil {
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+				return
+			}
+		}
+
+		if err = os.WriteFile(app.ConfigPath, data, 0644); err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	}
+}
+
+func mergeYAML(file1 string, yaml2 []byte) ([]byte, error) {
+	// 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
+}
diff --git a/installs_on_host/go2rtc/internal/api/static.go b/installs_on_host/go2rtc/internal/api/static.go
new file mode 100644
index 0000000..8de4007
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/api/static.go
@@ -0,0 +1,27 @@
+package api
+
+import (
+	"net/http"
+
+	"github.com/AlexxIT/go2rtc/www"
+)
+
+func initStatic(staticDir string) {
+	var root http.FileSystem
+	if staticDir != "" {
+		log.Info().Str("dir", staticDir).Msg("[api] serve static")
+		root = http.Dir(staticDir)
+	} else {
+		root = http.FS(www.Static)
+	}
+
+	base := len(basePath)
+	fileServer := http.FileServer(root)
+
+	HandleFunc("", func(w http.ResponseWriter, r *http.Request) {
+		if base > 0 {
+			r.URL.Path = r.URL.Path[base:]
+		}
+		fileServer.ServeHTTP(w, r)
+	})
+}
diff --git a/installs_on_host/go2rtc/internal/api/ws/README.md b/installs_on_host/go2rtc/internal/api/ws/README.md
new file mode 100644
index 0000000..5599ff8
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/api/ws/README.md
@@ -0,0 +1,69 @@
+# WebSocket
+
+Endpoint: `/api/ws`
+
+Query parameters:
+
+- `src` (required) - Stream name
+
+### WebRTC
+
+Request SDP:
+
+```json
+{"type":"webrtc/offer","value":"v=0\r\n..."}
+```
+
+Response SDP:
+
+```json
+{"type":"webrtc/answer","value":"v=0\r\n..."}
+```
+
+Request/response candidate:
+
+- empty value also allowed and optional
+
+```json
+{"type":"webrtc/candidate","value":"candidate:3277516026 1 udp 2130706431 192.168.1.123 54321 typ host"}
+```
+
+### MSE
+
+Request:
+
+- codecs list optional
+
+```json
+{"type":"mse","value":"avc1.640029,avc1.64002A,avc1.640033,hvc1.1.6.L153.B0,mp4a.40.2,mp4a.40.5,flac,opus"}
+```
+
+Response:
+
+```json
+{"type":"mse","value":"video/mp4; codecs=\"avc1.64001F,mp4a.40.2\""}
+```
+
+### HLS
+
+Request:
+
+```json
+{"type":"hls","value":"avc1.640029,avc1.64002A,avc1.640033,hvc1.1.6.L153.B0,mp4a.40.2,mp4a.40.5,flac"}
+```
+
+Response:
+
+- you MUST rewrite full HTTP path to `http://192.168.1.123:1984/api/hls/playlist.m3u8`
+
+```json
+{"type":"hls","value":"#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=1000000,CODECS=\"avc1.64001F,mp4a.40.2\"\nhls/playlist.m3u8?id=DvmHdd9w"}
+```
+
+### MJPEG
+
+Request/response:
+
+```json
+{"type":"mjpeg"}
+```
diff --git a/installs_on_host/go2rtc/internal/api/ws/ws.go b/installs_on_host/go2rtc/internal/api/ws/ws.go
new file mode 100644
index 0000000..02c2f90
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/api/ws/ws.go
@@ -0,0 +1,227 @@
+package ws
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/pkg/creds"
+	"github.com/gorilla/websocket"
+	"github.com/rs/zerolog"
+)
+
+func Init() {
+	var cfg struct {
+		Mod struct {
+			Origin string `yaml:"origin"`
+		} `yaml:"api"`
+	}
+
+	app.LoadConfig(&cfg)
+
+	log = app.GetLogger("api")
+
+	initWS(cfg.Mod.Origin)
+
+	api.HandleFunc("api/ws", apiWS)
+}
+
+var log zerolog.Logger
+
+// Message - struct for data exchange in Web API
+type Message struct {
+	Type  string `json:"type"`
+	Value any    `json:"value,omitempty"`
+}
+
+func (m *Message) String() (value string) {
+	if s, ok := m.Value.(string); ok {
+		return s
+	}
+	return
+}
+
+func (m *Message) Unmarshal(v any) error {
+	b, err := json.Marshal(m.Value)
+	if err != nil {
+		return err
+	}
+	return json.Unmarshal(b, v)
+}
+
+type WSHandler func(tr *Transport, msg *Message) error
+
+func HandleFunc(msgType string, handler WSHandler) {
+	wsHandlers[msgType] = handler
+}
+
+var wsHandlers = make(map[string]WSHandler)
+
+func initWS(origin string) {
+	wsUp = &websocket.Upgrader{
+		ReadBufferSize:  4096,       // for SDP
+		WriteBufferSize: 512 * 1024, // 512K
+	}
+
+	switch origin {
+	case "":
+		// same origin + ignore port
+		wsUp.CheckOrigin = func(r *http.Request) bool {
+			origin := r.Header["Origin"]
+			if len(origin) == 0 {
+				return true
+			}
+			o, err := url.Parse(origin[0])
+			if err != nil {
+				return false
+			}
+			if o.Host == r.Host {
+				return true
+			}
+			log.Trace().Msgf("[api] ws origin=%s, host=%s", o.Host, r.Host)
+			// https://github.com/AlexxIT/go2rtc/issues/118
+			if i := strings.IndexByte(o.Host, ':'); i > 0 {
+				return o.Host[:i] == r.Host
+			}
+			return false
+		}
+	case "*":
+		// any origin
+		wsUp.CheckOrigin = func(r *http.Request) bool {
+			return true
+		}
+	}
+}
+
+func apiWS(w http.ResponseWriter, r *http.Request) {
+	ws, err := wsUp.Upgrade(w, r, nil)
+	if err != nil {
+		origin := r.Header.Get("Origin")
+		log.Error().Err(err).Caller().Msgf("host=%s origin=%s", r.Host, origin)
+		return
+	}
+
+	tr := &Transport{Request: r}
+	tr.OnWrite(func(msg any) error {
+		_ = ws.SetWriteDeadline(time.Now().Add(time.Second * 5))
+
+		if data, ok := msg.([]byte); ok {
+			return ws.WriteMessage(websocket.BinaryMessage, data)
+		} else {
+			return ws.WriteJSON(msg)
+		}
+	})
+
+	for {
+		msg := new(Message)
+		if err = ws.ReadJSON(msg); err != nil {
+			if !websocket.IsCloseError(err, websocket.CloseNoStatusReceived) {
+				log.Trace().Err(err).Caller().Send()
+			}
+			_ = ws.Close()
+			break
+		}
+
+		log.Trace().Str("type", msg.Type).Msg("[api] ws msg")
+
+		if handler := wsHandlers[msg.Type]; handler != nil {
+			go func() {
+				if err = handler(tr, msg); err != nil {
+					errMsg := creds.SecretString(err.Error())
+					tr.Write(&Message{Type: "error", Value: msg.Type + ": " + errMsg})
+				}
+			}()
+		}
+	}
+
+	tr.Close()
+}
+
+var wsUp *websocket.Upgrader
+
+type Transport struct {
+	Request *http.Request
+
+	ctx map[any]any
+
+	closed bool
+	mx     sync.Mutex
+	wrmx   sync.Mutex
+
+	onChange func()
+	onWrite  func(msg any) error
+	onClose  []func()
+}
+
+func (t *Transport) OnWrite(f func(msg any) error) {
+	t.mx.Lock()
+	if t.onChange != nil {
+		t.onChange()
+	}
+	t.onWrite = f
+	t.mx.Unlock()
+}
+
+func (t *Transport) Write(msg any) {
+	t.wrmx.Lock()
+	_ = t.onWrite(msg)
+	t.wrmx.Unlock()
+}
+
+func (t *Transport) Close() {
+	t.mx.Lock()
+	for _, f := range t.onClose {
+		f()
+	}
+	t.closed = true
+	t.mx.Unlock()
+}
+
+func (t *Transport) OnChange(f func()) {
+	t.mx.Lock()
+	t.onChange = f
+	t.mx.Unlock()
+}
+
+func (t *Transport) OnClose(f func()) {
+	t.mx.Lock()
+	if t.closed {
+		f()
+	} else {
+		t.onClose = append(t.onClose, f)
+	}
+	t.mx.Unlock()
+}
+
+// WithContext - run function with Context variable
+func (t *Transport) WithContext(f func(ctx map[any]any)) {
+	t.mx.Lock()
+	if t.ctx == nil {
+		t.ctx = map[any]any{}
+	}
+	f(t.ctx)
+	t.mx.Unlock()
+}
+
+func (t *Transport) Writer() io.Writer {
+	return &writer{t: t}
+}
+
+type writer struct {
+	t *Transport
+}
+
+func (w *writer) Write(p []byte) (n int, err error) {
+	w.t.wrmx.Lock()
+	if err = w.t.onWrite(p); err == nil {
+		n = len(p)
+	}
+	w.t.wrmx.Unlock()
+	return
+}
diff --git a/installs_on_host/go2rtc/internal/app/README.md b/installs_on_host/go2rtc/internal/app/README.md
new file mode 100644
index 0000000..1fa9923
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/app/README.md
@@ -0,0 +1,97 @@
+# App
+
+The application module is responsible for reading configuration files, running other modules and setting up [logs](#log).
+
+The configuration can be edited through the application's WebUI with code highlighting, syntax and specification checking.
+
+- By default, go2rtc will search for the `go2rtc.yaml` config file in the current working directory
+- go2rtc supports multiple config files:
+  - `go2rtc -c config1.yaml -c config2.yaml -c config3.yaml`
+- go2rtc supports inline config in multiple formats from the command line:
+  - **YAML**: `go2rtc -c '{log: {format: text}}'`
+  - **JSON**: `go2rtc -c '{"log":{"format":"text"}}'`
+  - **key=value**: `go2rtc -c log.format=text`
+- Each subsequent config will overwrite the previous one (but only for defined params)
+
+```
+go2rtc -config "{log: {format: text}}" -config /config/go2rtc.yaml -config "{rtsp: {listen: ''}}" -config /usr/local/go2rtc/go2rtc.yaml
+```
+
+or a simpler version
+
+```
+go2rtc -c log.format=text -c /config/go2rtc.yaml -c rtsp.listen='' -c /usr/local/go2rtc/go2rtc.yaml
+```
+
+## Environment variables
+
+There is support for loading external variables into the config. First, they will be loaded from [credential files](https://systemd.io/CREDENTIALS). If `CREDENTIALS_DIRECTORY` is not set, then the key will be loaded from an environment variable. If no environment variable is set, then the string will be left as-is.
+
+```yaml
+streams:
+  camera1: rtsp://rtsp:${CAMERA_PASSWORD}@192.168.1.123/av_stream/ch0
+
+rtsp:
+  username: ${RTSP_USER:admin}   # "admin" if "RTSP_USER" not set
+  password: ${RTSP_PASS:secret}  # "secret" if "RTSP_PASS" not set
+```
+
+## JSON Schema
+
+Editors like [GoLand](https://www.jetbrains.com/go/) and [VS Code](https://code.visualstudio.com/) support autocomplete and syntax validation.
+
+```yaml
+# yaml-language-server: $schema=https://raw.githubusercontent.com/AlexxIT/go2rtc/master/www/schema.json
+```
+
+or from a running go2rtc:
+
+```yaml
+# yaml-language-server: $schema=http://localhost:1984/schema.json
+```
+
+## Defaults
+
+- Default values may change in updates
+- FFmpeg module has many presets, they are not listed here because they may also change in updates
+
+```yaml
+api:
+  listen: ":1984"  # default public port for WebUI and HTTP API
+
+ffmpeg:
+  bin: "ffmpeg"    # default binary path for FFmpeg
+
+log:
+  level: "info"    # default log level
+  output: "stdout"
+  time: "UNIXMS"
+
+rtsp:
+  listen: ":8554"  # default public port for RTSP server
+  default_query: "video&audio"
+
+srtp:
+  listen: ":8443"  # default public port for SRTP server (used for HomeKit)
+
+webrtc:
+  listen: ":8555"  # default public port for WebRTC server (TCP and UDP)
+  ice_servers:
+    - urls: [ "stun:stun.cloudflare.com:3478", "stun:stun.l.google.com:19302" ]
+```
+
+## Log
+
+You can set different log levels for different modules.
+
+```yaml
+log:
+  format: ""        # empty (default, autodetect color support), color, json, text 
+  level: "info"     # disabled, trace, debug, info (default), warn, error
+  output: "stdout"  # empty (only to memory), stderr, stdout (default)
+  time: "UNIXMS"    # empty (disable timestamp), UNIXMS (default), UNIXMICRO, UNIXNANO
+  
+  api: trace   # module name: log level
+```
+
+Modules: `api`, `streams`, `rtsp`, `webrtc`, `mp4`, `hls`, `mjpeg`, `hass`, `homekit`, `onvif`, `rtmp`, `webtorrent`, `wyoming`, `echo`, `exec`, `expr`, `ffmpeg`, `wyze`, `xiaomi`.
diff --git a/installs_on_host/go2rtc/internal/app/app.go b/installs_on_host/go2rtc/internal/app/app.go
new file mode 100644
index 0000000..cbce37e
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/app/app.go
@@ -0,0 +1,122 @@
+package app
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"os/exec"
+	"runtime"
+	"runtime/debug"
+)
+
+var (
+	Version    string
+	Modules    []string
+	UserAgent  string
+	ConfigPath string
+	Info       = make(map[string]any)
+)
+
+const usage = `Usage of go2rtc:
+
+  -c, --config   Path to config file or config string as YAML or JSON, support multiple
+  -d, --daemon   Run in background
+  -v, --version  Print version and exit
+`
+
+func Init() {
+	var config flagConfig
+	var daemon bool
+	var version bool
+
+	flag.Var(&config, "config", "")
+	flag.Var(&config, "c", "")
+	flag.BoolVar(&daemon, "daemon", false, "")
+	flag.BoolVar(&daemon, "d", false, "")
+	flag.BoolVar(&version, "version", false, "")
+	flag.BoolVar(&version, "v", false, "")
+
+	flag.Usage = func() { fmt.Print(usage) }
+	flag.Parse()
+
+	revision, vcsTime := readRevisionTime()
+
+	if version {
+		fmt.Printf("go2rtc version %s (%s) %s/%s\n", Version, revision, runtime.GOOS, runtime.GOARCH)
+		os.Exit(0)
+	}
+
+	if daemon && os.Getppid() != 1 {
+		if runtime.GOOS == "windows" {
+			fmt.Println("Daemon mode is not supported on Windows")
+			os.Exit(1)
+		}
+
+		// Re-run the program in background and exit
+		cmd := exec.Command(os.Args[0], os.Args[1:]...)
+		if err := cmd.Start(); err != nil {
+			fmt.Println("Failed to start daemon:", err)
+			os.Exit(1)
+		}
+		fmt.Println("Running in daemon mode with PID:", cmd.Process.Pid)
+		os.Exit(0)
+	}
+
+	UserAgent = "go2rtc/" + Version
+
+	Info["version"] = Version
+	Info["revision"] = revision
+
+	initConfig(config)
+	initLogger()
+
+	platform := fmt.Sprintf("%s/%s", runtime.GOOS, runtime.GOARCH)
+	Logger.Info().Str("version", Version).Str("platform", platform).Str("revision", revision).Msg("go2rtc")
+	Logger.Debug().Str("version", runtime.Version()).Str("vcs.time", vcsTime).Msg("build")
+
+	if ConfigPath != "" {
+		Logger.Info().Str("path", ConfigPath).Msg("config")
+	}
+
+	var cfg struct {
+		Mod struct {
+			Modules []string `yaml:"modules"`
+		} `yaml:"app"`
+	}
+
+	LoadConfig(&cfg)
+
+	Modules = cfg.Mod.Modules
+}
+
+func readRevisionTime() (revision, vcsTime string) {
+	if info, ok := debug.ReadBuildInfo(); ok {
+		for _, setting := range info.Settings {
+			switch setting.Key {
+			case "vcs.revision":
+				if len(setting.Value) > 7 {
+					revision = setting.Value[:7]
+				} else {
+					revision = setting.Value
+				}
+			case "vcs.time":
+				vcsTime = setting.Value
+			case "vcs.modified":
+				if setting.Value == "true" {
+					revision += ".dirty"
+				}
+			}
+		}
+
+		// Check version from -buildvcs info
+		// Format for tagged version : v1.9.13
+		// Format for modified code:   v1.9.14-0.20251215184105-753d6617ab58+dirty
+		if info.Main.Version != "v"+Version {
+			// Format: 1.9.13+dev.753d661[.dirty]
+			// Compatible with "awesomeversion" and "packaging.version" from python.
+			// Version will be larger than the previous release, but smaller than the next release.
+			Version += "+dev." + revision
+		}
+	}
+	return
+}
diff --git a/installs_on_host/go2rtc/internal/app/config.go b/installs_on_host/go2rtc/internal/app/config.go
new file mode 100644
index 0000000..0f95894
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/app/config.go
@@ -0,0 +1,117 @@
+package app
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	"github.com/AlexxIT/go2rtc/pkg/creds"
+	"github.com/AlexxIT/go2rtc/pkg/yaml"
+)
+
+func LoadConfig(v any) {
+	for _, data := range configs {
+		if err := yaml.Unmarshal(data, v); err != nil {
+			Logger.Warn().Err(err).Send()
+		}
+	}
+}
+
+var configMu sync.Mutex
+
+func PatchConfig(path []string, value any) error {
+	if ConfigPath == "" {
+		return errors.New("config file disabled")
+	}
+
+	configMu.Lock()
+	defer configMu.Unlock()
+
+	// empty config is OK
+	b, _ := os.ReadFile(ConfigPath)
+
+	b, err := yaml.Patch(b, path, value)
+	if err != nil {
+		return err
+	}
+
+	return os.WriteFile(ConfigPath, b, 0644)
+}
+
+type flagConfig []string
+
+func (c *flagConfig) String() string {
+	return strings.Join(*c, " ")
+}
+
+func (c *flagConfig) Set(value string) error {
+	*c = append(*c, value)
+	return nil
+}
+
+var configs [][]byte
+
+func initConfig(confs flagConfig) {
+	if confs == nil {
+		confs = []string{"go2rtc.yaml"}
+	}
+
+	for _, conf := range confs {
+		if len(conf) == 0 {
+			continue
+		}
+		if conf[0] == '{' {
+			// config as raw YAML or JSON
+			configs = append(configs, []byte(conf))
+		} else if data := parseConfString(conf); data != nil {
+			configs = append(configs, data)
+		} else {
+			// config as file
+			if ConfigPath == "" {
+				ConfigPath = conf
+				initStorage()
+			}
+
+			if data, _ = os.ReadFile(conf); data == nil {
+				continue
+			}
+
+			loadEnv(data)
+			data = creds.ReplaceVars(data)
+			configs = append(configs, data)
+		}
+	}
+
+	if ConfigPath != "" {
+		if !filepath.IsAbs(ConfigPath) {
+			if cwd, err := os.Getwd(); err == nil {
+				ConfigPath = filepath.Join(cwd, ConfigPath)
+			}
+		}
+		Info["config_path"] = ConfigPath
+	}
+}
+
+func parseConfString(s string) []byte {
+	i := strings.IndexByte(s, '=')
+	if i < 0 {
+		return nil
+	}
+
+	items := strings.Split(s[:i], ".")
+	if len(items) < 2 {
+		return nil
+	}
+
+	// `log.level=trace` => `{log: {level: trace}}`
+	var pre string
+	var suf = s[i+1:]
+	for _, item := range items {
+		pre += "{" + item + ": "
+		suf += "}"
+	}
+
+	return []byte(pre + suf)
+}
diff --git a/installs_on_host/go2rtc/internal/app/log.go b/installs_on_host/go2rtc/internal/app/log.go
new file mode 100644
index 0000000..61fd474
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/app/log.go
@@ -0,0 +1,191 @@
+package app
+
+import (
+	"io"
+	"os"
+	"strings"
+	"sync"
+
+	"github.com/AlexxIT/go2rtc/pkg/creds"
+	"github.com/mattn/go-isatty"
+	"github.com/rs/zerolog"
+)
+
+var MemoryLog = newBuffer()
+
+func GetLogger(module string) zerolog.Logger {
+	Logger.Trace().Str("module", module).Msgf("[log] init")
+
+	if s, ok := modules[module]; ok {
+		lvl, err := zerolog.ParseLevel(s)
+		if err == nil {
+			return Logger.Level(lvl)
+		}
+		Logger.Warn().Err(err).Caller().Send()
+	}
+
+	return Logger
+}
+
+// initLogger support:
+// - output: empty (only to memory), stderr, stdout
+// - format: empty (autodetect color support), color, json, text
+// - time:   empty (disable timestamp), UNIXMS, UNIXMICRO, UNIXNANO
+// - level:  disabled, trace, debug, info, warn, error...
+func initLogger() {
+	var cfg struct {
+		Mod map[string]string `yaml:"log"`
+	}
+
+	cfg.Mod = modules // defaults
+
+	LoadConfig(&cfg)
+
+	var writer io.Writer
+
+	switch output, path, _ := strings.Cut(modules["output"], ":"); output {
+	case "stderr":
+		writer = os.Stderr
+	case "stdout":
+		writer = os.Stdout
+	case "file":
+		if path == "" {
+			path = "go2rtc.log"
+		}
+		// if fail - only MemoryLog will be available
+		writer, _ = os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	}
+
+	timeFormat := modules["time"]
+
+	if writer != nil {
+		if format := modules["format"]; format != "json" {
+			console := &zerolog.ConsoleWriter{Out: writer}
+
+			switch format {
+			case "text":
+				console.NoColor = true
+			case "color":
+				console.NoColor = false // useless, but anyway
+			default:
+				// autodetection if output support color
+				// go-isatty - dependency for go-colorable - dependency for ConsoleWriter
+				console.NoColor = !isatty.IsTerminal(writer.(*os.File).Fd())
+			}
+
+			if timeFormat != "" {
+				console.TimeFormat = "15:04:05.000"
+			} else {
+				console.PartsOrder = []string{
+					zerolog.LevelFieldName,
+					zerolog.CallerFieldName,
+					zerolog.MessageFieldName,
+				}
+			}
+
+			writer = console
+		}
+
+		writer = zerolog.MultiLevelWriter(writer, MemoryLog)
+	} else {
+		writer = MemoryLog
+	}
+
+	writer = creds.SecretWriter(writer)
+
+	lvl, _ := zerolog.ParseLevel(modules["level"])
+	Logger = zerolog.New(writer).Level(lvl)
+
+	if timeFormat != "" {
+		zerolog.TimeFieldFormat = timeFormat
+		Logger = Logger.With().Timestamp().Logger()
+	}
+}
+
+var Logger zerolog.Logger
+
+// modules log levels
+var modules = map[string]string{
+	"format": "", // useless, but anyway
+	"level":  "info",
+	"output": "stdout", // TODO: change to stderr someday
+	"time":   zerolog.TimeFormatUnixMs,
+}
+
+const (
+	chunkCount = 16
+	chunkSize  = 1 << 16
+)
+
+type circularBuffer struct {
+	chunks [][]byte
+	r, w   int
+	mu     sync.Mutex
+}
+
+func newBuffer() *circularBuffer {
+	b := &circularBuffer{chunks: make([][]byte, 0, chunkCount)}
+	// create first chunk
+	b.chunks = append(b.chunks, make([]byte, 0, chunkSize))
+	return b
+}
+
+func (b *circularBuffer) Write(p []byte) (n int, err error) {
+	n = len(p)
+
+	b.mu.Lock()
+	// check if chunk has size
+	if len(b.chunks[b.w])+n > chunkSize {
+		// increase write chunk index
+		if b.w++; b.w == chunkCount {
+			b.w = 0
+		}
+		// check overflow
+		if b.r == b.w {
+			// increase read chunk index
+			if b.r++; b.r == chunkCount {
+				b.r = 0
+			}
+		}
+		// check if current chunk exists
+		if b.w == len(b.chunks) {
+			// allocate new chunk
+			b.chunks = append(b.chunks, make([]byte, 0, chunkSize))
+		} else {
+			// reset len of current chunk
+			b.chunks[b.w] = b.chunks[b.w][:0]
+		}
+	}
+
+	b.chunks[b.w] = append(b.chunks[b.w], p...)
+	b.mu.Unlock()
+	return
+}
+
+func (b *circularBuffer) WriteTo(w io.Writer) (n int64, err error) {
+	buf := make([]byte, 0, chunkCount*chunkSize)
+
+	// use temp buffer inside mutex because w.Write can take some time
+	b.mu.Lock()
+	for i := b.r; ; {
+		buf = append(buf, b.chunks[i]...)
+		if i == b.w {
+			break
+		}
+		if i++; i == chunkCount {
+			i = 0
+		}
+	}
+	b.mu.Unlock()
+
+	nn, err := w.Write(buf)
+	return int64(nn), err
+}
+
+func (b *circularBuffer) Reset() {
+	b.mu.Lock()
+	b.chunks[0] = b.chunks[0][:0]
+	b.r = 0
+	b.w = 0
+	b.mu.Unlock()
+}
diff --git a/installs_on_host/go2rtc/internal/app/storage.go b/installs_on_host/go2rtc/internal/app/storage.go
new file mode 100644
index 0000000..cfa1ca9
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/app/storage.go
@@ -0,0 +1,56 @@
+package app
+
+import (
+	"sync"
+
+	"github.com/AlexxIT/go2rtc/pkg/creds"
+	"github.com/AlexxIT/go2rtc/pkg/yaml"
+)
+
+func initStorage() {
+	storage = &envStorage{data: make(map[string]string)}
+	creds.SetStorage(storage)
+}
+
+func loadEnv(data []byte) {
+	var cfg struct {
+		Env map[string]string `yaml:"env"`
+	}
+
+	if err := yaml.Unmarshal(data, &cfg); err != nil {
+		return
+	}
+
+	storage.mu.Lock()
+	for name, value := range cfg.Env {
+		storage.data[name] = value
+		creds.AddSecret(value)
+	}
+	storage.mu.Unlock()
+}
+
+var storage *envStorage
+
+type envStorage struct {
+	data map[string]string
+	mu   sync.Mutex
+}
+
+func (s *envStorage) SetValue(name, value string) error {
+	if err := PatchConfig([]string{"env", name}, value); err != nil {
+		return err
+	}
+
+	s.mu.Lock()
+	s.data[name] = value
+	s.mu.Unlock()
+
+	return nil
+}
+
+func (s *envStorage) GetValue(name string) (value string, ok bool) {
+	s.mu.Lock()
+	value, ok = s.data[name]
+	s.mu.Unlock()
+	return
+}
diff --git a/installs_on_host/go2rtc/internal/bubble/README.md b/installs_on_host/go2rtc/internal/bubble/README.md
new file mode 100644
index 0000000..30ebad9
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/bubble/README.md
@@ -0,0 +1,15 @@
+# Bubble
+
+[`new in v1.6.1`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.6.1)
+
+Private format in some cameras from [dvr163.com](http://help.dvr163.com/) and [eseecloud.com](http://www.eseecloud.com/).
+
+## Configuration
+
+- you can skip `username`, `password`, `port`, `ch` and `stream` if they are default
+- set up separate streams for different channels and streams
+
+```yaml
+streams:
+  camera1: bubble://username:password@192.168.1.123:34567/bubble/live?ch=0&stream=0
+```
diff --git a/installs_on_host/go2rtc/internal/bubble/bubble.go b/installs_on_host/go2rtc/internal/bubble/bubble.go
new file mode 100644
index 0000000..6c526fc
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/bubble/bubble.go
@@ -0,0 +1,13 @@
+package bubble
+
+import (
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/bubble"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func Init() {
+	streams.HandleFunc("bubble", func(source string) (core.Producer, error) {
+		return bubble.Dial(source)
+	})
+}
diff --git a/installs_on_host/go2rtc/internal/debug/README.md b/installs_on_host/go2rtc/internal/debug/README.md
new file mode 100644
index 0000000..e03b2f8
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/debug/README.md
@@ -0,0 +1,3 @@
+# Debug
+
+This module provides `GET /api/stack`, with which you can find hanging goroutines
diff --git a/installs_on_host/go2rtc/internal/debug/debug.go b/installs_on_host/go2rtc/internal/debug/debug.go
new file mode 100644
index 0000000..fc7d245
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/debug/debug.go
@@ -0,0 +1,9 @@
+package debug
+
+import (
+	"github.com/AlexxIT/go2rtc/internal/api"
+)
+
+func Init() {
+	api.HandleFunc("api/stack", stackHandler)
+}
diff --git a/installs_on_host/go2rtc/internal/debug/stack.go b/installs_on_host/go2rtc/internal/debug/stack.go
new file mode 100644
index 0000000..6bc735a
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/debug/stack.go
@@ -0,0 +1,60 @@
+package debug
+
+import (
+	"bytes"
+	"fmt"
+	"net/http"
+	"runtime"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+)
+
+var stackSkip = [][]byte{
+	// main.go
+	[]byte("main.main()"),
+	[]byte("created by os/signal.Notify"),
+
+	// api/stack.go
+	[]byte("github.com/AlexxIT/go2rtc/internal/api.stackHandler"),
+
+	// api/api.go
+	[]byte("created by github.com/AlexxIT/go2rtc/internal/api.Init"),
+	[]byte("created by net/http.(*connReader).startBackgroundRead"),
+	[]byte("created by net/http.(*Server).Serve"), // TODO: why two?
+
+	[]byte("created by github.com/AlexxIT/go2rtc/internal/rtsp.Init"),
+	[]byte("created by github.com/AlexxIT/go2rtc/internal/srtp.Init"),
+
+	// homekit
+	[]byte("created by github.com/AlexxIT/go2rtc/internal/homekit.Init"),
+
+	// webrtc/api.go
+	[]byte("created by github.com/pion/ice/v4.NewTCPMuxDefault"),
+	[]byte("created by github.com/pion/ice/v4.NewUDPMuxDefault"),
+}
+
+func stackHandler(w http.ResponseWriter, r *http.Request) {
+	sep := []byte("\n\n")
+	buf := make([]byte, 65535)
+	i := 0
+	n := runtime.Stack(buf, true)
+	skipped := 0
+	for _, item := range bytes.Split(buf[:n], sep) {
+		for _, skip := range stackSkip {
+			if bytes.Contains(item, skip) {
+				item = nil
+				skipped++
+				break
+			}
+		}
+		if item != nil {
+			i += copy(buf[i:], item)
+			i += copy(buf[i:], sep)
+		}
+	}
+	i += copy(buf[i:], fmt.Sprintf(
+		"Total: %d, Skipped: %d", runtime.NumGoroutine(), skipped),
+	)
+
+	api.Response(w, buf[:i], api.MimeText)
+}
diff --git a/installs_on_host/go2rtc/internal/doorbird/README.md b/installs_on_host/go2rtc/internal/doorbird/README.md
new file mode 100644
index 0000000..0273b52
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/doorbird/README.md
@@ -0,0 +1,21 @@
+# Doorbird
+
+[`new in v1.9.8`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.9.8)
+
+This source type supports [Doorbird](https://www.doorbird.com/) devices including MJPEG stream, audio stream as well as two-way audio.
+
+It is recommended to create a separate user within your doorbird setup for go2rtc. Minimum permissions for the user are:
+
+- Watch always
+- API operator
+
+## Configuration
+
+```yaml
+streams:
+  doorbird1:
+    - rtsp://admin:password@192.168.1.123:8557/mpeg/720p/media.amp  # RTSP stream
+    - doorbird://admin:password@192.168.1.123?media=video           # MJPEG stream
+    - doorbird://admin:password@192.168.1.123?media=audio           # audio stream
+    - doorbird://admin:password@192.168.1.123                       # two-way audio
+```
diff --git a/installs_on_host/go2rtc/internal/doorbird/doorbird.go b/installs_on_host/go2rtc/internal/doorbird/doorbird.go
new file mode 100644
index 0000000..c56fc0f
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/doorbird/doorbird.go
@@ -0,0 +1,36 @@
+package doorbird
+
+import (
+	"net/url"
+
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/doorbird"
+)
+
+func Init() {
+	streams.RedirectFunc("doorbird", func(rawURL string) (string, error) {
+		u, err := url.Parse(rawURL)
+		if err != nil {
+			return "", err
+		}
+
+		// https://www.doorbird.com/downloads/api_lan.pdf
+		switch u.Query().Get("media") {
+		case "video":
+			u.Path = "/bha-api/video.cgi"
+		case "audio":
+			u.Path = "/bha-api/audio-receive.cgi"
+		default:
+			return "", nil
+		}
+
+		u.Scheme = "http"
+
+		return u.String(), nil
+	})
+
+	streams.HandleFunc("doorbird", func(source string) (core.Producer, error) {
+		return doorbird.Dial(source)
+	})
+}
diff --git a/installs_on_host/go2rtc/internal/dvrip/README.md b/installs_on_host/go2rtc/internal/dvrip/README.md
new file mode 100644
index 0000000..792834c
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/dvrip/README.md
@@ -0,0 +1,21 @@
+# DVR-IP
+
+[`new in v1.2.0`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.2.0)
+
+Private format from DVR-IP NVR, NetSurveillance, Sofia protocol (NETsurveillance ActiveX plugin XMeye SDK).
+
+## Configuration
+
+- you can skip `username`, `password`, `port`, `channel` and `subtype` if they are default
+- set up separate streams for different channels
+- use `subtype=0` for Main stream, and `subtype=1` for Extra1 stream
+- only the TCP protocol is supported
+
+```yaml
+streams:
+  only_stream: dvrip://username:password@192.168.1.123:34567?channel=0&subtype=0
+  only_tts: dvrip://username:password@192.168.1.123:34567?backchannel=1
+  two_way_audio:
+    - dvrip://username:password@192.168.1.123:34567?channel=0&subtype=0
+    - dvrip://username:password@192.168.1.123:34567?backchannel=1
+```
diff --git a/installs_on_host/go2rtc/internal/dvrip/dvrip.go b/installs_on_host/go2rtc/internal/dvrip/dvrip.go
new file mode 100644
index 0000000..db1c60d
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/dvrip/dvrip.go
@@ -0,0 +1,161 @@
+package dvrip
+
+import (
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"net"
+	"net/http"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/dvrip"
+)
+
+func Init() {
+	streams.HandleFunc("dvrip", dvrip.Dial)
+
+	// DVRIP client autodiscovery
+	api.HandleFunc("api/dvrip", apiDvrip)
+}
+
+const Port = 34569 // UDP port number for dvrip discovery
+
+func apiDvrip(w http.ResponseWriter, r *http.Request) {
+	items, err := discover()
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	api.ResponseSources(w, items)
+}
+
+func discover() ([]*api.Source, error) {
+	addr := &net.UDPAddr{
+		Port: Port,
+		IP:   net.IP{239, 255, 255, 250},
+	}
+
+	conn, err := net.ListenUDP("udp4", addr)
+	if err != nil {
+		return nil, err
+	}
+
+	defer conn.Close()
+
+	go sendBroadcasts(conn)
+
+	var items []*api.Source
+
+	for _, info := range getResponses(conn) {
+		if info.HostIP == "" || info.HostName == "" {
+			continue
+		}
+
+		host, err := hexToDecimalBytes(info.HostIP)
+		if err != nil {
+			continue
+		}
+
+		items = append(items, &api.Source{
+			Name: info.HostName,
+			URL:  "dvrip://user:pass@" + host + "?channel=0&subtype=0",
+		})
+	}
+
+	return items, nil
+}
+
+func sendBroadcasts(conn *net.UDPConn) {
+	// broadcasting the same multiple times because the devies some times don't answer
+	data, err := hex.DecodeString("ff00000000000000000000000000fa0500000000")
+	if err != nil {
+		return
+	}
+
+	addr := &net.UDPAddr{
+		Port: Port,
+		IP:   net.IP{255, 255, 255, 255},
+	}
+
+	for i := 0; i < 3; i++ {
+		time.Sleep(100 * time.Millisecond)
+		_, _ = conn.WriteToUDP(data, addr)
+	}
+}
+
+type Message struct {
+	NetCommon NetCommon `json:"NetWork.NetCommon"`
+	Ret       int       `json:"Ret"`
+	SessionID string    `json:"SessionID"`
+}
+
+type NetCommon struct {
+	BuildDate       string `json:"BuildDate"`
+	ChannelNum      int    `json:"ChannelNum"`
+	DeviceType      int    `json:"DeviceType"`
+	GateWay         string `json:"GateWay"`
+	HostIP          string `json:"HostIP"`
+	HostName        string `json:"HostName"`
+	HttpPort        int    `json:"HttpPort"`
+	MAC             string `json:"MAC"`
+	MonMode         string `json:"MonMode"`
+	NetConnectState int    `json:"NetConnectState"`
+	OtherFunction   string `json:"OtherFunction"`
+	SN              string `json:"SN"`
+	SSLPort         int    `json:"SSLPort"`
+	Submask         string `json:"Submask"`
+	TCPMaxConn      int    `json:"TCPMaxConn"`
+	TCPPort         int    `json:"TCPPort"`
+	UDPPort         int    `json:"UDPPort"`
+	UseHSDownLoad   bool   `json:"UseHSDownLoad"`
+	Version         string `json:"Version"`
+}
+
+func getResponses(conn *net.UDPConn) (infos []*NetCommon) {
+	if err := conn.SetReadDeadline(time.Now().Add(time.Second * 2)); err != nil {
+		return
+	}
+
+	var ips []net.IP // processed IPs
+
+	b := make([]byte, 4096)
+loop:
+	for {
+		n, addr, err := conn.ReadFromUDP(b)
+		if err != nil {
+			break
+		}
+
+		for _, ip := range ips {
+			if ip.Equal(addr.IP) {
+				continue loop
+			}
+		}
+
+		if n <= 20+1 {
+			continue
+		}
+
+		var msg Message
+
+		if err = json.Unmarshal(b[20:n-1], &msg); err != nil {
+			continue
+		}
+
+		infos = append(infos, &msg.NetCommon)
+		ips = append(ips, addr.IP)
+	}
+
+	return
+}
+
+func hexToDecimalBytes(hexIP string) (string, error) {
+	b, err := hex.DecodeString(hexIP[2:]) // remove the '0x' prefix
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("%d.%d.%d.%d", b[3], b[2], b[1], b[0]), nil
+}
diff --git a/installs_on_host/go2rtc/internal/echo/README.md b/installs_on_host/go2rtc/internal/echo/README.md
new file mode 100644
index 0000000..1dbd7dc
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/echo/README.md
@@ -0,0 +1,48 @@
+# Echo
+
+Some sources may have a dynamic link. And you will need to get it using a Bash or Python script. Your script should echo a link to the source. RTSP, FFmpeg or any of the supported sources.
+
+**Docker** and **Home Assistant add-on** users have preinstalled `python3`, `curl`, `jq`.
+
+## Configuration
+
+```yaml
+streams:
+  apple_hls: echo:python3 hls.py https://developer.apple.com/streaming/examples/basic-stream-osx-ios5.html
+```
+
+## Install python libraries
+
+**Docker** and **Hass Add-on** users have preinstalled `python3` without any additional libraries, like [requests](https://requests.readthedocs.io/) or others. If you need some additional libraries - you need to install them to folder with your script:
+
+1. Install [SSH & Web Terminal](https://github.com/hassio-addons/addon-ssh)
+2. Goto Add-on Web UI
+3. Install library: `pip install requests -t /config/echo`
+4. Add your script to `/config/echo/myscript.py`
+5. Use your script as source `echo:python3 /config/echo/myscript.py`
+
+## Example: Apple HLS
+
+```yaml
+streams:
+  apple_hls: echo:python3 hls.py https://developer.apple.com/streaming/examples/basic-stream-osx-ios5.html
+```
+
+**hls.py**
+
+```python
+import re
+import sys
+from urllib.parse import urljoin
+from urllib.request import urlopen
+
+html = urlopen(sys.argv[1]).read().decode("utf-8")
+url = re.search(r"https.+?m3u8", html)[0]
+
+html = urlopen(url).read().decode("utf-8")
+m = re.search(r"^[a-z0-1/_]+\.m3u8$", html, flags=re.MULTILINE)
+url = urljoin(url, m[0])
+
+# ffmpeg:https://devstreaming-cdn.apple.com/videos/streaming/examples/bipbop_16x9/gear1/prog_index.m3u8#video=copy
+print("ffmpeg:" + url + "#video=copy")
+```
diff --git a/installs_on_host/go2rtc/internal/echo/echo.go b/installs_on_host/go2rtc/internal/echo/echo.go
new file mode 100644
index 0000000..f33982f
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/echo/echo.go
@@ -0,0 +1,46 @@
+package echo
+
+import (
+	"bytes"
+	"errors"
+	"os/exec"
+	"slices"
+
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/shell"
+)
+
+func Init() {
+	var cfg struct {
+		Mod struct {
+			AllowPaths []string `yaml:"allow_paths"`
+		} `yaml:"echo"`
+	}
+
+	app.LoadConfig(&cfg)
+
+	allowPaths := cfg.Mod.AllowPaths
+
+	log := app.GetLogger("echo")
+
+	streams.RedirectFunc("echo", func(url string) (string, error) {
+		args := shell.QuoteSplit(url[5:])
+
+		if allowPaths != nil && !slices.Contains(allowPaths, args[0]) {
+			return "", errors.New("echo: bin not in allow_paths: " + args[0])
+		}
+
+		b, err := exec.Command(args[0], args[1:]...).Output()
+		if err != nil {
+			return "", err
+		}
+
+		b = bytes.TrimSpace(b)
+
+		log.Debug().Str("url", url).Msgf("[echo] %s", b)
+
+		return string(b), nil
+	})
+	streams.MarkInsecure("echo")
+}
diff --git a/installs_on_host/go2rtc/internal/eseecloud/README.md b/installs_on_host/go2rtc/internal/eseecloud/README.md
new file mode 100644
index 0000000..30db840
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/eseecloud/README.md
@@ -0,0 +1,12 @@
+# EseeCloud
+
+[`new in v1.9.10`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.9.10)
+
+This source is for cameras with a link like this `http://admin:@192.168.1.123:80/livestream/12`. Related [issue](https://github.com/AlexxIT/go2rtc/issues/1690).
+
+## Configuration
+
+```yaml
+streams:
+  camera1: eseecloud://user:pass@192.168.1.123:80/livestream/12
+```
diff --git a/installs_on_host/go2rtc/internal/eseecloud/eseecloud.go b/installs_on_host/go2rtc/internal/eseecloud/eseecloud.go
new file mode 100644
index 0000000..bb4d9d3
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/eseecloud/eseecloud.go
@@ -0,0 +1,10 @@
+package eseecloud
+
+import (
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/eseecloud"
+)
+
+func Init() {
+	streams.HandleFunc("eseecloud", eseecloud.Dial)
+}
diff --git a/installs_on_host/go2rtc/internal/exec/README.md b/installs_on_host/go2rtc/internal/exec/README.md
new file mode 100644
index 0000000..aba1c55
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/exec/README.md
@@ -0,0 +1,48 @@
+# Exec
+
+Exec source can run any external application and expect data from it. Two transports are supported - **pipe** ([`new in v1.5.0`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.5.0)) and **RTSP**.
+
+If you want to use **RTSP** transport, the command must contain the `{output}` argument in any place. On launch, it will be replaced by the local address of the RTSP server.
+
+**pipe** reads data from app stdout in different formats: **MJPEG**, **H.264/H.265 bitstream**, **MPEG-TS**. Also pipe can write data to app stdin in two formats: **PCMA** and **PCM/48000**.
+
+The source can be used with:
+
+- [FFmpeg](https://ffmpeg.org/) - go2rtc ffmpeg source is just a shortcut to exec source
+- [FFplay](https://ffmpeg.org/ffplay.html) - play audio on your server
+- [GStreamer](https://gstreamer.freedesktop.org/)
+- [Raspberry Pi Cameras](https://www.raspberrypi.com/documentation/computers/camera_software.html)
+- any of your own software
+
+## Configuration
+
+Pipe commands support parameters (format: `exec:{command}#{param1}#{param2}`):
+
+- `killsignal` - signal which will be sent to stop the process (numeric form)
+- `killtimeout` - time in seconds for forced termination with sigkill
+- `backchannel` - enable backchannel for two-way audio
+- `starttimeout` - time in seconds for waiting first byte from RTSP
+
+```yaml
+streams:
+  stream: exec:ffmpeg -re -i /media/BigBuckBunny.mp4 -c copy -rtsp_transport tcp -f rtsp {output}
+  picam_h264: exec:libcamera-vid -t 0 --inline -o -
+  picam_mjpeg: exec:libcamera-vid -t 0 --codec mjpeg -o -
+  pi5cam_h264: exec:libcamera-vid -t 0 --libav-format h264 -o -
+  canon: exec:gphoto2 --capture-movie --stdout#killsignal=2#killtimeout=5
+  play_pcma: exec:ffplay -fflags nobuffer -f alaw -ar 8000 -i -#backchannel=1
+  play_pcm48k: exec:ffplay -fflags nobuffer -f s16be -ar 48000 -i -#backchannel=1
+```
+
+## Backchannel
+
+- You can check audio card names in the **Go2rtc > WebUI > Add**
+- You can specify multiple backchannel lines with different codecs
+
+```yaml
+sources:
+  two_way_audio_win:
+    - exec:ffmpeg -hide_banner -f dshow -i "audio=Microphone (High Definition Audio Device)" -c pcm_s16le -ar 16000 -ac 1 -f wav -
+    - exec:ffplay -nodisp -probesize 32 -f s16le -ar 16000 -#backchannel=1#audio=s16le/16000
+    - exec:ffplay -nodisp -probesize 32 -f alaw -ar 8000 -#backchannel=1#audio=alaw/8000
+```
diff --git a/installs_on_host/go2rtc/internal/exec/exec.go b/installs_on_host/go2rtc/internal/exec/exec.go
new file mode 100644
index 0000000..e428aef
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/exec/exec.go
@@ -0,0 +1,279 @@
+package exec
+
+import (
+	"bufio"
+	"crypto/md5"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+	"net/url"
+	"os"
+	"slices"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/rtsp"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/magic"
+	"github.com/AlexxIT/go2rtc/pkg/pcm"
+	pkg "github.com/AlexxIT/go2rtc/pkg/rtsp"
+	"github.com/AlexxIT/go2rtc/pkg/shell"
+	"github.com/rs/zerolog"
+)
+
+func Init() {
+	var cfg struct {
+		Mod struct {
+			AllowPaths []string `yaml:"allow_paths"`
+		} `yaml:"exec"`
+	}
+
+	app.LoadConfig(&cfg)
+
+	allowPaths = cfg.Mod.AllowPaths
+
+	rtsp.HandleFunc(func(conn *pkg.Conn) bool {
+		waitersMu.Lock()
+		waiter := waiters[conn.URL.Path]
+		waitersMu.Unlock()
+
+		if waiter == nil {
+			return false
+		}
+
+		// unblocking write to channel
+		select {
+		case waiter <- conn:
+			return true
+		default:
+			return false
+		}
+	})
+
+	streams.HandleFunc("exec", execHandle)
+	streams.MarkInsecure("exec")
+
+	log = app.GetLogger("exec")
+}
+
+var allowPaths []string
+
+func execHandle(rawURL string) (prod core.Producer, err error) {
+	rawURL, rawQuery, _ := strings.Cut(rawURL, "#")
+	query := streams.ParseQuery(rawQuery)
+
+	var path string
+
+	// RTSP flow should have `{output}` inside URL
+	// pipe flow may have `#{params}` inside URL
+	if i := strings.Index(rawURL, "{output}"); i > 0 {
+		if rtsp.Port == "" {
+			return nil, errors.New("exec: rtsp module disabled")
+		}
+
+		sum := md5.Sum([]byte(rawURL))
+		path = "/" + hex.EncodeToString(sum[:])
+		rawURL = rawURL[:i] + "rtsp://127.0.0.1:" + rtsp.Port + path + rawURL[i+8:]
+	}
+
+	cmd := shell.NewCommand(rawURL[5:]) // remove `exec:`
+	cmd.Stderr = &logWriter{
+		buf:   make([]byte, 512),
+		debug: log.Debug().Enabled(),
+	}
+
+	if allowPaths != nil && !slices.Contains(allowPaths, cmd.Args[0]) {
+		_ = cmd.Close()
+		return nil, errors.New("exec: bin not in allow_paths: " + cmd.Args[0])
+	}
+
+	if s := query.Get("killsignal"); s != "" {
+		sig := syscall.Signal(core.Atoi(s))
+		cmd.Cancel = func() error {
+			log.Debug().Msgf("[exec] kill with signal=%d", sig)
+			return cmd.Process.Signal(sig)
+		}
+	}
+
+	if s := query.Get("killtimeout"); s != "" {
+		cmd.WaitDelay = time.Duration(core.Atoi(s)) * time.Second
+	}
+
+	if query.Get("backchannel") == "1" {
+		return pcm.NewBackchannel(cmd, query.Get("audio"))
+	}
+
+	var timeout time.Duration
+	if s := query.Get("starttimeout"); s != "" {
+		timeout = time.Duration(core.Atoi(s)) * time.Second
+	} else {
+		timeout = 30 * time.Second
+	}
+
+	if path == "" {
+		prod, err = handlePipe(rawURL, cmd)
+	} else {
+		prod, err = handleRTSP(rawURL, cmd, path, timeout)
+	}
+
+	if err != nil {
+		_ = cmd.Close()
+	}
+
+	return
+}
+
+func handlePipe(source string, cmd *shell.Command) (core.Producer, error) {
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		return nil, err
+	}
+
+	rd := struct {
+		io.Reader
+		io.Closer
+	}{
+		// add buffer for pipe reader to reduce syscall
+		bufio.NewReaderSize(stdout, core.BufferSize),
+		// stop cmd on close pipe call
+		cmd,
+	}
+
+	log.Debug().Strs("args", cmd.Args).Msg("[exec] run pipe")
+
+	ts := time.Now()
+
+	if err = cmd.Start(); err != nil {
+		return nil, err
+	}
+
+	prod, err := magic.Open(rd)
+	if err != nil {
+		return nil, fmt.Errorf("exec/pipe: %w\n%s", err, cmd.Stderr)
+	}
+
+	if info, ok := prod.(core.Info); ok {
+		info.SetProtocol("pipe")
+		setRemoteInfo(info, source, cmd.Args)
+	}
+
+	log.Debug().Stringer("launch", time.Since(ts)).Msg("[exec] run pipe")
+
+	return prod, nil
+}
+
+func handleRTSP(source string, cmd *shell.Command, path string, timeout time.Duration) (core.Producer, error) {
+	if log.Trace().Enabled() {
+		cmd.Stdout = os.Stdout
+	}
+
+	waiter := make(chan *pkg.Conn, 1)
+
+	waitersMu.Lock()
+	waiters[path] = waiter
+	waitersMu.Unlock()
+
+	defer func() {
+		waitersMu.Lock()
+		delete(waiters, path)
+		waitersMu.Unlock()
+	}()
+
+	log.Debug().Strs("args", cmd.Args).Msg("[exec] run rtsp")
+
+	ts := time.Now()
+
+	if err := cmd.Start(); err != nil {
+		log.Error().Err(err).Str("source", source).Msg("[exec]")
+		return nil, err
+	}
+
+	timer := time.NewTimer(timeout)
+	defer timer.Stop()
+
+	select {
+	case <-timer.C:
+		// haven't received data from app in timeout
+		log.Error().Str("source", source).Msg("[exec] timeout")
+		return nil, errors.New("exec: timeout")
+	case <-cmd.Done():
+		// app fail before we receive any data
+		return nil, fmt.Errorf("exec/rtsp\n%s", cmd.Stderr)
+	case prod := <-waiter:
+		// app started successfully
+		log.Debug().Stringer("launch", time.Since(ts)).Msg("[exec] run rtsp")
+		setRemoteInfo(prod, source, cmd.Args)
+		prod.OnClose = cmd.Close
+		return prod, nil
+	}
+}
+
+// internal
+
+var (
+	log       zerolog.Logger
+	waiters   = make(map[string]chan *pkg.Conn)
+	waitersMu sync.Mutex
+)
+
+type logWriter struct {
+	buf   []byte
+	debug bool
+	n     int
+}
+
+func (l *logWriter) String() string {
+	if l.n == len(l.buf) {
+		return string(l.buf) + "..."
+	}
+	return string(l.buf[:l.n])
+}
+
+func (l *logWriter) Write(p []byte) (n int, err error) {
+	if l.n < cap(l.buf) {
+		l.n += copy(l.buf[l.n:], p)
+	}
+	n = len(p)
+	if l.debug {
+		if p = trimSpace(p); p != nil {
+			log.Debug().Msgf("[exec] %s", p)
+		}
+	}
+	return
+}
+
+func trimSpace(b []byte) []byte {
+	start := 0
+	stop := len(b)
+	for ; start < stop; start++ {
+		if b[start] >= ' ' {
+			break // trim all ASCII before 0x20
+		}
+	}
+	for ; ; stop-- {
+		if stop == start {
+			return nil // skip empty output
+		}
+		if b[stop-1] > ' ' {
+			break // trim all ASCII before 0x21
+		}
+	}
+	return b[start:stop]
+}
+
+func setRemoteInfo(info core.Info, source string, args []string) {
+	info.SetSource(source)
+
+	if i := core.Index(args, "-i"); i > 0 && i < len(args)-1 {
+		rawURL := args[i+1]
+		if u, err := url.Parse(rawURL); err == nil && u.Host != "" {
+			info.SetRemoteAddr(u.Host)
+			info.SetURL(rawURL)
+		}
+	}
+}
diff --git a/installs_on_host/go2rtc/internal/expr/README.md b/installs_on_host/go2rtc/internal/expr/README.md
new file mode 100644
index 0000000..424f4d0
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/expr/README.md
@@ -0,0 +1,153 @@
+# Expr
+
+[`new in v1.8.2`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.8.2)
+
+[Expr](https://github.com/antonmedv/expr) - expression language and expression evaluation for Go.
+
+- [language definition](https://expr.medv.io/docs/Language-Definition) - takes best from JS, Python, Jinja2 syntax
+- your expression should return a link of any supported source
+- expression supports multiple operation, but:
+  - all operations must be separated by a semicolon
+  - all operations, except the last one, must declare a new variable (`let s = "abc";`)
+  - the last operation should return a string
+- go2rtc supports additional functions:
+  - `fetch` - JS-like HTTP requests
+  - `match` - JS-like RegExp queries
+
+## Fetch examples
+
+Multiple fetch requests are executed within a single session. They share the same cookie.
+
+**HTTP GET**
+
+```js
+var r = fetch('https://example.org/products.json');
+```
+
+**HTTP POST JSON**
+
+```js
+var r = fetch('https://example.org/post', {
+    method: 'POST',
+    // Content-Type: application/json will be set automatically
+    json: {username: 'example'}
+});
+```
+
+**HTTP POST Form**
+
+```js
+var r = fetch('https://example.org/post', {
+    method: 'POST',
+    // Content-Type: application/x-www-form-urlencoded will be set automatically
+    data: {username: 'example', password: 'password'}
+});
+```
+
+## Script examples
+
+**Two way audio for Dahua VTO**
+
+```yaml
+streams:
+  dahua_vto: |
+    expr:
+    let host = 'admin:password@192.168.1.123';
+
+    var r = fetch('http://' + host + '/cgi-bin/configManager.cgi?action=setConfig&Encode[0].MainFormat[0].Audio.Compression=G.711A&Encode[0].MainFormat[0].Audio.Frequency=8000');
+
+    'rtsp://' + host + '/cam/realmonitor?channel=1&subtype=0&unicast=true&proto=Onvif'
+```
+
+**dom.ru**
+
+You can get credentials from https://github.com/ad/domru
+
+```yaml
+streams:
+  dom_ru: |
+    expr:
+    let camera   = '***';
+    let token    = '***';
+    let operator = '***';
+
+    fetch('https://myhome.proptech.ru/rest/v1/forpost/cameras/' + camera + '/video', {
+      headers: {
+        'Authorization': 'Bearer ' + token,
+        'User-Agent': 'Google sdkgphone64x8664 | Android 14 | erth | 8.26.0 (82600010) | 0 | 0 | 0',
+        'Operator': operator
+      }
+    }).json().data.URL
+```
+
+**dom.ufanet.ru**
+
+```yaml
+streams:
+  ufanet_ru: |
+    expr:
+    let username = '***';
+    let password = '***';
+    let cameraid = '***';
+
+    let r1 = fetch('https://ucams.ufanet.ru/api/internal/login/', {
+      method: 'POST',
+      data: {username: username, password: password}
+    });
+    let r2 = fetch('https://ucams.ufanet.ru/api/v0/cameras/this/?lang=ru', {
+      method: 'POST',
+      json: {'fields': ['token_l', 'server'], 'token_l_ttl': 3600, 'numbers': [cameraid]},
+    }).json().results[0];
+
+    'rtsp://' + r2.server.domain + '/' + r2.number + '?token=' + r2.token_l
+```
+
+**Parse HLS files from Apple**
+
+Same example in two languages - python and expr.
+
+```yaml
+streams:
+  example_python: |
+    echo:python -c 'from urllib.request import urlopen; import re
+
+    # url1 = "https://devstreaming-cdn.apple.com/videos/streaming/examples/bipbop_16x9/bipbop_16x9_variant.m3u8"
+    html1 = urlopen("https://developer.apple.com/streaming/examples/basic-stream-osx-ios5.html").read().decode("utf-8")
+    url1 = re.search(r"https.+?m3u8", html1)[0]
+
+    # url2 = "gear1/prog_index.m3u8"
+    html2 = urlopen(url1).read().decode("utf-8")
+    url2 = re.search(r"^[a-z0-1/_]+\.m3u8$", html2, flags=re.MULTILINE)[0]
+
+    # url3 = "https://devstreaming-cdn.apple.com/videos/streaming/examples/bipbop_16x9/gear1/prog_index.m3u8"
+    url3 = url1[:url1.rindex("/")+1] + url2
+
+    print("ffmpeg:" + url3 + "#video=copy")'
+
+  example_expr: |
+    expr:
+
+    let html1 = fetch("https://developer.apple.com/streaming/examples/basic-stream-osx-ios5.html").text;
+    let url1 = match(html1, "https.+?m3u8")[0];
+
+    let html2 = fetch(url1).text;
+    let url2 = match(html2, "^[a-z0-1/_]+\\.m3u8$", "m")[0];
+
+    let url3 = url1[:lastIndexOf(url1, "/")+1] + url2;
+
+    "ffmpeg:" + url3 + "#video=copy"
+```
+
+## Comparison
+
+| expr                         | python                     | js                             |
+|------------------------------|----------------------------|--------------------------------|
+| let x = 1;                   | x = 1                      | let x = 1                      |
+| {a: 1, b: 2}                 | {"a": 1, "b": 2}           | {a: 1, b: 2}                   |
+| let r = fetch(url, {method}) | r = request(method, url)   | r = await fetch(url, {method}) |
+| r.ok                         | r.ok                       | r.ok                           |
+| r.status                     | r.status_code              | r.status                       |
+| r.text                       | r.text                     | await r.text()                 |
+| r.json()                     | r.json()                   | await r.json()                 |
+| r.headers                    | r.headers                  | r.headers                      |
+| let m = match(text, "abc")   | m = re.search("abc", text) | let m = text.match(/abc/)      |
diff --git a/installs_on_host/go2rtc/internal/expr/expr.go b/installs_on_host/go2rtc/internal/expr/expr.go
new file mode 100644
index 0000000..60d32a8
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/expr/expr.go
@@ -0,0 +1,29 @@
+package expr
+
+import (
+	"errors"
+
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/expr"
+)
+
+func Init() {
+	log := app.GetLogger("expr")
+
+	streams.RedirectFunc("expr", func(url string) (string, error) {
+		v, err := expr.Eval(url[5:], nil)
+		if err != nil {
+			return "", err
+		}
+
+		log.Debug().Msgf("[expr] url=%s", url)
+
+		if url = v.(string); url == "" {
+			return "", errors.New("expr: result is empty")
+		}
+
+		return url, nil
+	})
+	streams.MarkInsecure("expr")
+}
diff --git a/installs_on_host/go2rtc/internal/ffmpeg/README.md b/installs_on_host/go2rtc/internal/ffmpeg/README.md
new file mode 100644
index 0000000..03f2921
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ffmpeg/README.md
@@ -0,0 +1,62 @@
+# FFmpeg
+
+You can get any stream, file or device via FFmpeg and push it to go2rtc. The app will automatically start FFmpeg with the proper arguments when someone starts watching the stream.
+
+- FFmpeg preinstalled for **Docker** and **Home Assistant add-on** users
+- **Home Assistant add-on** users can target files from [/media](https://www.home-assistant.io/more-info/local-media/setup-media/) folder
+
+## Configuration
+
+Format: `ffmpeg:{input}#{param1}#{param2}#{param3}`. Examples:
+
+```yaml
+streams:
+  # [FILE] all tracks will be copied without transcoding codecs
+  file1: ffmpeg:/media/BigBuckBunny.mp4
+
+  # [FILE] video will be transcoded to H264, audio will be skipped
+  file2: ffmpeg:/media/BigBuckBunny.mp4#video=h264
+
+  # [FILE] video will be copied, audio will be transcoded to PCMU
+  file3: ffmpeg:/media/BigBuckBunny.mp4#video=copy#audio=pcmu
+
+  # [HLS] video will be copied, audio will be skipped
+  hls: ffmpeg:https://devstreaming-cdn.apple.com/videos/streaming/examples/bipbop_16x9/gear5/prog_index.m3u8#video=copy
+
+  # [MJPEG] video will be transcoded to H264
+  mjpeg: ffmpeg:http://185.97.122.128/cgi-bin/faststream.jpg#video=h264
+
+  # [RTSP] video with rotation, should be transcoded, so select H264
+  rotate: ffmpeg:rtsp://12345678@192.168.1.123/av_stream/ch0#video=h264#rotate=90
+```
+
+All transcoding formats have [built-in templates](ffmpeg.go): `h264`, `h265`, `opus`, `pcmu`, `pcmu/16000`, `pcmu/48000`, `pcma`, `pcma/16000`, `pcma/48000`, `aac`, `aac/16000`.
+
+But you can override them via YAML config. You can also add your own formats to the config and use them with source params.
+
+```yaml
+ffmpeg:
+  bin: ffmpeg  # path to ffmpeg binary
+  global: "-hide_banner"
+  timeout: 5  # default timeout in seconds for rtsp inputs
+  h264: "-codec:v libx264 -g:v 30 -preset:v superfast -tune:v zerolatency -profile:v main -level:v 4.1"
+  mycodec: "-any args that supported by ffmpeg..."
+  myinput: "-fflags nobuffer -flags low_delay -timeout {timeout} -i {input}"
+  myraw: "-ss 00:00:20"
+```
+
+- You can use go2rtc stream name as ffmpeg input (ex. `ffmpeg:camera1#video=h264`)
+- You can use `video` and `audio` params multiple times (ex. `#video=copy#audio=copy#audio=pcmu`)
+- You can use `rotate` param with `90`, `180`, `270` or `-90` values, important with transcoding (ex. `#video=h264#rotate=90`)
+- You can use `width` and/or `height` params, important with transcoding (ex. `#video=h264#width=1280`)
+- You can use `drawtext` to add a timestamp (ex. `drawtext=x=2:y=2:fontsize=12:fontcolor=white:box=1:boxcolor=black`)
+    - This will greatly increase the CPU of the server, even with hardware acceleration
+- You can use `timeout` param to set RTSP input timeout in seconds (ex. `#timeout=10`)
+- You can use `raw` param for any additional FFmpeg arguments (ex. `#raw=-vf transpose=1`)
+- You can use `input` param to override default input template (ex. `#input=rtsp/udp` will change RTSP transport from TCP to UDP+TCP)
+    - You can use raw input value (ex. `#input=-timeout {timeout} -i {input}`)
+    - You can add your own input templates
+
+Read more about [hardware acceleration](hardware/README.md).
+
+**PS.** It is recommended to check the available hardware in the WebUI add page.
diff --git a/installs_on_host/go2rtc/internal/ffmpeg/api.go b/installs_on_host/go2rtc/internal/ffmpeg/api.go
new file mode 100644
index 0000000..d802f87
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ffmpeg/api.go
@@ -0,0 +1,51 @@
+package ffmpeg
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/streams"
+)
+
+func apiFFmpeg(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		http.Error(w, "", http.StatusMethodNotAllowed)
+		return
+	}
+
+	query := r.URL.Query()
+	dst := query.Get("dst")
+	stream := streams.Get(dst)
+	if stream == nil {
+		http.Error(w, "", http.StatusNotFound)
+		return
+	}
+
+	var src string
+	if s := query.Get("file"); s != "" {
+		if streams.Validate(s) == nil {
+			src = "ffmpeg:" + s + "#audio=auto#input=file"
+		}
+	} else if s = query.Get("live"); s != "" {
+		if streams.Validate(s) == nil {
+			src = "ffmpeg:" + s + "#audio=auto"
+		}
+	} else if s = query.Get("text"); s != "" {
+		if strings.IndexAny(s, `'"&%$`) < 0 {
+			src = "ffmpeg:tts?text=" + s
+			if s = query.Get("voice"); s != "" {
+				src += "&voice=" + s
+			}
+			src += "#audio=auto"
+		}
+	}
+
+	if src == "" {
+		http.Error(w, "", http.StatusBadRequest)
+		return
+	}
+
+	if err := stream.Play(src); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+}
diff --git a/installs_on_host/go2rtc/internal/ffmpeg/device/README.md b/installs_on_host/go2rtc/internal/ffmpeg/device/README.md
new file mode 100644
index 0000000..0188b6f
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ffmpeg/device/README.md
@@ -0,0 +1,22 @@
+# FFmpeg Device
+
+You can get video from any USB camera or Webcam as RTSP or WebRTC stream. This is part of FFmpeg integration.
+
+- check available devices in web interface
+- `video_size` and `framerate` must be supported by your camera!
+- for Linux supported only video for now
+- for macOS you can stream FaceTime camera or whole desktop!
+- for macOS important to set right framerate
+
+## Configuration
+
+Format: `ffmpeg:device?{input-params}#{param1}#{param2}#{param3}`
+
+```yaml
+streams:
+  linux_usbcam:   ffmpeg:device?video=0&video_size=1280x720#video=h264
+  windows_webcam: ffmpeg:device?video=0#video=h264
+  macos_facetime: ffmpeg:device?video=0&audio=1&video_size=1280x720&framerate=30#video=h264#audio=pcma
+```
+
+**PS.** It is recommended to check the available devices in the WebUI add page.
diff --git a/installs_on_host/go2rtc/internal/ffmpeg/device/device_bsd.go b/installs_on_host/go2rtc/internal/ffmpeg/device/device_bsd.go
new file mode 100644
index 0000000..27d5b61
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ffmpeg/device/device_bsd.go
@@ -0,0 +1,99 @@
+//go:build freebsd || netbsd || openbsd || dragonfly
+
+package device
+
+import (
+	"net/url"
+	"os"
+	"os/exec"
+	"regexp"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func queryToInput(query url.Values) string {
+	if video := query.Get("video"); video != "" {
+		// https://ffmpeg.org/ffmpeg-devices.html#video4linux2_002c-v4l2
+		input := "-f v4l2"
+
+		for key, value := range query {
+			switch key {
+			case "resolution":
+				input += " -video_size " + value[0]
+			case "video_size", "pixel_format", "input_format", "framerate", "use_libv4l2":
+				input += " -" + key + " " + value[0]
+			}
+		}
+
+		return input + " -i " + indexToItem(videos, video)
+	}
+
+	if audio := query.Get("audio"); audio != "" {
+		input := "-f oss"
+
+		for key, value := range query {
+			switch key {
+			case "channels", "sample_rate":
+				input += " -" + key + " " + value[0]
+			}
+		}
+
+		return input + " -i " + indexToItem(audios, audio)
+	}
+
+	return ""
+}
+
+func initDevices() {
+	files, err := os.ReadDir("/dev")
+	if err != nil {
+		return
+	}
+
+	for _, file := range files {
+		if !strings.HasPrefix(file.Name(), core.KindVideo) {
+			continue
+		}
+
+		name := "/dev/" + file.Name()
+
+		cmd := exec.Command(
+			Bin, "-hide_banner", "-f", "v4l2", "-list_formats", "all", "-i", name,
+		)
+		b, _ := cmd.CombinedOutput()
+
+		// [video4linux2,v4l2 @ 0x860b92280] Raw       :     yuyv422 :           YUYV 4:2:2 : 640x480 160x120 176x144 320x176 320x240 352x288 432x240 544x288 640x360 752x416 800x448 800x600 864x480 960x544 960x720 1024x576 1184x656 1280x720 1280x960
+		// [video4linux2,v4l2 @ 0x860b92280] Compressed:       mjpeg :          Motion-JPEG : 640x480 160x120 176x144 320x176 320x240 352x288 432x240 544x288 640x360 752x416 800x448 800x600 864x480 960x544 960x720 1024x576 1184x656 1280x720 1280x960
+		re := regexp.MustCompile("(Raw *|Compressed): +(.+?) : +(.+?) : (.+)")
+		m := re.FindAllStringSubmatch(string(b), -1)
+		for _, i := range m {
+			size, _, _ := strings.Cut(i[4], " ")
+			stream := &api.Source{
+				Name: i[3],
+				Info: i[4],
+				URL:  "ffmpeg:device?video=" + name + "&input_format=" + i[2] + "&video_size=" + size,
+			}
+
+			if i[1] != "Compressed" {
+				stream.URL += "#video=h264#hardware"
+			}
+
+			videos = append(videos, name)
+			streams = append(streams, stream)
+		}
+	}
+
+	err = exec.Command(Bin, "-f", "oss", "-i", "/dev/dsp", "-t", "1", "-f", "null", "-").Run()
+	if err == nil {
+		stream := &api.Source{
+			Name: "OSS default",
+			Info: " ",
+			URL:  "ffmpeg:device?audio=default&channels=1&sample_rate=16000&#audio=opus",
+		}
+
+		audios = append(audios, "default")
+		streams = append(streams, stream)
+	}
+}
diff --git a/installs_on_host/go2rtc/internal/ffmpeg/device/device_darwin.go b/installs_on_host/go2rtc/internal/ffmpeg/device/device_darwin.go
new file mode 100644
index 0000000..ba97c0a
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ffmpeg/device/device_darwin.go
@@ -0,0 +1,88 @@
+//go:build darwin || ios
+
+package device
+
+import (
+	"net/url"
+	"os/exec"
+	"regexp"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func queryToInput(query url.Values) string {
+	video := query.Get("video")
+	audio := query.Get("audio")
+
+	if video == "" && audio == "" {
+		return ""
+	}
+
+	// https://ffmpeg.org/ffmpeg-devices.html#avfoundation
+	input := "-f avfoundation"
+
+	if video != "" {
+		video = indexToItem(videos, video)
+
+		for key, value := range query {
+			switch key {
+			case "resolution":
+				input += " -video_size " + value[0]
+			case "pixel_format", "framerate", "video_size", "capture_cursor", "capture_mouse_clicks", "capture_raw_data":
+				input += " -" + key + " " + value[0]
+			}
+		}
+	}
+
+	if audio != "" {
+		audio = indexToItem(audios, audio)
+	}
+
+	return input + ` -i "` + video + `:` + audio + `"`
+}
+
+func initDevices() {
+	// [AVFoundation indev @ 0x147f04510] AVFoundation video devices:
+	// [AVFoundation indev @ 0x147f04510] [0] FaceTime HD Camera
+	// [AVFoundation indev @ 0x147f04510] [1] Capture screen 0
+	// [AVFoundation indev @ 0x147f04510] AVFoundation audio devices:
+	// [AVFoundation indev @ 0x147f04510] [0] MacBook Pro Microphone
+	cmd := exec.Command(
+		Bin, "-hide_banner", "-list_devices", "true", "-f", "avfoundation", "-i", "",
+	)
+	b, _ := cmd.CombinedOutput()
+
+	re := regexp.MustCompile(`\[\d+] (.+)`)
+
+	var kind string
+	for _, line := range strings.Split(string(b), "\n") {
+		switch {
+		case strings.HasSuffix(line, "video devices:"):
+			kind = core.KindVideo
+			continue
+		case strings.HasSuffix(line, "audio devices:"):
+			kind = core.KindAudio
+			continue
+		}
+
+		m := re.FindStringSubmatch(line)
+		if m == nil {
+			continue
+		}
+
+		name := m[1]
+
+		switch kind {
+		case core.KindVideo:
+			videos = append(videos, name)
+		case core.KindAudio:
+			audios = append(audios, name)
+		}
+
+		streams = append(streams, &api.Source{
+			Name: name, URL: "ffmpeg:device?" + kind + "=" + name,
+		})
+	}
+}
diff --git a/installs_on_host/go2rtc/internal/ffmpeg/device/device_unix.go b/installs_on_host/go2rtc/internal/ffmpeg/device/device_unix.go
new file mode 100644
index 0000000..7b62187
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ffmpeg/device/device_unix.go
@@ -0,0 +1,101 @@
+//go:build unix && !darwin && !freebsd && !netbsd && !openbsd && !dragonfly
+
+package device
+
+import (
+	"net/url"
+	"os"
+	"os/exec"
+	"regexp"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func queryToInput(query url.Values) string {
+	if video := query.Get("video"); video != "" {
+		// https://ffmpeg.org/ffmpeg-devices.html#video4linux2_002c-v4l2
+		input := "-f v4l2"
+
+		for key, value := range query {
+			switch key {
+			case "resolution":
+				input += " -video_size " + value[0]
+			case "video_size", "pixel_format", "input_format", "framerate", "use_libv4l2":
+				input += " -" + key + " " + value[0]
+			}
+		}
+
+		return input + " -i " + indexToItem(videos, video)
+	}
+
+	if audio := query.Get("audio"); audio != "" {
+		// https://trac.ffmpeg.org/wiki/Capture/ALSA
+		input := "-f alsa"
+
+		for key, value := range query {
+			switch key {
+			case "channels", "sample_rate":
+				input += " -" + key + " " + value[0]
+			}
+		}
+
+		return input + " -i " + indexToItem(audios, audio)
+	}
+
+	return ""
+}
+
+func initDevices() {
+	files, err := os.ReadDir("/dev")
+	if err != nil {
+		return
+	}
+
+	for _, file := range files {
+		if !strings.HasPrefix(file.Name(), core.KindVideo) {
+			continue
+		}
+
+		name := "/dev/" + file.Name()
+
+		cmd := exec.Command(
+			Bin, "-hide_banner", "-f", "v4l2", "-list_formats", "all", "-i", name,
+		)
+		b, _ := cmd.CombinedOutput()
+
+		// [video4linux2,v4l2 @ 0x204e1c0] Compressed:       mjpeg :          Motion-JPEG : 640x360 1280x720 1920x1080
+		// [video4linux2,v4l2 @ 0x204e1c0] Raw       :     yuyv422 :           YUYV 4:2:2 : 640x360 1280x720 1920x1080
+		// [video4linux2,v4l2 @ 0x204e1c0] Compressed:        h264 :                H.264 : 640x360 1280x720 1920x1080
+		re := regexp.MustCompile("(Raw *|Compressed): +(.+?) : +(.+?) : (.+)")
+		m := re.FindAllStringSubmatch(string(b), -1)
+		for _, i := range m {
+			size, _, _ := strings.Cut(i[4], " ")
+			stream := &api.Source{
+				Name: i[3],
+				Info: i[4],
+				URL:  "ffmpeg:device?video=" + name + "&input_format=" + i[2] + "&video_size=" + size,
+			}
+
+			if i[1] != "Compressed" {
+				stream.URL += "#video=h264#hardware"
+			}
+
+			videos = append(videos, name)
+			streams = append(streams, stream)
+		}
+	}
+
+	err = exec.Command(Bin, "-f", "alsa", "-i", "default", "-t", "1", "-f", "null", "-").Run()
+	if err == nil {
+		stream := &api.Source{
+			Name: "ALSA default",
+			Info: " ",
+			URL:  "ffmpeg:device?audio=default&channels=1&sample_rate=16000&#audio=opus",
+		}
+
+		audios = append(audios, "default")
+		streams = append(streams, stream)
+	}
+}
diff --git a/installs_on_host/go2rtc/internal/ffmpeg/device/device_windows.go b/installs_on_host/go2rtc/internal/ffmpeg/device/device_windows.go
new file mode 100644
index 0000000..ff32831
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ffmpeg/device/device_windows.go
@@ -0,0 +1,90 @@
+//go:build windows
+
+package device
+
+import (
+	"net/url"
+	"os/exec"
+	"regexp"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func queryToInput(query url.Values) string {
+	video := query.Get("video")
+	audio := query.Get("audio")
+
+	if video == "" && audio == "" {
+		return ""
+	}
+
+	// https://ffmpeg.org/ffmpeg-devices.html#dshow
+	input := "-f dshow"
+
+	if video != "" {
+		video = indexToItem(videos, video)
+
+		for key, value := range query {
+			switch key {
+			case "resolution":
+				input += " -video_size " + value[0]
+			case "video_size", "framerate", "pixel_format":
+				input += " -" + key + " " + value[0]
+			}
+		}
+	}
+
+	if audio != "" {
+		audio = indexToItem(audios, audio)
+
+		for key, value := range query {
+			switch key {
+			case "sample_rate", "sample_size", "channels", "audio_buffer_size":
+				input += " -" + key + " " + value[0]
+			}
+		}
+	}
+
+	if video != "" {
+		input += ` -i "video=` + video
+
+		if audio != "" {
+			input += `:audio=` + audio
+		}
+
+		input += `"`
+	} else {
+		input += ` -i "audio=` + audio + `"`
+	}
+
+	return input
+}
+
+func initDevices() {
+	cmd := exec.Command(
+		Bin, "-hide_banner", "-list_devices", "true", "-f", "dshow", "-i", "",
+	)
+	b, _ := cmd.CombinedOutput()
+
+	re := regexp.MustCompile(`"([^"]+)" \((video|audio)\)`)
+	for _, m := range re.FindAllStringSubmatch(string(b), -1) {
+		name := m[1]
+		kind := m[2]
+
+		stream := &api.Source{
+			Name: name, URL: "ffmpeg:device?" + kind + "=" + name,
+		}
+
+		switch kind {
+		case core.KindVideo:
+			videos = append(videos, name)
+			stream.URL += "#video=h264#hardware"
+		case core.KindAudio:
+			audios = append(audios, name)
+			stream.URL += "&channels=1&sample_rate=16000&audio_buffer_size=10"
+		}
+
+		streams = append(streams, stream)
+	}
+}
diff --git a/installs_on_host/go2rtc/internal/ffmpeg/device/devices.go b/installs_on_host/go2rtc/internal/ffmpeg/device/devices.go
new file mode 100644
index 0000000..69b1344
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ffmpeg/device/devices.go
@@ -0,0 +1,46 @@
+package device
+
+import (
+	"net/http"
+	"net/url"
+	"strconv"
+	"sync"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+)
+
+func Init(bin string) {
+	Bin = bin
+
+	api.HandleFunc("api/ffmpeg/devices", apiDevices)
+}
+
+func GetInput(src string) string {
+	query, err := url.ParseQuery(src)
+	if err != nil {
+		return ""
+	}
+
+	runonce.Do(initDevices)
+
+	return queryToInput(query)
+}
+
+var Bin string
+
+var videos, audios []string
+var streams []*api.Source
+var runonce sync.Once
+
+func apiDevices(w http.ResponseWriter, r *http.Request) {
+	runonce.Do(initDevices)
+
+	api.ResponseSources(w, streams)
+}
+
+func indexToItem(items []string, index string) string {
+	if i, err := strconv.Atoi(index); err == nil && i < len(items) {
+		return items[i]
+	}
+	return index
+}
diff --git a/installs_on_host/go2rtc/internal/ffmpeg/ffmpeg.go b/installs_on_host/go2rtc/internal/ffmpeg/ffmpeg.go
new file mode 100644
index 0000000..a3d589b
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ffmpeg/ffmpeg.go
@@ -0,0 +1,388 @@
+package ffmpeg
+
+import (
+	"net/url"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/ffmpeg/device"
+	"github.com/AlexxIT/go2rtc/internal/ffmpeg/hardware"
+	"github.com/AlexxIT/go2rtc/internal/ffmpeg/virtual"
+	"github.com/AlexxIT/go2rtc/internal/rtsp"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/ffmpeg"
+	"github.com/rs/zerolog"
+)
+
+func Init() {
+	var cfg struct {
+		Mod map[string]string `yaml:"ffmpeg"`
+		Log struct {
+			Level string `yaml:"ffmpeg"`
+		} `yaml:"log"`
+	}
+
+	cfg.Mod = defaults // will be overriden from yaml
+	cfg.Log.Level = "error"
+
+	app.LoadConfig(&cfg)
+
+	log = app.GetLogger("ffmpeg")
+
+	// zerolog levels: trace debug         info warn    error fatal panic disabled
+	// FFmpeg  levels: trace debug verbose info warning error fatal panic quiet
+	if cfg.Log.Level == "warn" {
+		cfg.Log.Level = "warning"
+	}
+	defaults["global"] += " -v " + cfg.Log.Level
+
+	streams.RedirectFunc("ffmpeg", func(url string) (string, error) {
+		if _, err := Version(); err != nil {
+			return "", err
+		}
+		args := parseArgs(url[7:])
+		if core.Contains(args.Codecs, "auto") {
+			return "", nil // force call streams.HandleFunc("ffmpeg")
+		}
+		return "exec:" + args.String(), nil
+	})
+
+	streams.HandleFunc("ffmpeg", NewProducer)
+
+	api.HandleFunc("api/ffmpeg", apiFFmpeg)
+
+	device.Init(defaults["bin"])
+	hardware.Init(defaults["bin"])
+}
+
+var defaults = map[string]string{
+	"bin":     "ffmpeg",
+	"global":  "-hide_banner",
+	"timeout": "5",
+
+	// inputs
+	"file":     "-re -i {input}",
+	"http":     "-fflags nobuffer -flags low_delay -i {input}",
+	"rtsp":     "-fflags nobuffer -flags low_delay -timeout {timeout} -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i {input}",
+	"rtsp/udp": "-fflags nobuffer -flags low_delay -timeout {timeout} -user_agent go2rtc/ffmpeg -i {input}",
+
+	// output
+	"output":       "-user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}",
+	"output/mjpeg": "-f mjpeg -",
+	"output/raw":   "-f yuv4mpegpipe -",
+	"output/aac":   "-f adts -",
+	"output/wav":   "-f wav -",
+
+	// `-preset superfast` - we can't use ultrafast because it doesn't support `-profile main -level 4.1`
+	// `-tune zerolatency` - for minimal latency
+	// `-profile high -level 4.1` - most used streaming profile
+	// `-pix_fmt:v yuv420p` - important for Telegram
+	"h264":  "-c:v libx264 -g 50 -profile:v high -level:v 4.1 -preset:v superfast -tune:v zerolatency -pix_fmt:v yuv420p",
+	"h265":  "-c:v libx265 -g 50 -profile:v main -x265-params level=5.1:high-tier=0 -preset:v superfast -tune:v zerolatency -pix_fmt:v yuv420p",
+	"mjpeg": "-c:v mjpeg",
+	//"mjpeg": "-c:v mjpeg -force_duplicated_matrix:v 1 -huffman:v 0 -pix_fmt:v yuvj420p",
+
+	"raw":         "-c:v rawvideo",
+	"raw/gray8":   "-c:v rawvideo -pix_fmt:v gray8",
+	"raw/yuv420p": "-c:v rawvideo -pix_fmt:v yuv420p",
+	"raw/yuv422p": "-c:v rawvideo -pix_fmt:v yuv422p",
+	"raw/yuv444p": "-c:v rawvideo -pix_fmt:v yuv444p",
+
+	// https://ffmpeg.org/ffmpeg-codecs.html#libopus-1
+	// https://github.com/pion/webrtc/issues/1514
+	// https://ffmpeg.org/ffmpeg-resampler.html
+	// `-async 1` or `-min_comp 0` - force resampling for static timestamp inc, important for WebRTC audio quality
+	"opus":       "-c:a libopus -application:a lowdelay -min_comp 0",
+	"opus/16000": "-c:a libopus -application:a lowdelay -min_comp 0 -ar:a 16000 -ac:a 1",
+	"pcmu":       "-c:a pcm_mulaw -ar:a 8000 -ac:a 1",
+	"pcmu/8000":  "-c:a pcm_mulaw -ar:a 8000 -ac:a 1",
+	"pcmu/16000": "-c:a pcm_mulaw -ar:a 16000 -ac:a 1",
+	"pcmu/48000": "-c:a pcm_mulaw -ar:a 48000 -ac:a 1",
+	"pcma":       "-c:a pcm_alaw -ar:a 8000 -ac:a 1",
+	"pcma/8000":  "-c:a pcm_alaw -ar:a 8000 -ac:a 1",
+	"pcma/16000": "-c:a pcm_alaw -ar:a 16000 -ac:a 1",
+	"pcma/48000": "-c:a pcm_alaw -ar:a 48000 -ac:a 1",
+	"aac":        "-c:a aac", // keep sample rate and channels
+	"aac/16000":  "-c:a aac -ar:a 16000 -ac:a 1",
+	"mp3":        "-c:a libmp3lame -q:a 8",
+	"pcm":        "-c:a pcm_s16be -ar:a 8000 -ac:a 1",
+	"pcm/8000":   "-c:a pcm_s16be -ar:a 8000 -ac:a 1",
+	"pcm/16000":  "-c:a pcm_s16be -ar:a 16000 -ac:a 1",
+	"pcm/48000":  "-c:a pcm_s16be -ar:a 48000 -ac:a 1",
+	"pcml":       "-c:a pcm_s16le -ar:a 8000 -ac:a 1",
+	"pcml/8000":  "-c:a pcm_s16le -ar:a 8000 -ac:a 1",
+	"pcml/16000": "-c:a pcm_s16le -ar:a 16000 -ac:a 1",
+	"pcml/44100": "-c:a pcm_s16le -ar:a 44100 -ac:a 1",
+
+	// hardware Intel and AMD on Linux
+	// better not to set `-async_depth:v 1` like for QSV, because framedrops
+	// `-bf 0` - disable B-frames is very important
+	"h264/vaapi":  "-c:v h264_vaapi -g 50 -bf 0 -profile:v high -level:v 4.1 -sei:v 0",
+	"h265/vaapi":  "-c:v hevc_vaapi -g 50 -bf 0 -profile:v main -level:v 5.1 -sei:v 0",
+	"mjpeg/vaapi": "-c:v mjpeg_vaapi",
+
+	// hardware Raspberry
+	"h264/v4l2m2m": "-c:v h264_v4l2m2m -g 50 -bf 0",
+	"h265/v4l2m2m": "-c:v hevc_v4l2m2m -g 50 -bf 0",
+
+	// hardware Rockchip
+	// important to use custom ffmpeg https://github.com/AlexxIT/go2rtc/issues/768
+	// hevc - doesn't have a profile setting
+	"h264/rkmpp":  "-c:v h264_rkmpp -g 50 -bf 0 -profile:v high -level:v 4.1",
+	"h265/rkmpp":  "-c:v hevc_rkmpp -g 50 -bf 0 -profile:v main -level:v 5.1",
+	"mjpeg/rkmpp": "-c:v mjpeg_rkmpp",
+
+	// hardware NVidia on Linux and Windows
+	// preset=p2 - faster, tune=ll - low latency
+	"h264/cuda": "-c:v h264_nvenc -g 50 -bf 0 -profile:v high -level:v auto -preset:v p2 -tune:v ll",
+	"h265/cuda": "-c:v hevc_nvenc -g 50 -bf 0 -profile:v main -level:v auto",
+
+	// hardware Intel on Windows
+	"h264/dxva2":  "-c:v h264_qsv -g 50 -bf 0 -profile:v high -level:v 4.1 -async_depth:v 1",
+	"h265/dxva2":  "-c:v hevc_qsv -g 50 -bf 0 -profile:v main -level:v 5.1 -async_depth:v 1",
+	"mjpeg/dxva2": "-c:v mjpeg_qsv",
+
+	// hardware macOS
+	"h264/videotoolbox": "-c:v h264_videotoolbox -g 50 -bf 0 -profile:v high -level:v 4.1",
+	"h265/videotoolbox": "-c:v hevc_videotoolbox -g 50 -bf 0 -profile:v main -level:v 5.1",
+}
+
+var log zerolog.Logger
+
+// configTemplate - return template from config (defaults) if exist or return raw template
+func configTemplate(template string) string {
+	if s := defaults[template]; s != "" {
+		return s
+	}
+	return template
+}
+
+// inputTemplate - select input template from YAML config by template name
+// if query has input param - select another template by this name
+// if there is no another template - use input param as template
+func inputTemplate(name, s string, query url.Values) string {
+	var template string
+	if input := query.Get("input"); input != "" {
+		template = configTemplate(input)
+	} else {
+		template = defaults[name]
+	}
+	if strings.Contains(template, "{timeout}") {
+		timeout := query.Get("timeout")
+		if timeout == "" {
+			timeout = defaults["timeout"]
+		}
+		template = strings.Replace(template, "{timeout}", timeout+"000000", 1)
+	}
+	return strings.Replace(template, "{input}", s, 1)
+}
+
+func parseArgs(s string) *ffmpeg.Args {
+	// init FFmpeg arguments
+	args := &ffmpeg.Args{
+		Bin:     defaults["bin"],
+		Global:  defaults["global"],
+		Output:  defaults["output"],
+		Version: verAV,
+	}
+
+	var source = s
+	var query url.Values
+	if i := strings.IndexByte(s, '#'); i >= 0 {
+		query = streams.ParseQuery(s[i+1:])
+		args.Video = len(query["video"])
+		args.Audio = len(query["audio"])
+		s = s[:i]
+	}
+
+	// Parse input:
+	//   1. Input as xxxx:// link (http or rtsp or any other)
+	//   2. Input as stream name
+	//   3. Input as FFmpeg device (local USB camera)
+	if i := strings.Index(s, "://"); i > 0 {
+		switch s[:i] {
+		case "http", "https", "rtmp":
+			args.Input = inputTemplate("http", s, query)
+		case "rtsp", "rtsps":
+			// https://ffmpeg.org/ffmpeg-protocols.html#rtsp
+			// skip unnecessary input tracks
+			switch {
+			case (args.Video > 0 && args.Audio > 0) || (args.Video == 0 && args.Audio == 0):
+				args.Input = "-allowed_media_types video+audio "
+			case args.Video > 0:
+				args.Input = "-allowed_media_types video "
+			case args.Audio > 0:
+				args.Input = "-allowed_media_types audio "
+			}
+
+			args.Input += inputTemplate("rtsp", s, query)
+		default:
+			args.Input = "-i " + s
+		}
+	} else if streams.Get(s) != nil {
+		s = "rtsp://127.0.0.1:" + rtsp.Port + "/" + s
+		switch {
+		case args.Video > 0 && args.Audio == 0:
+			s += "?video"
+		case args.Audio > 0 && args.Video == 0:
+			s += "?audio"
+		default:
+			s += "?video&audio"
+		}
+		s += "&source=ffmpeg:" + url.QueryEscape(source)
+		for _, v := range query["query"] {
+			s += "&" + v
+		}
+		args.Input = inputTemplate("rtsp", s, query)
+	} else if i = strings.Index(s, "?"); i > 0 {
+		switch s[:i] {
+		case "device":
+			args.Input = device.GetInput(s[i+1:])
+		case "virtual":
+			args.Input = virtual.GetInput(s[i+1:])
+		case "tts":
+			args.Input = virtual.GetInputTTS(s[i+1:])
+		}
+	} else {
+		args.Input = inputTemplate("file", s, query)
+	}
+
+	if query["async"] != nil {
+		args.Input = "-use_wallclock_as_timestamps 1 -async 1 " + args.Input
+	}
+
+	// Parse query params:
+	//   1. `width`/`height` params
+	//   2. `rotate` param
+	//   3. `video` params (support multiple)
+	//   4. `audio` params (support multiple)
+	//   5. `hardware` param
+	if query != nil {
+		// 1. Process raw params for FFmpeg
+		for _, raw := range query["raw"] {
+			// support templates https://github.com/AlexxIT/go2rtc/issues/487
+			raw = configTemplate(raw)
+			args.AddCodec(raw)
+		}
+
+		// 2. Process video filters (resize and rotation)
+		if query["width"] != nil || query["height"] != nil {
+			filter := "scale="
+			if query["width"] != nil {
+				filter += query["width"][0]
+			} else {
+				filter += "-1"
+			}
+			filter += ":"
+			if query["height"] != nil {
+				filter += query["height"][0]
+			} else {
+				filter += "-1"
+			}
+			args.AddFilter(filter)
+		}
+
+		if query["rotate"] != nil {
+			var filter string
+			switch query["rotate"][0] {
+			case "90":
+				filter = "transpose=1" // 90 degrees clockwise
+			case "180":
+				filter = "transpose=1,transpose=1"
+			case "-90", "270":
+				filter = "transpose=2" // 90 degrees counterclockwise
+			}
+			if filter != "" {
+				args.AddFilter(filter)
+			}
+		}
+
+		for _, drawtext := range query["drawtext"] {
+			// support templates https://github.com/AlexxIT/go2rtc/issues/487
+			drawtext = configTemplate(drawtext)
+
+			// support default timestamp format
+			if !strings.Contains(drawtext, "text=") {
+				drawtext += `:text='%{localtime\:%Y-%m-%d %X}'`
+			}
+
+			args.AddFilter("drawtext=" + drawtext)
+		}
+
+		// 3. Process video codecs
+		if args.Video > 0 {
+			for _, video := range query["video"] {
+				if video != "copy" {
+					if codec := defaults[video]; codec != "" {
+						args.AddCodec(codec)
+					} else {
+						args.AddCodec(video)
+					}
+				} else {
+					args.AddCodec("-c:v copy")
+				}
+			}
+		}
+
+		if query["bitrate"] != nil {
+			// https://trac.ffmpeg.org/wiki/Limiting%20the%20output%20bitrate
+			b := query["bitrate"][0]
+			args.AddCodec("-b:v " + b + " -maxrate " + b + " -bufsize " + b)
+		}
+
+		// 4. Process audio codecs
+		if args.Audio > 0 {
+			for _, audio := range query["audio"] {
+				if audio != "copy" {
+					if codec := defaults[audio]; codec != "" {
+						args.AddCodec(codec)
+					} else {
+						args.AddCodec(audio)
+					}
+				} else {
+					args.AddCodec("-c:a copy")
+				}
+			}
+		}
+
+		if query["hardware"] != nil {
+			hardware.MakeHardware(args, query["hardware"][0], defaults)
+		}
+	}
+
+	switch {
+	case args.Video == 0 && args.Audio == 0:
+		args.AddCodec("-c copy")
+	case args.Video == 0:
+		args.AddCodec("-vn")
+	case args.Audio == 0:
+		args.AddCodec("-an")
+	}
+
+	// change otput from RTSP to some other pipe format
+	switch {
+	case args.Video == 0 && args.Audio == 0:
+		// no transcoding from mjpeg input (ffmpeg device with support output as raw MJPEG)
+		if strings.Contains(args.Input, " mjpeg ") {
+			args.Output = defaults["output/mjpeg"]
+		}
+	case args.Video == 1 && args.Audio == 0:
+		switch core.Before(query.Get("video"), "/") {
+		case "mjpeg":
+			args.Output = defaults["output/mjpeg"]
+		case "raw":
+			args.Output = defaults["output/raw"]
+		}
+	case args.Video == 0 && args.Audio == 1:
+		switch core.Before(query.Get("audio"), "/") {
+		case "aac":
+			args.Output = defaults["output/aac"]
+		case "pcma", "pcmu", "pcml":
+			args.Output = defaults["output/wav"]
+		}
+	}
+
+	return args
+}
diff --git a/installs_on_host/go2rtc/internal/ffmpeg/ffmpeg_test.go b/installs_on_host/go2rtc/internal/ffmpeg/ffmpeg_test.go
new file mode 100644
index 0000000..b9d0218
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ffmpeg/ffmpeg_test.go
@@ -0,0 +1,396 @@
+package ffmpeg
+
+import (
+	"testing"
+
+	"github.com/AlexxIT/go2rtc/pkg/ffmpeg"
+	"github.com/stretchr/testify/require"
+)
+
+func TestParseArgsFile(t *testing.T) {
+	tests := []struct {
+		name   string
+		source string
+		expect string
+	}{
+		{
+			name:   "[FILE] all tracks will be copied without transcoding codecs",
+			source: "/media/bbb.mp4",
+			expect: `ffmpeg -hide_banner -re -i /media/bbb.mp4 -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[FILE] video will be transcoded to H264, audio will be skipped",
+			source: "/media/bbb.mp4#video=h264",
+			expect: `ffmpeg -hide_banner -re -i /media/bbb.mp4 -c:v libx264 -g 50 -profile:v high -level:v 4.1 -preset:v superfast -tune:v zerolatency -pix_fmt:v yuv420p -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[FILE] video will be copied, audio will be transcoded to pcmu",
+			source: "/media/bbb.mp4#video=copy#audio=pcmu",
+			expect: `ffmpeg -hide_banner -re -i /media/bbb.mp4 -c:v copy -c:a pcm_mulaw -ar:a 8000 -ac:a 1 -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[FILE] video will be transcoded to H265 and rotate 270º, audio will be skipped",
+			source: "/media/bbb.mp4#video=h265#rotate=-90",
+			expect: `ffmpeg -hide_banner -re -i /media/bbb.mp4 -c:v libx265 -g 50 -profile:v main -level:v 5.1 -preset:v superfast -tune:v zerolatency -pix_fmt:v yuv420p -an -vf "transpose=2" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[FILE] video will be output for MJPEG to pipe, audio will be skipped",
+			source: "/media/bbb.mp4#video=mjpeg",
+			expect: `ffmpeg -hide_banner -re -i /media/bbb.mp4 -c:v mjpeg -an -f mjpeg -`,
+		},
+		{
+			name:   "https://github.com/AlexxIT/go2rtc/issues/509",
+			source: "ffmpeg:test.mp4#raw=-ss 00:00:20",
+			expect: `ffmpeg -hide_banner -re -i ffmpeg:test.mp4 -ss 00:00:20 -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			args := parseArgs(test.source)
+			require.Equal(t, test.expect, args.String())
+		})
+	}
+}
+
+func TestParseArgsDevice(t *testing.T) {
+	tests := []struct {
+		name   string
+		source string
+		expect string
+	}{
+		{
+			name:   "[DEVICE] video will be output for MJPEG to pipe, with size 1920x1080",
+			source: "device?video=0&video_size=1920x1080",
+			expect: `ffmpeg -hide_banner -f dshow -video_size 1920x1080 -i "video=0" -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[DEVICE] video will be transcoded to H265 with framerate 20, audio will be skipped",
+			source: "device?video=0&framerate=20#video=h265",
+			expect: `ffmpeg -hide_banner -f dshow -framerate 20 -i "video=0" -c:v libx265 -g 50 -profile:v main -level:v 5.1 -preset:v superfast -tune:v zerolatency -pix_fmt:v yuv420p -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[DEVICE] video/audio",
+			source: "device?video=FaceTime HD Camera&audio=Microphone (High Definition Audio Device)",
+			expect: `ffmpeg -hide_banner -f dshow -i "video=FaceTime HD Camera:audio=Microphone (High Definition Audio Device)" -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			args := parseArgs(test.source)
+			require.Equal(t, test.expect, args.String())
+		})
+	}
+}
+
+func TestParseArgsIpCam(t *testing.T) {
+	tests := []struct {
+		name   string
+		source string
+		expect string
+	}{
+		{
+			name:   "[HTTP] video will be copied",
+			source: "http://example.com",
+			expect: `ffmpeg -hide_banner -fflags nobuffer -flags low_delay -i http://example.com -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[HTTP-MJPEG] video will be transcoded to H264",
+			source: "http://example.com#video=h264",
+			expect: `ffmpeg -hide_banner -fflags nobuffer -flags low_delay -i http://example.com -c:v libx264 -g 50 -profile:v high -level:v 4.1 -preset:v superfast -tune:v zerolatency -pix_fmt:v yuv420p -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[HLS] video will be copied, audio will be skipped",
+			source: "https://example.com#video=copy",
+			expect: `ffmpeg -hide_banner -fflags nobuffer -flags low_delay -i https://example.com -c:v copy -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[RTSP] video will be copied without transcoding codecs",
+			source: "rtsp://example.com",
+			expect: `ffmpeg -hide_banner -allowed_media_types video+audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[RTSP] video with resize to 1280x720, should be transcoded, so select H265",
+			source: "rtsp://example.com#video=h265#width=1280#height=720",
+			expect: `ffmpeg -hide_banner -allowed_media_types video -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:v libx265 -g 50 -profile:v main -level:v 5.1 -preset:v superfast -tune:v zerolatency -pix_fmt:v yuv420p -an -vf "scale=1280:720" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[RTSP] video will be copied, changing RTSP transport from TCP to UDP+TCP",
+			source: "rtsp://example.com#input=rtsp/udp",
+			expect: `ffmpeg -hide_banner -allowed_media_types video+audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -i rtsp://example.com -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[RTMP] video will be copied, changing RTSP transport from TCP to UDP+TCP",
+			source: "rtmp://example.com#input=rtsp/udp",
+			expect: `ffmpeg -hide_banner -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -i rtmp://example.com -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[RTSP] custom timeout",
+			source: "rtsp://example.com#timeout=10",
+			expect: `ffmpeg -hide_banner -allowed_media_types video+audio -fflags nobuffer -flags low_delay -timeout 10000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			args := parseArgs(test.source)
+			require.Equal(t, test.expect, args.String())
+		})
+	}
+}
+
+func TestParseArgsAudio(t *testing.T) {
+	tests := []struct {
+		name   string
+		source string
+		expect string
+	}{
+		{
+			name:   "[AUDIO] audio will be transcoded to AAC, video will be skipped",
+			source: "rtsp://example.com#audio=aac",
+			expect: `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:a aac -vn -f adts -`,
+		},
+		{
+			name:   "[AUDIO] audio will be transcoded to AAC/16000, video will be skipped",
+			source: "rtsp://example.com#audio=aac/16000",
+			expect: `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:a aac -ar:a 16000 -ac:a 1 -vn -f adts -`,
+		},
+		{
+			name:   "[AUDIO] audio will be transcoded to OPUS, video will be skipped",
+			source: "rtsp://example.com#audio=opus",
+			expect: `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:a libopus -application:a lowdelay -min_comp 0 -vn -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[AUDIO] audio will be transcoded to PCMU, video will be skipped",
+			source: "rtsp://example.com#audio=pcmu",
+			expect: `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:a pcm_mulaw -ar:a 8000 -ac:a 1 -vn -f wav -`,
+		},
+		{
+			name:   "[AUDIO] audio will be transcoded to PCMU/16000, video will be skipped",
+			source: "rtsp://example.com#audio=pcmu/16000",
+			expect: `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:a pcm_mulaw -ar:a 16000 -ac:a 1 -vn -f wav -`,
+		},
+		{
+			name:   "[AUDIO] audio will be transcoded to PCMU/48000, video will be skipped",
+			source: "rtsp://example.com#audio=pcmu/48000",
+			expect: `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:a pcm_mulaw -ar:a 48000 -ac:a 1 -vn -f wav -`,
+		},
+		{
+			name:   "[AUDIO] audio will be transcoded to PCMA, video will be skipped",
+			source: "rtsp://example.com#audio=pcma",
+			expect: `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:a pcm_alaw -ar:a 8000 -ac:a 1 -vn -f wav -`,
+		},
+		{
+			name:   "[AUDIO] audio will be transcoded to PCMA/16000, video will be skipped",
+			source: "rtsp://example.com#audio=pcma/16000",
+			expect: `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:a pcm_alaw -ar:a 16000 -ac:a 1 -vn -f wav -`,
+		},
+		{
+			name:   "[AUDIO] audio will be transcoded to PCMA/48000, video will be skipped",
+			source: "rtsp://example.com#audio=pcma/48000",
+			expect: `ffmpeg -hide_banner -allowed_media_types audio -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:a pcm_alaw -ar:a 48000 -ac:a 1 -vn -f wav -`,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			args := parseArgs(test.source)
+			require.Equal(t, test.expect, args.String())
+		})
+	}
+}
+
+func TestParseArgsHwVaapi(t *testing.T) {
+	tests := []struct {
+		name   string
+		source string
+		expect string
+	}{
+		{
+			name:   "[HTTP-MJPEG] video will be transcoded to H264",
+			source: "http:///example.com#video=h264#hardware=vaapi",
+			expect: `ffmpeg -hide_banner -hwaccel vaapi -hwaccel_output_format vaapi -hwaccel_flags allow_profile_mismatch -fflags nobuffer -flags low_delay -i http:///example.com -c:v h264_vaapi -g 50 -bf 0 -profile:v high -level:v 4.1 -sei:v 0 -an -vf "format=vaapi|nv12,hwupload,scale_vaapi=out_color_matrix=bt709:out_range=tv:format=nv12" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[RTSP] video with rotation, should be transcoded, so select H264",
+			source: "rtsp://example.com#video=h264#rotate=180#hardware=vaapi",
+			expect: `ffmpeg -hide_banner -hwaccel vaapi -hwaccel_output_format vaapi -hwaccel_flags allow_profile_mismatch -allowed_media_types video -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:v h264_vaapi -g 50 -bf 0 -profile:v high -level:v 4.1 -sei:v 0 -an -vf "format=vaapi|nv12,hwupload,transpose_vaapi=4,scale_vaapi=out_color_matrix=bt709:out_range=tv:format=nv12" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[RTSP] video with resize to 1280x720, should be transcoded, so select H265",
+			source: "rtsp://example.com#video=h265#width=1280#height=720#hardware=vaapi",
+			expect: `ffmpeg -hide_banner -hwaccel vaapi -hwaccel_output_format vaapi -hwaccel_flags allow_profile_mismatch -allowed_media_types video -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:v hevc_vaapi -g 50 -bf 0 -profile:v main -level:v 5.1 -sei:v 0 -an -vf "format=vaapi|nv12,hwupload,scale_vaapi=1280:720" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[FILE] video will be output for MJPEG to pipe, audio will be skipped",
+			source: "/media/bbb.mp4#video=mjpeg#hardware=vaapi",
+			expect: `ffmpeg -hide_banner -hwaccel vaapi -hwaccel_output_format vaapi -hwaccel_flags allow_profile_mismatch -re -i /media/bbb.mp4 -c:v mjpeg_vaapi -an -vf "format=vaapi|nv12,hwupload" -f mjpeg -`,
+		},
+		{
+			name:   "[DEVICE] MJPEG video with size 1920x1080 will be transcoded to H265",
+			source: "device?video=0&video_size=1920x1080#video=h265#hardware=vaapi",
+			expect: `ffmpeg -hide_banner -hwaccel vaapi -hwaccel_output_format vaapi -hwaccel_flags allow_profile_mismatch -f dshow -video_size 1920x1080 -i "video=0" -c:v hevc_vaapi -g 50 -bf 0 -profile:v main -level:v 5.1 -sei:v 0 -an -vf "format=vaapi|nv12,hwupload" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			args := parseArgs(test.source)
+			require.Equal(t, test.expect, args.String())
+		})
+	}
+}
+
+func _TestParseArgsHwV4l2m2m(t *testing.T) {
+	// [HTTP-MJPEG] video will be transcoded to H264
+	args := parseArgs("http:///example.com#video=h264#hardware=v4l2m2m")
+	require.Equal(t, `ffmpeg -hide_banner -fflags nobuffer -flags low_delay -i http:///example.com -c:v h264_v4l2m2m -g 50 -bf 0 -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
+
+	// [RTSP] video with rotation, should be transcoded, so select H264
+	args = parseArgs("rtsp://example.com#video=h264#rotate=180#hardware=v4l2m2m")
+	require.Equal(t, `ffmpeg -hide_banner -allowed_media_types video -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:v h264_v4l2m2m -g 50 -bf 0 -an -vf "transpose=1,transpose=1" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
+
+	// [RTSP] video with resize to 1280x720, should be transcoded, so select H265
+	args = parseArgs("rtsp://example.com#video=h265#width=1280#height=720#hardware=v4l2m2m")
+	require.Equal(t, `ffmpeg -hide_banner -allowed_media_types video -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:v hevc_v4l2m2m -g 50 -bf 0 -an -vf "scale=1280:720" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
+
+	// [DEVICE] MJPEG video with size 1920x1080 will be transcoded to H265
+	args = parseArgs("device?video=0&video_size=1920x1080#video=h265#hardware=v4l2m2m")
+	require.Equal(t, `ffmpeg -hide_banner -f dshow -video_size 1920x1080 -i video="0" -c:v hevc_v4l2m2m -g 50 -bf 0 -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
+}
+
+func TestParseArgsHwRKMPP(t *testing.T) {
+	tests := []struct {
+		name   string
+		source string
+		expect string
+	}{
+		{
+			name:   "[FILE] transcoding to H264",
+			source: "bbb.mp4#video=h264#hardware=rkmpp",
+			expect: `ffmpeg -hide_banner -hwaccel rkmpp -hwaccel_output_format drm_prime -afbc rga -re -i bbb.mp4 -c:v h264_rkmpp -g 50 -bf 0 -profile:v high -level:v 4.1 -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[FILE] transcoding with rotation",
+			source: "bbb.mp4#video=h264#rotate=180#hardware=rkmpp",
+			expect: `ffmpeg -hide_banner -hwaccel rkmpp -hwaccel_output_format drm_prime -afbc rga -re -i bbb.mp4 -c:v h264_rkmpp -g 50 -bf 0 -profile:v high -level:v 4.1 -an -vf "format=drm_prime|nv12,hwupload,vpp_rkrga=transpose=4" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			name:   "[FILE] transcoding with scaling",
+			source: "bbb.mp4#video=h264#height=320#hardware=rkmpp",
+			expect: `ffmpeg -hide_banner -hwaccel rkmpp -hwaccel_output_format drm_prime -afbc rga -re -i bbb.mp4 -c:v h264_rkmpp -g 50 -bf 0 -profile:v high -level:v 4.1 -an -vf "format=drm_prime|nv12,hwupload,scale_rkrga=-1:320:force_original_aspect_ratio=0" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			args := parseArgs(test.source)
+			require.Equal(t, test.expect, args.String())
+		})
+	}
+}
+
+func _TestParseArgsHwCuda(t *testing.T) {
+	// [HTTP-MJPEG] video will be transcoded to H264
+	args := parseArgs("http:///example.com#video=h264#hardware=cuda")
+	require.Equal(t, `ffmpeg -hide_banner -hwaccel cuda -hwaccel_output_format cuda -fflags nobuffer -flags low_delay -i http:///example.com -c:v h264_nvenc -g 50 -bf 0 -profile:v high -level:v auto -preset:v p2 -tune:v ll -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
+
+	// [RTSP] video with rotation, should be transcoded, so select H264
+	args = parseArgs("rtsp://example.com#video=h264#rotate=180#hardware=cuda")
+	require.Equal(t, `ffmpeg -hide_banner -hwaccel cuda -hwaccel_output_format nv12 -allowed_media_types video -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:v h264_nvenc -g 50 -bf 0 -profile:v high -level:v auto -preset:v p2 -tune:v ll -an -vf "transpose=1,transpose=1,hwupload" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
+
+	// [RTSP] video with resize to 1280x720, should be transcoded, so select H265
+	args = parseArgs("rtsp://example.com#video=h265#width=1280#height=720#hardware=cuda")
+	require.Equal(t, `ffmpeg -hide_banner -hwaccel cuda -hwaccel_output_format cuda -allowed_media_types video -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:v hevc_nvenc -g 50 -bf 0 -profile:v high -level:v auto -an -vf "scale_cuda=1280:720" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
+
+	// [DEVICE] MJPEG video with size 1920x1080 will be transcoded to H265
+	args = parseArgs("device?video=0&video_size=1920x1080#video=h265#hardware=cuda")
+	require.Equal(t, `ffmpeg -hide_banner -hwaccel cuda -hwaccel_output_format cuda -f dshow -video_size 1920x1080 -i video="0" -c:v hevc_nvenc -g 50 -bf 0 -profile:v high -level:v auto -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
+}
+
+func _TestParseArgsHwDxva2(t *testing.T) {
+	// [HTTP-MJPEG] video will be transcoded to H264
+	args := parseArgs("http:///example.com#video=h264#hardware=dxva2")
+	require.Equal(t, `ffmpeg -hide_banner -hwaccel dxva2 -hwaccel_output_format dxva2_vld -fflags nobuffer -flags low_delay -i http:///example.com -c:v h264_qsv -g 50 -bf 0 -profile:v high -level:v 4.1 -async_depth:v 1 -an -vf "hwmap=derive_device=qsv,format=qsv" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
+
+	// [RTSP] video with rotation, should be transcoded, so select H264
+	args = parseArgs("rtsp://example.com#video=h264#rotate=180#hardware=dxva2")
+	require.Equal(t, `ffmpeg -hide_banner -hwaccel dxva2 -hwaccel_output_format dxva2_vld -allowed_media_types video -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:v h264_qsv -g 50 -bf 0 -profile:v high -level:v 4.1 -async_depth:v 1 -an -vf "hwmap=derive_device=qsv,format=qsv,transpose=1,transpose=1" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
+
+	// [RTSP] video with resize to 1280x720, should be transcoded, so select H265
+	args = parseArgs("rtsp://example.com#video=h265#width=1280#height=720#hardware=dxva2")
+	require.Equal(t, `ffmpeg -hide_banner -hwaccel dxva2 -hwaccel_output_format dxva2_vld -allowed_media_types video -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:v hevc_qsv -g 50 -bf 0 -profile:v high -level:v 5.1 -async_depth:v 1 -an -vf "hwmap=derive_device=qsv,format=qsv,scale_qsv=1280:720" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
+
+	// [FILE] video will be output for MJPEG to pipe, audio will be skipped
+	args = parseArgs("/media/bbb.mp4#video=mjpeg#hardware=dxva2")
+	require.Equal(t, `ffmpeg -hide_banner -hwaccel dxva2 -hwaccel_output_format dxva2_vld -re -i /media/bbb.mp4 -c:v mjpeg_qsv -profile:v high -level:v 5.1 -an -vf "hwmap=derive_device=qsv,format=qsv" -f mjpeg -`, args.String())
+
+	// [DEVICE] MJPEG video with size 1920x1080 will be transcoded to H265
+	args = parseArgs("device?video=0&video_size=1920x1080#video=h265#hardware=dxva2")
+	require.Equal(t, `ffmpeg -hide_banner -hwaccel dxva2 -hwaccel_output_format dxva2_vld -f dshow -video_size 1920x1080 -i video="0" -c:v hevc_qsv -g 50 -bf 0 -profile:v high -level:v 5.1 -async_depth:v 1 -an -vf "hwmap=derive_device=qsv,format=qsv" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
+}
+
+func _TestParseArgsHwVideotoolbox(t *testing.T) {
+	// [HTTP-MJPEG] video will be transcoded to H264
+	args := parseArgs("http:///example.com#video=h264#hardware=videotoolbox")
+	require.Equal(t, `ffmpeg -hide_banner -hwaccel videotoolbox -hwaccel_output_format videotoolbox_vld -fflags nobuffer -flags low_delay -i http:///example.com -c:v h264_videotoolbox -g 50 -bf 0 -profile:v high -level:v 4.1 -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
+
+	// [RTSP] video with rotation, should be transcoded, so select H264
+	args = parseArgs("rtsp://example.com#video=h264#rotate=180#hardware=videotoolbox")
+	require.Equal(t, `ffmpeg -hide_banner -hwaccel videotoolbox -hwaccel_output_format videotoolbox_vld -allowed_media_types video -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:v h264_videotoolbox -g 50 -bf 0 -profile:v high -level:v 4.1 -an -vf "transpose=1,transpose=1" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
+
+	// [RTSP] video with resize to 1280x720, should be transcoded, so select H265
+	args = parseArgs("rtsp://example.com#video=h265#width=1280#height=720#hardware=videotoolbox")
+	require.Equal(t, `ffmpeg -hide_banner -hwaccel videotoolbox -hwaccel_output_format videotoolbox_vld -allowed_media_types video -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c:v hevc_videotoolbox -g 50 -bf 0 -profile:v high -level:v 5.1 -an -vf "scale=1280:720" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
+
+	// [DEVICE] MJPEG video with size 1920x1080 will be transcoded to H265
+	args = parseArgs("device?video=0&video_size=1920x1080#video=h265#hardware=videotoolbox")
+	require.Equal(t, `ffmpeg -hide_banner -hwaccel videotoolbox -hwaccel_output_format videotoolbox_vld -f dshow -video_size 1920x1080 -i video="0" -c:v hevc_videotoolbox -g 50 -bf 0 -profile:v high -level:v 5.1 -an -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
+}
+
+func TestDeckLink(t *testing.T) {
+	args := parseArgs(`DeckLink SDI (2)#video=h264#hardware=vaapi#input=-format_code Hp29 -f decklink -i "{input}"`)
+	require.Equal(t, `ffmpeg -hide_banner -hwaccel vaapi -hwaccel_output_format vaapi -hwaccel_flags allow_profile_mismatch -format_code Hp29 -f decklink -i "DeckLink SDI (2)" -c:v h264_vaapi -g 50 -bf 0 -profile:v high -level:v 4.1 -sei:v 0 -an -vf "format=vaapi|nv12,hwupload,scale_vaapi=out_color_matrix=bt709:out_range=tv:format=nv12" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`, args.String())
+}
+
+func TestDrawText(t *testing.T) {
+	tests := []struct {
+		name   string
+		source string
+		expect string
+	}{
+		{
+			source: "http:///example.com#video=h264#drawtext=fontsize=12",
+			expect: `ffmpeg -hide_banner -fflags nobuffer -flags low_delay -i http:///example.com -c:v libx264 -g 50 -profile:v high -level:v 4.1 -preset:v superfast -tune:v zerolatency -pix_fmt:v yuv420p -an -vf "drawtext=fontsize=12:text='%{localtime\:%Y-%m-%d %X}'" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			source: "http:///example.com#video=h264#width=640#drawtext=fontsize=12",
+			expect: `ffmpeg -hide_banner -fflags nobuffer -flags low_delay -i http:///example.com -c:v libx264 -g 50 -profile:v high -level:v 4.1 -preset:v superfast -tune:v zerolatency -pix_fmt:v yuv420p -an -vf "scale=640:-1,drawtext=fontsize=12:text='%{localtime\:%Y-%m-%d %X}'" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+		{
+			source: "http:///example.com#video=h264#width=640#drawtext=fontsize=12#hardware=vaapi",
+			expect: `ffmpeg -hide_banner -hwaccel vaapi -hwaccel_output_format nv12 -hwaccel_flags allow_profile_mismatch -fflags nobuffer -flags low_delay -i http:///example.com -c:v h264_vaapi -g 50 -bf 0 -profile:v high -level:v 4.1 -sei:v 0 -an -vf "scale=640:-1,drawtext=fontsize=12:text='%{localtime\:%Y-%m-%d %X}',hwupload" -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			args := parseArgs(test.source)
+			require.Equal(t, test.expect, args.String())
+		})
+	}
+}
+
+func TestVersion(t *testing.T) {
+	verAV = ffmpeg.Version61
+	tests := []struct {
+		name   string
+		source string
+		expect string
+	}{
+		{
+			source: "/media/bbb.mp4",
+			expect: `ffmpeg -hide_banner -readrate_initial_burst 0.001 -re -i /media/bbb.mp4 -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			args := parseArgs(test.source)
+			require.Equal(t, test.expect, args.String())
+		})
+	}
+}
diff --git a/installs_on_host/go2rtc/internal/ffmpeg/hardware/README.md b/installs_on_host/go2rtc/internal/ffmpeg/hardware/README.md
new file mode 100644
index 0000000..6cad4c2
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ffmpeg/hardware/README.md
@@ -0,0 +1,106 @@
+# Hardware
+
+You **DON'T** need hardware acceleration if:
+
+- you're not using the [FFmpeg source](../README.md)
+- you're using only `#video=copy` for the FFmpeg source
+- you're using only `#audio=...` (any audio) transcoding for the FFmpeg source
+
+You **NEED** hardware acceleration if you're using `#video=h264`, `#video=h265`, `#video=mjpeg` (video) transcoding.
+
+## Important
+
+- Acceleration is disabled by default because it can be unstable (this may change in the future)
+- go2rtc can automatically detect supported hardware acceleration if enabled
+- go2rtc will enable hardware decoding only if hardware encoding is supported
+- go2rtc will use the same GPU for decoder and encoder
+- Intel and AMD will switch to a software decoder if the input codec isn't supported by the hardware decoder
+- NVIDIA will fail if the input codec isn't supported by the hardware decoder
+- Raspberry Pi always uses a software decoder
+
+```yaml
+streams:
+  # auto select hardware encoder
+  camera1_hw: ffmpeg:rtsp://rtsp:12345678@192.168.1.123/av_stream/ch0#video=h264#hardware
+
+  # manual select hardware encoder (vaapi, cuda, v4l2m2m, dxva2, videotoolbox)
+  camera1_vaapi: ffmpeg:rtsp://rtsp:12345678@192.168.1.123/av_stream/ch0#video=h264#hardware=vaapi
+```
+
+## Docker and Hass Addon
+
+There are two versions of the Docker container and Hass Add-on:
+
+- Latest (Alpine) supports hardware acceleration for Intel iGPU (CPU with graphics) and Raspberry Pi.
+- Hardware (Debian 12) supports Intel iGPU, AMD GPU, NVIDIA GPU.
+
+## Intel iGPU
+
+**Supported on:** Windows binary, Linux binary, Docker, Hass Addon.
+
+If you have an Intel Sandy Bridge (2011) CPU with graphics, you already have hardware decoding/encoding support for `AVC/H.264`.
+
+If you have an Intel Skylake (2015) CPU with graphics, you already have hardware decoding/encoding support for `AVC/H.264`, `HEVC/H.265` and `MJPEG`.
+
+Read more [here](https://en.wikipedia.org/wiki/Intel_Quick_Sync_Video#Hardware_decoding_and_encoding) and [here](https://en.wikipedia.org/wiki/Intel_Graphics_Technology#Capabilities_(GPU_video_acceleration)).
+
+Linux and Docker:
+
+- It may be important to have a recent OS and Linux kernel. For example, on my **Debian 10 (kernel 4.19)** it did not work, but after updating to **Debian 11 (kernel 5.10)** everything was fine.
+- If you run into trouble, check that you have the `/dev/dri/` folder on your host.
+
+Docker users should add the `--privileged` option to the container for access to the hardware.
+
+**PS.** Supported via [VAAPI](https://trac.ffmpeg.org/wiki/Hardware/VAAPI) engine on Linux and [DXVA2+QSV](https://trac.ffmpeg.org/wiki/Hardware/QuickSync) engine on Windows.
+
+## AMD GPU
+
+*I don't have the hardware to test this!!!*
+
+**Supported on:** Linux binary, Docker, Hass Addon.
+
+Docker users should install: `alexxit/go2rtc:master-hardware`. Docker users should add the `--privileged` option to the container for access to the hardware.
+
+Hass Addon users should install **go2rtc master hardware** version.
+
+**PS.** Supported via [VAAPI](https://trac.ffmpeg.org/wiki/Hardware/VAAPI) engine.
+
+## NVIDIA GPU
+
+**Supported on:** Windows binary, Linux binary, Docker.
+
+Docker users should install: `alexxit/go2rtc:master-hardware`.
+
+Read more [here](https://docs.frigate.video/configuration/hardware_acceleration) and [here](https://jellyfin.org/docs/general/administration/hardware-acceleration/#nvidia-hardware-acceleration-on-docker-linux).
+
+**PS.** Supported via [CUDA](https://trac.ffmpeg.org/wiki/HWAccelIntro#CUDANVENCNVDEC) engine.
+
+## Raspberry Pi 3
+
+**Supported on:** Linux binary, Docker, Hass Addon.
+
+I don't recommend using transcoding on the Raspberry Pi 3. It's extremely slow, even with hardware acceleration. Also, it may fail when transcoding a 2K+ stream.
+
+## Raspberry Pi 4
+
+*I don't have the hardware to test this!!!*
+
+**Supported on:** Linux binary, Docker, Hass Addon.
+
+**PS.** Supported via [v4l2m2m](https://lalitm.com/hw-encoding-raspi/) engine.
+
+## macOS
+
+In my tests, transcoding is faster on the M1 CPU than on the M1 GPU. Transcoding time on the M1 CPU is better than any Intel iGPU and comparable to an NVIDIA RTX 2070.
+
+**PS.** Supported via [videotoolbox](https://trac.ffmpeg.org/wiki/HWAccelIntro#VideoToolbox) engine.
+
+## Rockchip
+
+- It's important to use a custom FFmpeg build with Rockchip support from [@nyanmisaka](https://github.com/nyanmisaka/ffmpeg-rockchip)
+  - Static binaries from [@MarcA711](https://github.com/MarcA711/Rockchip-FFmpeg-Builds/releases/)
+- It's important to have Linux kernel 5.10 or 6.1
+
+**Tested**
+
+- [Orange Pi 3B](https://www.armbian.com/orangepi3b/) with Armbian 6.1, supports transcoding H.264, H.265, MJPEG
diff --git a/installs_on_host/go2rtc/internal/ffmpeg/hardware/hardware.go b/installs_on_host/go2rtc/internal/ffmpeg/hardware/hardware.go
new file mode 100644
index 0000000..8016689
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ffmpeg/hardware/hardware.go
@@ -0,0 +1,210 @@
+package hardware
+
+import (
+	"net/http"
+	"os/exec"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/pkg/ffmpeg"
+)
+
+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
+	EngineRKMPP        = "rkmpp"        // Rockchip
+)
+
+func Init(bin string) {
+	api.HandleFunc("api/ffmpeg/hardware", func(w http.ResponseWriter, r *http.Request) {
+		api.ResponseSources(w, ProbeAll(bin))
+	})
+}
+
+// MakeHardware converts software FFmpeg args to hardware args
+// empty engine for autoselect
+func MakeHardware(args *ffmpeg.Args, engine string, defaults map[string]string) {
+	for i, codec := range args.Codecs {
+		if len(codec) < 10 {
+			continue // skip short line (-c:v mjpeg...)
+		}
+
+		// 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
+		if engine == "" && name != "h265" {
+			if engine = cache[name]; engine == "" {
+				engine = ProbeHardware(args.Bin, name)
+				cache[name] = engine
+			}
+		}
+
+		switch engine {
+		case EngineVAAPI:
+			args.Codecs[i] = defaults[name+"/"+engine]
+
+			if !args.HasFilters("drawtext=") {
+				args.Input = "-hwaccel vaapi -hwaccel_output_format vaapi -hwaccel_flags allow_profile_mismatch " + args.Input
+
+				if name == "h264" {
+					fixPixelFormat(args)
+				}
+
+				for i, filter := range args.Filters {
+					if strings.HasPrefix(filter, "scale=") {
+						args.Filters[i] = "scale_vaapi=" + filter[6:]
+					}
+					if strings.HasPrefix(filter, "transpose=") {
+						if filter == "transpose=1,transpose=1" { // 180 degrees half-turn
+							args.Filters[i] = "transpose_vaapi=4" // reversal
+						} else {
+							args.Filters[i] = "transpose_vaapi=" + filter[10:]
+						}
+					}
+				}
+
+				// fix if input doesn't support hwaccel, do nothing when support
+				// insert as first filter before hardware scale and transpose
+				args.InsertFilter("format=vaapi|nv12,hwupload")
+			} else {
+				// enable software pixel for drawtext, scale and transpose
+				args.Input = "-hwaccel vaapi -hwaccel_output_format nv12 -hwaccel_flags allow_profile_mismatch " + args.Input
+
+				args.AddFilter("hwupload")
+			}
+
+		case EngineCUDA:
+			args.Codecs[i] = defaults[name+"/"+engine]
+
+			// CUDA doesn't support hardware transpose
+			// https://github.com/AlexxIT/go2rtc/issues/389
+			if !args.HasFilters("drawtext=", "transpose=") {
+				args.Input = "-hwaccel cuda -hwaccel_output_format cuda " + args.Input
+
+				for i, filter := range args.Filters {
+					if strings.HasPrefix(filter, "scale=") {
+						args.Filters[i] = "scale_cuda=" + filter[6:]
+					}
+				}
+			} else {
+				args.Input = "-hwaccel cuda -hwaccel_output_format nv12 " + args.Input
+
+				args.AddFilter("hwupload")
+			}
+
+		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]
+
+		case EngineRKMPP:
+			args.Codecs[i] = defaults[name+"/"+engine]
+
+			if !args.HasFilters("drawtext=") {
+				args.Input = "-hwaccel rkmpp -hwaccel_output_format drm_prime -afbc rga " + args.Input
+
+				for i, filter := range args.Filters {
+					if strings.HasPrefix(filter, "scale=") {
+						args.Filters[i] = "scale_rkrga=" + filter[6:] + ":force_original_aspect_ratio=0"
+					}
+					if strings.HasPrefix(filter, "transpose=") {
+						if filter == "transpose=1,transpose=1" { // 180 degrees half-turn
+							args.Filters[i] = "vpp_rkrga=transpose=4" // reversal
+						} else {
+							args.Filters[i] = "vpp_rkrga=transpose=" + filter[10:]
+						}
+					}
+				}
+
+				if len(args.Filters) > 0 {
+					// fix if input doesn't support hwaccel, do nothing when support
+					// insert as first filter before hardware scale and transpose
+					args.InsertFilter("format=drm_prime|nv12,hwupload")
+				}
+			} else {
+				// enable software pixel for drawtext, scale and transpose
+				args.Input = "-hwaccel rkmpp -hwaccel_output_format nv12 -afbc rga " + args.Input
+
+				args.AddFilter("hwupload")
+			}
+		}
+	}
+}
+
+var cache = map[string]string{}
+
+func run(bin string, args string) bool {
+	err := exec.Command(bin, strings.Split(args, " ")...).Run()
+	return err == nil
+}
+
+func runToString(bin string, args string) string {
+	if run(bin, args) {
+		return "OK"
+	} else {
+		return "ERROR"
+	}
+}
+
+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
+}
+
+// fixPixelFormat:
+//   - good h264 pixel: yuv420p(tv, bt709) == yuv420p (mpeg/limited/tv)
+//   - bad h264 pixel: yuvj420p(pc, bt709) == yuvj420p (jpeg/full/pc)
+//   - bad jpeg pixel: yuvj422p(pc, bt470bg)
+func fixPixelFormat(args *ffmpeg.Args) {
+	// in my tests this filters has same CPU/GPU load:
+	//   - "hwupload"
+	//   - "hwupload,scale_vaapi=out_color_matrix=bt709:out_range=tv"
+	//   - "hwupload,scale_vaapi=out_color_matrix=bt709:out_range=tv:format=nv12"
+	const fixPixFmt = "out_color_matrix=bt709:out_range=tv:format=nv12"
+
+	for i, filter := range args.Filters {
+		if strings.HasPrefix(filter, "scale=") {
+			args.Filters[i] = filter + ":" + fixPixFmt
+			return
+		}
+	}
+
+	args.Filters = append(args.Filters, "scale="+fixPixFmt)
+}
diff --git a/installs_on_host/go2rtc/internal/ffmpeg/hardware/hardware_bsd.go b/installs_on_host/go2rtc/internal/ffmpeg/hardware/hardware_bsd.go
new file mode 100644
index 0000000..de24ac5
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ffmpeg/hardware/hardware_bsd.go
@@ -0,0 +1,62 @@
+//go:build freebsd || netbsd || openbsd || dragonfly
+
+package hardware
+
+import (
+	"runtime"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+)
+
+const (
+	ProbeV4L2M2MH264 = "-f lavfi -i testsrc2 -t 1 -c h264_v4l2m2m -f null -"
+	ProbeV4L2M2MH265 = "-f lavfi -i testsrc2 -t 1 -c hevc_v4l2m2m -f null -"
+	ProbeRKMPPH264   = "-f lavfi -i testsrc2 -t 1 -c h264_rkmpp_encoder -f null -"
+	ProbeRKMPPH265   = "-f lavfi -i testsrc2 -t 1 -c hevc_rkmpp_encoder -f null -"
+)
+
+func ProbeAll(bin string) []*api.Source {
+	return []*api.Source{
+		{
+			Name: runToString(bin, ProbeV4L2M2MH264),
+			URL:  "ffmpeg:...#video=h264#hardware=" + EngineV4L2M2M,
+		},
+		{
+			Name: runToString(bin, ProbeV4L2M2MH265),
+			URL:  "ffmpeg:...#video=h265#hardware=" + EngineV4L2M2M,
+		},
+		{
+			Name: runToString(bin, ProbeRKMPPH264),
+			URL:  "ffmpeg:...#video=h264#hardware=" + EngineRKMPP,
+		},
+		{
+			Name: runToString(bin, ProbeRKMPPH265),
+			URL:  "ffmpeg:...#video=h265#hardware=" + EngineRKMPP,
+		},
+	}
+}
+
+func ProbeHardware(bin, name string) string {
+	if runtime.GOARCH == "arm64" || runtime.GOARCH == "arm" {
+		switch name {
+		case "h264":
+			if run(bin, ProbeV4L2M2MH264) {
+				return EngineV4L2M2M
+			}
+			if run(bin, ProbeRKMPPH264) {
+				return EngineRKMPP
+			}
+		case "h265":
+			if run(bin, ProbeV4L2M2MH265) {
+				return EngineV4L2M2M
+			}
+			if run(bin, ProbeRKMPPH265) {
+				return EngineRKMPP
+			}
+		}
+
+		return EngineSoftware
+	}
+
+	return EngineSoftware
+}
diff --git a/installs_on_host/go2rtc/internal/ffmpeg/hardware/hardware_darwin.go b/installs_on_host/go2rtc/internal/ffmpeg/hardware/hardware_darwin.go
new file mode 100644
index 0000000..b150551
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ffmpeg/hardware/hardware_darwin.go
@@ -0,0 +1,39 @@
+//go:build darwin || ios
+
+package hardware
+
+import (
+	"github.com/AlexxIT/go2rtc/internal/api"
+)
+
+const ProbeVideoToolboxH264 = "-f lavfi -i testsrc2=size=svga -t 1 -c h264_videotoolbox -f null -"
+const ProbeVideoToolboxH265 = "-f lavfi -i testsrc2=size=svga -t 1 -c hevc_videotoolbox -f null -"
+
+func ProbeAll(bin string) []*api.Source {
+	return []*api.Source{
+		{
+			Name: runToString(bin, ProbeVideoToolboxH264),
+			URL:  "ffmpeg:...#video=h264#hardware=" + EngineVideoToolbox,
+		},
+		{
+			Name: runToString(bin, ProbeVideoToolboxH265),
+			URL:  "ffmpeg:...#video=h265#hardware=" + EngineVideoToolbox,
+		},
+	}
+}
+
+func ProbeHardware(bin, name string) string {
+	switch name {
+	case "h264":
+		if run(bin, ProbeVideoToolboxH264) {
+			return EngineVideoToolbox
+		}
+
+	case "h265":
+		if run(bin, ProbeVideoToolboxH265) {
+			return EngineVideoToolbox
+		}
+	}
+
+	return EngineSoftware
+}
diff --git a/installs_on_host/go2rtc/internal/ffmpeg/hardware/hardware_unix.go b/installs_on_host/go2rtc/internal/ffmpeg/hardware/hardware_unix.go
new file mode 100644
index 0000000..e8000e1
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ffmpeg/hardware/hardware_unix.go
@@ -0,0 +1,124 @@
+//go:build unix && !darwin && !freebsd && !netbsd && !openbsd && !dragonfly
+
+package hardware
+
+import (
+	"runtime"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+)
+
+const (
+	ProbeV4L2M2MH264 = "-f lavfi -i testsrc2 -t 1 -c h264_v4l2m2m -f null -"
+	ProbeV4L2M2MH265 = "-f lavfi -i testsrc2 -t 1 -c hevc_v4l2m2m -f null -"
+	ProbeRKMPPH264   = "-f lavfi -i testsrc2 -t 1 -c h264_rkmpp -f null -"
+	ProbeRKMPPH265   = "-f lavfi -i testsrc2 -t 1 -c hevc_rkmpp -f null -"
+	ProbeRKMPPJPEG   = "-f lavfi -i testsrc2 -t 1 -c mjpeg_rkmpp -f null -"
+	ProbeVAAPIH264   = "-init_hw_device vaapi -f lavfi -i testsrc2 -t 1 -vf format=nv12,hwupload -c h264_vaapi -f null -"
+	ProbeVAAPIH265   = "-init_hw_device vaapi -f lavfi -i testsrc2 -t 1 -vf format=nv12,hwupload -c hevc_vaapi -f null -"
+	ProbeVAAPIJPEG   = "-init_hw_device vaapi -f lavfi -i testsrc2 -t 1 -vf format=nv12,hwupload -c mjpeg_vaapi -f null -"
+	ProbeCUDAH264    = "-init_hw_device cuda -f lavfi -i testsrc2 -t 1 -c h264_nvenc -f null -"
+	ProbeCUDAH265    = "-init_hw_device cuda -f lavfi -i testsrc2 -t 1 -c hevc_nvenc -f null -"
+)
+
+func ProbeAll(bin string) []*api.Source {
+	if runtime.GOARCH == "arm64" || runtime.GOARCH == "arm" {
+		return []*api.Source{
+			{
+				Name: runToString(bin, ProbeV4L2M2MH264),
+				URL:  "ffmpeg:...#video=h264#hardware=" + EngineV4L2M2M,
+			},
+			{
+				Name: runToString(bin, ProbeV4L2M2MH265),
+				URL:  "ffmpeg:...#video=h265#hardware=" + EngineV4L2M2M,
+			},
+			{
+				Name: runToString(bin, ProbeRKMPPH264),
+				URL:  "ffmpeg:...#video=h264#hardware=" + EngineRKMPP,
+			},
+			{
+				Name: runToString(bin, ProbeRKMPPH265),
+				URL:  "ffmpeg:...#video=h265#hardware=" + EngineRKMPP,
+			},
+			{
+				Name: runToString(bin, ProbeRKMPPJPEG),
+				URL:  "ffmpeg:...#video=mjpeg#hardware=" + EngineRKMPP,
+			},
+		}
+	}
+
+	return []*api.Source{
+		{
+			Name: runToString(bin, ProbeVAAPIH264),
+			URL:  "ffmpeg:...#video=h264#hardware=" + EngineVAAPI,
+		},
+		{
+			Name: runToString(bin, ProbeVAAPIH265),
+			URL:  "ffmpeg:...#video=h265#hardware=" + EngineVAAPI,
+		},
+		{
+			Name: runToString(bin, ProbeVAAPIJPEG),
+			URL:  "ffmpeg:...#video=mjpeg#hardware=" + EngineVAAPI,
+		},
+		{
+			Name: runToString(bin, ProbeCUDAH264),
+			URL:  "ffmpeg:...#video=h264#hardware=" + EngineCUDA,
+		},
+		{
+			Name: runToString(bin, ProbeCUDAH265),
+			URL:  "ffmpeg:...#video=h265#hardware=" + EngineCUDA,
+		},
+	}
+}
+
+func ProbeHardware(bin, name string) string {
+	if runtime.GOARCH == "arm64" || runtime.GOARCH == "arm" {
+		switch name {
+		case "h264":
+			if run(bin, ProbeV4L2M2MH264) {
+				return EngineV4L2M2M
+			}
+			if run(bin, ProbeRKMPPH264) {
+				return EngineRKMPP
+			}
+		case "h265":
+			if run(bin, ProbeV4L2M2MH265) {
+				return EngineV4L2M2M
+			}
+			if run(bin, ProbeRKMPPH265) {
+				return EngineRKMPP
+			}
+		case "mjpeg":
+			if run(bin, ProbeRKMPPJPEG) {
+				return EngineRKMPP
+			}
+		}
+
+		return EngineSoftware
+	}
+
+	switch name {
+	case "h264":
+		if run(bin, ProbeCUDAH264) {
+			return EngineCUDA
+		}
+		if run(bin, ProbeVAAPIH264) {
+			return EngineVAAPI
+		}
+
+	case "h265":
+		if run(bin, ProbeCUDAH265) {
+			return EngineCUDA
+		}
+		if run(bin, ProbeVAAPIH265) {
+			return EngineVAAPI
+		}
+
+	case "mjpeg":
+		if run(bin, ProbeVAAPIJPEG) {
+			return EngineVAAPI
+		}
+	}
+
+	return EngineSoftware
+}
diff --git a/installs_on_host/go2rtc/internal/ffmpeg/hardware/hardware_windows.go b/installs_on_host/go2rtc/internal/ffmpeg/hardware/hardware_windows.go
new file mode 100644
index 0000000..cdf0e12
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ffmpeg/hardware/hardware_windows.go
@@ -0,0 +1,63 @@
+//go:build windows
+
+package hardware
+
+import "github.com/AlexxIT/go2rtc/internal/api"
+
+const ProbeDXVA2H264 = "-init_hw_device dxva2 -f lavfi -i testsrc2 -t 1 -c h264_qsv -f null -"
+const ProbeDXVA2H265 = "-init_hw_device dxva2 -f lavfi -i testsrc2 -t 1 -c hevc_qsv -f null -"
+const ProbeDXVA2JPEG = "-init_hw_device dxva2 -f lavfi -i testsrc2 -t 1 -c mjpeg_qsv -f null -"
+const ProbeCUDAH264 = "-init_hw_device cuda -f lavfi -i testsrc2 -t 1 -c h264_nvenc -f null -"
+const ProbeCUDAH265 = "-init_hw_device cuda -f lavfi -i testsrc2 -t 1 -c hevc_nvenc -f null -"
+
+func ProbeAll(bin string) []*api.Source {
+	return []*api.Source{
+		{
+			Name: runToString(bin, ProbeDXVA2H264),
+			URL:  "ffmpeg:...#video=h264#hardware=" + EngineDXVA2,
+		},
+		{
+			Name: runToString(bin, ProbeDXVA2H265),
+			URL:  "ffmpeg:...#video=h265#hardware=" + EngineDXVA2,
+		},
+		{
+			Name: runToString(bin, ProbeDXVA2JPEG),
+			URL:  "ffmpeg:...#video=mjpeg#hardware=" + EngineDXVA2,
+		},
+		{
+			Name: runToString(bin, ProbeCUDAH264),
+			URL:  "ffmpeg:...#video=h264#hardware=" + EngineCUDA,
+		},
+		{
+			Name: runToString(bin, ProbeCUDAH265),
+			URL:  "ffmpeg:...#video=h265#hardware=" + EngineCUDA,
+		},
+	}
+}
+
+func ProbeHardware(bin, name string) string {
+	switch name {
+	case "h264":
+		if run(bin, ProbeCUDAH264) {
+			return EngineCUDA
+		}
+		if run(bin, ProbeDXVA2H264) {
+			return EngineDXVA2
+		}
+
+	case "h265":
+		if run(bin, ProbeCUDAH265) {
+			return EngineCUDA
+		}
+		if run(bin, ProbeDXVA2H265) {
+			return EngineDXVA2
+		}
+
+	case "mjpeg":
+		if run(bin, ProbeDXVA2JPEG) {
+			return EngineDXVA2
+		}
+	}
+
+	return EngineSoftware
+}
diff --git a/installs_on_host/go2rtc/internal/ffmpeg/jpeg.go b/installs_on_host/go2rtc/internal/ffmpeg/jpeg.go
new file mode 100644
index 0000000..63d886d
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ffmpeg/jpeg.go
@@ -0,0 +1,83 @@
+package ffmpeg
+
+import (
+	"bytes"
+	"fmt"
+	"net/url"
+	"os/exec"
+
+	"github.com/AlexxIT/go2rtc/internal/ffmpeg/hardware"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/ffmpeg"
+	"github.com/AlexxIT/go2rtc/pkg/shell"
+)
+
+func JPEGWithQuery(b []byte, query url.Values) ([]byte, error) {
+	args := parseQuery(query)
+	return transcode(b, args.String())
+}
+
+func JPEGWithScale(b []byte, width, height int) ([]byte, error) {
+	args := defaultArgs()
+	args.AddFilter(fmt.Sprintf("scale=%d:%d", width, height))
+	return transcode(b, args.String())
+}
+
+func transcode(b []byte, args string) ([]byte, error) {
+	cmdArgs := shell.QuoteSplit(args)
+	cmd := exec.Command(cmdArgs[0], cmdArgs[1:]...)
+	cmd.Stdin = bytes.NewBuffer(b)
+	return cmd.Output()
+}
+
+func defaultArgs() *ffmpeg.Args {
+	return &ffmpeg.Args{
+		Bin:    defaults["bin"],
+		Global: defaults["global"],
+		Input:  "-i -",
+		Codecs: []string{defaults["mjpeg"]},
+		Output: defaults["output/mjpeg"],
+	}
+}
+
+func parseQuery(query url.Values) *ffmpeg.Args {
+	args := defaultArgs()
+
+	var width = -1
+	var height = -1
+	var r, hw string
+
+	for k, v := range query {
+		switch k {
+		case "width", "w":
+			width = core.Atoi(v[0])
+		case "height", "h":
+			height = core.Atoi(v[0])
+		case "rotate":
+			r = v[0]
+		case "hardware", "hw":
+			hw = v[0]
+		}
+	}
+
+	if width > 0 || height > 0 {
+		args.AddFilter(fmt.Sprintf("scale=%d:%d", width, height))
+	}
+
+	if r != "" {
+		switch r {
+		case "90":
+			args.AddFilter("transpose=1") // 90 degrees clockwise
+		case "180":
+			args.AddFilter("transpose=1,transpose=1")
+		case "-90", "270":
+			args.AddFilter("transpose=2") // 90 degrees counterclockwise
+		}
+	}
+
+	if hw != "" {
+		hardware.MakeHardware(args, hw, defaults)
+	}
+
+	return args
+}
diff --git a/installs_on_host/go2rtc/internal/ffmpeg/jpeg_test.go b/installs_on_host/go2rtc/internal/ffmpeg/jpeg_test.go
new file mode 100644
index 0000000..299d225
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ffmpeg/jpeg_test.go
@@ -0,0 +1,23 @@
+package ffmpeg
+
+import (
+	"net/url"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestParseQuery(t *testing.T) {
+	args := parseQuery(nil)
+	require.Equal(t, `ffmpeg -hide_banner -i - -c:v mjpeg -f mjpeg -`, args.String())
+
+	query, err := url.ParseQuery("h=480")
+	require.Nil(t, err)
+	args = parseQuery(query)
+	require.Equal(t, `ffmpeg -hide_banner -i - -c:v mjpeg -vf "scale=-1:480" -f mjpeg -`, args.String())
+
+	query, err = url.ParseQuery("hw=vaapi")
+	require.Nil(t, err)
+	args = parseQuery(query)
+	require.Equal(t, `ffmpeg -hide_banner -hwaccel vaapi -hwaccel_output_format vaapi -hwaccel_flags allow_profile_mismatch -i - -c:v mjpeg_vaapi -vf "format=vaapi|nv12,hwupload" -f mjpeg -`, args.String())
+}
diff --git a/installs_on_host/go2rtc/internal/ffmpeg/producer.go b/installs_on_host/go2rtc/internal/ffmpeg/producer.go
new file mode 100644
index 0000000..fb04446
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ffmpeg/producer.go
@@ -0,0 +1,122 @@
+package ffmpeg
+
+import (
+	"encoding/json"
+	"errors"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/aac"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+type Producer struct {
+	core.Connection
+	url    string
+	query  url.Values
+	ffmpeg core.Producer
+}
+
+// NewProducer - FFmpeg producer with auto selection video/audio codec based on client capabilities
+func NewProducer(url string) (core.Producer, error) {
+	p := &Producer{}
+
+	i := strings.IndexByte(url, '#')
+	p.url, p.query = url[:i], streams.ParseQuery(url[i+1:])
+
+	// ffmpeg.NewProducer support only one audio
+	if len(p.query["video"]) != 0 || len(p.query["audio"]) != 1 {
+		return nil, errors.New("ffmpeg: unsupported params: " + url[i:])
+	}
+
+	p.ID = core.NewID()
+	p.FormatName = "ffmpeg"
+	p.Medias = []*core.Media{
+		{
+			// we can support only audio, because don't know FmtpLine for H264 and PayloadType for MJPEG
+			Kind:      core.KindAudio,
+			Direction: core.DirectionRecvonly,
+			// codecs in order from best to worst
+			Codecs: []*core.Codec{
+				// OPUS will always marked as OPUS/48000/2
+				{Name: core.CodecOpus, ClockRate: 48000, Channels: 2},
+				{Name: core.CodecPCML, ClockRate: 16000},
+				{Name: core.CodecPCM, ClockRate: 16000},
+				{Name: core.CodecPCMA, ClockRate: 16000},
+				{Name: core.CodecPCMU, ClockRate: 16000},
+				{Name: core.CodecPCML, ClockRate: 8000},
+				{Name: core.CodecPCM, ClockRate: 8000},
+				{Name: core.CodecPCMA, ClockRate: 8000},
+				{Name: core.CodecPCMU, ClockRate: 8000},
+				// AAC has unknown problems on Dahua two way
+				{Name: core.CodecAAC, ClockRate: 16000, FmtpLine: aac.FMTP + "1408"},
+			},
+		},
+	}
+	return p, nil
+}
+
+func (p *Producer) Start() error {
+	var err error
+	if p.ffmpeg, err = streams.GetProducer(p.newURL()); err != nil {
+		return err
+	}
+
+	for i, media := range p.ffmpeg.GetMedias() {
+		track, err := p.ffmpeg.GetTrack(media, media.Codecs[0])
+		if err != nil {
+			return err
+		}
+		p.Receivers[i].Replace(track)
+	}
+
+	return p.ffmpeg.Start()
+}
+
+func (p *Producer) Stop() error {
+	if p.ffmpeg == nil {
+		return nil
+	}
+	return p.ffmpeg.Stop()
+}
+
+func (p *Producer) MarshalJSON() ([]byte, error) {
+	if p.ffmpeg == nil {
+		return json.Marshal(p.Connection)
+	}
+	return json.Marshal(p.ffmpeg)
+}
+
+func (p *Producer) newURL() string {
+	s := p.url
+	// rewrite codecs in url from auto to known presets from defaults
+	for _, receiver := range p.Receivers {
+		codec := receiver.Codec
+		switch codec.Name {
+		case core.CodecOpus:
+			s += "#audio=opus/16000"
+		case core.CodecAAC:
+			s += "#audio=aac/16000"
+		case core.CodecPCML:
+			s += "#audio=pcml/" + strconv.Itoa(int(codec.ClockRate))
+		case core.CodecPCM:
+			s += "#audio=pcm/" + strconv.Itoa(int(codec.ClockRate))
+		case core.CodecPCMA:
+			s += "#audio=pcma/" + strconv.Itoa(int(codec.ClockRate))
+		case core.CodecPCMU:
+			s += "#audio=pcmu/" + strconv.Itoa(int(codec.ClockRate))
+		}
+	}
+	// add other params
+	for key, values := range p.query {
+		if key != "audio" {
+			for _, value := range values {
+				s += "#" + key + "=" + value
+			}
+		}
+	}
+
+	return s
+}
diff --git a/installs_on_host/go2rtc/internal/ffmpeg/version.go b/installs_on_host/go2rtc/internal/ffmpeg/version.go
new file mode 100644
index 0000000..717e08a
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ffmpeg/version.go
@@ -0,0 +1,46 @@
+package ffmpeg
+
+import (
+	"errors"
+	"os/exec"
+	"sync"
+
+	"github.com/AlexxIT/go2rtc/pkg/ffmpeg"
+)
+
+var verMu sync.Mutex
+var verErr error
+var verFF string
+var verAV string
+
+func Version() (string, error) {
+	verMu.Lock()
+	defer verMu.Unlock()
+
+	if verFF != "" {
+		return verFF, verErr
+	}
+
+	cmd := exec.Command(defaults["bin"], "-version")
+	b, err := cmd.Output()
+	if err != nil {
+		verFF = "-"
+		verErr = err
+		return verFF, verErr
+	}
+
+	verFF, verAV = ffmpeg.ParseVersion(b)
+
+	if verFF == "" {
+		verFF = "?"
+	}
+
+	// better to compare libavformat, because nightly/master builds
+	if verAV != "" && verAV < ffmpeg.Version50 {
+		verErr = errors.New("ffmpeg: unsupported version: " + verFF)
+	}
+
+	log.Debug().Str("version", verFF).Str("libavformat", verAV).Msgf("[ffmpeg] bin")
+
+	return verFF, verErr
+}
diff --git a/installs_on_host/go2rtc/internal/ffmpeg/virtual/virtual.go b/installs_on_host/go2rtc/internal/ffmpeg/virtual/virtual.go
new file mode 100644
index 0000000..4dc3b02
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ffmpeg/virtual/virtual.go
@@ -0,0 +1,79 @@
+package virtual
+
+import (
+	"net/url"
+)
+
+func GetInput(src string) string {
+	query, err := url.ParseQuery(src)
+	if err != nil {
+		return ""
+	}
+
+	input := "-re"
+
+	for _, video := range query["video"] {
+		// https://ffmpeg.org/ffmpeg-filters.html
+		sep := "=" // first separator
+
+		if video == "" {
+			video = "testsrc=decimals=2" // default video
+			sep = ":"
+		}
+
+		input += " -f lavfi -i " + video
+
+		// set defaults (using Add instead of Set)
+		query.Add("size", "1920x1080")
+
+		for key, values := range query {
+			value := values[0]
+
+			// https://ffmpeg.org/ffmpeg-utils.html#video-size-syntax
+			switch key {
+			case "color", "rate", "duration", "sar", "decimals":
+			case "size":
+				switch value {
+				case "720":
+					value = "1280x720" // crf=1 -> 12 Mbps
+				case "1080":
+					value = "1920x1080" // crf=1 -> 25 Mbps
+				case "2K":
+					value = "2560x1440" // crf=1 -> 43 Mbps
+				case "4K":
+					value = "3840x2160" // crf=1 -> 103 Mbps
+				case "8K":
+					value = "7680x4230" // https://reolink.com/blog/8k-resolution/
+				}
+			default:
+				continue
+			}
+
+			input += sep + key + "=" + value
+			sep = ":" // next separator
+		}
+
+		if s := query.Get("format"); s != "" {
+			input += ",format=" + s
+		}
+	}
+
+	return input
+}
+
+func GetInputTTS(src string) string {
+	query, err := url.ParseQuery(src)
+	if err != nil {
+		return ""
+	}
+
+	input := `-re -f lavfi -i "flite=text='` + query.Get("text") + `'`
+
+	// ffmpeg -f lavfi -i flite=list_voices=1
+	// awb, kal, kal16, rms, slt
+	if voice := query.Get("voice"); voice != "" {
+		input += ":voice" + voice
+	}
+
+	return input + `"`
+}
diff --git a/installs_on_host/go2rtc/internal/ffmpeg/virtual/virtual_test.go b/installs_on_host/go2rtc/internal/ffmpeg/virtual/virtual_test.go
new file mode 100644
index 0000000..b648a9c
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ffmpeg/virtual/virtual_test.go
@@ -0,0 +1,20 @@
+package virtual
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestGetInput(t *testing.T) {
+	s := GetInput("video")
+	require.Equal(t, "-re -f lavfi -i testsrc=decimals=2:size=1920x1080", s)
+
+	s = GetInput("video=testsrc2&size=4K")
+	require.Equal(t, "-re -f lavfi -i testsrc2=size=3840x2160", s)
+}
+
+func TestGetInputTTS(t *testing.T) {
+	s := GetInputTTS("text=hello world&voice=slt")
+	require.Equal(t, `-re -f lavfi -i "flite=text='hello world':voiceslt"`, s)
+}
diff --git a/installs_on_host/go2rtc/internal/flussonic/README.md b/installs_on_host/go2rtc/internal/flussonic/README.md
new file mode 100644
index 0000000..d4f4291
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/flussonic/README.md
@@ -0,0 +1,5 @@
+# Flussonic
+
+[`new in v1.9.10`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.9.10)
+
+Support streams from [Flussonic](https://flussonic.com/) server. Related [issue](https://github.com/AlexxIT/go2rtc/issues/1678).
diff --git a/installs_on_host/go2rtc/internal/flussonic/flussonic.go b/installs_on_host/go2rtc/internal/flussonic/flussonic.go
new file mode 100644
index 0000000..6e87428
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/flussonic/flussonic.go
@@ -0,0 +1,10 @@
+package flussonic
+
+import (
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/flussonic"
+)
+
+func Init() {
+	streams.HandleFunc("flussonic", flussonic.Dial)
+}
diff --git a/installs_on_host/go2rtc/internal/gopro/README.md b/installs_on_host/go2rtc/internal/gopro/README.md
new file mode 100644
index 0000000..d55e31e
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/gopro/README.md
@@ -0,0 +1,29 @@
+# GoPro
+
+[`new in v1.8.3`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.8.3)
+
+Support streaming from [GoPro](https://gopro.com/) cameras, connected via USB or Wi-Fi to Linux, Mac, Windows.
+
+Supported models: HERO9, HERO10, HERO11, HERO12.  
+Supported OS: Linux, Mac, Windows, [HassOS](https://www.home-assistant.io/installation/)
+
+Other camera models have different APIs. I will try to add them in future versions.
+
+## Configuration
+
+- USB-connected cameras create a new network interface in the system
+- Linux users do not need to install anything
+- Windows users should install the [network driver](https://community.gopro.com/s/article/GoPro-Webcam)
+- if the camera is detected but the stream does not start, you need to disable the firewall
+
+1. Discover camera address: WebUI > Add > GoPro
+2. Add camera to config
+
+```yaml
+streams:
+  hero12: gopro://172.20.100.51
+```
+
+## Useful links
+
+- https://gopro.github.io/OpenGoPro/
diff --git a/installs_on_host/go2rtc/internal/gopro/gopro.go b/installs_on_host/go2rtc/internal/gopro/gopro.go
new file mode 100644
index 0000000..ee57804
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/gopro/gopro.go
@@ -0,0 +1,28 @@
+package gopro
+
+import (
+	"net/http"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/gopro"
+)
+
+func Init() {
+	streams.HandleFunc("gopro", func(source string) (core.Producer, error) {
+		return gopro.Dial(source)
+	})
+
+	api.HandleFunc("api/gopro", apiGoPro)
+}
+
+func apiGoPro(w http.ResponseWriter, r *http.Request) {
+	var items []*api.Source
+
+	for _, host := range gopro.Discovery() {
+		items = append(items, &api.Source{Name: host, URL: "gopro://" + host})
+	}
+
+	api.ResponseSources(w, items)
+}
diff --git a/installs_on_host/go2rtc/internal/hass/README.md b/installs_on_host/go2rtc/internal/hass/README.md
new file mode 100644
index 0000000..0495c05
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/hass/README.md
@@ -0,0 +1,41 @@
+# Hass
+
+Support import camera links from [Home Assistant](https://www.home-assistant.io/) config files:
+
+- [Generic Camera](https://www.home-assistant.io/integrations/generic/), setup via GUI
+- [HomeKit Camera](https://www.home-assistant.io/integrations/homekit_controller/)
+- [ONVIF](https://www.home-assistant.io/integrations/onvif/)
+- [Roborock](https://github.com/humbertogontijo/homeassistant-roborock) vacuums with camera
+
+## Configuration
+
+```yaml
+hass:
+  config: "/config"  # skip this setting if you are a Home Assistant add-on user
+
+streams:
+  generic_camera: hass:Camera1  # Settings > Integrations > Integration Name
+  aqara_g3: hass:Camera-Hub-G3-AB12
+```
+
+### WebRTC Cameras
+
+[`new in v1.6.0`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.6.0)
+
+Any cameras in WebRTC format are supported. But at the moment Home Assistant only supports some [Nest](https://www.home-assistant.io/integrations/nest/) cameras in this format.
+
+**Important.** The Nest API only allows you to get a link to a stream for 5 minutes.
+Do not use this with Frigate! If the stream expires, Frigate will consume all available RAM on your machine within seconds.
+It's recommended to use [Nest source](../nest/README.md) - it supports extending the stream.
+
+```yaml
+streams:
+  # link to Home Assistant Supervised
+  hass-webrtc1: hass://supervisor?entity_id=camera.nest_doorbell
+  # link to external Home Assistant with Long-Lived Access Tokens
+  hass-webrtc2: hass://192.168.1.123:8123?entity_id=camera.nest_doorbell&token=eyXYZ...
+```
+
+### RTSP Cameras
+
+By default, the Home Assistant API does not allow you to get a dynamic RTSP link to a camera stream. [This method](https://github.com/felipecrs/hass-expose-camera-stream-source#importing-cameras-from-home-assistant-to-go2rtc-or-frigate) can work around it.
diff --git a/installs_on_host/go2rtc/internal/hass/api.go b/installs_on_host/go2rtc/internal/hass/api.go
new file mode 100644
index 0000000..9f110fc
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/hass/api.go
@@ -0,0 +1,104 @@
+package hass
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"net"
+	"net/http"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/internal/webrtc"
+)
+
+func apiOK(w http.ResponseWriter, r *http.Request) {
+	api.Response(w, `{"status":1,"payload":{}}`, api.MimeJSON)
+}
+
+func apiStream(w http.ResponseWriter, r *http.Request) {
+	switch {
+	// /stream/{id}/add
+	case strings.HasSuffix(r.RequestURI, "/add"):
+		var v addJSON
+		if err := json.NewDecoder(r.Body).Decode(&v); err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		// we can get three types of links:
+		// 1. link to go2rtc stream: rtsp://...:8554/{stream_name}
+		// 2. static link to Hass camera
+		// 3. dynamic link to Hass camera
+		if _, err := streams.Patch(v.Name, v.Channels.First.Url); err == nil {
+			apiOK(w, r)
+		} else {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+		}
+
+	// /stream/{id}/channel/0/webrtc
+	default:
+		i := strings.IndexByte(r.RequestURI[8:], '/')
+		if i <= 0 {
+			http.Error(w, "", http.StatusBadRequest)
+			return
+		}
+
+		name := r.RequestURI[8 : 8+i]
+		stream := streams.Get(name)
+		if stream == nil {
+			http.Error(w, api.StreamNotFound, http.StatusNotFound)
+			return
+		}
+
+		if err := r.ParseForm(); err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		s := r.FormValue("data")
+		offer, err := base64.StdEncoding.DecodeString(s)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		s, err = webrtc.ExchangeSDP(stream, string(offer), "hass/webrtc", r.UserAgent())
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		s = base64.StdEncoding.EncodeToString([]byte(s))
+		_, _ = w.Write([]byte(s))
+	}
+}
+
+func HassioAddr() string {
+	ints, _ := net.Interfaces()
+
+	for _, i := range ints {
+		if i.Name != "hassio" {
+			continue
+		}
+
+		addrs, _ := i.Addrs()
+		for _, addr := range addrs {
+			if addr, ok := addr.(*net.IPNet); ok {
+				return addr.IP.String()
+			}
+		}
+	}
+
+	return ""
+}
+
+type addJSON struct {
+	Name     string `json:"name"`
+	Channels struct {
+		First struct {
+			//Name string `json:"name"`
+			Url string `json:"url"`
+		} `json:"0"`
+	} `json:"channels"`
+}
diff --git a/installs_on_host/go2rtc/internal/hass/hass.go b/installs_on_host/go2rtc/internal/hass/hass.go
new file mode 100644
index 0000000..99c6369
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/hass/hass.go
@@ -0,0 +1,219 @@
+package hass
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+	"path"
+	"strings"
+	"sync"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/roborock"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/hass"
+	"github.com/rs/zerolog"
+)
+
+func Init() {
+	var conf struct {
+		API struct {
+			Listen string `yaml:"listen"`
+		} `yaml:"api"`
+		Mod struct {
+			Config string `yaml:"config"`
+		} `yaml:"hass"`
+	}
+
+	app.LoadConfig(&conf)
+
+	log = app.GetLogger("hass")
+
+	// support API for https://www.home-assistant.io/integrations/rtsp_to_webrtc/
+	api.HandleFunc("/static", apiOK)
+	api.HandleFunc("/streams", apiOK)
+	api.HandleFunc("/stream/", apiStream)
+
+	streams.RedirectFunc("hass", func(rawURL string) (string, error) {
+		rawURL, rawQuery, _ := strings.Cut(rawURL, "#")
+
+		if location := entities[rawURL[5:]]; location != "" {
+			if rawQuery != "" {
+				return location + "#" + rawQuery, nil
+			}
+			return location, nil
+		}
+
+		return "", nil
+	})
+
+	streams.HandleFunc("hass", func(source string) (core.Producer, error) {
+		// support hass://supervisor?entity_id=camera.driveway_doorbell
+		return hass.NewClient(source)
+	})
+
+	// load static entries from Hass config
+	if err := importConfig(conf.Mod.Config); err != nil {
+		log.Trace().Msgf("[hass] can't import config: %s", err)
+
+		api.HandleFunc("api/hass", func(w http.ResponseWriter, _ *http.Request) {
+			http.Error(w, "no hass config", http.StatusNotFound)
+		})
+		return
+	}
+
+	api.HandleFunc("api/hass", func(w http.ResponseWriter, _ *http.Request) {
+		once.Do(func() {
+			// load WebRTC entities from Hass API, works only for add-on version
+			if token := hass.SupervisorToken(); token != "" {
+				if err := importWebRTC(token); err != nil {
+					log.Warn().Err(err).Caller().Send()
+				}
+			}
+		})
+
+		var items []*api.Source
+		for name, url := range entities {
+			items = append(items, &api.Source{
+				Name: name, URL: "hass:" + name, Location: url,
+			})
+		}
+		api.ResponseSources(w, items)
+	})
+
+	// for Addon listen on hassio interface, so WebUI feature will work
+	if conf.API.Listen == "127.0.0.1:1984" {
+		if addr := HassioAddr(); addr != "" {
+			addr += ":1984"
+			go func() {
+				log.Info().Str("addr", addr).Msg("[hass] listen")
+				if err := http.ListenAndServe(addr, api.Handler); err != nil {
+					log.Error().Err(err).Caller().Send()
+				}
+			}()
+		}
+	}
+}
+
+func importConfig(config string) error {
+	// support load cameras from Hass config file
+	filename := path.Join(config, ".storage/core.config_entries")
+	b, err := os.ReadFile(filename)
+	if err != nil {
+		return err
+	}
+
+	var storage struct {
+		Data struct {
+			Entries []struct {
+				Title   string          `json:"title"`
+				Domain  string          `json:"domain"`
+				Data    json.RawMessage `json:"data"`
+				Options json.RawMessage `json:"options"`
+			} `json:"entries"`
+		} `json:"data"`
+	}
+
+	if err = json.Unmarshal(b, &storage); err != nil {
+		return err
+	}
+
+	for _, entrie := range storage.Data.Entries {
+		switch entrie.Domain {
+		case "generic":
+			var options struct {
+				StreamSource string `json:"stream_source"`
+			}
+			if err = json.Unmarshal(entrie.Options, &options); err != nil {
+				continue
+			}
+			entities[entrie.Title] = options.StreamSource
+
+		case "homekit_controller":
+			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
+			}
+			entities[entrie.Title] = fmt.Sprintf(
+				"homekit://%s:%d?client_id=%s&client_private=%s%s&device_id=%s&device_public=%s",
+				data.DeviceHost, data.DevicePort,
+				data.ClientID, data.ClientPrivate, data.ClientPublic,
+				data.DeviceID, data.DevicePublic,
+			)
+
+		case "roborock":
+			_ = json.Unmarshal(entrie.Data, &roborock.Auth)
+
+		case "onvif":
+			var data struct {
+				Host     string `json:"host" json:"host"`
+				Port     uint16 `json:"port" json:"port"`
+				Username string `json:"username" json:"username"`
+				Password string `json:"password" json:"password"`
+			}
+			if err = json.Unmarshal(entrie.Data, &data); err != nil {
+				continue
+			}
+
+			if data.Username != "" && data.Password != "" {
+				entities[entrie.Title] = fmt.Sprintf(
+					"onvif://%s:%s@%s:%d", data.Username, data.Password, data.Host, data.Port,
+				)
+			} else {
+				entities[entrie.Title] = fmt.Sprintf("onvif://%s:%d", data.Host, data.Port)
+			}
+
+		default:
+			continue
+		}
+
+		log.Debug().Str("url", "hass:"+entrie.Title).Msg("[hass] load config")
+		//streams.Get("hass:" + entrie.Title)
+	}
+
+	return nil
+}
+
+func importWebRTC(token string) error {
+	hassAPI, err := hass.NewAPI("ws://supervisor/core/websocket", token)
+	if err != nil {
+		return err
+	}
+
+	webrtcEntities, err := hassAPI.GetWebRTCEntities()
+	if err != nil {
+		return err
+	}
+
+	if len(webrtcEntities) == 0 {
+		log.Debug().Msg("[hass] webrtc cameras not found")
+	}
+
+	for name, entityID := range webrtcEntities {
+		entities[name] = "hass://supervisor?entity_id=" + entityID
+
+		log.Debug().Msgf("[hass] load webrtc name=%s entity_id=%s", name, entityID)
+	}
+
+	return nil
+}
+
+var entities = map[string]string{}
+var log zerolog.Logger
+var once sync.Once
diff --git a/installs_on_host/go2rtc/internal/hls/README.md b/installs_on_host/go2rtc/internal/hls/README.md
new file mode 100644
index 0000000..64471bd
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/hls/README.md
@@ -0,0 +1,19 @@
+# HLS
+
+[`new in v1.1.0`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.1.0)
+
+[HLS](https://en.wikipedia.org/wiki/HTTP_Live_Streaming) is the worst technology for real-time streaming. 
+It can only be useful on devices that do not support more modern technology, like [WebRTC](../webrtc/README.md), [MP4](../mp4/README.md).
+
+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](../../README.md#codecs-filters).
+
+## Useful links
+
+- https://walterebert.com/playground/video/hls/
diff --git a/installs_on_host/go2rtc/internal/hls/hls.go b/installs_on_host/go2rtc/internal/hls/hls.go
new file mode 100644
index 0000000..5c13645
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/hls/hls.go
@@ -0,0 +1,217 @@
+package hls
+
+import (
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/api/ws"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/mp4"
+	"github.com/AlexxIT/go2rtc/pkg/mpegts"
+	"github.com/rs/zerolog"
+)
+
+func Init() {
+	log = app.GetLogger("hls")
+
+	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)
+
+	ws.HandleFunc("hls", handlerWSHLS)
+}
+
+var log zerolog.Logger
+
+const keepalive = 5 * time.Second
+
+// once I saw 404 on MP4 segment, so better to use mutex
+var sessions = map[string]*Session{}
+var sessionsMu sync.RWMutex
+
+func handlerStream(w http.ResponseWriter, r *http.Request) {
+	// 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.Get(src)
+	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
+		return
+	}
+
+	var cons core.Consumer
+
+	// use fMP4 with codecs filter and TS without
+	medias := mp4.ParseQuery(r.URL.Query())
+	if medias != nil {
+		c := mp4.NewConsumer(medias)
+		c.FormatName = "hls/fmp4"
+		c.WithRequest(r)
+		cons = c
+	} else {
+		c := mpegts.NewConsumer()
+		c.FormatName = "hls/mpegts"
+		c.WithRequest(r)
+		cons = c
+	}
+
+	if err := stream.AddConsumer(cons); err != nil {
+		log.Error().Err(err).Caller().Send()
+		return
+	}
+
+	session := NewSession(cons)
+	session.alive = time.AfterFunc(keepalive, func() {
+		sessionsMu.Lock()
+		delete(sessions, session.id)
+		sessionsMu.Unlock()
+
+		stream.RemoveConsumer(cons)
+	})
+
+	sessionsMu.Lock()
+	sessions[session.id] = session
+	sessionsMu.Unlock()
+
+	go session.Run()
+
+	if _, err := w.Write(session.Main()); 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")
+	sessionsMu.RLock()
+	session := sessions[sid]
+	sessionsMu.RUnlock()
+	if session == nil {
+		http.NotFound(w, r)
+		return
+	}
+
+	if _, err := w.Write(session.Playlist()); 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")
+	sessionsMu.RLock()
+	session := sessions[sid]
+	sessionsMu.RUnlock()
+	if session == nil {
+		http.NotFound(w, r)
+		return
+	}
+
+	session.alive.Reset(keepalive)
+
+	data := session.Segment()
+	if data == nil {
+		log.Warn().Msgf("[hls] can't get segment %s", r.URL.RawQuery)
+		http.NotFound(w, r)
+		return
+	}
+
+	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")
+	sessionsMu.RLock()
+	session := sessions[sid]
+	sessionsMu.RUnlock()
+	if session == nil {
+		http.NotFound(w, r)
+		return
+	}
+
+	data := session.Init()
+	if data == nil {
+		log.Warn().Msgf("[hls] can't get init %s", r.URL.RawQuery)
+		http.NotFound(w, r)
+		return
+	}
+
+	if _, err := w.Write(data); 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")
+		return
+	}
+
+	query := r.URL.Query()
+
+	sid := query.Get("id")
+	sessionsMu.RLock()
+	session := sessions[sid]
+	sessionsMu.RUnlock()
+	if session == nil {
+		http.NotFound(w, r)
+		return
+	}
+
+	session.alive.Reset(keepalive)
+
+	data := session.Segment()
+	if data == nil {
+		log.Warn().Msgf("[hls] can't get segment %s", r.URL.RawQuery)
+		http.NotFound(w, r)
+		return
+	}
+
+	if _, err := w.Write(data); err != nil {
+		log.Error().Err(err).Caller().Send()
+	}
+}
diff --git a/installs_on_host/go2rtc/internal/hls/session.go b/installs_on_host/go2rtc/internal/hls/session.go
new file mode 100644
index 0000000..9f07ad4
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/hls/session.go
@@ -0,0 +1,127 @@
+package hls
+
+import (
+	"fmt"
+	"io"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/mp4"
+)
+
+type Session struct {
+	cons     core.Consumer
+	id       string
+	template string
+	init     []byte
+	buffer   []byte
+	seq      int
+	alive    *time.Timer
+	mu       sync.Mutex
+}
+
+func NewSession(cons core.Consumer) *Session {
+	s := &Session{
+		id:   core.RandString(8, 62),
+		cons: cons,
+	}
+
+	// two segments important for Chromecast
+	if _, ok := cons.(*mp4.Consumer); ok {
+		s.template = `#EXTM3U
+#EXT-X-VERSION:6
+#EXT-X-TARGETDURATION:1
+#EXT-X-MEDIA-SEQUENCE:%d
+#EXT-X-MAP:URI="init.mp4?id=` + s.id + `"
+#EXTINF:0.500,
+segment.m4s?id=` + s.id + `&n=%d
+#EXTINF:0.500,
+segment.m4s?id=` + s.id + `&n=%d`
+	} else {
+		s.template = `#EXTM3U
+#EXT-X-VERSION:3
+#EXT-X-TARGETDURATION:1
+#EXT-X-MEDIA-SEQUENCE:%d
+#EXTINF:0.500,
+segment.ts?id=` + s.id + `&n=%d
+#EXTINF:0.500,
+segment.ts?id=` + s.id + `&n=%d`
+	}
+
+	return s
+}
+
+func (s *Session) Write(p []byte) (n int, err error) {
+	s.mu.Lock()
+	if s.init == nil {
+		s.init = p
+	} else {
+		s.buffer = append(s.buffer, p...)
+	}
+	s.mu.Unlock()
+	return len(p), nil
+}
+
+func (s *Session) Run() {
+	_, _ = s.cons.(io.WriterTo).WriteTo(s)
+}
+
+func (s *Session) Main() []byte {
+	type withCodecs interface {
+		Codecs() []*core.Codec
+	}
+
+	codecs := mp4.MimeCodecs(s.cons.(withCodecs).Codecs())
+	codecs = strings.Replace(codecs, mp4.MimeFlac, "fLaC", 1)
+
+	// bandwidth important for Safari, codecs useful for smooth playback
+	return []byte(`#EXTM3U
+#EXT-X-STREAM-INF:BANDWIDTH=192000,CODECS="` + codecs + `"
+hls/playlist.m3u8?id=` + s.id)
+}
+
+func (s *Session) Playlist() []byte {
+	return []byte(fmt.Sprintf(s.template, s.seq, s.seq, s.seq+1))
+}
+
+func (s *Session) Init() (init []byte) {
+	for i := 0; i < 60 && init == nil; i++ {
+		if i > 0 {
+			time.Sleep(50 * time.Millisecond)
+		}
+
+		s.mu.Lock()
+		// return init only when have some buffer
+		if len(s.buffer) > 0 {
+			init = s.init
+		}
+		s.mu.Unlock()
+	}
+
+	return
+}
+
+func (s *Session) Segment() (segment []byte) {
+	for i := 0; i < 60 && segment == nil; i++ {
+		if i > 0 {
+			time.Sleep(50 * time.Millisecond)
+		}
+
+		s.mu.Lock()
+		if len(s.buffer) > 0 {
+			segment = s.buffer
+			if _, ok := s.cons.(*mp4.Consumer); ok {
+				s.buffer = nil
+			} else {
+				// for TS important to start new segment with init
+				s.buffer = s.init
+			}
+			s.seq++
+		}
+		s.mu.Unlock()
+	}
+
+	return
+}
diff --git a/installs_on_host/go2rtc/internal/hls/ws.go b/installs_on_host/go2rtc/internal/hls/ws.go
new file mode 100644
index 0000000..00eedfe
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/hls/ws.go
@@ -0,0 +1,52 @@
+package hls
+
+import (
+	"errors"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/api/ws"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/mp4"
+)
+
+func handlerWSHLS(tr *ws.Transport, msg *ws.Message) error {
+	stream, _ := streams.GetOrPatch(tr.Request.URL.Query())
+	if stream == nil {
+		return errors.New(api.StreamNotFound)
+	}
+
+	codecs := msg.String()
+	medias := mp4.ParseCodecs(codecs, true)
+	cons := mp4.NewConsumer(medias)
+	cons.FormatName = "hls/fmp4"
+	cons.WithRequest(tr.Request)
+
+	log.Trace().Msgf("[hls] new ws consumer codecs=%s", codecs)
+
+	if err := stream.AddConsumer(cons); err != nil {
+		log.Error().Err(err).Caller().Send()
+		return err
+	}
+
+	session := NewSession(cons)
+
+	session.alive = time.AfterFunc(keepalive, func() {
+		sessionsMu.Lock()
+		delete(sessions, session.id)
+		sessionsMu.Unlock()
+
+		stream.RemoveConsumer(cons)
+	})
+
+	sessionsMu.Lock()
+	sessions[session.id] = session
+	sessionsMu.Unlock()
+
+	go session.Run()
+
+	main := session.Main()
+	tr.Write(&ws.Message{Type: "hls", Value: string(main)})
+
+	return nil
+}
diff --git a/installs_on_host/go2rtc/internal/homekit/README.md b/installs_on_host/go2rtc/internal/homekit/README.md
new file mode 100644
index 0000000..0e78fcc
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/homekit/README.md
@@ -0,0 +1,97 @@
+# Apple HomeKit
+
+This module supports both client and server for the [Apple HomeKit](https://www.apple.com/home-app/accessories/) protocol.
+
+## HomeKit Client
+
+**Important:**
+
+- You can use HomeKit Cameras **without Apple devices** (iPhone, iPad, etc.), it's just a yet another protocol
+- HomeKit device can be paired with only one ecosystem. So, if you have paired it to an iPhone (Apple Home), you can't pair it with Home Assistant or go2rtc. Or if you have paired it to go2rtc, you can't pair it with an iPhone
+- HomeKit device should be on the same network with working [mDNS](https://en.wikipedia.org/wiki/Multicast_DNS) between the device and go2rtc
+
+go2rtc supports importing paired HomeKit devices from [Home Assistant](../hass/README.md). 
+So you can use HomeKit camera with Home Assistant and go2rtc simultaneously. 
+If you are using Home Assistant, I recommend pairing devices with it; it will give you more options.
+
+You can pair device with go2rtc on the HomeKit page. If you can't see your devices, reload the page. 
+Also, try rebooting your HomeKit device (power off). If you still can't see it, you have a problem with mDNS.
+
+If you see a device but it does not have a pairing button, it is paired to some ecosystem (Apple Home, Home Assistant, HomeBridge, etc.). You need to delete the device from that ecosystem, and it will be available for pairing. If you cannot unpair the device, you will have to reset it.
+
+**Important:**
+
+- HomeKit audio uses very non-standard **AAC-ELD** codec with very non-standard params and specification violations
+- Audio can't be played in `VLC` and probably any other player
+- Audio should be transcoded for use with MSE, WebRTC, etc.
+
+### Client Configuration
+
+Recommended settings for using HomeKit Camera with WebRTC, MSE, MP4, RTSP:
+
+```yaml
+streams:
+  aqara_g3:
+    - hass:Camera-Hub-G3-AB12
+    - ffmpeg:aqara_g3#audio=aac#audio=opus
+```
+
+RTSP link with "normal" audio for any player: `rtsp://192.168.1.123:8554/aqara_g3?video&audio=aac`
+
+**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).
+
+## HomeKit Server
+
+[`new in v1.7.0`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.7.0)
+
+HomeKit module can work in two modes:
+
+- export any H264 camera to Apple HomeKit
+- transparent proxy any Apple HomeKit camera (Aqara, Eve, Eufy, etc.) back to Apple HomeKit, so you will have all camera features in Apple Home and also will have RTSP/WebRTC/MP4/etc. from your HomeKit camera
+
+**Important**
+
+- HomeKit cameras support only H264 video and OPUS audio
+
+### Server Configuration
+
+**Minimal config**
+
+```yaml
+streams:
+  dahua1: rtsp://admin:password@192.168.1.123/cam/realmonitor?channel=1&subtype=0
+homekit:
+  dahua1:  # same stream ID from streams list, default PIN - 19550224
+```
+
+**Full config**
+
+```yaml
+streams:
+  dahua1:
+    - rtsp://admin:password@192.168.1.123/cam/realmonitor?channel=1&subtype=0
+    - ffmpeg:dahua1#video=h264#hardware  # if your camera doesn't support H264, important for HomeKit
+    - ffmpeg:dahua1#audio=opus           # only OPUS audio supported by HomeKit
+
+homekit:
+  dahua1:                   # same stream ID from streams list
+    pin: 12345678           # custom PIN, default: 19550224
+    name: Dahua camera      # custom camera name, default: generated from stream ID
+    device_id: dahua1       # custom ID, default: generated from stream ID
+    device_private: dahua1  # custom key, default: generated from stream ID
+```
+
+**Proxy HomeKit camera**
+
+- Video stream from HomeKit camera to Apple device (iPhone, Apple TV) will be transmitted directly
+- Video stream from HomeKit camera to RTSP/WebRTC/MP4/etc. will be transmitted via go2rtc
+
+```yaml
+streams:
+  aqara1:
+    - homekit://...
+    - ffmpeg:aqara1#audio=aac#audio=opus  # optional audio transcoding
+
+homekit:
+  aqara1:  # same stream ID from streams list
+```
diff --git a/installs_on_host/go2rtc/internal/homekit/api.go b/installs_on_host/go2rtc/internal/homekit/api.go
new file mode 100644
index 0000000..885a40f
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/homekit/api.go
@@ -0,0 +1,181 @@
+package homekit
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/hap"
+	"github.com/AlexxIT/go2rtc/pkg/mdns"
+)
+
+func apiDiscovery(w http.ResponseWriter, r *http.Request) {
+	sources, err := discovery()
+	if err != nil {
+		api.Error(w, err)
+		return
+	}
+
+	urls := findHomeKitURLs()
+	for id, u := range urls {
+		deviceID := u.Query().Get("device_id")
+		for _, source := range sources {
+			if strings.Contains(source.URL, deviceID) {
+				source.Location = id
+				break
+			}
+		}
+	}
+
+	for _, source := range sources {
+		if source.Location == "" {
+			source.Location = " "
+		}
+	}
+
+	api.ResponseSources(w, sources)
+}
+
+func apiHomekit(w http.ResponseWriter, r *http.Request) {
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	switch r.Method {
+	case "GET":
+		if id := r.Form.Get("id"); id != "" {
+			if srv := servers[id]; srv != nil {
+				api.ResponsePrettyJSON(w, srv)
+			} else {
+				http.Error(w, "server not found", http.StatusNotFound)
+			}
+		} else {
+			api.ResponsePrettyJSON(w, servers)
+		}
+
+	case "POST":
+		id := r.Form.Get("id")
+		rawURL := r.Form.Get("src") + "&pin=" + r.Form.Get("pin")
+		if err := apiPair(id, rawURL); err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+		}
+
+	case "DELETE":
+		id := r.Form.Get("id")
+		if err := apiUnpair(id); err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+		}
+	}
+}
+
+func apiHomekitAccessories(w http.ResponseWriter, r *http.Request) {
+	id := r.URL.Query().Get("id")
+	stream := streams.Get(id)
+	if stream == nil {
+		http.Error(w, "", http.StatusNotFound)
+		return
+	}
+
+	rawURL := findHomeKitURL(stream.Sources())
+	if rawURL == "" {
+		http.Error(w, "", http.StatusBadRequest)
+		return
+	}
+
+	client, err := hap.Dial(rawURL)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	defer client.Close()
+
+	res, err := client.Get(hap.PathAccessories)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", api.MimeJSON)
+	_, _ = io.Copy(w, res.Body)
+}
+
+func discovery() ([]*api.Source, error) {
+	var sources []*api.Source
+
+	// 1. Get streams from Discovery
+	err := mdns.Discovery(mdns.ServiceHAP, func(entry *mdns.ServiceEntry) bool {
+		log.Trace().Msgf("[homekit] mdns=%s", entry)
+
+		category := entry.Info[hap.TXTCategory]
+		if entry.Complete() && (category == hap.CategoryCamera || category == hap.CategoryDoorbell) {
+			source := &api.Source{
+				Name: entry.Name,
+				Info: entry.Info[hap.TXTModel],
+				URL: fmt.Sprintf(
+					"homekit://%s:%d?device_id=%s&feature=%s&status=%s",
+					entry.IP, entry.Port, entry.Info[hap.TXTDeviceID],
+					entry.Info[hap.TXTFeatureFlags], entry.Info[hap.TXTStatusFlags],
+				),
+			}
+
+			sources = append(sources, source)
+		}
+		return false
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return sources, nil
+}
+
+func apiPair(id, url string) error {
+	conn, err := hap.Pair(url)
+	if err != nil {
+		return err
+	}
+
+	streams.New(id, conn.URL())
+
+	return app.PatchConfig([]string{"streams", id}, conn.URL())
+}
+
+func apiUnpair(id string) error {
+	stream := streams.Get(id)
+	if stream == nil {
+		return errors.New(api.StreamNotFound)
+	}
+
+	rawURL := findHomeKitURL(stream.Sources())
+	if rawURL == "" {
+		return errors.New("not homekit source")
+	}
+
+	if err := hap.Unpair(rawURL); err != nil {
+		return err
+	}
+
+	streams.Delete(id)
+
+	return app.PatchConfig([]string{"streams", id}, nil)
+}
+
+func findHomeKitURLs() map[string]*url.URL {
+	urls := map[string]*url.URL{}
+	for name, sources := range streams.GetAllSources() {
+		if rawURL := findHomeKitURL(sources); rawURL != "" {
+			if u, err := url.Parse(rawURL); err == nil {
+				urls[name] = u
+			}
+		}
+	}
+	return urls
+}
diff --git a/installs_on_host/go2rtc/internal/homekit/homekit.go b/installs_on_host/go2rtc/internal/homekit/homekit.go
new file mode 100644
index 0000000..59b84b3
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/homekit/homekit.go
@@ -0,0 +1,211 @@
+package homekit
+
+import (
+	"errors"
+	"net/http"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/srtp"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/hap"
+	"github.com/AlexxIT/go2rtc/pkg/hap/camera"
+	"github.com/AlexxIT/go2rtc/pkg/homekit"
+	"github.com/AlexxIT/go2rtc/pkg/mdns"
+	"github.com/rs/zerolog"
+)
+
+func Init() {
+	var cfg struct {
+		Mod map[string]struct {
+			Pin           string   `yaml:"pin"`
+			Name          string   `yaml:"name"`
+			DeviceID      string   `yaml:"device_id"`
+			DevicePrivate string   `yaml:"device_private"`
+			CategoryID    string   `yaml:"category_id"`
+			Pairings      []string `yaml:"pairings"`
+		} `yaml:"homekit"`
+	}
+	app.LoadConfig(&cfg)
+
+	log = app.GetLogger("homekit")
+
+	streams.HandleFunc("homekit", streamHandler)
+
+	api.HandleFunc("api/homekit", apiHomekit)
+	api.HandleFunc("api/homekit/accessories", apiHomekitAccessories)
+	api.HandleFunc("api/discovery/homekit", apiDiscovery)
+
+	if cfg.Mod == nil {
+		return
+	}
+
+	hosts = map[string]*server{}
+	servers = map[string]*server{}
+	var entries []*mdns.ServiceEntry
+
+	for id, conf := range cfg.Mod {
+		stream := streams.Get(id)
+		if stream == nil {
+			log.Warn().Msgf("[homekit] missing stream: %s", id)
+			continue
+		}
+
+		if conf.Pin == "" {
+			conf.Pin = "19550224" // default PIN
+		}
+
+		pin, err := hap.SanitizePin(conf.Pin)
+		if err != nil {
+			log.Error().Err(err).Caller().Send()
+			continue
+		}
+
+		deviceID := calcDeviceID(conf.DeviceID, id) // random MAC-address
+		name := calcName(conf.Name, deviceID)
+		setupID := calcSetupID(id)
+
+		srv := &server{
+			stream:   id,
+			pairings: conf.Pairings,
+			setupID:  setupID,
+		}
+
+		srv.hap = &hap.Server{
+			Pin:             pin,
+			DeviceID:        deviceID,
+			DevicePrivate:   calcDevicePrivate(conf.DevicePrivate, id),
+			GetClientPublic: srv.GetPair,
+		}
+
+		srv.mdns = &mdns.ServiceEntry{
+			Name: name,
+			Port: uint16(api.Port),
+			Info: map[string]string{
+				hap.TXTConfigNumber: "1",
+				hap.TXTFeatureFlags: "0",
+				hap.TXTDeviceID:     deviceID,
+				hap.TXTModel:        app.UserAgent,
+				hap.TXTProtoVersion: "1.1",
+				hap.TXTStateNumber:  "1",
+				hap.TXTStatusFlags:  hap.StatusNotPaired,
+				hap.TXTCategory:     calcCategoryID(conf.CategoryID),
+				hap.TXTSetupHash:    hap.SetupHash(setupID, deviceID),
+			},
+		}
+		entries = append(entries, srv.mdns)
+
+		srv.UpdateStatus()
+
+		if url := findHomeKitURL(stream.Sources()); url != "" {
+			// 1. Act as transparent proxy for HomeKit camera
+			srv.proxyURL = url
+		} else {
+			// 2. Act as basic HomeKit camera
+			srv.accessory = camera.NewAccessory("AlexxIT", "go2rtc", name, "-", app.Version)
+		}
+
+		host := srv.mdns.Host(mdns.ServiceHAP)
+		hosts[host] = srv
+		servers[id] = srv
+
+		log.Trace().Msgf("[homekit] new server: %s", srv.mdns)
+	}
+
+	api.HandleFunc(hap.PathPairSetup, hapHandler)
+	api.HandleFunc(hap.PathPairVerify, hapHandler)
+
+	go func() {
+		if err := mdns.Serve(mdns.ServiceHAP, entries); err != nil {
+			log.Error().Err(err).Caller().Send()
+		}
+	}()
+}
+
+var log zerolog.Logger
+var hosts map[string]*server
+var servers map[string]*server
+
+func streamHandler(rawURL string) (core.Producer, error) {
+	if srtp.Server == nil {
+		return nil, errors.New("homekit: can't work without SRTP server")
+	}
+
+	rawURL, rawQuery, _ := strings.Cut(rawURL, "#")
+	client, err := homekit.Dial(rawURL, srtp.Server)
+	if client != nil && rawQuery != "" {
+		query := streams.ParseQuery(rawQuery)
+		client.MaxWidth = core.Atoi(query.Get("maxwidth"))
+		client.MaxHeight = core.Atoi(query.Get("maxheight"))
+		client.Bitrate = parseBitrate(query.Get("bitrate"))
+	}
+
+	return client, err
+}
+
+func resolve(host string) *server {
+	if len(hosts) == 1 {
+		for _, srv := range hosts {
+			return srv
+		}
+	}
+	if srv, ok := hosts[host]; ok {
+		return srv
+	}
+	return nil
+}
+
+func hapHandler(w http.ResponseWriter, r *http.Request) {
+	// Can support multiple HomeKit cameras on single port ONLY for Apple devices.
+	// Doesn't support Home Assistant and any other open source projects
+	// because they don't send the host header in requests.
+	srv := resolve(r.Host)
+	if srv == nil {
+		log.Error().Msg("[homekit] unknown host: " + r.Host)
+		return
+	}
+	srv.Handle(w, r)
+}
+
+func findHomeKitURL(sources []string) string {
+	if len(sources) == 0 {
+		return ""
+	}
+
+	url := sources[0]
+	if strings.HasPrefix(url, "homekit") {
+		return url
+	}
+
+	if strings.HasPrefix(url, "hass") {
+		location, _ := streams.Location(url)
+		if strings.HasPrefix(location, "homekit") {
+			return location
+		}
+	}
+
+	return ""
+}
+
+func parseBitrate(s string) int {
+	n := len(s)
+	if n == 0 {
+		return 0
+	}
+
+	var k int
+	switch n--; s[n] {
+	case 'K':
+		k = 1024
+		s = s[:n]
+	case 'M':
+		k = 1024 * 1024
+		s = s[:n]
+	default:
+		k = 1
+	}
+
+	return k * core.Atoi(s)
+}
diff --git a/installs_on_host/go2rtc/internal/homekit/server.go b/installs_on_host/go2rtc/internal/homekit/server.go
new file mode 100644
index 0000000..86cfbc1
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/homekit/server.go
@@ -0,0 +1,405 @@
+package homekit
+
+import (
+	"crypto/ed25519"
+	"crypto/sha512"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"slices"
+	"strings"
+	"sync"
+
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/ffmpeg"
+	srtp2 "github.com/AlexxIT/go2rtc/internal/srtp"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/hap"
+	"github.com/AlexxIT/go2rtc/pkg/hap/camera"
+	"github.com/AlexxIT/go2rtc/pkg/hap/hds"
+	"github.com/AlexxIT/go2rtc/pkg/hap/tlv8"
+	"github.com/AlexxIT/go2rtc/pkg/homekit"
+	"github.com/AlexxIT/go2rtc/pkg/magic"
+	"github.com/AlexxIT/go2rtc/pkg/mdns"
+)
+
+type server struct {
+	hap  *hap.Server // server for HAP connection and encryption
+	mdns *mdns.ServiceEntry
+
+	pairings []string // pairings list
+	conns    []any
+	mu       sync.Mutex
+
+	accessory *hap.Accessory // HAP accessory
+	consumer  *homekit.Consumer
+	proxyURL  string
+	setupID   string
+	stream    string // stream name from YAML
+}
+
+func (s *server) MarshalJSON() ([]byte, error) {
+	v := struct {
+		Name       string `json:"name"`
+		DeviceID   string `json:"device_id"`
+		Paired     int    `json:"paired,omitempty"`
+		CategoryID string `json:"category_id,omitempty"`
+		SetupCode  string `json:"setup_code,omitempty"`
+		SetupID    string `json:"setup_id,omitempty"`
+		Conns      []any  `json:"connections,omitempty"`
+	}{
+		Name:       s.mdns.Name,
+		DeviceID:   s.mdns.Info[hap.TXTDeviceID],
+		CategoryID: s.mdns.Info[hap.TXTCategory],
+		Paired:     len(s.pairings),
+		Conns:      s.conns,
+	}
+	if v.Paired == 0 {
+		v.SetupCode = s.hap.Pin
+		v.SetupID = s.setupID
+	}
+	return json.Marshal(v)
+}
+
+func (s *server) Handle(w http.ResponseWriter, r *http.Request) {
+	conn, rw, err := w.(http.Hijacker).Hijack()
+	if err != nil {
+		return
+	}
+
+	defer conn.Close()
+
+	// Fix reading from Body after Hijack.
+	r.Body = io.NopCloser(rw)
+
+	switch r.RequestURI {
+	case hap.PathPairSetup:
+		id, key, err := s.hap.PairSetup(r, rw)
+		if err != nil {
+			log.Error().Err(err).Caller().Send()
+			return
+		}
+
+		s.AddPair(id, key, hap.PermissionAdmin)
+
+	case hap.PathPairVerify:
+		id, key, err := s.hap.PairVerify(r, rw)
+		if err != nil {
+			log.Debug().Err(err).Caller().Send()
+			return
+		}
+
+		log.Debug().Str("stream", s.stream).Str("client_id", id).Msgf("[homekit] %s: new conn", conn.RemoteAddr())
+
+		controller, err := hap.NewConn(conn, rw, key, false)
+		if err != nil {
+			log.Error().Err(err).Caller().Send()
+			return
+		}
+
+		s.AddConn(controller)
+		defer s.DelConn(controller)
+
+		var handler homekit.HandlerFunc
+
+		switch {
+		case s.accessory != nil:
+			handler = homekit.ServerHandler(s)
+		case s.proxyURL != "":
+			client, err := hap.Dial(s.proxyURL)
+			if err != nil {
+				log.Error().Err(err).Caller().Send()
+				return
+			}
+			handler = homekit.ProxyHandler(s, client.Conn)
+		}
+
+		// If your iPhone goes to sleep, it will be an EOF error.
+		if err = handler(controller); err != nil && !errors.Is(err, io.EOF) {
+			log.Error().Err(err).Caller().Send()
+			return
+		}
+	}
+}
+
+type logger struct {
+	v any
+}
+
+func (l logger) String() string {
+	switch v := l.v.(type) {
+	case *hap.Conn:
+		return "hap " + v.RemoteAddr().String()
+	case *hds.Conn:
+		return "hds " + v.RemoteAddr().String()
+	case *homekit.Consumer:
+		return "rtp " + v.RemoteAddr
+	}
+	return "unknown"
+}
+
+func (s *server) AddConn(v any) {
+	log.Trace().Str("stream", s.stream).Msgf("[homekit] add conn %s", logger{v})
+	s.mu.Lock()
+	s.conns = append(s.conns, v)
+	s.mu.Unlock()
+}
+
+func (s *server) DelConn(v any) {
+	log.Trace().Str("stream", s.stream).Msgf("[homekit] del conn %s", logger{v})
+	s.mu.Lock()
+	if i := slices.Index(s.conns, v); i >= 0 {
+		s.conns = slices.Delete(s.conns, i, i+1)
+	}
+	s.mu.Unlock()
+}
+
+func (s *server) UpdateStatus() {
+	// true status is important, or device may be offline in Apple Home
+	if len(s.pairings) == 0 {
+		s.mdns.Info[hap.TXTStatusFlags] = hap.StatusNotPaired
+	} else {
+		s.mdns.Info[hap.TXTStatusFlags] = hap.StatusPaired
+	}
+}
+
+func (s *server) pairIndex(id string) int {
+	id = "client_id=" + id
+	for i, pairing := range s.pairings {
+		if strings.HasPrefix(pairing, id) {
+			return i
+		}
+	}
+	return -1
+}
+
+func (s *server) GetPair(id string) []byte {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if i := s.pairIndex(id); i >= 0 {
+		query, _ := url.ParseQuery(s.pairings[i])
+		b, _ := hex.DecodeString(query.Get("client_public"))
+		return b
+	}
+	return nil
+}
+
+func (s *server) AddPair(id string, public []byte, permissions byte) {
+	log.Debug().Str("stream", s.stream).Msgf("[homekit] add pair id=%s public=%x perm=%d", id, public, permissions)
+
+	s.mu.Lock()
+	if s.pairIndex(id) < 0 {
+		s.pairings = append(s.pairings, fmt.Sprintf(
+			"client_id=%s&client_public=%x&permissions=%d", id, public, permissions,
+		))
+		s.UpdateStatus()
+		s.PatchConfig()
+	}
+	s.mu.Unlock()
+}
+
+func (s *server) DelPair(id string) {
+	log.Debug().Str("stream", s.stream).Msgf("[homekit] del pair id=%s", id)
+
+	s.mu.Lock()
+	if i := s.pairIndex(id); i >= 0 {
+		s.pairings = append(s.pairings[:i], s.pairings[i+1:]...)
+		s.UpdateStatus()
+		s.PatchConfig()
+	}
+	s.mu.Unlock()
+}
+
+func (s *server) PatchConfig() {
+	if err := app.PatchConfig([]string{"homekit", s.stream, "pairings"}, s.pairings); err != nil {
+		log.Error().Err(err).Msgf(
+			"[homekit] can't save %s pairings=%v", s.stream, s.pairings,
+		)
+	}
+}
+
+func (s *server) GetAccessories(_ net.Conn) []*hap.Accessory {
+	return []*hap.Accessory{s.accessory}
+}
+
+func (s *server) GetCharacteristic(conn net.Conn, aid uint8, iid uint64) any {
+	log.Trace().Str("stream", s.stream).Msgf("[homekit] get char aid=%d iid=0x%x", aid, iid)
+
+	char := s.accessory.GetCharacterByID(iid)
+	if char == nil {
+		log.Warn().Msgf("[homekit] get unknown characteristic: %d", iid)
+		return nil
+	}
+
+	switch char.Type {
+	case camera.TypeSetupEndpoints:
+		consumer := s.consumer
+		if consumer == nil {
+			return nil
+		}
+
+		answer := consumer.GetAnswer()
+		v, err := tlv8.MarshalBase64(answer)
+		if err != nil {
+			return nil
+		}
+
+		return v
+	}
+
+	return char.Value
+}
+
+func (s *server) SetCharacteristic(conn net.Conn, aid uint8, iid uint64, value any) {
+	log.Trace().Str("stream", s.stream).Msgf("[homekit] set char aid=%d iid=0x%x value=%v", aid, iid, value)
+
+	char := s.accessory.GetCharacterByID(iid)
+	if char == nil {
+		log.Warn().Msgf("[homekit] set unknown characteristic: %d", iid)
+		return
+	}
+
+	switch char.Type {
+	case camera.TypeSetupEndpoints:
+		var offer camera.SetupEndpointsRequest
+		if err := tlv8.UnmarshalBase64(value, &offer); err != nil {
+			return
+		}
+
+		consumer := homekit.NewConsumer(conn, srtp2.Server)
+		consumer.SetOffer(&offer)
+		s.consumer = consumer
+
+	case camera.TypeSelectedStreamConfiguration:
+		var conf camera.SelectedStreamConfiguration
+		if err := tlv8.UnmarshalBase64(value, &conf); err != nil {
+			return
+		}
+
+		log.Trace().Str("stream", s.stream).Msgf("[homekit] stream id=%x cmd=%d", conf.Control.SessionID, conf.Control.Command)
+
+		switch conf.Control.Command {
+		case camera.SessionCommandEnd:
+			for _, consumer := range s.conns {
+				if consumer, ok := consumer.(*homekit.Consumer); ok {
+					if consumer.SessionID() == conf.Control.SessionID {
+						_ = consumer.Stop()
+						return
+					}
+				}
+			}
+
+		case camera.SessionCommandStart:
+			consumer := s.consumer
+			if consumer == nil {
+				return
+			}
+
+			if !consumer.SetConfig(&conf) {
+				log.Warn().Msgf("[homekit] wrong config")
+				return
+			}
+
+			s.AddConn(consumer)
+
+			stream := streams.Get(s.stream)
+			if err := stream.AddConsumer(consumer); err != nil {
+				return
+			}
+
+			go func() {
+				_, _ = consumer.WriteTo(nil)
+				stream.RemoveConsumer(consumer)
+
+				s.DelConn(consumer)
+			}()
+		}
+	}
+}
+
+func (s *server) GetImage(conn net.Conn, width, height int) []byte {
+	log.Trace().Str("stream", s.stream).Msgf("[homekit] get image width=%d height=%d", width, height)
+
+	stream := streams.Get(s.stream)
+	cons := magic.NewKeyframe()
+
+	if err := stream.AddConsumer(cons); err != nil {
+		return nil
+	}
+
+	once := &core.OnceBuffer{} // init and first frame
+	_, _ = cons.WriteTo(once)
+	b := once.Buffer()
+
+	stream.RemoveConsumer(cons)
+
+	switch cons.CodecName() {
+	case core.CodecH264, core.CodecH265:
+		var err error
+		if b, err = ffmpeg.JPEGWithScale(b, width, height); err != nil {
+			return nil
+		}
+	}
+
+	return b
+}
+
+func calcName(name, seed string) string {
+	if name != "" {
+		return name
+	}
+	b := sha512.Sum512([]byte(seed))
+	return fmt.Sprintf("go2rtc-%02X%02X", b[0], b[2])
+}
+
+func calcDeviceID(deviceID, seed string) string {
+	if deviceID != "" {
+		if len(deviceID) >= 17 {
+			// 1. Returd device_id as is (ex. AA:BB:CC:DD:EE:FF)
+			return deviceID
+		}
+		// 2. Use device_id as seed if not zero
+		seed = deviceID
+	}
+	b := sha512.Sum512([]byte(seed))
+	return fmt.Sprintf("%02X:%02X:%02X:%02X:%02X:%02X", b[32], b[34], b[36], b[38], b[40], b[42])
+}
+
+func calcDevicePrivate(private, seed string) []byte {
+	if private != "" {
+		// 1. Decode private from HEX string
+		if b, _ := hex.DecodeString(private); len(b) == ed25519.PrivateKeySize {
+			// 2. Return if OK
+			return b
+		}
+		// 3. Use private as seed if not zero
+		seed = private
+	}
+	b := sha512.Sum512([]byte(seed))
+	return ed25519.NewKeyFromSeed(b[:ed25519.SeedSize])
+}
+
+func calcSetupID(seed string) string {
+	b := sha512.Sum512([]byte(seed))
+	return fmt.Sprintf("%02X%02X", b[44], b[46])
+}
+
+func calcCategoryID(categoryID string) string {
+	switch categoryID {
+	case "bridge":
+		return hap.CategoryBridge
+	case "doorbell":
+		return hap.CategoryDoorbell
+	}
+	if core.Atoi(categoryID) > 0 {
+		return categoryID
+	}
+	return hap.CategoryCamera
+}
diff --git a/installs_on_host/go2rtc/internal/http/README.md b/installs_on_host/go2rtc/internal/http/README.md
new file mode 100644
index 0000000..b8147b6
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/http/README.md
@@ -0,0 +1,47 @@
+# HTTP
+
+This source supports receiving a stream via an HTTP link.
+
+It can determine the source format from the`Content-Type` HTTP header:
+
+- **HTTP-JPEG** (`image/jpeg`) - camera snapshot link, can be converted by go2rtc to MJPEG stream
+- **HTTP-MJPEG** (`multipart/x-mixed-replace`) - A continuous sequence of JPEG frames (with HTTP headers).
+- **HLS** (`application/vnd.apple.mpegurl`) - A popular [HTTP Live Streaming](https://en.wikipedia.org/wiki/HTTP_Live_Streaming) (HLS) format, which is not designed for real-time media transmission.
+
+> [!WARNING]
+> The HLS format is not designed for real time and is supported quite poorly. It is recommended to use it via ffmpeg source with buffering enabled (disabled by default).
+
+## TCP
+
+Source also supports HTTP and TCP streams with autodetection for different formats:
+
+- `adts` - Audio stream in [AAC](https://en.wikipedia.org/wiki/Advanced_Audio_Coding) codec with Audio Data Transport Stream (ADTS) headers.
+- `flv` - The legacy but still used [Flash Video](https://en.wikipedia.org/wiki/Flash_Video) format.
+- `h264` - AVC/H.264 bitstream.
+- `hevc` - HEVC/H.265 bitstream.
+- `mjpeg` - A continuous sequence of JPEG frames (without HTTP headers).
+- `mpegts` - The legacy [MPEG transport stream](https://en.wikipedia.org/wiki/MPEG_transport_stream) format.
+- `wav` - Audio stream in [WAV](https://en.wikipedia.org/wiki/WAV) format.
+- `yuv4mpegpipe` - Raw YUV frame stream with YUV4MPEG header.
+
+## Configuration
+
+```yaml
+streams:
+  # [HTTP-FLV] stream in video/x-flv format
+  http_flv: http://192.168.1.123:20880/api/camera/stream/780900131155/657617
+  
+  # [JPEG] snapshots from Dahua camera, will be converted to MJPEG stream
+  dahua_snap: http://admin:password@192.168.1.123/cgi-bin/snapshot.cgi?channel=1
+
+  # [MJPEG] stream will be proxied without modification
+  http_mjpeg: https://mjpeg.sanford.io/count.mjpeg
+
+  # [MJPEG or H.264/H.265 bitstream or MPEG-TS]
+  tcp_magic: tcp://192.168.1.123:12345
+
+  # Add custom header
+  custom_header: "https://mjpeg.sanford.io/count.mjpeg#header=Authorization: Bearer XXX"
+```
+
+**PS.** Dahua camera has a bug: if you select MJPEG codec for RTSP second stream, snapshot won't work.
diff --git a/installs_on_host/go2rtc/internal/http/http.go b/installs_on_host/go2rtc/internal/http/http.go
new file mode 100644
index 0000000..4b0560c
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/http/http.go
@@ -0,0 +1,134 @@
+package http
+
+import (
+	"errors"
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/hls"
+	"github.com/AlexxIT/go2rtc/pkg/image"
+	"github.com/AlexxIT/go2rtc/pkg/magic"
+	"github.com/AlexxIT/go2rtc/pkg/mpjpeg"
+	"github.com/AlexxIT/go2rtc/pkg/pcm"
+	"github.com/AlexxIT/go2rtc/pkg/tcp"
+)
+
+func Init() {
+	streams.HandleFunc("http", handleHTTP)
+	streams.HandleFunc("https", handleHTTP)
+	streams.HandleFunc("httpx", handleHTTP)
+
+	streams.HandleFunc("tcp", handleTCP)
+
+	api.HandleFunc("api/stream", apiStream)
+}
+
+func handleHTTP(rawURL string) (core.Producer, error) {
+	rawURL, rawQuery, _ := strings.Cut(rawURL, "#")
+
+	// first we get the Content-Type to define supported producer
+	req, err := http.NewRequest("GET", rawURL, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	if rawQuery != "" {
+		query := streams.ParseQuery(rawQuery)
+
+		for _, header := range query["header"] {
+			key, value, _ := strings.Cut(header, ":")
+			req.Header.Add(key, strings.TrimSpace(value))
+		}
+	}
+
+	prod, err := do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	if info, ok := prod.(core.Info); ok {
+		info.SetProtocol("http")
+		info.SetRemoteAddr(req.URL.Host) // TODO: rewrite to net.Conn
+		info.SetURL(rawURL)
+	}
+
+	return prod, nil
+}
+
+func do(req *http.Request) (core.Producer, error) {
+	res, err := tcp.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	if res.StatusCode != http.StatusOK {
+		return nil, errors.New(res.Status)
+	}
+
+	// 1. Guess format from content type
+	ct := res.Header.Get("Content-Type")
+	if i := strings.IndexByte(ct, ';'); i > 0 {
+		ct = ct[:i]
+	}
+
+	var ext string
+	if i := strings.LastIndexByte(req.URL.Path, '.'); i > 0 {
+		ext = req.URL.Path[i+1:]
+	}
+
+	switch {
+	case ct == "application/vnd.apple.mpegurl" || ext == "m3u8":
+		return hls.OpenURL(req.URL, res.Body)
+	case ct == "image/jpeg":
+		return image.Open(res)
+	case ct == "multipart/x-mixed-replace":
+		return mpjpeg.Open(res.Body)
+	//https://www.iana.org/assignments/media-types/audio/basic
+	case ct == "audio/basic":
+		return pcm.Open(res.Body)
+	}
+
+	return magic.Open(res.Body)
+}
+
+func handleTCP(rawURL string) (core.Producer, error) {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	conn, err := net.DialTimeout("tcp", u.Host, core.ConnDialTimeout)
+	if err != nil {
+		return nil, err
+	}
+
+	return magic.Open(conn)
+}
+
+func apiStream(w http.ResponseWriter, r *http.Request) {
+	dst := r.URL.Query().Get("dst")
+	stream := streams.Get(dst)
+	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
+		return
+	}
+
+	client, err := magic.Open(r.Body)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	stream.AddProducer(client)
+	defer stream.RemoveProducer(client)
+
+	if err = client.Start(); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+}
diff --git a/installs_on_host/go2rtc/internal/isapi/README.md b/installs_on_host/go2rtc/internal/isapi/README.md
new file mode 100644
index 0000000..63892f7
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/isapi/README.md
@@ -0,0 +1,14 @@
+# Hikvision ISAPI
+
+[`new in v1.3.0`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.3.0)
+
+This source type supports only backchannel audio for the [Hikvision ISAPI](https://tpp.hikvision.com/download/ISAPI_OTAP) protocol. So it should be used as a second source in addition to the RTSP protocol.
+
+## Configuration
+
+```yaml
+streams:
+  hikvision1:
+    - rtsp://admin:password@192.168.1.123:554/Streaming/Channels/101
+    - isapi://admin:password@192.168.1.123:80/
+```
diff --git a/installs_on_host/go2rtc/internal/isapi/init.go b/installs_on_host/go2rtc/internal/isapi/init.go
new file mode 100644
index 0000000..887a674
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/isapi/init.go
@@ -0,0 +1,13 @@
+package isapi
+
+import (
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/isapi"
+)
+
+func Init() {
+	streams.HandleFunc("isapi", func(source string) (core.Producer, error) {
+		return isapi.Dial(source)
+	})
+}
diff --git a/installs_on_host/go2rtc/internal/ivideon/README.md b/installs_on_host/go2rtc/internal/ivideon/README.md
new file mode 100644
index 0000000..9974d0d
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ivideon/README.md
@@ -0,0 +1,10 @@
+# Ivideon
+
+Support public cameras from the service [Ivideon](https://tv.ivideon.com/).
+
+## Configuration
+
+```yaml
+streams:
+  quailcam: ivideon:100-tu5dkUPct39cTp9oNEN2B6/0
+```
diff --git a/installs_on_host/go2rtc/internal/ivideon/ivideon.go b/installs_on_host/go2rtc/internal/ivideon/ivideon.go
new file mode 100644
index 0000000..51ddb89
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ivideon/ivideon.go
@@ -0,0 +1,10 @@
+package ivideon
+
+import (
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/ivideon"
+)
+
+func Init() {
+	streams.HandleFunc("ivideon", ivideon.Dial)
+}
diff --git a/installs_on_host/go2rtc/internal/kasa/README.md b/installs_on_host/go2rtc/internal/kasa/README.md
new file mode 100644
index 0000000..0ce115e
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/kasa/README.md
@@ -0,0 +1,15 @@
+# TP-Link Kasa
+
+[`new in v1.7.0`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.7.0)
+
+[TP-Link Kasa](https://www.kasasmart.com/) non-standard protocol [more info](https://medium.com/@hu3vjeen/reverse-engineering-tp-link-kc100-bac4641bf1cd).
+
+- `username` - urlsafe email, `alex@gmail.com` -> `alex%40gmail.com`
+- `password` - base64password, `secret1` -> `c2VjcmV0MQ==`
+
+```yaml
+streams:
+  kc401: kasa://username:password@192.168.1.123:19443/https/stream/mixed
+```
+
+Tested: KD110, KC200, KC401, KC420WS, EC71.
diff --git a/installs_on_host/go2rtc/internal/kasa/kasa.go b/installs_on_host/go2rtc/internal/kasa/kasa.go
new file mode 100644
index 0000000..11f5c98
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/kasa/kasa.go
@@ -0,0 +1,13 @@
+package kasa
+
+import (
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/kasa"
+)
+
+func Init() {
+	streams.HandleFunc("kasa", func(source string) (core.Producer, error) {
+		return kasa.Dial(source)
+	})
+}
diff --git a/installs_on_host/go2rtc/internal/mjpeg/README.md b/installs_on_host/go2rtc/internal/mjpeg/README.md
new file mode 100644
index 0000000..4258c41
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/mjpeg/README.md
@@ -0,0 +1,108 @@
+# Motion JPEG
+
+- This module can provide and receive streams in MJPEG format.
+- This module is also responsible for receiving snapshots in JPEG format.
+- This module also supports streaming to the server console (terminal) in the **animated ASCII art** format.
+
+## MJPEG Client
+
+**Important.** For a stream in MJPEG format, your source MUST contain the MJPEG codec. If your stream has the MJPEG codec, you can receive an **MJPEG stream** or **JPEG snapshots** via the API.
+
+You can receive an MJPEG stream in several ways:
+
+- some cameras support MJPEG codec inside [RTSP stream](../rtsp/README.md) (ex. second stream for Dahua cameras)
+- some cameras have an HTTP link with [MJPEG stream](../http/README.md)
+- some cameras have an HTTP link with snapshots - go2rtc can convert them to [MJPEG stream](../http/README.md)
+- you can convert an H264/H265 stream from your camera via [FFmpeg integration](../ffmpeg/README.md)
+
+With this example, your stream will have both H264 and MJPEG codecs:
+
+```yaml
+streams:
+  camera1:
+    - rtsp://rtsp:12345678@192.168.1.123/av_stream/ch0
+    - ffmpeg:camera1#video=mjpeg
+```
+
+## MJPEG Server
+
+### mpjpeg
+
+Output a stream in [MJPEG](https://en.wikipedia.org/wiki/Motion_JPEG) format. In [FFmpeg](https://ffmpeg.org/), this format is called `mpjpeg` because it contains HTTP headers.
+
+```
+ffplay http://192.168.1.123:1984/api/stream.mjpeg?src=camera1
+```
+
+### jpeg
+
+Receiving a JPEG snapshot.
+
+```
+curl http://192.168.1.123:1984/api/frame.jpeg?src=camera1
+```
+
+- You can use `width`/`w` and/or `height`/`h` parameters.
+- You can use `rotate` param with `90`, `180`, `270` or `-90` values.
+- You can use `hardware`/`hw` param [read more](https://github.com/AlexxIT/go2rtc/wiki/Hardware-acceleration).
+- You can use `cache` param (`1m`, `10s`, etc.) to get a cached snapshot.
+  - The snapshot is cached only when requested with the `cache` parameter.
+  - A cached snapshot will be used if its time is not older than the time specified in the `cache` parameter.
+  - The `cache` parameter does not check the image dimensions from the cache and those specified in the query.
+
+### ascii
+
+Stream as ASCII to Terminal. This format is just for fun. You can boast to your friends that you can stream cameras even to the server console without a GUI.
+
+[![](https://img.youtube.com/vi/sHj_3h_sX7M/mqdefault.jpg)](https://www.youtube.com/watch?v=sHj_3h_sX7M)
+
+> The demo video features a combination of several settings for this format with added audio. Of course, the format doesn't support audio out of the box.
+
+**Tips**
+
+- this feature works only with MJPEG codec (use transcoding)
+- choose a low frame rate (FPS)
+- choose the width and height to fit in your terminal
+- different terminals support different numbers of colors (8, 256, rgb)
+- URL-encode the `text` parameter
+- you can stream any camera or file from disk
+
+**go2rtc.yaml** - transcoding to MJPEG, terminal size - 210x59 (16/9), fps - 10
+
+```yaml
+streams:
+  gamazda: ffmpeg:gamazda.mp4#video=mjpeg#hardware#width=210#height=59#raw=-r 10
+```
+
+**API params**
+
+- `color` - foreground color, values: empty, `8`, `256`, `rgb`, [SGR](https://en.wikipedia.org/wiki/ANSI_escape_code)
+  - example: `30` (black), `37` (white), `38;5;226` (yellow)
+- `back` - background color, values: empty, `8`, `256`, `rgb`, [SGR](https://en.wikipedia.org/wiki/ANSI_escape_code)
+  - example: `40` (black), `47` (white), `48;5;226` (yellow)
+- `text` - character set, values: empty, one character, `block`, list of chars (in order of brightness)
+  - example: `%20` (space), `block` (keyword for block elements), `ox` (two chars)
+
+**Examples**
+
+```bash
+% curl "http://192.168.1.123:1984/api/stream.ascii?src=gamazda"
+% curl "http://192.168.1.123:1984/api/stream.ascii?src=gamazda&color=256"
+% curl "http://192.168.1.123:1984/api/stream.ascii?src=gamazda&back=256&text=%20"
+% curl "http://192.168.1.123:1984/api/stream.ascii?src=gamazda&back=8&text=%20%20"
+% curl "http://192.168.1.123:1984/api/stream.ascii?src=gamazda&text=helloworld"
+```
+
+### yuv4mpegpipe
+
+Raw [YUV](https://en.wikipedia.org/wiki/Y%E2%80%B2UV) frame stream with [YUV4MPEG](https://manned.org/yuv4mpeg) header.
+
+```
+ffplay http://192.168.1.123:1984/api/stream.y4m?src=camera1
+```
+
+## Streaming ingest
+
+```shell
+ffmpeg -re -i BigBuckBunny.mp4 -c mjpeg -f mpjpeg http://localhost:1984/api/stream.mjpeg?dst=camera1
+```
diff --git a/installs_on_host/go2rtc/internal/mjpeg/mjpeg.go b/installs_on_host/go2rtc/internal/mjpeg/mjpeg.go
new file mode 100644
index 0000000..e9f973a
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/mjpeg/mjpeg.go
@@ -0,0 +1,237 @@
+package mjpeg
+
+import (
+	"errors"
+	"io"
+	"net/http"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/api/ws"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/ffmpeg"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/ascii"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/magic"
+	"github.com/AlexxIT/go2rtc/pkg/mjpeg"
+	"github.com/AlexxIT/go2rtc/pkg/mpjpeg"
+	"github.com/AlexxIT/go2rtc/pkg/y4m"
+	"github.com/rs/zerolog"
+)
+
+func Init() {
+	api.HandleFunc("api/frame.jpeg", handlerKeyframe)
+	api.HandleFunc("api/stream.mjpeg", handlerStream)
+	api.HandleFunc("api/stream.ascii", handlerStream)
+	api.HandleFunc("api/stream.y4m", apiStreamY4M)
+
+	ws.HandleFunc("mjpeg", handlerWS)
+
+	log = app.GetLogger("mjpeg")
+}
+
+var log zerolog.Logger
+
+func handlerKeyframe(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+	stream, _ := streams.GetOrPatch(query)
+	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
+		return
+	}
+
+	var b []byte
+
+	if s := query.Get("cache"); s != "" {
+		if timeout, err := time.ParseDuration(s); err == nil {
+			src := query.Get("src")
+
+			cacheMu.Lock()
+			entry, found := cache[src]
+			cacheMu.Unlock()
+
+			if found && time.Since(entry.timestamp) < timeout {
+				writeJPEGResponse(w, entry.payload)
+				return
+			}
+
+			defer func() {
+				if b == nil {
+					return
+				}
+				entry = cacheEntry{payload: b, timestamp: time.Now()}
+				cacheMu.Lock()
+				if cache == nil {
+					cache = map[string]cacheEntry{src: entry}
+				} else {
+					cache[src] = entry
+				}
+				cacheMu.Unlock()
+			}()
+		}
+	}
+
+	cons := magic.NewKeyframe()
+	cons.WithRequest(r)
+
+	if err := stream.AddConsumer(cons); err != nil {
+		log.Error().Err(err).Caller().Send()
+		return
+	}
+
+	once := &core.OnceBuffer{} // init and first frame
+	_, _ = cons.WriteTo(once)
+	b = once.Buffer()
+
+	stream.RemoveConsumer(cons)
+
+	switch cons.CodecName() {
+	case core.CodecH264, core.CodecH265:
+		ts := time.Now()
+		var err error
+		if b, err = ffmpeg.JPEGWithQuery(b, query); err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		log.Debug().Msgf("[mjpeg] transcoding time=%s", time.Since(ts))
+	case core.CodecJPEG:
+		b = mjpeg.FixJPEG(b)
+	}
+
+	writeJPEGResponse(w, b)
+}
+
+var cache map[string]cacheEntry
+var cacheMu sync.Mutex
+
+// cacheEntry represents a cached keyframe with its timestamp
+type cacheEntry struct {
+	payload   []byte
+	timestamp time.Time
+}
+
+func writeJPEGResponse(w http.ResponseWriter, b []byte) {
+	h := w.Header()
+	h.Set("Content-Type", "image/jpeg")
+	h.Set("Content-Length", strconv.Itoa(len(b)))
+	h.Set("Cache-Control", "no-cache")
+	h.Set("Connection", "close")
+	h.Set("Pragma", "no-cache")
+
+	if _, err := w.Write(b); err != nil {
+		log.Error().Err(err).Caller().Send()
+	}
+}
+
+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.Get(src)
+	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
+		return
+	}
+
+	cons := mjpeg.NewConsumer()
+	cons.WithRequest(r)
+
+	if err := stream.AddConsumer(cons); err != nil {
+		log.Error().Err(err).Msg("[api.mjpeg] add consumer")
+		return
+	}
+
+	h := w.Header()
+	h.Set("Cache-Control", "no-cache")
+	h.Set("Connection", "close")
+	h.Set("Pragma", "no-cache")
+
+	if strings.HasSuffix(r.URL.Path, "mjpeg") {
+		wr := mjpeg.NewWriter(w)
+		_, _ = cons.WriteTo(wr)
+	} else {
+		cons.FormatName = "ascii"
+
+		query := r.URL.Query()
+		wr := ascii.NewWriter(w, query.Get("color"), query.Get("back"), query.Get("text"))
+		_, _ = cons.WriteTo(wr)
+	}
+
+	stream.RemoveConsumer(cons)
+}
+
+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
+	}
+
+	prod, _ := mpjpeg.Open(r.Body)
+	prod.WithRequest(r)
+
+	stream.AddProducer(prod)
+
+	if err := prod.Start(); err != nil && err != io.EOF {
+		log.Warn().Err(err).Caller().Send()
+	}
+
+	stream.RemoveProducer(prod)
+}
+
+func handlerWS(tr *ws.Transport, _ *ws.Message) error {
+	stream, _ := streams.GetOrPatch(tr.Request.URL.Query())
+	if stream == nil {
+		return errors.New(api.StreamNotFound)
+	}
+
+	cons := mjpeg.NewConsumer()
+	cons.WithRequest(tr.Request)
+
+	if err := stream.AddConsumer(cons); err != nil {
+		log.Debug().Err(err).Msg("[mjpeg] add consumer")
+		return err
+	}
+
+	tr.Write(&ws.Message{Type: "mjpeg"})
+
+	go cons.WriteTo(tr.Writer())
+
+	tr.OnClose(func() {
+		stream.RemoveConsumer(cons)
+	})
+
+	return nil
+}
+
+func apiStreamY4M(w http.ResponseWriter, r *http.Request) {
+	src := r.URL.Query().Get("src")
+	stream := streams.Get(src)
+	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
+		return
+	}
+
+	cons := y4m.NewConsumer()
+	cons.WithRequest(r)
+
+	if err := stream.AddConsumer(cons); err != nil {
+		log.Error().Err(err).Caller().Send()
+		return
+	}
+
+	_, _ = cons.WriteTo(w)
+
+	stream.RemoveConsumer(cons)
+}
diff --git a/installs_on_host/go2rtc/internal/mp4/README.md b/installs_on_host/go2rtc/internal/mp4/README.md
new file mode 100644
index 0000000..f2e3222
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/mp4/README.md
@@ -0,0 +1,66 @@
+# MP4
+
+This module provides several features:
+
+1. MSE stream (fMP4 over WebSocket)
+2. Camera snapshots in MP4 format (single frame), can be sent to [Telegram](#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 in this case.
+
+## API examples
+
+- MP4 snapshot: `http://192.168.1.123:1984/api/frame.mp4?src=camera1` (H264, H265)
+- MP4 stream: `http://192.168.1.123:1984/api/stream.mp4?src=camera1` (H264, H265, AAC)
+- MP4 file: `http://192.168.1.123:1984/api/stream.mp4?src=camera1` (H264, H265*, AAC, OPUS, MP3, PCMA, PCMU, PCM)
+    - You can use `mp4`, `mp4=flac` and `mp4=all` param for codec filters
+    - You can use `duration` param in seconds (ex. `duration=15`)
+    - You can use `filename` param (ex. `filename=record.mp4`)
+    - You can use `rotate` param with `90`, `180` or `270` values
+    - You can use `scale` param with positive integer values (ex. `scale=4:3`)
+
+Read more about [codecs filters](../../README.md#codecs-filters).
+
+**PS.** Rotate and scale params don't use transcoding and change video using metadata.
+
+## Snapshot to Telegram
+
+This examples for Home Assistant [Telegram Bot](https://www.home-assistant.io/integrations/telegram_bot/) integration.
+
+- change `url` to your go2rtc web API (`http://localhost:1984/` for most users)
+- change `target` to your Telegram chat ID (support list)
+- change `src=camera1` to your stream name from go2rtc config
+
+**Important.** Snapshot will be near instant for most cameras and many sources, except `ffmpeg` source. Because it takes a long time for ffmpeg to start streaming with video, even when you use `#video=copy`. Also the delay can be with cameras that do not start the stream with a keyframe.
+
+### Snapshot from H264 or H265 camera
+
+```yaml
+service: telegram_bot.send_video
+data:
+  url: http://localhost:1984/api/frame.mp4?src=camera1
+  target: 123456789
+```
+
+### Record from H264 or H265 camera
+
+Record from service call to the future. Doesn't support loopback.
+
+- `mp4=flac` - adds support PCM audio family
+- `filename=record.mp4` - set name for downloaded file
+
+```yaml
+service: telegram_bot.send_video
+data:
+  url: http://localhost:1984/api/stream.mp4?src=camera1&mp4=flac&duration=5&filename=record.mp4  # duration in seconds
+  target: 123456789
+```
+
+### Snapshot from JPEG or MJPEG camera
+
+This example works via the [mjpeg](../mjpeg/README.md) module.
+
+```yaml
+service: telegram_bot.send_photo
+data:
+  url: http://localhost:1984/api/frame.jpeg?src=camera1
+  target: 123456789
+```
diff --git a/installs_on_host/go2rtc/internal/mp4/mp4.go b/installs_on_host/go2rtc/internal/mp4/mp4.go
new file mode 100644
index 0000000..d0a6d97
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/mp4/mp4.go
@@ -0,0 +1,146 @@
+package mp4
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/api/ws"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/mp4"
+	"github.com/rs/zerolog"
+)
+
+func Init() {
+	log = app.GetLogger("mp4")
+
+	ws.HandleFunc("mse", handlerWSMSE)
+	ws.HandleFunc("mp4", handlerWSMP4)
+
+	api.HandleFunc("api/frame.mp4", handlerKeyframe)
+	api.HandleFunc("api/stream.mp4", handlerMP4)
+}
+
+var log zerolog.Logger
+
+func handlerKeyframe(w http.ResponseWriter, r *http.Request) {
+	// 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
+		}
+	}
+
+	query := r.URL.Query()
+	src := query.Get("src")
+	stream := streams.Get(src)
+	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
+		return
+	}
+
+	cons := mp4.NewKeyframe(nil)
+
+	if err := stream.AddConsumer(cons); err != nil {
+		log.Error().Err(err).Caller().Send()
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	once := &core.OnceBuffer{} // init and first frame
+	_, _ = cons.WriteTo(once)
+
+	stream.RemoveConsumer(cons)
+
+	// Apple Safari won't show frame without length
+	header := w.Header()
+	header.Set("Content-Length", strconv.Itoa(once.Len()))
+	header.Set("Content-Type", mp4.ContentType(cons.Codecs()))
+
+	if filename := query.Get("filename"); filename != "" {
+		header.Set("Content-Disposition", `attachment; filename="`+filename+`"`)
+	}
+
+	if _, err := once.WriteTo(w); err != nil {
+		log.Error().Err(err).Caller().Send()
+	}
+}
+
+func handlerMP4(w http.ResponseWriter, r *http.Request) {
+	log.Trace().Msgf("[mp4] %s %+v", r.Method, r.Header)
+
+	query := r.URL.Query()
+
+	ua := r.UserAgent()
+	if strings.Contains(ua, " Safari/") && !strings.Contains(ua, " Chrome/") && !query.Has("duration") {
+		// auto redirect to HLS/fMP4 format, because Safari not support MP4 stream
+		url := "stream.m3u8?" + r.URL.RawQuery
+		if !query.Has("mp4") {
+			url += "&mp4"
+		}
+
+		http.Redirect(w, r, url, http.StatusMovedPermanently)
+		return
+	}
+
+	stream, _ := streams.GetOrPatch(query)
+	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
+		return
+	}
+
+	medias := mp4.ParseQuery(r.URL.Query())
+	cons := mp4.NewConsumer(medias)
+	cons.FormatName = "mp4"
+	cons.Protocol = "http"
+	cons.WithRequest(r)
+
+	if err := stream.AddConsumer(cons); err != nil {
+		log.Error().Err(err).Caller().Send()
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	if rotate := query.Get("rotate"); rotate != "" {
+		cons.Rotate = core.Atoi(rotate)
+	}
+
+	if scale := query.Get("scale"); scale != "" {
+		if sx, sy, ok := strings.Cut(scale, ":"); ok {
+			cons.ScaleX = core.Atoi(sx)
+			cons.ScaleY = core.Atoi(sy)
+		}
+	}
+
+	header := w.Header()
+	header.Set("Content-Type", mp4.ContentType(cons.Codecs()))
+
+	if filename := query.Get("filename"); filename != "" {
+		header.Set("Content-Disposition", `attachment; filename="`+filename+`"`)
+	}
+
+	ctx := r.Context() // handle when the client drops the connection
+
+	if i := core.Atoi(query.Get("duration")); i > 0 {
+		timeout := time.Second * time.Duration(i)
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, timeout)
+		defer cancel()
+	}
+
+	go func() {
+		<-ctx.Done()
+		_ = cons.Stop()
+		stream.RemoveConsumer(cons)
+	}()
+
+	_, _ = cons.WriteTo(w)
+}
diff --git a/installs_on_host/go2rtc/internal/mp4/ws.go b/installs_on_host/go2rtc/internal/mp4/ws.go
new file mode 100644
index 0000000..c1afac2
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/mp4/ws.go
@@ -0,0 +1,74 @@
+package mp4
+
+import (
+	"errors"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/api/ws"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/mp4"
+)
+
+func handlerWSMSE(tr *ws.Transport, msg *ws.Message) error {
+	stream, _ := streams.GetOrPatch(tr.Request.URL.Query())
+	if stream == nil {
+		return errors.New(api.StreamNotFound)
+	}
+
+	var medias []*core.Media
+	if codecs := msg.String(); codecs != "" {
+		log.Trace().Str("codecs", codecs).Msgf("[mp4] new WS/MSE consumer")
+		medias = mp4.ParseCodecs(codecs, true)
+	}
+
+	cons := mp4.NewConsumer(medias)
+	cons.FormatName = "mse/fmp4"
+	cons.WithRequest(tr.Request)
+
+	if err := stream.AddConsumer(cons); err != nil {
+		log.Debug().Err(err).Msg("[mp4] add consumer")
+		return err
+	}
+
+	tr.Write(&ws.Message{Type: "mse", Value: mp4.ContentType(cons.Codecs())})
+
+	go cons.WriteTo(tr.Writer())
+
+	tr.OnClose(func() {
+		stream.RemoveConsumer(cons)
+	})
+
+	return nil
+}
+
+func handlerWSMP4(tr *ws.Transport, msg *ws.Message) error {
+	stream, _ := streams.GetOrPatch(tr.Request.URL.Query())
+	if stream == nil {
+		return errors.New(api.StreamNotFound)
+	}
+
+	var medias []*core.Media
+	if codecs := msg.String(); codecs != "" {
+		log.Trace().Str("codecs", codecs).Msgf("[mp4] new WS/MP4 consumer")
+		medias = mp4.ParseCodecs(codecs, false)
+	}
+
+	cons := mp4.NewKeyframe(medias)
+	cons.WithRequest(tr.Request)
+
+	if err := stream.AddConsumer(cons); err != nil {
+		log.Error().Err(err).Caller().Send()
+		return err
+	}
+
+	tr.Write(&ws.Message{Type: "mse", Value: mp4.ContentType(cons.Codecs())})
+
+	go cons.WriteTo(tr.Writer())
+
+	tr.OnClose(func() {
+		stream.RemoveConsumer(cons)
+	})
+
+	return nil
+}
diff --git a/installs_on_host/go2rtc/internal/mpeg/README.md b/installs_on_host/go2rtc/internal/mpeg/README.md
new file mode 100644
index 0000000..e1c444b
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/mpeg/README.md
@@ -0,0 +1,25 @@
+# MPEG
+
+This module provides an [HTTP API](../api/README.md) for:
+ 
+- Streaming output in `mpegts` format.
+- Streaming output in `adts` format.
+- Streaming ingest in `mpegts` format.
+
+## MPEG-TS Server
+
+```shell
+ffplay http://localhost:1984/api/stream.ts?src=camera1
+```
+
+## ADTS Server
+
+```shell
+ffplay http://localhost:1984/api/stream.aac?src=camera1
+```
+
+## Streaming ingest
+
+```shell
+ffmpeg -re -i BigBuckBunny.mp4 -c copy -f mpegts http://localhost:1984/api/stream.ts?dst=camera1
+```
diff --git a/installs_on_host/go2rtc/internal/mpeg/mpeg.go b/installs_on_host/go2rtc/internal/mpeg/mpeg.go
new file mode 100644
index 0000000..0a55299
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/mpeg/mpeg.go
@@ -0,0 +1,92 @@
+package mpeg
+
+import (
+	"net/http"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/aac"
+	"github.com/AlexxIT/go2rtc/pkg/mpegts"
+)
+
+func Init() {
+	api.HandleFunc("api/stream.ts", apiHandle)
+	api.HandleFunc("api/stream.aac", apiStreamAAC)
+}
+
+func apiHandle(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		outputMpegTS(w, r)
+	} else {
+		inputMpegTS(w, r)
+	}
+}
+
+func outputMpegTS(w http.ResponseWriter, r *http.Request) {
+	src := r.URL.Query().Get("src")
+	stream := streams.Get(src)
+	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
+		return
+	}
+
+	cons := mpegts.NewConsumer()
+	cons.WithRequest(r)
+
+	if err := stream.AddConsumer(cons); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Add("Content-Type", "video/mp2t")
+
+	_, _ = cons.WriteTo(w)
+
+	stream.RemoveConsumer(cons)
+}
+
+func inputMpegTS(w http.ResponseWriter, r *http.Request) {
+	dst := r.URL.Query().Get("dst")
+	stream := streams.Get(dst)
+	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
+		return
+	}
+
+	client, err := mpegts.Open(r.Body)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	stream.AddProducer(client)
+	defer stream.RemoveProducer(client)
+
+	if err = client.Start(); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+}
+
+func apiStreamAAC(w http.ResponseWriter, r *http.Request) {
+	src := r.URL.Query().Get("src")
+	stream := streams.Get(src)
+	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
+		return
+	}
+
+	cons := aac.NewConsumer()
+	cons.WithRequest(r)
+
+	if err := stream.AddConsumer(cons); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Add("Content-Type", "audio/aac")
+
+	_, _ = cons.WriteTo(w)
+
+	stream.RemoveConsumer(cons)
+}
diff --git a/installs_on_host/go2rtc/internal/multitrans/README.md b/installs_on_host/go2rtc/internal/multitrans/README.md
new file mode 100644
index 0000000..ab3c383
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/multitrans/README.md
@@ -0,0 +1,22 @@
+# TP-Link MULTITRANS
+
+[`new in v1.9.14`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.9.14) by [@forrestsocool](https://github.com/forrestsocool)
+
+Two-way audio support for Chinese version of [TP-Link](https://www.tp-link.com.cn/) cameras.
+
+## Configuration
+
+```yaml
+streams:
+  tplink_cam:
+    # video uses standard RTSP
+    - rtsp://admin:admin@192.168.1.202:554/stream1
+    # two-way audio uses MULTITRANS schema
+    - multitrans://admin:admin@192.168.1.202:554
+```
+
+## Useful links
+
+- https://www.tp-link.com.cn/list_2549.html
+- https://github.com/AlexxIT/go2rtc/issues/1724
+- https://github.com/bingooo/hass-tplink-ipc/
diff --git a/installs_on_host/go2rtc/internal/multitrans/multitrans.go b/installs_on_host/go2rtc/internal/multitrans/multitrans.go
new file mode 100644
index 0000000..31e6a9a
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/multitrans/multitrans.go
@@ -0,0 +1,10 @@
+package multitrans
+
+import (
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/multitrans"
+)
+
+func Init() {
+	streams.HandleFunc("multitrans", multitrans.Dial)
+}
diff --git a/installs_on_host/go2rtc/internal/nest/README.md b/installs_on_host/go2rtc/internal/nest/README.md
new file mode 100644
index 0000000..d8e24d3
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/nest/README.md
@@ -0,0 +1,11 @@
+# Google Nest
+
+[`new in v1.6.0`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.6.0)
+
+For simplicity, it is recommended to connect the Nest/WebRTC camera to the [Home Assistant](../hass/README.md). 
+But if you can somehow get the below parameters, Nest/WebRTC source will work without Home Assistant.
+
+```yaml
+streams:
+  nest-doorbell: nest:?client_id=***&client_secret=***&refresh_token=***&project_id=***&device_id=***
+```
diff --git a/installs_on_host/go2rtc/internal/nest/init.go b/installs_on_host/go2rtc/internal/nest/init.go
new file mode 100644
index 0000000..8289af7
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/nest/init.go
@@ -0,0 +1,52 @@
+package nest
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/nest"
+)
+
+func Init() {
+	streams.HandleFunc("nest", func(source string) (core.Producer, error) {
+		return nest.Dial(source)
+	})
+
+	api.HandleFunc("api/nest", apiNest)
+}
+
+func apiNest(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+	cliendID := query.Get("client_id")
+	cliendSecret := query.Get("client_secret")
+	refreshToken := query.Get("refresh_token")
+	projectID := query.Get("project_id")
+
+	nestAPI, err := nest.NewAPI(cliendID, cliendSecret, refreshToken)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	devices, err := nestAPI.GetDevices(projectID)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	var items []*api.Source
+
+	for _, device := range devices {
+		query.Set("device_id", device.DeviceID)
+		query.Set("protocols", strings.Join(device.Protocols, ","))
+
+		items = append(items, &api.Source{
+			Name: device.Name, URL: "nest:?" + query.Encode(),
+		})
+	}
+
+	api.ResponseSources(w, items)
+}
diff --git a/installs_on_host/go2rtc/internal/ngrok/README.md b/installs_on_host/go2rtc/internal/ngrok/README.md
new file mode 100644
index 0000000..bc5539e
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ngrok/README.md
@@ -0,0 +1,54 @@
+# ngrok
+
+With the ngrok integration, you can get external access to your streams when your Internet connection is behind a private IP address.
+
+- you may need external access for two different things:
+    - WebRTC streams (tunnel the WebRTC TCP port, e.g. 8555)
+    - go2rtc web interface (tunnel the API HTTP port, e.g. 1984)
+- ngrok supports authorization for your web interface
+- ngrok automatically adds HTTPS to your web interface
+
+The ngrok free subscription has the following limitations:
+
+- You can reserve a free domain for serving the web interface, but the TCP address you get will always be random and will change with each restart of the ngrok agent (not a problem for WebRTC streams)
+- You can forward multiple ports from a single agent, but you can only run one ngrok agent on the free plan
+
+go2rtc will automatically get your external TCP address (if you enable it in the ngrok config) and use it for WebRTC connections (if you enable it in the WebRTC config).
+
+You need to manually download the [ngrok agent](https://ngrok.com/download) for your OS and register with the [ngrok service](https://ngrok.com/signup).
+
+**Tunnel for only WebRTC Stream**
+
+You need to add your [ngrok authtoken](https://dashboard.ngrok.com/get-started/your-authtoken) and WebRTC TCP port to YAML:
+
+```yaml
+ngrok:
+  command: ngrok tcp 8555 --authtoken eW91IHNoYWxsIG5vdCBwYXNzCnlvdSBzaGFsbCBub3QgcGFzcw
+```
+
+**Tunnel for WebRTC and Web interface**
+
+You need to create `ngrok.yaml` config file and add it to the go2rtc config:
+
+```yaml
+ngrok:
+  command: ngrok start --all --config ngrok.yaml
+```
+
+ngrok config example:
+
+```yaml
+version: "2"
+authtoken: eW91IHNoYWxsIG5vdCBwYXNzCnlvdSBzaGFsbCBub3QgcGFzcw
+tunnels:
+  api:
+    addr: 1984  # use the same port as in the go2rtc config
+    proto: http
+    basic_auth:
+      - admin:password  # you can set login/pass for your web interface
+  webrtc:
+    addr: 8555  # use the same port as in the go2rtc config
+    proto: tcp
+```
+
+See the [ngrok agent documentation](https://ngrok.com/docs/agent/config/) for more details on the ngrok configuration file.
diff --git a/installs_on_host/go2rtc/internal/ngrok/ngrok.go b/installs_on_host/go2rtc/internal/ngrok/ngrok.go
new file mode 100644
index 0000000..28b5564
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ngrok/ngrok.go
@@ -0,0 +1,84 @@
+package ngrok
+
+import (
+	"fmt"
+	"net"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/webrtc"
+	"github.com/AlexxIT/go2rtc/pkg/ngrok"
+	"github.com/rs/zerolog"
+)
+
+func Init() {
+	var cfg struct {
+		Mod struct {
+			Cmd string `yaml:"command"`
+		} `yaml:"ngrok"`
+	}
+
+	app.LoadConfig(&cfg)
+
+	if cfg.Mod.Cmd == "" {
+		return
+	}
+
+	log = app.GetLogger("ngrok")
+
+	ngr, err := ngrok.NewNgrok(cfg.Mod.Cmd)
+	if err != nil {
+		log.Error().Err(err).Msg("[ngrok] start")
+	}
+
+	ngr.Listen(func(msg any) {
+		if msg := msg.(*ngrok.Message); msg != nil {
+			if strings.HasPrefix(msg.Line, "ERROR:") {
+				log.Warn().Msg("[ngrok] " + msg.Line)
+			} else {
+				log.Debug().Msg("[ngrok] " + msg.Line)
+			}
+
+			// Addr: "//localhost:8555", URL: "tcp://1.tcp.eu.ngrok.io:12345"
+			if strings.HasPrefix(msg.Addr, "//localhost:") && strings.HasPrefix(msg.URL, "tcp://") {
+				// don't know if really necessary use IP
+				address, err := ConvertHostToIP(msg.URL[6:])
+				if err != nil {
+					log.Warn().Err(err).Msg("[ngrok] add candidate")
+					return
+				}
+
+				log.Info().Str("addr", address).Msg("[ngrok] add external candidate for WebRTC")
+
+				webrtc.AddCandidate("tcp", address)
+			}
+		}
+	})
+
+	go func() {
+		if err = ngr.Serve(); err != nil {
+			log.Error().Err(err).Msg("[ngrok] run")
+		}
+	}()
+
+}
+
+var log zerolog.Logger
+
+func ConvertHostToIP(address string) (string, error) {
+	host, port, err := net.SplitHostPort(address)
+	if err != nil {
+		return "", err
+	}
+
+	ip, err := net.LookupIP(host)
+	if err != nil {
+		return "", err
+	}
+
+	if len(ip) == 0 {
+		return "", fmt.Errorf("can't resolve: %s", host)
+	}
+
+	return ip[0].String() + ":" + port, nil
+}
diff --git a/installs_on_host/go2rtc/internal/onvif/README.md b/installs_on_host/go2rtc/internal/onvif/README.md
new file mode 100644
index 0000000..63f8b1a
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/onvif/README.md
@@ -0,0 +1,42 @@
+# ONVIF
+
+## ONVIF Client
+
+[`new in v1.5.0`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.5.0)
+
+The source is not very useful if you already know RTSP and snapshot links for your camera. But it can be useful if you don't.
+
+**WebUI > Add** webpage supports ONVIF autodiscovery. Your server must be on the same subnet as the camera. If you use Docker, you must use "network host".
+
+```yaml
+streams:
+  dahua1: onvif://admin:password@192.168.1.123
+  reolink1: onvif://admin:password@192.168.1.123:8000
+  tapo1: onvif://admin:password@192.168.1.123:2020
+```
+
+## ONVIF Server
+
+A regular camera has a single video source (`GetVideoSources`) and two profiles (`GetProfiles`).
+
+Go2rtc has one video source and one profile per stream.
+
+## Tested clients
+
+Go2rtc works as ONVIF server:
+
+- Happytime onvif client (windows)
+- Home Assistant ONVIF integration (linux)
+- Onvier (android)
+- ONVIF Device Manager (windows)
+
+PS. Supports only TCP transport for RTSP protocol. UDP and HTTP transports - unsupported yet.
+
+## Tested cameras
+
+Go2rtc works as ONVIF client:
+
+- Dahua IPC-K42
+- OpenIPC
+- Reolink RLC-520A
+- TP-Link Tapo TC60
diff --git a/installs_on_host/go2rtc/internal/onvif/onvif.go b/installs_on_host/go2rtc/internal/onvif/onvif.go
new file mode 100644
index 0000000..c305b70
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/onvif/onvif.go
@@ -0,0 +1,238 @@
+package onvif
+
+import (
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/rtsp"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/onvif"
+	"github.com/rs/zerolog"
+)
+
+func Init() {
+	log = app.GetLogger("onvif")
+
+	streams.HandleFunc("onvif", streamOnvif)
+
+	// ONVIF server on all suburls
+	api.HandleFunc("/onvif/", onvifDeviceService)
+
+	// ONVIF client autodiscovery
+	api.HandleFunc("api/onvif", apiOnvif)
+}
+
+var log zerolog.Logger
+
+func streamOnvif(rawURL string) (core.Producer, error) {
+	client, err := onvif.NewClient(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	uri, err := client.GetURI()
+	if err != nil {
+		return nil, err
+	}
+
+	// Append hash-based arguments to the retrieved URI
+	if i := strings.IndexByte(rawURL, '#'); i > 0 {
+		uri += rawURL[i:]
+	}
+
+	log.Debug().Msgf("[onvif] new uri=%s", uri)
+
+	if err = streams.Validate(uri); err != nil {
+		return nil, err
+	}
+
+	return streams.GetProducer(uri)
+}
+
+func onvifDeviceService(w http.ResponseWriter, r *http.Request) {
+	b, err := io.ReadAll(r.Body)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	operation := onvif.GetRequestAction(b)
+	if operation == "" {
+		http.Error(w, "malformed request body", http.StatusBadRequest)
+		return
+	}
+
+	log.Trace().Msgf("[onvif] server request %s %s:\n%s", r.Method, r.RequestURI, b)
+
+	switch operation {
+	case onvif.ServiceGetServiceCapabilities, // important for Hass
+		onvif.DeviceGetNetworkInterfaces, // important for Hass
+		onvif.DeviceGetSystemDateAndTime, // important for Hass
+		onvif.DeviceSetSystemDateAndTime, // return just OK
+		onvif.DeviceGetDiscoveryMode,
+		onvif.DeviceGetDNS,
+		onvif.DeviceGetHostname,
+		onvif.DeviceGetNetworkDefaultGateway,
+		onvif.DeviceGetNetworkProtocols,
+		onvif.DeviceGetNTP,
+		onvif.DeviceGetScopes,
+		onvif.MediaGetVideoEncoderConfiguration,
+		onvif.MediaGetVideoEncoderConfigurations,
+		onvif.MediaGetAudioEncoderConfigurations,
+		onvif.MediaGetVideoEncoderConfigurationOptions,
+		onvif.MediaGetAudioSources,
+		onvif.MediaGetAudioSourceConfigurations:
+		b = onvif.StaticResponse(operation)
+
+	case onvif.DeviceGetCapabilities:
+		// important for Hass: Media section
+		b = onvif.GetCapabilitiesResponse(r.Host)
+
+	case onvif.DeviceGetServices:
+		b = onvif.GetServicesResponse(r.Host)
+
+	case onvif.DeviceGetDeviceInformation:
+		// important for Hass: SerialNumber (unique server ID)
+		b = onvif.GetDeviceInformationResponse("", "go2rtc", app.Version, r.Host)
+
+	case onvif.DeviceSystemReboot:
+		b = onvif.StaticResponse(operation)
+
+		time.AfterFunc(time.Second, func() {
+			os.Exit(0)
+		})
+
+	case onvif.MediaGetVideoSources:
+		b = onvif.GetVideoSourcesResponse(streams.GetAllNames())
+
+	case onvif.MediaGetProfiles:
+		// important for Hass: H264 codec, width, height
+		b = onvif.GetProfilesResponse(streams.GetAllNames())
+
+	case onvif.MediaGetProfile:
+		token := onvif.FindTagValue(b, "ProfileToken")
+		b = onvif.GetProfileResponse(token)
+
+	case onvif.MediaGetVideoSourceConfigurations:
+		// important for Happytime Onvif Client
+		b = onvif.GetVideoSourceConfigurationsResponse(streams.GetAllNames())
+
+	case onvif.MediaGetVideoSourceConfiguration:
+		token := onvif.FindTagValue(b, "ConfigurationToken")
+		b = onvif.GetVideoSourceConfigurationResponse(token)
+
+	case onvif.MediaGetStreamUri:
+		host, _, err := net.SplitHostPort(r.Host)
+		if err != nil {
+			host = r.Host // in case of Host without port
+		}
+
+		uri := "rtsp://" + host + ":" + rtsp.Port + "/" + onvif.FindTagValue(b, "ProfileToken")
+		b = onvif.GetStreamUriResponse(uri)
+
+	case onvif.MediaGetSnapshotUri:
+		uri := "http://" + r.Host + "/api/frame.jpeg?src=" + onvif.FindTagValue(b, "ProfileToken")
+		b = onvif.GetSnapshotUriResponse(uri)
+
+	default:
+		http.Error(w, "unsupported operation", http.StatusBadRequest)
+		log.Warn().Msgf("[onvif] unsupported operation: %s", operation)
+		log.Debug().Msgf("[onvif] unsupported request:\n%s", b)
+		return
+	}
+
+	log.Trace().Msgf("[onvif] server response:\n%s", b)
+
+	w.Header().Set("Content-Type", "application/soap+xml; charset=utf-8")
+	if _, err = w.Write(b); err != nil {
+		log.Error().Err(err).Caller().Send()
+	}
+}
+
+func apiOnvif(w http.ResponseWriter, r *http.Request) {
+	src := r.URL.Query().Get("src")
+
+	var items []*api.Source
+
+	if src == "" {
+		devices, err := onvif.DiscoveryStreamingDevices()
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		for _, device := range devices {
+			u, err := url.Parse(device.URL)
+			if err != nil {
+				log.Warn().Str("url", device.URL).Msg("[onvif] broken")
+				continue
+			}
+
+			if u.Scheme != "http" {
+				log.Warn().Str("url", device.URL).Msg("[onvif] unsupported")
+				continue
+			}
+
+			u.Scheme = "onvif"
+			u.User = url.UserPassword("user", "pass")
+
+			if u.Path == onvif.PathDevice {
+				u.Path = ""
+			}
+
+			items = append(items, &api.Source{
+				Name: u.Host,
+				URL:  u.String(),
+				Info: device.Name + " " + device.Hardware,
+			})
+		}
+	} else {
+		client, err := onvif.NewClient(src)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		if l := log.Trace(); l.Enabled() {
+			b, _ := client.MediaRequest(onvif.MediaGetProfiles)
+			l.Msgf("[onvif] src=%s profiles:\n%s", src, b)
+		}
+
+		name, err := client.GetName()
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		tokens, err := client.GetProfilesTokens()
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		for i, token := range tokens {
+			items = append(items, &api.Source{
+				Name: name + " stream" + strconv.Itoa(i),
+				URL:  src + "?subtype=" + token,
+			})
+		}
+
+		if len(tokens) > 0 && client.HasSnapshots() {
+			items = append(items, &api.Source{
+				Name: name + " snapshot",
+				URL:  src + "?subtype=" + tokens[0] + "&snapshot",
+			})
+		}
+	}
+
+	api.ResponseSources(w, items)
+}
diff --git a/installs_on_host/go2rtc/internal/pinggy/README.md b/installs_on_host/go2rtc/internal/pinggy/README.md
new file mode 100644
index 0000000..49afa5a
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/pinggy/README.md
@@ -0,0 +1,54 @@
+# Pinggy
+
+[Pinggy](https://pinggy.io/) - nice service for public tunnels to your local services.
+
+**Features:**
+
+- A free account does not require registration.
+- It does not require downloading third-party binaries and works over the SSH protocol.
+- Works with HTTP, TCP and UDP protocols.
+- Creates HTTPS for your HTTP services.
+
+> [!IMPORTANT]
+> A free account creates a tunnel with a random address that only works for an hour. It is suitable for testing purposes ONLY.
+
+> [!CAUTION]
+> Public access to go2rtc without authorization puts your entire home network at risk. Use with caution.
+
+**Why:**
+
+- It's easy to set up HTTPS for testing two-way audio.
+- It's easy to check whether external access via WebRTC technology will work.
+- It's easy to share direct access to your RTSP or HTTP camera with the go2rtc developer. If such access is necessary to debug your problem.
+
+## Configuration
+
+You will find public links in the go2rtc log after startup.
+
+**Tunnel to go2rtc WebUI.**
+
+```yaml
+pinggy:
+  tunnel: http://localhost:1984
+```
+
+**Tunnel to RTSP camera.**
+
+For example, you have camera: `rtsp://admin:password@192.168.1.123/cam/realmonitor?channel=1&subtype=0`
+
+```yaml
+pinggy:
+  tunnel: tcp://192.168.10.91:554
+```
+
+In go2rtc logs you will get similar output:
+
+```
+16:17:43.167 INF [pinggy] proxy url=tcp://abcde-123-123-123-123.a.free.pinggy.link:12345
+```
+
+Now you have a working stream:
+
+```
+rtsp://admin:password@abcde-123-123-123-123.a.free.pinggy.link:12345/cam/realmonitor?channel=1&subtype=0
+```
diff --git a/installs_on_host/go2rtc/internal/pinggy/pinggy.go b/installs_on_host/go2rtc/internal/pinggy/pinggy.go
new file mode 100644
index 0000000..2e7258e
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/pinggy/pinggy.go
@@ -0,0 +1,60 @@
+package pinggy
+
+import (
+	"net/url"
+
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/pkg/pinggy"
+	"github.com/rs/zerolog"
+)
+
+func Init() {
+	var cfg struct {
+		Mod struct {
+			Tunnel string `yaml:"tunnel"`
+		} `yaml:"pinggy"`
+	}
+
+	app.LoadConfig(&cfg)
+
+	if cfg.Mod.Tunnel == "" {
+		return
+	}
+
+	log = app.GetLogger("pinggy")
+
+	u, err := url.Parse(cfg.Mod.Tunnel)
+	if err != nil {
+		log.Error().Err(err).Send()
+		return
+	}
+
+	go proxy(u.Scheme, u.Host)
+}
+
+var log zerolog.Logger
+
+func proxy(proto, address string) {
+	client, err := pinggy.NewClient(proto)
+	if err != nil {
+		log.Error().Err(err).Send()
+		return
+	}
+	defer client.Close()
+
+	urls, err := client.GetURLs()
+	if err != nil {
+		log.Error().Err(err).Send()
+		return
+	}
+
+	for _, s := range urls {
+		log.Info().Str("url", s).Msgf("[pinggy] proxy")
+	}
+
+	err = client.Proxy(address)
+	if err != nil {
+		log.Error().Err(err).Send()
+		return
+	}
+}
diff --git a/installs_on_host/go2rtc/internal/ring/README.md b/installs_on_host/go2rtc/internal/ring/README.md
new file mode 100644
index 0000000..a3464a7
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ring/README.md
@@ -0,0 +1,17 @@
+# Ring
+
+[`new in v1.9.13`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.9.13) by [@seydx](https://github.com/seydx)
+
+This source type supports Ring cameras with [two-way audio](../../README.md#two-way-audio) support.
+
+## Configuration
+
+If you have a `refresh_token` and `device_id`, you can use them in the `go2rtc.yaml` config file.
+
+Otherwise, you can use the go2rtc web interface and add your Ring account (WebUI > Add > Ring). Once added, it will list all your Ring cameras.
+
+```yaml
+streams:
+  ring: ring:?device_id=XXX&refresh_token=XXX
+  ring_snapshot: ring:?device_id=XXX&refresh_token=XXX&snapshot
+```
diff --git a/installs_on_host/go2rtc/internal/ring/ring.go b/installs_on_host/go2rtc/internal/ring/ring.go
new file mode 100644
index 0000000..7fdb284
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/ring/ring.go
@@ -0,0 +1,106 @@
+package ring
+
+import (
+	"net/http"
+	"net/url"
+
+	"fmt"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/ring"
+)
+
+func Init() {
+	streams.HandleFunc("ring", func(source string) (core.Producer, error) {
+		return ring.Dial(source)
+	})
+
+	api.HandleFunc("api/ring", apiRing)
+}
+
+func apiRing(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+	var ringAPI *ring.RingApi
+
+	// Check auth method
+	if email := query.Get("email"); email != "" {
+		// Email/Password Flow
+		password := query.Get("password")
+		code := query.Get("code")
+
+		var err error
+		ringAPI, err = ring.NewRestClient(ring.EmailAuth{
+			Email:    email,
+			Password: password,
+		}, nil)
+
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		// Try authentication (this will trigger 2FA if needed)
+		if _, err = ringAPI.GetAuth(code); err != nil {
+			if ringAPI.Using2FA {
+				// Return 2FA prompt
+				api.ResponseJSON(w, map[string]interface{}{
+					"needs_2fa": true,
+					"prompt":    ringAPI.PromptFor2FA,
+				})
+				return
+			}
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	} else if refreshToken := query.Get("refresh_token"); refreshToken != "" {
+		// Refresh Token Flow
+		if refreshToken == "" {
+			http.Error(w, "either email/password or refresh_token is required", http.StatusBadRequest)
+			return
+		}
+
+		var err error
+		ringAPI, err = ring.NewRestClient(ring.RefreshTokenAuth{
+			RefreshToken: refreshToken,
+		}, nil)
+
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	} else {
+		http.Error(w, "either email/password or refresh token is required", http.StatusBadRequest)
+		return
+	}
+
+	devices, err := ringAPI.FetchRingDevices()
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	cleanQuery := url.Values{}
+	cleanQuery.Set("refresh_token", ringAPI.RefreshToken)
+
+	var items []*api.Source
+	for _, camera := range devices.AllCameras {
+		cleanQuery.Set("camera_id", fmt.Sprint(camera.ID))
+		cleanQuery.Set("device_id", camera.DeviceID)
+
+		// Stream source
+		items = append(items, &api.Source{
+			Name: camera.Description,
+			URL:  "ring:?" + cleanQuery.Encode(),
+		})
+
+		// Snapshot source
+		items = append(items, &api.Source{
+			Name: camera.Description + " Snapshot",
+			URL:  "ring:?" + cleanQuery.Encode() + "&snapshot",
+		})
+	}
+
+	api.ResponseSources(w, items)
+}
diff --git a/installs_on_host/go2rtc/internal/roborock/README.md b/installs_on_host/go2rtc/internal/roborock/README.md
new file mode 100644
index 0000000..3361200
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/roborock/README.md
@@ -0,0 +1,15 @@
+# Roborock
+
+[`new in v1.3.0`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.3.0)
+
+This source type supports Roborock vacuums with cameras. Known working models:
+
+- **Roborock S6 MaxV** - only video (the vacuum has no microphone)
+- **Roborock S7 MaxV** - video and two-way audio
+- **Roborock Qrevo MaxV** - video and two-way audio
+
+## Configuration
+
+This source supports loading Roborock credentials from the Home Assistant [custom integration](https://github.com/humbertogontijo/homeassistant-roborock) or the [core integration](https://www.home-assistant.io/integrations/roborock). Otherwise, you need to log in to your Roborock account (MiHome account is not supported). Go to go2rtc WebUI > Add webpage. Copy the `roborock://...` source for your vacuum and paste it into your `go2rtc.yaml` config.
+
+If you have a pattern PIN for your vacuum, add it as a numeric PIN (lines: 123, 456, 789) to the end of the `roborock` link.
diff --git a/installs_on_host/go2rtc/internal/roborock/roborock.go b/installs_on_host/go2rtc/internal/roborock/roborock.go
new file mode 100644
index 0000000..32a436d
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/roborock/roborock.go
@@ -0,0 +1,92 @@
+package roborock
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/roborock"
+)
+
+func Init() {
+	streams.HandleFunc("roborock", func(source string) (core.Producer, error) {
+		return roborock.Dial(source)
+	})
+
+	api.HandleFunc("api/roborock", apiHandle)
+}
+
+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.Source
+
+	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.Source{Name: device.Name, URL: source})
+	}
+
+	api.ResponseSources(w, items)
+}
diff --git a/installs_on_host/go2rtc/internal/rtmp/README.md b/installs_on_host/go2rtc/internal/rtmp/README.md
new file mode 100644
index 0000000..6667238
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/rtmp/README.md
@@ -0,0 +1,118 @@
+# Real-Time Messaging Protocol
+
+This module provides the following features for the RTMP protocol:
+
+- Streaming input - [RTMP client](#rtmp-client)
+- Streaming output and ingest in `rtmp` format - [RTMP server](#rtmp-server)
+- Streaming output and ingest in `flv` format - [FLV server](#flv-server)
+
+## RTMP Client
+
+You can get a stream from an RTMP server, for example [Nginx with nginx-rtmp-module](https://github.com/arut/nginx-rtmp-module).
+
+### Client Configuration
+
+```yaml
+streams:
+  rtmp_stream: rtmp://192.168.1.123/live/camera1
+```
+
+## RTMP Server
+
+[`new in v1.8.0`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.8.0)
+
+Streaming output stream in `rtmp` format:
+
+```shell
+ffplay rtmp://localhost:1935/camera1
+```
+
+Streaming ingest stream in `rtmp` format:
+
+```shell
+ffmpeg -re -i BigBuckBunny.mp4 -c copy -f flv rtmp://localhost:1935/camera1
+```
+
+### Server Configuration
+
+By default, the RTMP server is disabled.
+
+```yaml
+rtmp:
+  listen: ":1935"  # by default - disabled!
+```
+
+## FLV Server
+
+Streaming output in `flv` format.
+
+```shell
+ffplay http://localhost:1984/stream.flv?src=camera1
+```
+
+Streaming ingest in `flv` format.
+
+```shell
+ffmpeg -re -i BigBuckBunny.mp4 -c copy -f flv http://localhost:1984/api/stream.flv?dst=camera1
+```
+
+## Tested clients
+
+| From   | To                              | Comment |
+|--------|---------------------------------|---------|
+| go2rtc | Reolink RLC-520A fw. v3.1.0.801 | OK      |
+
+**go2rtc.yaml**
+
+```yaml
+streams:
+  rtmp-reolink1: rtmp://192.168.10.92/bcs/channel0_main.bcs?channel=0&stream=0&user=admin&password=password
+  rtmp-reolink2: rtmp://192.168.10.92/bcs/channel0_sub.bcs?channel=0&stream=1&user=admin&password=password
+  rtmp-reolink3: rtmp://192.168.10.92/bcs/channel0_ext.bcs?channel=0&stream=1&user=admin&password=password
+```
+
+## Tested server
+
+| From                   | To     | Comment             |
+|------------------------|--------|---------------------|
+| OBS 31.0.2             | go2rtc | OK                  |
+| OpenIPC 2.5.03.02-lite | go2rtc | OK                  |
+| FFmpeg 6.1             | go2rtc | OK                  |
+| GoPro Black 12         | go2rtc | OK, 1080p, 5000kbps |
+
+**go2rtc.yaml**
+
+```yaml
+rtmp:
+  listen: :1935
+streams:
+  tmp:
+```
+
+**OBS**
+ 
+Settings > Stream:
+
+- Service: Custom
+- Server: rtmp://192.168.10.101/tmp
+- Stream Key: `<empty>`
+- Use auth: `<disabled>`
+
+**OpenIPC**
+
+WebUI > Majestic > Settings > Outgoing
+
+- Enable
+- Address: rtmp://192.168.10.101/tmp
+- Save
+- Restart
+
+**FFmpeg**
+
+```shell
+ffmpeg -re -i bbb.mp4 -c copy -f flv rtmp://192.168.10.101/tmp
+```
+
+**GoPro**
+
+GoPro Quik > Camera > Translation > Other
diff --git a/installs_on_host/go2rtc/internal/rtmp/rtmp.go b/installs_on_host/go2rtc/internal/rtmp/rtmp.go
new file mode 100644
index 0000000..b3d7f93
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/rtmp/rtmp.go
@@ -0,0 +1,199 @@
+package rtmp
+
+import (
+	"errors"
+	"io"
+	"net"
+	"net/http"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/flv"
+	"github.com/AlexxIT/go2rtc/pkg/rtmp"
+	"github.com/rs/zerolog"
+)
+
+func Init() {
+	var conf struct {
+		Mod struct {
+			Listen string `yaml:"listen" json:"listen"`
+		} `yaml:"rtmp"`
+	}
+
+	app.LoadConfig(&conf)
+
+	log = app.GetLogger("rtmp")
+
+	streams.HandleFunc("rtmp", streamsHandle)
+	streams.HandleFunc("rtmps", streamsHandle)
+	streams.HandleFunc("rtmpx", streamsHandle)
+
+	api.HandleFunc("api/stream.flv", apiHandle)
+
+	streams.HandleConsumerFunc("rtmp", streamsConsumerHandle)
+	streams.HandleConsumerFunc("rtmps", streamsConsumerHandle)
+	streams.HandleConsumerFunc("rtmpx", streamsConsumerHandle)
+
+	address := conf.Mod.Listen
+	if address == "" {
+		return
+	}
+
+	ln, err := net.Listen("tcp", address)
+	if err != nil {
+		log.Error().Err(err).Caller().Send()
+		return
+	}
+
+	log.Info().Str("addr", address).Msg("[rtmp] listen")
+
+	go func() {
+		for {
+			conn, err := ln.Accept()
+			if err != nil {
+				return
+			}
+
+			go func() {
+				if err = tcpHandle(conn); err != nil {
+					log.Error().Err(err).Caller().Send()
+				}
+			}()
+		}
+	}()
+}
+
+func tcpHandle(netConn net.Conn) error {
+	rtmpConn, err := rtmp.NewServer(netConn)
+	if err != nil {
+		return err
+	}
+
+	if err = rtmpConn.ReadCommands(); err != nil {
+		return err
+	}
+
+	switch rtmpConn.Intent {
+	case rtmp.CommandPlay:
+		stream := streams.Get(rtmpConn.App)
+		if stream == nil {
+			return errors.New("stream not found: " + rtmpConn.App)
+		}
+
+		cons := flv.NewConsumer()
+		if err = stream.AddConsumer(cons); err != nil {
+			return err
+		}
+
+		defer stream.RemoveConsumer(cons)
+
+		if err = rtmpConn.WriteStart(); err != nil {
+			return err
+		}
+
+		_, _ = cons.WriteTo(rtmpConn)
+
+		return nil
+
+	case rtmp.CommandPublish:
+		stream := streams.Get(rtmpConn.App)
+		if stream == nil {
+			return errors.New("stream not found: " + rtmpConn.App)
+		}
+
+		if err = rtmpConn.WriteStart(); err != nil {
+			return err
+		}
+
+		prod, err := rtmpConn.Producer()
+		if err != nil {
+			return err
+		}
+
+		stream.AddProducer(prod)
+
+		defer stream.RemoveProducer(prod)
+
+		_ = prod.Start()
+
+		return nil
+	}
+
+	return errors.New("rtmp: unknown command: " + rtmpConn.Intent)
+}
+
+var log zerolog.Logger
+
+func streamsHandle(url string) (core.Producer, error) {
+	return rtmp.DialPlay(url)
+}
+
+func streamsConsumerHandle(url string) (core.Consumer, func(), error) {
+	cons := flv.NewConsumer()
+	run := func() {
+		wr, err := rtmp.DialPublish(url, cons)
+		if err != nil {
+			return
+		}
+		_, err = cons.WriteTo(wr)
+	}
+
+	return cons, run, nil
+}
+
+func apiHandle(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		outputFLV(w, r)
+	} else {
+		inputFLV(w, r)
+	}
+}
+
+func outputFLV(w http.ResponseWriter, r *http.Request) {
+	src := r.URL.Query().Get("src")
+	stream := streams.Get(src)
+	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
+		return
+	}
+
+	cons := flv.NewConsumer()
+	cons.WithRequest(r)
+
+	if err := stream.AddConsumer(cons); err != nil {
+		log.Error().Err(err).Caller().Send()
+		return
+	}
+
+	h := w.Header()
+	h.Set("Content-Type", "video/x-flv")
+
+	_, _ = cons.WriteTo(w)
+
+	stream.RemoveConsumer(cons)
+}
+
+func inputFLV(w http.ResponseWriter, r *http.Request) {
+	dst := r.URL.Query().Get("dst")
+	stream := streams.Get(dst)
+	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
+		return
+	}
+
+	client, err := flv.Open(r.Body)
+	if 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)
+}
diff --git a/installs_on_host/go2rtc/internal/rtsp/README.md b/installs_on_host/go2rtc/internal/rtsp/README.md
new file mode 100644
index 0000000..cd7c84a
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/rtsp/README.md
@@ -0,0 +1,93 @@
+# Real Time Streaming Protocol
+
+This module provides the following features for the RTSP protocol:
+
+ - Streaming input - [RTSP client](#rtsp-client)
+ - Streaming output - [RTSP server](#rtsp-server)
+ - [Streaming ingest](#streaming-ingest)
+ - [Two-way audio](#two-way-audio)
+
+## RTSP Client
+
+### Configuration
+
+```yaml
+streams:
+  sonoff_camera: rtsp://rtsp:12345678@192.168.1.123/av_stream/ch0
+  dahua_camera:
+    - rtsp://admin:password@192.168.1.123/cam/realmonitor?channel=1&subtype=0&unicast=true&proto=Onvif
+    - rtsp://admin:password@192.168.1.123/cam/realmonitor?channel=1&subtype=1#backchannel=0
+  amcrest_doorbell:
+    - rtsp://username:password@192.168.1.123:554/cam/realmonitor?channel=1&subtype=0#backchannel=0
+  unifi_camera: rtspx://192.168.1.123:7441/fD6ouM72bWoFijxK
+  glichy_camera: ffmpeg:rtsp://username:password@192.168.1.123/live/ch00_1 
+```
+
+### Recommendations
+
+- **Amcrest Doorbell** users may want to disable two-way audio, because with an active stream, you won't have a working call button. You need to add `#backchannel=0` to the end of your RTSP link in YAML config file
+- **Dahua Doorbell** users may want to change [audio codec](https://github.com/AlexxIT/go2rtc/issues/49#issuecomment-2127107379) for proper two-way audio. Make sure not to request backchannel multiple times by adding `#backchannel=0` to other stream sources of the same doorbell. The `unicast=true&proto=Onvif` is preferred for two-way audio as this makes the doorbell accept multiple codecs for the incoming audio
+- **Reolink** users may want NOT to use RTSP protocol at all, some camera models have a very awful, unusable stream implementation
+- **Ubiquiti UniFi** users may want to disable HTTPS verification. Use `rtspx://` prefix instead of `rtsps://`. And don't use `?enableSrtp` [suffix](https://github.com/AlexxIT/go2rtc/issues/81)
+- **TP-Link Tapo** users may skip login and password, because go2rtc supports login [without them](https://drmnsamoliu.github.io/video.html)
+- If your camera has two RTSP links, you can add both as sources. This is useful when streams have different codecs, for 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](../ffmpeg/README.md). It will not add CPU load if you don't use transcoding
+- If the stream from your camera is very glitchy, try to use transcoding with [ffmpeg source](../ffmpeg/README.md)
+
+### Other options
+
+Format: `rtsp...#{param1}#{param2}#{param3}`
+
+- Add custom timeout `#timeout=30` (in seconds)
+- Ignore audio - `#media=video` or ignore video - `#media=audio`
+- Ignore two-way audio API `#backchannel=0` - important for some glitchy cameras
+- Use WebSocket transport `#transport=ws...`
+
+### RTSP over WebSocket
+
+```yaml
+streams:
+  # WebSocket with authorization, RTSP - without
+  axis-rtsp-ws:  rtsp://192.168.1.123:4567/axis-media/media.amp?overview=0&camera=1&resolution=1280x720&videoframeskipmode=empty&Axis-Orig-Sw=true#transport=ws://user:pass@192.168.1.123:4567/rtsp-over-websocket
+  # WebSocket without authorization, RTSP - with
+  dahua-rtsp-ws: rtsp://user:pass@192.168.1.123/cam/realmonitor?channel=1&subtype=1&proto=Private3#transport=ws://192.168.1.123/rtspoverwebsocket
+```
+
+## RTSP Server
+
+You can get any stream as RTSP-stream: `rtsp://192.168.1.123:8554/{stream_name}`
+
+You can enable external password protection for your RTSP streams. Password protection is always disabled for localhost calls (ex. FFmpeg or Home Assistant on the same server).
+
+### Configuration
+
+```yaml
+rtsp:
+  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](../../README.md#codecs-filters).
+
+## Streaming ingest
+
+```shell
+ffmpeg -re -i BigBuckBunny.mp4 -c copy -rtsp_transport tcp -f rtsp rtsp://localhost:8554/camera1
+```
+
+## Two-way audio
+
+Before purchasing, it is difficult to understand whether the camera supports two-way audio via the RTSP protocol or not. This isn't usually mentioned in a camera's description. You can only find out by reading reviews from real buyers.
+
+A camera is considered to support two-way audio if it supports the ONVIF Profile T protocol. But in reality, this isn't always the case. And the ONVIF protocol has no connection with the camera's RTSP implementation.
+
+In go2rtc you can find out if the camera supports two-way audio via WebUI > stream probe.
diff --git a/installs_on_host/go2rtc/internal/rtsp/rtsp.go b/installs_on_host/go2rtc/internal/rtsp/rtsp.go
new file mode 100644
index 0000000..31c2c5d
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/rtsp/rtsp.go
@@ -0,0 +1,312 @@
+package rtsp
+
+import (
+	"errors"
+	"io"
+	"net"
+	"net/url"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/rtsp"
+	"github.com/AlexxIT/go2rtc/pkg/tcp"
+	"github.com/rs/zerolog"
+)
+
+func Init() {
+	var conf struct {
+		Mod struct {
+			Listen       string `yaml:"listen" json:"listen"`
+			Username     string `yaml:"username" json:"-"`
+			Password     string `yaml:"password" json:"-"`
+			DefaultQuery string `yaml:"default_query" json:"default_query"`
+			PacketSize   uint16 `yaml:"pkt_size" json:"pkt_size,omitempty"`
+		} `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")
+
+	// RTSP client support
+	streams.HandleFunc("rtsp", rtspHandler)
+	streams.HandleFunc("rtsps", rtspHandler)
+	streams.HandleFunc("rtspx", rtspHandler)
+
+	// RTSP server support
+	address := conf.Mod.Listen
+	if address == "" {
+		return
+	}
+
+	ln, err := net.Listen("tcp", address)
+	if err != nil {
+		log.Error().Err(err).Msg("[rtsp] listen")
+		return
+	}
+
+	_, Port, _ = net.SplitHostPort(address)
+
+	log.Info().Str("addr", address).Msg("[rtsp] listen")
+
+	if query, err := url.ParseQuery(conf.Mod.DefaultQuery); err == nil {
+		defaultMedias = ParseQuery(query)
+	}
+
+	go func() {
+		for {
+			conn, err := ln.Accept()
+			if err != nil {
+				return
+			}
+
+			c := rtsp.NewServer(conn)
+			c.PacketSize = conf.Mod.PacketSize
+			// skip check auth for localhost
+			if conf.Mod.Username != "" && !conn.RemoteAddr().(*net.TCPAddr).IP.IsLoopback() {
+				c.Auth(conf.Mod.Username, conf.Mod.Password)
+			}
+			go tcpHandler(c)
+		}
+	}()
+}
+
+type Handler func(conn *rtsp.Conn) bool
+
+func HandleFunc(handler Handler) {
+	handlers = append(handlers, handler)
+}
+
+var Port string
+
+// internal
+
+var log zerolog.Logger
+var handlers []Handler
+var defaultMedias []*core.Media
+
+func rtspHandler(rawURL string) (core.Producer, error) {
+	rawURL, rawQuery, _ := strings.Cut(rawURL, "#")
+
+	conn := rtsp.NewClient(rawURL)
+	conn.Backchannel = true
+	conn.UserAgent = app.UserAgent
+
+	if rawQuery != "" {
+		query := streams.ParseQuery(rawQuery)
+		conn.Backchannel = query.Get("backchannel") == "1"
+		conn.Media = query.Get("media")
+		conn.Timeout = core.Atoi(query.Get("timeout"))
+		conn.Transport = query.Get("transport")
+	}
+
+	if log.Trace().Enabled() {
+		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 {
+		return nil, err
+	}
+
+	if err := conn.Describe(); err != nil {
+		if !conn.Backchannel {
+			return nil, err
+		}
+		log.Trace().Msgf("[rtsp] describe (backchannel=%t) err: %v", conn.Backchannel, err)
+
+		// second try without backchannel, we need to reconnect
+		conn.Backchannel = false
+		if err = conn.Dial(); err != nil {
+			return nil, err
+		}
+		if err = conn.Describe(); err != nil {
+			return nil, err
+		}
+	}
+
+	return conn, nil
+}
+
+func tcpHandler(conn *rtsp.Conn) {
+	var name string
+	var closer func()
+
+	trace := log.Trace().Enabled()
+	level := zerolog.WarnLevel
+
+	conn.Listen(func(msg any) {
+		if trace {
+			switch msg := msg.(type) {
+			case *tcp.Request:
+				log.Trace().Msgf("[rtsp] server request:\n%s", msg)
+			case *tcp.Response:
+				log.Trace().Msgf("[rtsp] server response:\n%s", msg)
+			}
+		}
+
+		switch msg {
+		case rtsp.MethodDescribe:
+			if len(conn.URL.Path) == 0 {
+				log.Warn().Msg("[rtsp] server empty URL on DESCRIBE")
+				return
+			}
+
+			name = conn.URL.Path[1:]
+
+			stream := streams.Get(name)
+			if stream == nil {
+				return
+			}
+
+			log.Debug().Str("stream", name).Msg("[rtsp] new consumer")
+
+			conn.SessionName = app.UserAgent
+
+			query := conn.URL.Query()
+			conn.Medias = ParseQuery(query)
+			if conn.Medias == nil {
+				for _, media := range defaultMedias {
+					conn.Medias = append(conn.Medias, media.Clone())
+				}
+			}
+
+			if query.Get("backchannel") == "1" {
+				conn.Medias = append(conn.Medias, &core.Media{
+					Kind:      core.KindAudio,
+					Direction: core.DirectionRecvonly,
+					Codecs: []*core.Codec{
+						{Name: core.CodecOpus, ClockRate: 48000, Channels: 2},
+						{Name: core.CodecPCM, ClockRate: 16000},
+						{Name: core.CodecPCMA, ClockRate: 16000},
+						{Name: core.CodecPCMU, ClockRate: 16000},
+						{Name: core.CodecPCM, ClockRate: 8000},
+						{Name: core.CodecPCMA, ClockRate: 8000},
+						{Name: core.CodecPCMU, ClockRate: 8000},
+						{Name: core.CodecAAC, ClockRate: 8000},
+						{Name: core.CodecAAC, ClockRate: 16000},
+					},
+				})
+			}
+
+			if s := query.Get("pkt_size"); s != "" {
+				conn.PacketSize = uint16(core.Atoi(s))
+			}
+
+			// param name like ffmpeg style https://ffmpeg.org/ffmpeg-protocols.html
+			if s := query.Get("log_level"); s != "" {
+				if lvl, err := zerolog.ParseLevel(s); err == nil {
+					level = lvl
+				}
+			}
+
+			// will help to protect looping requests to same source
+			conn.Connection.Source = query.Get("source")
+
+			if err := stream.AddConsumer(conn); err != nil {
+				log.WithLevel(level).Err(err).Str("stream", name).Msg("[rtsp]")
+				return
+			}
+
+			closer = func() {
+				stream.RemoveConsumer(conn)
+			}
+
+		case rtsp.MethodAnnounce:
+			if len(conn.URL.Path) == 0 {
+				log.Warn().Msg("[rtsp] server empty URL on ANNOUNCE")
+				return
+			}
+
+			name = conn.URL.Path[1:]
+
+			stream := streams.Get(name)
+			if stream == nil {
+				return
+			}
+
+			query := conn.URL.Query()
+			if s := query.Get("timeout"); s != "" {
+				conn.Timeout = core.Atoi(s)
+			}
+
+			log.Debug().Str("stream", name).Msg("[rtsp] new producer")
+
+			stream.AddProducer(conn)
+
+			closer = func() {
+				stream.RemoveProducer(conn)
+			}
+		}
+	})
+
+	if err := conn.Accept(); err != nil {
+		if errors.Is(err, rtsp.FailedAuth) {
+			log.Warn().Str("remote_addr", conn.Connection.RemoteAddr).Msg("[rtsp] failed authentication")
+		} else if err != io.EOF {
+			log.WithLevel(level).Err(err).Caller().Send()
+		}
+		if closer != nil {
+			closer()
+		}
+		_ = conn.Close()
+		return
+	}
+
+	for _, handler := range handlers {
+		if handler(conn) {
+			return
+		}
+	}
+
+	if closer != nil {
+		if err := conn.Handle(); err != nil {
+			log.Debug().Err(err).Msg("[rtsp] handle")
+		}
+
+		closer()
+
+		log.Debug().Str("stream", name).Msg("[rtsp] disconnect")
+	}
+
+	_ = conn.Close()
+}
+
+func ParseQuery(query map[string][]string) []*core.Media {
+	if v := query["mp4"]; v != nil {
+		return []*core.Media{
+			{
+				Kind:      core.KindVideo,
+				Direction: core.DirectionSendonly,
+				Codecs: []*core.Codec{
+					{Name: core.CodecH264},
+					{Name: core.CodecH265},
+				},
+			},
+			{
+				Kind:      core.KindAudio,
+				Direction: core.DirectionSendonly,
+				Codecs: []*core.Codec{
+					{Name: core.CodecAAC},
+				},
+			},
+		}
+	}
+
+	return core.ParseQuery(query)
+}
diff --git a/installs_on_host/go2rtc/internal/srtp/README.md b/installs_on_host/go2rtc/internal/srtp/README.md
new file mode 100644
index 0000000..9bc36d0
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/srtp/README.md
@@ -0,0 +1,13 @@
+# SRTP
+
+This is a support module for the [HomeKit](../homekit/README.md) module.
+
+> [!NOTE]
+> This module can be removed and its functionality transferred to the homekit module.
+
+## Configuration
+
+```yaml
+srtp:
+  listen: :8443  # enabled by default
+```
diff --git a/installs_on_host/go2rtc/internal/srtp/srtp.go b/installs_on_host/go2rtc/internal/srtp/srtp.go
new file mode 100644
index 0000000..2cf7b6e
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/srtp/srtp.go
@@ -0,0 +1,29 @@
+package srtp
+
+import (
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/pkg/srtp"
+)
+
+func Init() {
+	var cfg struct {
+		Mod struct {
+			Listen string `yaml:"listen"`
+		} `yaml:"srtp"`
+	}
+
+	// default config
+	cfg.Mod.Listen = ":8443"
+
+	// load config from YAML
+	app.LoadConfig(&cfg)
+
+	if cfg.Mod.Listen == "" {
+		return
+	}
+
+	// create SRTP server (endpoint) for receiving video from HomeKit cameras
+	Server = srtp.NewServer(cfg.Mod.Listen)
+}
+
+var Server *srtp.Server
diff --git a/installs_on_host/go2rtc/internal/streams/README.md b/installs_on_host/go2rtc/internal/streams/README.md
new file mode 100644
index 0000000..2f3eb39
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/streams/README.md
@@ -0,0 +1,141 @@
+# Streams
+
+This core module is responsible for managing the stream list.
+
+## Stream to camera
+
+[`new in v1.3.0`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.3.0)
+
+go2rtc supports playing 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](../../README.md#two-way-audio) support.
+
+API example:
+
+```text
+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](../ffmpeg/README.md) 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](../tapo/README.md))
+- 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 the 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
+
+## Publish stream
+
+[`new in v1.8.0`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.8.0)
+
+You can publish any stream to streaming services (YouTube, Telegram, etc.) via RTMP/RTMPS. Important:
+
+- Supported codecs: H264 for video and AAC for audio
+- AAC audio is required for YouTube; videos without audio will not work
+- You don't need to enable [RTMP module](../rtmp/README.md) listening for this task
+
+You can use the API:
+
+```text
+POST http://localhost:1984/api/streams?src=camera1&dst=rtmps://...
+```
+
+Or config file:
+
+```yaml
+publish:
+  # publish stream "video_audio_transcode" to Telegram
+  video_audio_transcode:
+    - rtmps://xxx-x.rtmp.t.me/s/xxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxx
+  # publish stream "audio_transcode" to Telegram and YouTube
+  audio_transcode:
+    - rtmps://xxx-x.rtmp.t.me/s/xxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxx
+    - rtmp://xxx.rtmp.youtube.com/live2/xxxx-xxxx-xxxx-xxxx-xxxx
+
+streams:
+  video_audio_transcode:
+    - ffmpeg:rtsp://user:pass@192.168.1.123/stream1#video=h264#hardware#audio=aac
+  audio_transcode:
+    - ffmpeg:rtsp://user:pass@192.168.1.123/stream1#video=copy#audio=aac
+```
+
+- **Telegram Desktop App** > Any public or private channel or group (where you admin) > Live stream > Start with... > Start streaming.
+- **YouTube** > Create > Go live > Stream latency: Ultra low-latency > Copy: Stream URL + Stream key.
+
+## Preload stream
+
+[`new in v1.9.11`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.9.11)
+
+You can preload any stream on go2rtc start. This is useful for cameras that take a long time to start up.
+
+```yaml
+preload:
+  camera1:                                     # default: video&audio = ANY
+  camera2: "video"                             # preload only video track
+  camera3: "video=h264&audio=opus"             # preload H264 video and OPUS audio
+
+streams:
+  camera1: 
+    - rtsp://192.168.1.100/stream
+  camera2: 
+    - rtsp://192.168.1.101/stream  
+  camera3: 
+    - rtsp://192.168.1.102/h265stream
+    - ffmpeg:camera3#video=h264#audio=opus#hardware
+```
+
+## Examples
+
+```yaml
+streams:
+  # known RTSP sources
+  rtsp-dahua1:   rtsp://admin:password@192.168.10.90/cam/realmonitor?channel=1&subtype=0&unicast=true&proto=Onvif
+  rtsp-dahua2:   rtsp://admin:password@192.168.10.90/cam/realmonitor?channel=1&subtype=1
+  rtsp-tplink1:  rtsp://admin:password@192.168.10.91/stream1
+  rtsp-tplink2:  rtsp://admin:password@192.168.10.91/stream2
+  rtsp-reolink1: rtsp://admin:password@192.168.10.92/h264Preview_01_main
+  rtsp-reolink2: rtsp://admin:password@192.168.10.92/h264Preview_01_sub
+  rtsp-sonoff1:  rtsp://admin:password@192.168.10.93/av_stream/ch0
+  rtsp-sonoff2:  rtsp://admin:password@192.168.10.93/av_stream/ch1
+
+  # known RTMP sources
+  rtmp-reolink1: rtmp://192.168.10.92/bcs/channel0_main.bcs?channel=0&stream=0&user=admin&password=password
+  rtmp-reolink2: rtmp://192.168.10.92/bcs/channel0_sub.bcs?channel=0&stream=1&user=admin&password=password
+  rtmp-reolink3: rtmp://192.168.10.92/bcs/channel0_ext.bcs?channel=0&stream=1&user=admin&password=password
+
+  # known HTTP sources
+  http-reolink1: http://192.168.10.92/flv?port=1935&app=bcs&stream=channel0_main.bcs&user=admin&password=password
+  http-reolink2: http://192.168.10.92/flv?port=1935&app=bcs&stream=channel0_sub.bcs&user=admin&password=password
+  http-reolink3: http://192.168.10.92/flv?port=1935&app=bcs&stream=channel0_ext.bcs&user=admin&password=password
+
+  # known ONVIF sources
+  onvif-dahua1:   onvif://admin:password@192.168.10.90?subtype=MediaProfile00000
+  onvif-dahua2:   onvif://admin:password@192.168.10.90?subtype=MediaProfile00001
+  onvif-dahua3:   onvif://admin:password@192.168.10.90?subtype=MediaProfile00000&snapshot
+  onvif-tplink1:  onvif://admin:password@192.168.10.91:2020?subtype=profile_1
+  onvif-tplink2:  onvif://admin:password@192.168.10.91:2020?subtype=profile_2
+  onvif-reolink1: onvif://admin:password@192.168.10.92:8000?subtype=000
+  onvif-reolink2: onvif://admin:password@192.168.10.92:8000?subtype=001
+  onvif-reolink3: onvif://admin:password@192.168.10.92:8000?subtype=000&snapshot
+  onvif-openipc1: onvif://admin:password@192.168.10.95:80?subtype=PROFILE_000
+  onvif-openipc2: onvif://admin:password@192.168.10.95:80?subtype=PROFILE_001
+
+  # some EXEC examples
+  exec-h264-pipe:   exec:ffmpeg -re -i bbb.mp4 -c copy -f h264 -
+  exec-flv-pipe:    exec:ffmpeg -re -i bbb.mp4 -c copy -f flv -
+  exec-mpegts-pipe: exec:ffmpeg -re -i bbb.mp4 -c copy -f mpegts -
+  exec-adts-pipe:   exec:ffmpeg -re -i bbb.mp4 -c copy -f adts -
+  exec-mjpeg-pipe:  exec:ffmpeg -re -i bbb.mp4 -c mjpeg -f mjpeg -
+  exec-hevc-pipe:   exec:ffmpeg -re -i bbb.mp4 -c libx265 -preset superfast -tune zerolatency -f hevc -
+  exec-wav-pipe:    exec:ffmpeg -re -i bbb.mp4 -c pcm_alaw -ar 8000 -ac 1 -f wav -
+  exec-y4m-pipe:    exec:ffmpeg -re -i bbb.mp4 -c rawvideo -f yuv4mpegpipe -
+  exec-pcma-pipe:   exec:ffmpeg -re -i numb.mp3 -c:a pcm_alaw -ar:a 8000 -ac:a 1 -f wav -
+  exec-pcmu-pipe:   exec:ffmpeg -re -i numb.mp3 -c:a pcm_mulaw -ar:a 8000 -ac:a 1 -f wav -
+  exec-s16le-pipe:  exec:ffmpeg -re -i numb.mp3 -c:a pcm_s16le -ar:a 16000 -ac:a 1 -f wav -
+
+  # some FFmpeg examples
+  ffmpeg-video-h264: ffmpeg:virtual?video#video=h264
+  ffmpeg-video-4K:   ffmpeg:virtual?video&size=4K#video=h264
+  ffmpeg-video-10s:  ffmpeg:virtual?video&duration=10#video=h264
+  ffmpeg-video-src2: ffmpeg:virtual?video=testsrc2&size=2K#video=h264
+```
diff --git a/installs_on_host/go2rtc/internal/streams/add_consumer.go b/installs_on_host/go2rtc/internal/streams/add_consumer.go
new file mode 100644
index 0000000..7400ce6
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/streams/add_consumer.go
@@ -0,0 +1,166 @@
+package streams
+
+import (
+	"errors"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func (s *Stream) AddConsumer(cons core.Consumer) (err error) {
+	// support for multiple simultaneous pending from different consumers
+	consN := s.pending.Add(1) - 1
+
+	var prodErrors = make([]error, len(s.producers))
+	var prodMedias []*core.Media
+	var prodStarts []*Producer
+
+	// Step 1. Get consumer medias
+	consMedias := cons.GetMedias()
+	for _, consMedia := range consMedias {
+		log.Trace().Msgf("[streams] check cons=%d media=%s", consN, consMedia)
+
+	producers:
+		for prodN, prod := range s.producers {
+			// check for loop request, ex. `camera1: ffmpeg:camera1`
+			if info, ok := cons.(core.Info); ok && prod.url == info.GetSource() {
+				log.Trace().Msgf("[streams] skip cons=%d prod=%d", consN, prodN)
+				continue
+			}
+
+			if prodErrors[prodN] != nil {
+				log.Trace().Msgf("[streams] skip cons=%d prod=%d", consN, prodN)
+				continue
+			}
+
+			if err = prod.Dial(); err != nil {
+				log.Trace().Err(err).Msgf("[streams] dial cons=%d prod=%d", consN, prodN)
+				prodErrors[prodN] = err
+				continue
+			}
+
+			// Step 2. Get producer medias (not tracks yet)
+			for _, prodMedia := range prod.GetMedias() {
+				log.Trace().Msgf("[streams] check cons=%d prod=%d media=%s", consN, prodN, prodMedia)
+				prodMedias = append(prodMedias, prodMedia)
+
+				// Step 3. Match consumer/producer codecs list
+				prodCodec, consCodec := prodMedia.MatchMedia(consMedia)
+				if prodCodec == nil {
+					continue
+				}
+
+				var track *core.Receiver
+
+				switch prodMedia.Direction {
+				case core.DirectionRecvonly:
+					log.Trace().Msgf("[streams] match cons=%d <= prod=%d", consN, prodN)
+
+					// Step 4. Get recvonly track from producer
+					if track, err = prod.GetTrack(prodMedia, prodCodec); err != nil {
+						log.Info().Err(err).Msg("[streams] can't get track")
+						prodErrors[prodN] = err
+						continue
+					}
+					// Step 5. Add track to consumer
+					if err = cons.AddTrack(consMedia, consCodec, track); err != nil {
+						log.Info().Err(err).Msg("[streams] can't add track")
+						continue
+					}
+
+				case core.DirectionSendonly:
+					log.Trace().Msgf("[streams] match cons=%d => prod=%d", consN, prodN)
+
+					// Step 4. Get recvonly track from consumer (backchannel)
+					if track, err = cons.(core.Producer).GetTrack(consMedia, consCodec); err != nil {
+						log.Info().Err(err).Msg("[streams] can't get track")
+						continue
+					}
+					// Step 5. Add track to producer
+					if err = prod.AddTrack(prodMedia, prodCodec, track); err != nil {
+						log.Info().Err(err).Msg("[streams] can't add track")
+						prodErrors[prodN] = err
+						continue
+					}
+				}
+
+				prodStarts = append(prodStarts, prod)
+
+				if !consMedia.MatchAll() {
+					break producers
+				}
+			}
+		}
+	}
+
+	// stop producers if they don't have readers
+	if s.pending.Add(-1) == 0 {
+		s.stopProducers()
+	}
+
+	if len(prodStarts) == 0 {
+		return formatError(consMedias, prodMedias, prodErrors)
+	}
+
+	s.mu.Lock()
+	s.consumers = append(s.consumers, cons)
+	s.mu.Unlock()
+
+	// there may be duplicates, but that's not a problem
+	for _, prod := range prodStarts {
+		prod.start()
+	}
+
+	return nil
+}
+
+func formatError(consMedias, prodMedias []*core.Media, prodErrors []error) error {
+	// 1. Return errors if any not nil
+	var text string
+
+	for _, err := range prodErrors {
+		if err != nil {
+			text = appendString(text, err.Error())
+		}
+	}
+
+	if len(text) != 0 {
+		return errors.New("streams: " + text)
+	}
+
+	// 2. Return "codecs not matched"
+	if prodMedias != nil {
+		var prod, cons string
+
+		for _, media := range prodMedias {
+			if media.Direction == core.DirectionRecvonly {
+				for _, codec := range media.Codecs {
+					prod = appendString(prod, media.Kind+":"+codec.PrintName())
+				}
+			}
+		}
+
+		for _, media := range consMedias {
+			if media.Direction == core.DirectionSendonly {
+				for _, codec := range media.Codecs {
+					cons = appendString(cons, media.Kind+":"+codec.PrintName())
+				}
+			}
+		}
+
+		return errors.New("streams: codecs not matched: " + prod + " => " + cons)
+	}
+
+	// 3. Return unknown error
+	return errors.New("streams: unknown error")
+}
+
+func appendString(s, elem string) string {
+	if strings.Contains(s, elem) {
+		return s
+	}
+	if len(s) == 0 {
+		return elem
+	}
+	return s + ", " + elem
+}
diff --git a/installs_on_host/go2rtc/internal/streams/api.go b/installs_on_host/go2rtc/internal/streams/api.go
new file mode 100644
index 0000000..d6142eb
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/streams/api.go
@@ -0,0 +1,181 @@
+package streams
+
+import (
+	"net/http"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/creds"
+	"github.com/AlexxIT/go2rtc/pkg/probe"
+)
+
+func apiStreams(w http.ResponseWriter, r *http.Request) {
+	w = creds.SecretResponse(w)
+
+	query := r.URL.Query()
+	src := query.Get("src")
+
+	// without source - return all streams list
+	if src == "" && r.Method != "POST" {
+		api.ResponseJSON(w, streams)
+		return
+	}
+
+	// Not sure about all this API. Should be rewrited...
+	switch r.Method {
+	case "GET":
+		stream := Get(src)
+		if stream == nil {
+			http.Error(w, "", http.StatusNotFound)
+			return
+		}
+
+		cons := probe.Create("probe", query)
+		if len(cons.Medias) != 0 {
+			cons.WithRequest(r)
+			if err := stream.AddConsumer(cons); err != nil {
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+				return
+			}
+
+			api.ResponsePrettyJSON(w, stream)
+
+			stream.RemoveConsumer(cons)
+		} else {
+			api.ResponsePrettyJSON(w, streams[src])
+		}
+
+	case "PUT":
+		name := query.Get("name")
+		if name == "" {
+			name = src
+		}
+
+		if _, err := New(name, query["src"]...); err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		if err := app.PatchConfig([]string{"streams", name}, query["src"]); err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+		}
+
+	case "PATCH":
+		name := query.Get("name")
+		if name == "" {
+			http.Error(w, "", http.StatusBadRequest)
+			return
+		}
+
+		// support {input} templates: https://github.com/AlexxIT/go2rtc#module-hass
+		if _, err := Patch(name, src); err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+		}
+
+	case "POST":
+		// with dst - redirect source to dst
+		if dst := query.Get("dst"); dst != "" {
+			if stream := Get(dst); stream != nil {
+				if err := Validate(src); err != nil {
+					http.Error(w, err.Error(), http.StatusBadRequest)
+				} else if err = stream.Play(src); err != nil {
+					http.Error(w, err.Error(), http.StatusInternalServerError)
+				} else {
+					api.ResponseJSON(w, stream)
+				}
+			} else if stream = Get(src); stream != nil {
+				if err := Validate(dst); err != nil {
+					http.Error(w, err.Error(), http.StatusBadRequest)
+				} else if err = stream.Publish(dst); err != nil {
+					http.Error(w, err.Error(), http.StatusInternalServerError)
+				}
+			} else {
+				http.Error(w, "", http.StatusNotFound)
+			}
+		} else {
+			http.Error(w, "", http.StatusBadRequest)
+		}
+
+	case "DELETE":
+		delete(streams, src)
+
+		if err := app.PatchConfig([]string{"streams", src}, nil); err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+		}
+	}
+}
+
+func apiStreamsDOT(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+
+	dot := make([]byte, 0, 1024)
+	dot = append(dot, "digraph {\n"...)
+	if query.Has("src") {
+		for _, name := range query["src"] {
+			if stream := streams[name]; stream != nil {
+				dot = AppendDOT(dot, stream)
+			}
+		}
+	} else {
+		for _, stream := range streams {
+			dot = AppendDOT(dot, stream)
+		}
+	}
+	dot = append(dot, '}')
+
+	dot = []byte(creds.SecretString(string(dot)))
+
+	api.Response(w, dot, "text/vnd.graphviz")
+}
+
+func apiPreload(w http.ResponseWriter, r *http.Request) {
+	// GET - return all preloads
+	if r.Method == "GET" {
+		api.ResponseJSON(w, GetPreloads())
+		return
+	}
+
+	query := r.URL.Query()
+	src := query.Get("src")
+
+	switch r.Method {
+	case "PUT":
+		// it's safe to delete from map while iterating
+		for k := range query {
+			switch k {
+			case core.KindVideo, core.KindAudio, "microphone":
+			default:
+				delete(query, k)
+			}
+		}
+
+		rawQuery := query.Encode()
+
+		if err := AddPreload(src, rawQuery); err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		if err := app.PatchConfig([]string{"preload", src}, rawQuery); err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+		}
+
+	case "DELETE":
+		if err := DelPreload(src); err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		if err := app.PatchConfig([]string{"preload", src}, nil); err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+		}
+
+	default:
+		http.Error(w, "", http.StatusMethodNotAllowed)
+	}
+}
+
+func apiSchemes(w http.ResponseWriter, r *http.Request) {
+	api.ResponseJSON(w, SupportedSchemes())
+}
diff --git a/installs_on_host/go2rtc/internal/streams/api_test.go b/installs_on_host/go2rtc/internal/streams/api_test.go
new file mode 100644
index 0000000..2cb93d2
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/streams/api_test.go
@@ -0,0 +1,66 @@
+package streams
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/stretchr/testify/require"
+)
+
+func TestApiSchemes(t *testing.T) {
+	// Setup: Register some test handlers and redirects
+	HandleFunc("rtsp", func(url string) (core.Producer, error) { return nil, nil })
+	HandleFunc("rtmp", func(url string) (core.Producer, error) { return nil, nil })
+	RedirectFunc("http", func(url string) (string, error) { return "", nil })
+
+	t.Run("GET request returns schemes", func(t *testing.T) {
+		req := httptest.NewRequest("GET", "/api/schemes", nil)
+		w := httptest.NewRecorder()
+
+		apiSchemes(w, req)
+
+		require.Equal(t, http.StatusOK, w.Code)
+		require.Equal(t, "application/json", w.Header().Get("Content-Type"))
+
+		var schemes []string
+		err := json.Unmarshal(w.Body.Bytes(), &schemes)
+		require.NoError(t, err)
+		require.NotEmpty(t, schemes)
+
+		// Check that our test schemes are in the response
+		require.Contains(t, schemes, "rtsp")
+		require.Contains(t, schemes, "rtmp")
+		require.Contains(t, schemes, "http")
+	})
+}
+
+func TestApiSchemesNoDuplicates(t *testing.T) {
+	// Setup: Register a scheme in both handlers and redirects
+	HandleFunc("duplicate", func(url string) (core.Producer, error) { return nil, nil })
+	RedirectFunc("duplicate", func(url string) (string, error) { return "", nil })
+
+	req := httptest.NewRequest("GET", "/api/schemes", nil)
+	w := httptest.NewRecorder()
+
+	apiSchemes(w, req)
+
+	require.Equal(t, http.StatusOK, w.Code)
+
+	var schemes []string
+	err := json.Unmarshal(w.Body.Bytes(), &schemes)
+	require.NoError(t, err)
+
+	// Count occurrences of "duplicate"
+	count := 0
+	for _, scheme := range schemes {
+		if scheme == "duplicate" {
+			count++
+		}
+	}
+
+	// Should only appear once
+	require.Equal(t, 1, count, "scheme 'duplicate' should appear exactly once")
+}
diff --git a/installs_on_host/go2rtc/internal/streams/dot.go b/installs_on_host/go2rtc/internal/streams/dot.go
new file mode 100644
index 0000000..e041797
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/streams/dot.go
@@ -0,0 +1,176 @@
+package streams
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+func AppendDOT(dot []byte, stream *Stream) []byte {
+	for _, prod := range stream.producers {
+		if prod.conn == nil {
+			continue
+		}
+		c, err := marshalConn(prod.conn)
+		if err != nil {
+			continue
+		}
+		dot = c.appendDOT(dot, "producer")
+	}
+	for _, cons := range stream.consumers {
+		c, err := marshalConn(cons)
+		if err != nil {
+			continue
+		}
+		dot = c.appendDOT(dot, "consumer")
+	}
+	return dot
+}
+
+func marshalConn(v any) (*conn, error) {
+	b, err := json.Marshal(v)
+	if err != nil {
+		return nil, err
+	}
+	var c conn
+	if err = json.Unmarshal(b, &c); err != nil {
+		return nil, err
+	}
+	return &c, nil
+}
+
+const bytesK = "KMGTP"
+
+func humanBytes(i int) string {
+	if i < 1000 {
+		return fmt.Sprintf("%d B", i)
+	}
+
+	f := float64(i) / 1000
+	var n uint8
+	for f >= 1000 && n < 5 {
+		f /= 1000
+		n++
+	}
+	return fmt.Sprintf("%.2f %cB", f, bytesK[n])
+}
+
+type node struct {
+	ID     uint32         `json:"id"`
+	Codec  map[string]any `json:"codec"`
+	Parent uint32         `json:"parent"`
+	Childs []uint32       `json:"childs"`
+	Bytes  int            `json:"bytes"`
+	//Packets uint32         `json:"packets"`
+	//Drops   uint32         `json:"drops"`
+}
+
+var codecKeys = []string{"codec_name", "sample_rate", "channels", "profile", "level"}
+
+func (n *node) name() string {
+	if name, ok := n.Codec["codec_name"].(string); ok {
+		return name
+	}
+	return "unknown"
+}
+
+func (n *node) codec() []byte {
+	b := make([]byte, 0, 128)
+	for _, k := range codecKeys {
+		if v := n.Codec[k]; v != nil {
+			b = fmt.Appendf(b, "%s=%v\n", k, v)
+		}
+	}
+	if l := len(b); l > 0 {
+		return b[:l-1]
+	}
+	return b
+}
+
+func (n *node) appendDOT(dot []byte, group string) []byte {
+	dot = fmt.Appendf(dot, "%d [group=%s, label=%q, title=%q];\n", n.ID, group, n.name(), n.codec())
+	//for _, sink := range n.Childs {
+	//	dot = fmt.Appendf(dot, "%d -> %d;\n", n.ID, sink)
+	//}
+	return dot
+}
+
+type conn struct {
+	ID         uint32 `json:"id"`
+	FormatName string `json:"format_name"`
+	Protocol   string `json:"protocol"`
+	RemoteAddr string `json:"remote_addr"`
+	Source     string `json:"source"`
+	URL        string `json:"url"`
+	UserAgent  string `json:"user_agent"`
+	Receivers  []node `json:"receivers"`
+	Senders    []node `json:"senders"`
+	BytesRecv  int    `json:"bytes_recv"`
+	BytesSend  int    `json:"bytes_send"`
+}
+
+func (c *conn) appendDOT(dot []byte, group string) []byte {
+	host := c.host()
+	dot = fmt.Appendf(dot, "%s [group=host];\n", host)
+	dot = fmt.Appendf(dot, "%d [group=%s, label=%q, title=%q];\n", c.ID, group, c.FormatName, c.label())
+	if group == "producer" {
+		dot = fmt.Appendf(dot, "%s -> %d [label=%q];\n", host, c.ID, humanBytes(c.BytesRecv))
+	} else {
+		dot = fmt.Appendf(dot, "%d -> %s [label=%q];\n", c.ID, host, humanBytes(c.BytesSend))
+	}
+
+	for _, recv := range c.Receivers {
+		dot = fmt.Appendf(dot, "%d -> %d [label=%q];\n", c.ID, recv.ID, humanBytes(recv.Bytes))
+		dot = recv.appendDOT(dot, "node")
+	}
+	for _, send := range c.Senders {
+		dot = fmt.Appendf(dot, "%d -> %d [label=%q];\n", send.Parent, c.ID, humanBytes(send.Bytes))
+		//dot = fmt.Appendf(dot, "%d -> %d [label=%q];\n", send.ID, c.ID, humanBytes(send.Bytes))
+		//dot = send.appendDOT(dot, "node")
+	}
+	return dot
+}
+
+func (c *conn) host() (s string) {
+	if c.Protocol == "pipe" {
+		return "127.0.0.1"
+	}
+
+	if s = c.RemoteAddr; s == "" {
+		return "unknown"
+	}
+
+	if i := strings.Index(s, "forwarded"); i > 0 {
+		s = s[i+10:]
+	}
+
+	if s[0] == '[' {
+		if i := strings.Index(s, "]"); i > 0 {
+			return s[1:i]
+		}
+	}
+
+	if i := strings.IndexAny(s, " ,:"); i > 0 {
+		return s[:i]
+	}
+	return
+}
+
+func (c *conn) label() string {
+	var sb strings.Builder
+	sb.WriteString("format_name=" + c.FormatName)
+	if c.Protocol != "" {
+		sb.WriteString("\nprotocol=" + c.Protocol)
+	}
+	if c.Source != "" {
+		sb.WriteString("\nsource=" + c.Source)
+	}
+	if c.URL != "" {
+		sb.WriteString("\nurl=" + c.URL)
+	}
+	if c.UserAgent != "" {
+		sb.WriteString("\nuser_agent=" + c.UserAgent)
+	}
+	// escape quotes https://github.com/AlexxIT/go2rtc/issues/1603
+	return strings.ReplaceAll(sb.String(), `"`, `'`)
+}
diff --git a/installs_on_host/go2rtc/internal/streams/handlers.go b/installs_on_host/go2rtc/internal/streams/handlers.go
new file mode 100644
index 0000000..9433044
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/streams/handlers.go
@@ -0,0 +1,134 @@
+package streams
+
+import (
+	"errors"
+	"regexp"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+type Handler func(source string) (core.Producer, error)
+
+var handlers = map[string]Handler{}
+
+func HandleFunc(scheme string, handler Handler) {
+	handlers[scheme] = handler
+}
+
+func SupportedSchemes() []string {
+	uniqueKeys := make(map[string]struct{}, len(handlers)+len(redirects))
+	for scheme := range handlers {
+		uniqueKeys[scheme] = struct{}{}
+	}
+	for scheme := range redirects {
+		uniqueKeys[scheme] = struct{}{}
+	}
+	resultKeys := make([]string, 0, len(uniqueKeys))
+	for key := range uniqueKeys {
+		resultKeys = append(resultKeys, key)
+	}
+	return resultKeys
+}
+
+func HasProducer(url string) bool {
+	if i := strings.IndexByte(url, ':'); i > 0 {
+		scheme := url[:i]
+
+		if _, ok := handlers[scheme]; ok {
+			return true
+		}
+
+		if _, ok := redirects[scheme]; ok {
+			return true
+		}
+	}
+
+	return false
+}
+
+func GetProducer(url string) (core.Producer, error) {
+	if i := strings.IndexByte(url, ':'); i > 0 {
+		scheme := url[:i]
+
+		if redirect, ok := redirects[scheme]; ok {
+			location, err := redirect(url)
+			if err != nil {
+				return nil, err
+			}
+			if location != "" {
+				return GetProducer(location)
+			}
+		}
+
+		if handler, ok := handlers[scheme]; ok {
+			return handler(url)
+		}
+	}
+
+	return nil, errors.New("streams: unsupported scheme: " + url)
+}
+
+// Redirect can return: location URL or error or empty URL and error
+type Redirect func(url string) (string, error)
+
+var redirects = map[string]Redirect{}
+
+func RedirectFunc(scheme string, redirect Redirect) {
+	redirects[scheme] = redirect
+}
+
+func Location(url string) (string, error) {
+	if i := strings.IndexByte(url, ':'); i > 0 {
+		scheme := url[:i]
+
+		if redirect, ok := redirects[scheme]; ok {
+			return redirect(url)
+		}
+	}
+
+	return "", nil
+}
+
+// TODO: rework
+
+type ConsumerHandler func(url string) (core.Consumer, func(), error)
+
+var consumerHandlers = map[string]ConsumerHandler{}
+
+func HandleConsumerFunc(scheme string, handler ConsumerHandler) {
+	consumerHandlers[scheme] = handler
+}
+
+func GetConsumer(url string) (core.Consumer, func(), error) {
+	if i := strings.IndexByte(url, ':'); i > 0 {
+		scheme := url[:i]
+
+		if handler, ok := consumerHandlers[scheme]; ok {
+			return handler(url)
+		}
+	}
+
+	return nil, nil, errors.New("streams: unsupported scheme: " + url)
+}
+
+var insecure = map[string]bool{}
+
+func MarkInsecure(scheme string) {
+	insecure[scheme] = true
+}
+
+var sanitize = regexp.MustCompile(`\s`)
+
+func Validate(source string) error {
+	// TODO: Review the entire logic of insecure sources
+	if i := strings.IndexByte(source, ':'); i > 0 {
+		if insecure[source[:i]] {
+			return errors.New("streams: source from insecure producer")
+		}
+	}
+	if sanitize.MatchString(source) {
+		return errors.New("streams: source with spaces may be insecure")
+	}
+	return nil
+}
diff --git a/installs_on_host/go2rtc/internal/streams/helpers.go b/installs_on_host/go2rtc/internal/streams/helpers.go
new file mode 100644
index 0000000..2ead1aa
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/streams/helpers.go
@@ -0,0 +1,22 @@
+package streams
+
+import (
+	"net/url"
+	"strings"
+)
+
+func ParseQuery(s string) url.Values {
+	if len(s) == 0 {
+		return nil
+	}
+	params := url.Values{}
+	for _, key := range strings.Split(s, "#") {
+		var value string
+		i := strings.IndexByte(key, '=')
+		if i > 0 {
+			key, value = key[:i], key[i+1:]
+		}
+		params[key] = append(params[key], value)
+	}
+	return params
+}
diff --git a/installs_on_host/go2rtc/internal/streams/play.go b/installs_on_host/go2rtc/internal/streams/play.go
new file mode 100644
index 0000000..1f8c4ad
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/streams/play.go
@@ -0,0 +1,163 @@
+package streams
+
+import (
+	"errors"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func (s *Stream) Play(urlOrProd any) error {
+	s.mu.Lock()
+	for _, producer := range s.producers {
+		if producer.state == stateInternal && producer.conn != nil {
+			_ = producer.conn.Stop()
+		}
+	}
+	s.mu.Unlock()
+
+	var source string
+	var src core.Producer
+
+	switch urlOrProd.(type) {
+	case string:
+		if source = urlOrProd.(string); source == "" {
+			return nil
+		}
+	case core.Producer:
+		src = urlOrProd.(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() {
+			_ = dst.Start()
+			_ = src.Stop()
+			s.RemoveInternalConsumer(cons)
+		}()
+
+		go func() {
+			_ = src.Start()
+			// little timeout before stop dst, so the buffer can be transferred
+			time.Sleep(time.Second)
+			_ = dst.Stop()
+			s.RemoveProducer(src)
+		}()
+
+		return nil
+	}
+
+	return errors.New("can't find consumer")
+}
+
+func (s *Stream) AddInternalProducer(conn core.Producer) {
+	producer := &Producer{conn: conn, state: stateInternal, url: "internal"}
+	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 {
+				log.Warn().Err(err).Msg("[streams] can't get track")
+				continue
+			}
+
+			if err = cons.AddTrack(consMedia, consCodec, track); err != nil {
+				log.Warn().Err(err).Msg("[streams] can't add track")
+				continue
+			}
+
+			return true
+		}
+	}
+
+	return false
+}
diff --git a/installs_on_host/go2rtc/internal/streams/preload.go b/installs_on_host/go2rtc/internal/streams/preload.go
new file mode 100644
index 0000000..ac4403d
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/streams/preload.go
@@ -0,0 +1,69 @@
+package streams
+
+import (
+	"fmt"
+	"maps"
+	"net/url"
+	"sync"
+
+	"github.com/AlexxIT/go2rtc/pkg/probe"
+)
+
+type Preload struct {
+	stream *Stream      // Don't include the stream in JSON to avoid leaking secrets.
+	Cons   *probe.Probe `json:"consumer"`
+	Query  string       `json:"query"`
+}
+
+var preloads = map[string]*Preload{}
+var preloadsMu sync.Mutex
+
+func AddPreload(name, rawQuery string) error {
+	if rawQuery == "" {
+		rawQuery = "video&audio"
+	}
+
+	query, err := url.ParseQuery(rawQuery)
+	if err != nil {
+		return err
+	}
+
+	preloadsMu.Lock()
+	defer preloadsMu.Unlock()
+
+	if p := preloads[name]; p != nil {
+		p.stream.RemoveConsumer(p.Cons)
+	}
+
+	stream := Get(name)
+	if stream == nil {
+		return fmt.Errorf("streams: stream not found: %s", name)
+	}
+	cons := probe.Create("preload", query)
+
+	if err = stream.AddConsumer(cons); err != nil {
+		return err
+	}
+
+	preloads[name] = &Preload{stream: stream, Cons: cons, Query: rawQuery}
+	return nil
+}
+
+func DelPreload(name string) error {
+	preloadsMu.Lock()
+	defer preloadsMu.Unlock()
+
+	if p := preloads[name]; p != nil {
+		p.stream.RemoveConsumer(p.Cons)
+		delete(preloads, name)
+		return nil
+	}
+
+	return fmt.Errorf("streams: preload not found: %s", name)
+}
+
+func GetPreloads() map[string]*Preload {
+	preloadsMu.Lock()
+	defer preloadsMu.Unlock()
+	return maps.Clone(preloads)
+}
diff --git a/installs_on_host/go2rtc/internal/streams/producer.go b/installs_on_host/go2rtc/internal/streams/producer.go
new file mode 100644
index 0000000..09e2dcc
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/streams/producer.go
@@ -0,0 +1,270 @@
+package streams
+
+import (
+	"encoding/json"
+	"errors"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+type state byte
+
+const (
+	stateNone state = iota
+	stateMedias
+	stateTracks
+	stateStart
+	stateExternal
+	stateInternal
+)
+
+type Producer struct {
+	core.Listener
+
+	url      string
+	template string
+
+	conn      core.Producer
+	receivers []*core.Receiver
+	senders   []*core.Receiver
+
+	state    state
+	mu       sync.Mutex
+	workerID int
+}
+
+const SourceTemplate = "{input}"
+
+func NewProducer(source string) *Producer {
+	if strings.Contains(source, SourceTemplate) {
+		return &Producer{template: source}
+	}
+
+	return &Producer{url: source}
+}
+
+func (p *Producer) SetSource(s string) {
+	if p.template == "" {
+		p.url = s
+	} else {
+		p.url = strings.Replace(p.template, SourceTemplate, s, 1)
+	}
+}
+
+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()
+
+	if p.conn == nil {
+		return nil
+	}
+
+	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) MarshalJSON() ([]byte, error) {
+	if conn := p.conn; conn != nil {
+		return json.Marshal(conn)
+	}
+	info := map[string]string{"url": p.url}
+	return json.Marshal(info)
+}
+
+// internals
+
+func (p *Producer) start() {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if p.state != stateTracks {
+		return
+	}
+
+	log.Debug().Msgf("[streams] start producer url=%s", p.url)
+
+	p.state = stateStart
+	p.workerID++
+
+	go p.worker(p.conn, p.workerID)
+}
+
+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, 0)
+}
+
+func (p *Producer) reconnect(workerID, retry int) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if p.workerID != workerID {
+		log.Trace().Msgf("[streams] stop reconnect url=%s", p.url)
+		return
+	}
+
+	log.Debug().Msgf("[streams] retry=%d to url=%s", retry, p.url)
+
+	conn, err := GetProducer(p.url)
+	if err != nil {
+		log.Debug().Msgf("[streams] producer=%s", err)
+
+		timeout := time.Minute
+		if retry < 5 {
+			timeout = time.Second
+		} else if retry < 10 {
+			timeout = time.Second * 5
+		} else if retry < 20 {
+			timeout = time.Second * 10
+		}
+
+		time.AfterFunc(timeout, func() {
+			p.reconnect(workerID, retry+1)
+		})
+		return
+	}
+
+	for _, media := range conn.GetMedias() {
+		switch media.Direction {
+		case core.DirectionRecvonly:
+			for i, receiver := range p.receivers {
+				codec := media.MatchCodec(receiver.Codec)
+				if codec == nil {
+					continue
+				}
+
+				track, err := conn.GetTrack(media, codec)
+				if err != nil {
+					continue
+				}
+
+				receiver.Replace(track)
+				p.receivers[i] = track
+				break
+			}
+
+		case core.DirectionSendonly:
+			for _, sender := range p.senders {
+				codec := media.MatchCodec(sender.Codec)
+				if codec == nil {
+					continue
+				}
+
+				_ = conn.(core.Consumer).AddTrack(media, codec, sender)
+			}
+		}
+	}
+
+	// stop previous connection after moving tracks (fix ghost exec/ffmpeg)
+	_ = p.conn.Stop()
+	// swap connections
+	p.conn = conn
+
+	go p.worker(conn, workerID)
+}
+
+func (p *Producer) stop() {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	switch p.state {
+	case stateExternal:
+		log.Trace().Msgf("[streams] skip stop external producer")
+		return
+	case stateNone:
+		log.Trace().Msgf("[streams] skip stop none producer")
+		return
+	case stateStart:
+		p.workerID++
+	}
+
+	log.Debug().Msgf("[streams] stop producer url=%s", p.url)
+
+	if p.conn != nil {
+		_ = p.conn.Stop()
+		p.conn = nil
+	}
+
+	p.state = stateNone
+	p.receivers = nil
+	p.senders = nil
+}
diff --git a/installs_on_host/go2rtc/internal/streams/publish.go b/installs_on_host/go2rtc/internal/streams/publish.go
new file mode 100644
index 0000000..a16dcec
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/streams/publish.go
@@ -0,0 +1,38 @@
+package streams
+
+import "time"
+
+func (s *Stream) Publish(url string) error {
+	cons, run, err := GetConsumer(url)
+	if err != nil {
+		return err
+	}
+
+	if err = s.AddConsumer(cons); err != nil {
+		return err
+	}
+
+	go func() {
+		run()
+		s.RemoveConsumer(cons)
+
+		// TODO: more smart retry
+		time.Sleep(5 * time.Second)
+		_ = s.Publish(url)
+	}()
+
+	return nil
+}
+
+func Publish(stream *Stream, destination any) {
+	switch v := destination.(type) {
+	case string:
+		if err := stream.Publish(v); err != nil {
+			log.Error().Err(err).Caller().Send()
+		}
+	case []any:
+		for _, v := range v {
+			Publish(stream, v)
+		}
+	}
+}
diff --git a/installs_on_host/go2rtc/internal/streams/stream.go b/installs_on_host/go2rtc/internal/streams/stream.go
new file mode 100644
index 0000000..984c73e
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/streams/stream.go
@@ -0,0 +1,130 @@
+package streams
+
+import (
+	"encoding/json"
+	"sync"
+	"sync/atomic"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+type Stream struct {
+	producers []*Producer
+	consumers []core.Consumer
+	mu        sync.Mutex
+	pending   atomic.Int32
+}
+
+func NewStream(source any) *Stream {
+	switch source := source.(type) {
+	case string:
+		return &Stream{
+			producers: []*Producer{NewProducer(source)},
+		}
+	case []string:
+		s := new(Stream)
+		for _, str := range source {
+			s.producers = append(s.producers, NewProducer(str))
+		}
+		return s
+	case []any:
+		s := new(Stream)
+		for _, src := range source {
+			str, ok := src.(string)
+			if !ok {
+				log.Error().Msgf("[stream] NewStream: Expected string, got %v", src)
+				continue
+			}
+			s.producers = append(s.producers, NewProducer(str))
+		}
+		return s
+	case map[string]any:
+		return NewStream(source["url"])
+	case nil:
+		return new(Stream)
+	default:
+		panic(core.Caller())
+	}
+}
+
+func (s *Stream) Sources() []string {
+	sources := make([]string, 0, len(s.producers))
+	for _, prod := range s.producers {
+		sources = append(sources, prod.url)
+	}
+	return sources
+}
+
+func (s *Stream) SetSource(source string) {
+	for _, prod := range s.producers {
+		prod.SetSource(source)
+	}
+}
+
+func (s *Stream) RemoveConsumer(cons core.Consumer) {
+	_ = cons.Stop()
+
+	s.mu.Lock()
+	for i, consumer := range s.consumers {
+		if consumer == cons {
+			s.consumers = append(s.consumers[:i], s.consumers[i+1:]...)
+			break
+		}
+	}
+	s.mu.Unlock()
+
+	s.stopProducers()
+}
+
+func (s *Stream) AddProducer(prod core.Producer) {
+	producer := &Producer{conn: prod, state: stateExternal, url: "external"}
+	s.mu.Lock()
+	s.producers = append(s.producers, producer)
+	s.mu.Unlock()
+}
+
+func (s *Stream) RemoveProducer(prod core.Producer) {
+	s.mu.Lock()
+	for i, producer := range s.producers {
+		if producer.conn == prod {
+			s.producers = append(s.producers[:i], s.producers[i+1:]...)
+			break
+		}
+	}
+	s.mu.Unlock()
+}
+
+func (s *Stream) stopProducers() {
+	if s.pending.Load() > 0 {
+		log.Trace().Msg("[streams] skip stop pending producer")
+		return
+	}
+
+	s.mu.Lock()
+producers:
+	for _, producer := range s.producers {
+		for _, track := range producer.receivers {
+			if len(track.Senders()) > 0 {
+				continue producers
+			}
+		}
+		for _, track := range producer.senders {
+			if len(track.Senders()) > 0 {
+				continue producers
+			}
+		}
+		producer.stop()
+	}
+	s.mu.Unlock()
+}
+
+func (s *Stream) MarshalJSON() ([]byte, error) {
+	var info = struct {
+		Producers []*Producer     `json:"producers"`
+		Consumers []core.Consumer `json:"consumers"`
+	}{
+		Producers: s.producers,
+		Consumers: s.consumers,
+	}
+	return json.Marshal(info)
+}
diff --git a/installs_on_host/go2rtc/internal/streams/stream_test.go b/installs_on_host/go2rtc/internal/streams/stream_test.go
new file mode 100644
index 0000000..bc4c18b
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/streams/stream_test.go
@@ -0,0 +1,42 @@
+package streams
+
+import (
+	"net/url"
+	"testing"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/stretchr/testify/require"
+)
+
+func TestRecursion(t *testing.T) {
+	// create stream with some source
+	stream1, err := New("from_yaml", "does_not_matter")
+	require.NoError(t, err)
+	require.Len(t, streams, 1)
+
+	// ask another unnamed stream that links go2rtc
+	query, err := url.ParseQuery("src=rtsp://localhost:8554/from_yaml?video")
+	require.NoError(t, err)
+	stream2, err := GetOrPatch(query)
+	require.NoError(t, err)
+
+	// check stream is same
+	require.Equal(t, stream1, stream2)
+	// check stream urls is same
+	require.Equal(t, stream1.producers[0].url, stream2.producers[0].url)
+	require.Len(t, streams, 2)
+}
+
+func TestTempate(t *testing.T) {
+	HandleFunc("rtsp", func(url string) (core.Producer, error) { return nil, nil }) // bypass HasProducer
+
+	// config from yaml
+	stream1, err := New("camera.from_hass", "ffmpeg:{input}#video=copy")
+	require.NoError(t, err)
+	// request from hass
+	stream2, err := Patch("camera.from_hass", "rtsp://example.com")
+	require.NoError(t, err)
+
+	require.Equal(t, stream1, stream2)
+	require.Equal(t, "ffmpeg:rtsp://example.com#video=copy", stream1.producers[0].url)
+}
diff --git a/installs_on_host/go2rtc/internal/streams/streams.go b/installs_on_host/go2rtc/internal/streams/streams.go
new file mode 100644
index 0000000..f3b8df0
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/streams/streams.go
@@ -0,0 +1,176 @@
+package streams
+
+import (
+	"errors"
+	"net/url"
+	"sync"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/rs/zerolog"
+)
+
+func Init() {
+	var cfg struct {
+		Streams map[string]any    `yaml:"streams"`
+		Publish map[string]any    `yaml:"publish"`
+		Preload map[string]string `yaml:"preload"`
+	}
+
+	app.LoadConfig(&cfg)
+
+	log = app.GetLogger("streams")
+
+	for name, item := range cfg.Streams {
+		streams[name] = NewStream(item)
+	}
+
+	api.HandleFunc("api/streams", apiStreams)
+	api.HandleFunc("api/streams.dot", apiStreamsDOT)
+	api.HandleFunc("api/preload", apiPreload)
+	api.HandleFunc("api/schemes", apiSchemes)
+
+	if cfg.Publish == nil && cfg.Preload == nil {
+		return
+	}
+
+	time.AfterFunc(time.Second, func() {
+		// range for nil map is OK
+		for name, dst := range cfg.Publish {
+			if stream := Get(name); stream != nil {
+				Publish(stream, dst)
+			}
+		}
+		for name, rawQuery := range cfg.Preload {
+			if err := AddPreload(name, rawQuery); err != nil {
+				log.Error().Err(err).Caller().Send()
+			}
+		}
+	})
+}
+
+func New(name string, sources ...string) (*Stream, error) {
+	for _, source := range sources {
+		if !HasProducer(source) {
+			return nil, errors.New("streams: source not supported")
+		}
+
+		if err := Validate(source); err != nil {
+			return nil, err
+		}
+	}
+
+	stream := NewStream(sources)
+
+	streamsMu.Lock()
+	streams[name] = stream
+	streamsMu.Unlock()
+
+	return stream, nil
+}
+
+func Patch(name string, source string) (*Stream, error) {
+	streamsMu.Lock()
+	defer streamsMu.Unlock()
+
+	// check if source links to some stream name from go2rtc
+	if u, err := url.Parse(source); err == nil && u.Scheme == "rtsp" && len(u.Path) > 1 {
+		rtspName := u.Path[1:]
+		if stream, ok := streams[rtspName]; ok {
+			if streams[name] != stream {
+				// link (alias) streams[name] to streams[rtspName]
+				streams[name] = stream
+			}
+			return stream, nil
+		}
+	}
+
+	if stream, ok := streams[source]; ok {
+		if name != source {
+			// link (alias) streams[name] to streams[source]
+			streams[name] = stream
+		}
+		return stream, nil
+	}
+
+	// check if src has supported scheme
+	if !HasProducer(source) {
+		return nil, errors.New("streams: source not supported")
+	}
+
+	if err := Validate(source); err != nil {
+		return nil, err
+	}
+
+	// check an existing stream with this name
+	if stream, ok := streams[name]; ok {
+		stream.SetSource(source)
+		return stream, nil
+	}
+
+	// create new stream with this name
+	stream := NewStream(source)
+	streams[name] = stream
+	return stream, nil
+}
+
+func GetOrPatch(query url.Values) (*Stream, error) {
+	// check if src param exists
+	source := query.Get("src")
+	if source == "" {
+		return nil, errors.New("streams: source empty")
+	}
+
+	// check if src is stream name
+	if stream := Get(source); stream != nil {
+		return stream, nil
+	}
+
+	// check if name param provided
+	if name := query.Get("name"); name != "" {
+		return Patch(name, source)
+	}
+
+	// return new stream with src as name
+	return Patch(source, source)
+}
+
+var log zerolog.Logger
+
+// streams map
+
+var streams = map[string]*Stream{}
+var streamsMu sync.Mutex
+
+func Get(name string) *Stream {
+	streamsMu.Lock()
+	defer streamsMu.Unlock()
+	return streams[name]
+}
+
+func Delete(name string) {
+	streamsMu.Lock()
+	defer streamsMu.Unlock()
+	delete(streams, name)
+}
+
+func GetAllNames() []string {
+	streamsMu.Lock()
+	names := make([]string, 0, len(streams))
+	for name := range streams {
+		names = append(names, name)
+	}
+	streamsMu.Unlock()
+	return names
+}
+
+func GetAllSources() map[string][]string {
+	streamsMu.Lock()
+	sources := make(map[string][]string, len(streams))
+	for name, stream := range streams {
+		sources[name] = stream.Sources()
+	}
+	streamsMu.Unlock()
+	return sources
+}
diff --git a/installs_on_host/go2rtc/internal/tapo/README.md b/installs_on_host/go2rtc/internal/tapo/README.md
new file mode 100644
index 0000000..e8723d2
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/tapo/README.md
@@ -0,0 +1,61 @@
+# TP-Link Tapo
+
+[`new in v1.2.0`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.2.0)
+
+[TP-Link Tapo](https://www.tapo.com/) proprietary camera protocol with **two-way audio** support.
+
+- stream quality is the same as [RTSP protocol](https://www.tapo.com/en/faq/34/)
+- use the **cloud password**, this is not the RTSP password! you do not need to add a login!
+- you can also use **UPPERCASE** MD5 hash from your cloud password with `admin` username
+- some new camera firmwares require SHA256 instead of MD5
+
+## Configuration
+
+```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:UPPERCASE-MD5@192.168.1.123
+  # admin username and UPPERCASE SHA256 cloud-password hash
+  camera3: tapo://admin:UPPERCASE-SHA256@192.168.1.123
+  # VGA stream (the so called substream, the lower resolution one)
+  camera4: tapo://cloud-password@192.168.1.123?subtype=1 
+  # HD stream (default)
+  camera5: tapo://cloud-password@192.168.1.123?subtype=0 
+```
+
+```bash
+echo -n "cloud password" | md5 | awk '{print toupper($0)}'
+echo -n "cloud password" | shasum -a 256 | awk '{print toupper($0)}'
+```
+
+## TP-Link Kasa
+
+[`new in v1.7.0`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.7.0)
+
+> [!NOTE]
+> This source should be moved to separate module. Because it's source code not related to Tapo.
+
+[TP-Link Kasa](https://www.kasasmart.com/) non-standard protocol [more info](https://medium.com/@hu3vjeen/reverse-engineering-tp-link-kc100-bac4641bf1cd).
+
+- `username` - urlsafe email, `alex@gmail.com` -> `alex%40gmail.com`
+- `password` - base64password, `secret1` -> `c2VjcmV0MQ==`
+
+```yaml
+streams:
+  kc401: kasa://username:password@192.168.1.123:19443/https/stream/mixed
+```
+
+Tested: KD110, KC200, KC401, KC420WS, EC71.
+
+## TP-Link Vigi
+
+[`new in v1.9.8`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.9.8)
+
+[TP-Link VIGI](https://www.vigi.com/) cameras. These are cameras from a different sub-brand, but the format is very similar to Tapo. Only the authorization is different. Read more [here](https://github.com/AlexxIT/go2rtc/issues/1470).
+
+```yaml
+streams:
+  camera1: vigi://admin:{password}@192.168.1.123
+```
diff --git a/installs_on_host/go2rtc/internal/tapo/tapo.go b/installs_on_host/go2rtc/internal/tapo/tapo.go
new file mode 100644
index 0000000..88eff5c
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/tapo/tapo.go
@@ -0,0 +1,22 @@
+package tapo
+
+import (
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/kasa"
+	"github.com/AlexxIT/go2rtc/pkg/tapo"
+)
+
+func Init() {
+	streams.HandleFunc("kasa", func(source string) (core.Producer, error) {
+		return kasa.Dial(source)
+	})
+
+	streams.HandleFunc("tapo", func(source string) (core.Producer, error) {
+		return tapo.Dial(source)
+	})
+
+	streams.HandleFunc("vigi", func(source string) (core.Producer, error) {
+		return tapo.Dial(source)
+	})
+}
diff --git a/installs_on_host/go2rtc/internal/tuya/README.md b/installs_on_host/go2rtc/internal/tuya/README.md
new file mode 100644
index 0000000..e9295ee
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/tuya/README.md
@@ -0,0 +1,39 @@
+# Tuya
+
+[`new in v1.9.13`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.9.13) by [@seydx](https://github.com/seydx)
+
+[Tuya](https://www.tuya.com/) is a proprietary camera protocol with **two-way audio** support. go2rtc supports `Tuya Smart API` and `Tuya Cloud API`.
+
+**Tuya Smart API (recommended)**:
+- **Smart Life accounts are NOT supported**, you need to create a Tuya Smart account. If the cameras are already added to the Smart Life app, you need to remove them and add them again to the [Tuya Smart](https://play.google.com/store/apps/details?id=com.tuya.smart) app.
+- Cameras can be discovered through the go2rtc web interface via Tuya Smart account (Add > Tuya > Select region and fill in email and password > Login).
+
+**Tuya Cloud API**:
+- Requires setting up a cloud project in the Tuya Developer Platform.
+- Obtain `device_id`, `client_id`, `client_secret`, and `uid` from [Tuya IoT Platform](https://iot.tuya.com/). [Here's a guide](https://xzetsubou.github.io/hass-localtuya/cloud_api/).
+- Please ensure that you have subscribed to the `IoT Video Live Stream` service (Free Trial) in the Tuya Developer Platform, otherwise the stream will not work (Tuya Developer Platform > Service API > Authorize > IoT Video Live Stream).
+
+## Configuration
+
+Use the `resolution` parameter to select the stream (not all cameras support an `hd` stream through WebRTC even if the camera supports it):
+- `hd` - HD stream (default)
+- `sd` - SD stream
+
+```yaml
+streams:
+  # Tuya Smart API: WebRTC main stream (use Add > Tuya to discover the URL)
+  tuya_main:
+    - tuya://protect-us.ismartlife.me?device_id=XXX&email=XXX&password=XXX
+
+  # Tuya Smart API: WebRTC sub stream (use Add > Tuya to discover the URL)
+  tuya_sub:
+    - tuya://protect-us.ismartlife.me?device_id=XXX&email=XXX&password=XXX&resolution=sd
+
+  # Tuya Cloud API: WebRTC main stream
+  tuya_webrtc:
+   - tuya://openapi.tuyaus.com?device_id=XXX&uid=XXX&client_id=XXX&client_secret=XXX
+  
+  # Tuya Cloud API: WebRTC sub stream
+  tuya_webrtc_sd:
+   - tuya://openapi.tuyaus.com?device_id=XXX&uid=XXX&client_id=XXX&client_secret=XXX&resolution=sd
+```
diff --git a/installs_on_host/go2rtc/internal/tuya/tuya.go b/installs_on_host/go2rtc/internal/tuya/tuya.go
new file mode 100644
index 0000000..9dcf272
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/tuya/tuya.go
@@ -0,0 +1,248 @@
+package tuya
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strconv"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/tuya"
+)
+
+func Init() {
+	streams.HandleFunc("tuya", func(source string) (core.Producer, error) {
+		return tuya.Dial(source)
+	})
+
+	api.HandleFunc("api/tuya", apiTuya)
+}
+
+func apiTuya(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+	region := query.Get("region")
+	email := query.Get("email")
+	password := query.Get("password")
+
+	if email == "" || password == "" || region == "" {
+		http.Error(w, "email, password and region are required", http.StatusBadRequest)
+		return
+	}
+
+	var tuyaRegion *tuya.Region
+	for _, r := range tuya.AvailableRegions {
+		if r.Host == region {
+			tuyaRegion = &r
+			break
+		}
+	}
+
+	if tuyaRegion == nil {
+		http.Error(w, fmt.Sprintf("invalid region: %s", region), http.StatusBadRequest)
+		return
+	}
+
+	httpClient := tuya.CreateHTTPClientWithSession()
+
+	_, err := login(httpClient, tuyaRegion.Host, email, password, tuyaRegion.Continent)
+	if err != nil {
+		http.Error(w, fmt.Sprintf("login failed: %v", err), http.StatusInternalServerError)
+		return
+	}
+
+	tuyaAPI, err := tuya.NewTuyaSmartApiClient(
+		httpClient,
+		tuyaRegion.Host,
+		email,
+		password,
+		"",
+	)
+
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	var devices []tuya.Device
+
+	homes, _ := tuyaAPI.GetHomeList()
+	if homes != nil && len(homes.Result) > 0 {
+		for _, home := range homes.Result {
+			roomList, err := tuyaAPI.GetRoomList(strconv.Itoa(home.Gid))
+			if err != nil {
+				continue
+			}
+
+			for _, room := range roomList.Result {
+				for _, device := range room.DeviceList {
+					if (device.Category == "sp" || device.Category == "dghsxj") && !containsDevice(devices, device.DeviceId) {
+						devices = append(devices, device)
+					}
+				}
+			}
+		}
+	}
+
+	sharedHomes, _ := tuyaAPI.GetSharedHomeList()
+	if sharedHomes != nil && len(sharedHomes.Result.SecurityWebCShareInfoList) > 0 {
+		for _, sharedHome := range sharedHomes.Result.SecurityWebCShareInfoList {
+			for _, device := range sharedHome.DeviceInfoList {
+				if (device.Category == "sp" || device.Category == "dghsxj") && !containsDevice(devices, device.DeviceId) {
+					devices = append(devices, device)
+				}
+			}
+		}
+	}
+
+	if len(devices) == 0 {
+		http.Error(w, "no cameras found", http.StatusNotFound)
+		return
+	}
+
+	var items []*api.Source
+	for _, device := range devices {
+		cleanQuery := url.Values{}
+		cleanQuery.Set("device_id", device.DeviceId)
+		cleanQuery.Set("email", email)
+		cleanQuery.Set("password", password)
+		url := fmt.Sprintf("tuya://%s?%s", tuyaRegion.Host, cleanQuery.Encode())
+
+		items = append(items, &api.Source{
+			Name: device.DeviceName,
+			URL:  url,
+		})
+	}
+
+	api.ResponseSources(w, items)
+}
+
+func login(client *http.Client, serverHost, email, password, countryCode string) (*tuya.LoginResult, error) {
+	tokenResp, err := getLoginToken(client, serverHost, email, countryCode)
+	if err != nil {
+		return nil, err
+	}
+
+	encryptedPassword, err := tuya.EncryptPassword(password, tokenResp.Result.PbKey)
+	if err != nil {
+		return nil, fmt.Errorf("failed to encrypt password: %v", err)
+	}
+
+	var loginResp *tuya.PasswordLoginResponse
+	var url string
+
+	loginReq := tuya.PasswordLoginRequest{
+		CountryCode: countryCode,
+		Passwd:      encryptedPassword,
+		Token:       tokenResp.Result.Token,
+		IfEncrypt:   1,
+		Options:     `{"group":1}`,
+	}
+
+	if tuya.IsEmailAddress(email) {
+		url = fmt.Sprintf("https://%s/api/private/email/login", serverHost)
+		loginReq.Email = email
+	} else {
+		url = fmt.Sprintf("https://%s/api/private/phone/login", serverHost)
+		loginReq.Mobile = email
+	}
+
+	loginResp, err = performLogin(client, url, loginReq, serverHost)
+
+	if err != nil {
+		return nil, err
+	}
+
+	if !loginResp.Success {
+		return nil, errors.New(loginResp.ErrorMsg)
+	}
+
+	return &loginResp.Result, nil
+}
+
+func getLoginToken(client *http.Client, serverHost, username, countryCode string) (*tuya.LoginTokenResponse, error) {
+	url := fmt.Sprintf("https://%s/api/login/token", serverHost)
+
+	tokenReq := tuya.LoginTokenRequest{
+		CountryCode: countryCode,
+		Username:    username,
+		IsUid:       false,
+	}
+
+	jsonData, err := json.Marshal(tokenReq)
+	if err != nil {
+		return nil, err
+	}
+
+	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Set("Content-Type", "application/json; charset=utf-8")
+	req.Header.Set("Accept", "*/*")
+	req.Header.Set("Origin", fmt.Sprintf("https://%s", serverHost))
+	req.Header.Set("Referer", fmt.Sprintf("https://%s/login", serverHost))
+	req.Header.Set("X-Requested-With", "XMLHttpRequest")
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	var tokenResp tuya.LoginTokenResponse
+	if err = json.NewDecoder(resp.Body).Decode(&tokenResp); err != nil {
+		return nil, err
+	}
+
+	if !tokenResp.Success {
+		return nil, errors.New("tuya: " + tokenResp.Msg)
+	}
+
+	return &tokenResp, nil
+}
+
+func performLogin(client *http.Client, url string, loginReq tuya.PasswordLoginRequest, serverHost string) (*tuya.PasswordLoginResponse, error) {
+	jsonData, err := json.Marshal(loginReq)
+	if err != nil {
+		return nil, err
+	}
+
+	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Set("Content-Type", "application/json; charset=utf-8")
+	req.Header.Set("Accept", "*/*")
+	req.Header.Set("Origin", fmt.Sprintf("https://%s", serverHost))
+	req.Header.Set("Referer", fmt.Sprintf("https://%s/login", serverHost))
+	req.Header.Set("X-Requested-With", "XMLHttpRequest")
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	var loginResp tuya.PasswordLoginResponse
+	if err := json.NewDecoder(resp.Body).Decode(&loginResp); err != nil {
+		return nil, err
+	}
+
+	return &loginResp, nil
+}
+
+func containsDevice(devices []tuya.Device, deviceID string) bool {
+	for _, device := range devices {
+		if device.DeviceId == deviceID {
+			return true
+		}
+	}
+	return false
+}
diff --git a/installs_on_host/go2rtc/internal/v4l2/README.md b/installs_on_host/go2rtc/internal/v4l2/README.md
new file mode 100644
index 0000000..8731cf4
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/v4l2/README.md
@@ -0,0 +1,41 @@
+# Video4Linux
+
+[`new in v1.9.9`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.9.9)
+
+What you should to know about [V4L2](https://en.wikipedia.org/wiki/Video4Linux):
+
+- V4L2 (Video for Linux API version 2) works only in Linux
+- supports USB cameras and other similar devices
+- one device can only be connected to one software simultaneously
+- cameras support a fixed list of formats, resolutions and frame rates
+- basic cameras supports only RAW (non-compressed) pixel formats
+- regular cameras supports MJPEG format (series of JPEG frames)
+- advances cameras support H264 format (MSE/MP4, WebRTC compatible)
+- using MJPEG and H264 formats (if the camera supports them) won't cost you the CPU usage
+- transcoding RAW format to MJPEG or H264 - will cost you a significant CPU usage
+- H265 (HEVC) format is also supported (if the camera supports it)
+
+Tests show that the basic Keenetic router with MIPS processor can broadcast three MJPEG cameras in the following resolutions: 1600х1200 + 640х480 + 640х480. The USB bus bandwidth is no more enough for larger resolutions. CPU consumption is no more than 5%.
+
+Supported formats for your camera can be found here: **Go2rtc > WebUI > Add > V4L2**.
+
+## RAW format
+
+Example:
+
+```yaml
+streams:
+  camera1: v4l2:device?video=/dev/video0&input_format=yuyv422&video_size=1280x720&framerate=10
+```
+
+Go2rtc supports built-in transcoding of RAW to MJPEG format. This does not need to be additionally configured.
+
+```
+ffplay http://localhost:1984/api/stream.mjpeg?src=camera1
+```
+
+**Important.** You don't have to transcode the RAW format to transmit it over the network. You can stream it in `y4m` format, which is perfectly supported by ffmpeg. It won't cost you a CPU usage. But will require high network bandwidth.
+
+```
+ffplay http://localhost:1984/api/stream.y4m?src=camera1
+```
diff --git a/installs_on_host/go2rtc/internal/v4l2/v4l2.go b/installs_on_host/go2rtc/internal/v4l2/v4l2.go
new file mode 100644
index 0000000..3f2e62e
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/v4l2/v4l2.go
@@ -0,0 +1,7 @@
+//go:build !(linux && (386 || arm || mipsle || amd64 || arm64))
+
+package v4l2
+
+func Init() {
+	// not supported
+}
diff --git a/installs_on_host/go2rtc/internal/v4l2/v4l2_linux.go b/installs_on_host/go2rtc/internal/v4l2/v4l2_linux.go
new file mode 100644
index 0000000..0bb0547
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/v4l2/v4l2_linux.go
@@ -0,0 +1,91 @@
+//go:build linux && (386 || arm || mipsle || amd64 || arm64)
+
+package v4l2
+
+import (
+	"encoding/binary"
+	"fmt"
+	"net/http"
+	"os"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/v4l2"
+	"github.com/AlexxIT/go2rtc/pkg/v4l2/device"
+)
+
+func Init() {
+	streams.HandleFunc("v4l2", func(source string) (core.Producer, error) {
+		return v4l2.Open(source)
+	})
+
+	api.HandleFunc("api/v4l2", apiV4L2)
+}
+
+func apiV4L2(w http.ResponseWriter, r *http.Request) {
+	files, err := os.ReadDir("/dev")
+	if err != nil {
+		return
+	}
+
+	var sources []*api.Source
+
+	for _, file := range files {
+		if !strings.HasPrefix(file.Name(), core.KindVideo) {
+			continue
+		}
+
+		path := "/dev/" + file.Name()
+
+		dev, err := device.Open(path)
+		if err != nil {
+			continue
+		}
+
+		formats, _ := dev.ListFormats()
+		for _, fourCC := range formats {
+			name, ffmpeg := findFormat(fourCC)
+			source := &api.Source{Name: name}
+
+			sizes, _ := dev.ListSizes(fourCC)
+			for _, wh := range sizes {
+				if source.Info != "" {
+					source.Info += " "
+				}
+
+				source.Info += fmt.Sprintf("%dx%d", wh[0], wh[1])
+
+				frameRates, _ := dev.ListFrameRates(fourCC, wh[0], wh[1])
+				for _, fr := range frameRates {
+					source.Info += fmt.Sprintf("@%d", fr)
+
+					if source.URL == "" && ffmpeg != "" {
+						source.URL = fmt.Sprintf(
+							"v4l2:device?video=%s&input_format=%s&video_size=%dx%d&framerate=%d",
+							path, ffmpeg, wh[0], wh[1], fr,
+						)
+					}
+				}
+			}
+
+			if source.Info != "" {
+				sources = append(sources, source)
+			}
+		}
+
+		_ = dev.Close()
+	}
+
+	api.ResponseSources(w, sources)
+}
+
+func findFormat(fourCC uint32) (name, ffmpeg string) {
+	for _, format := range device.Formats {
+		if format.FourCC == fourCC {
+			return format.Name, format.FFmpeg
+		}
+	}
+	return string(binary.LittleEndian.AppendUint32(nil, fourCC)), ""
+}
diff --git a/installs_on_host/go2rtc/internal/webrtc/README.md b/installs_on_host/go2rtc/internal/webrtc/README.md
new file mode 100644
index 0000000..5a7e1e7
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/webrtc/README.md
@@ -0,0 +1,263 @@
+# WebRTC
+
+## WebRTC Client
+
+[`new in v1.3.0`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.3.0)
+
+This source type supports four connection formats.
+
+### Creality
+
+[`new in v1.9.10`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.9.10)
+
+[Creality](https://www.creality.com/) 3D printer camera. Read more [here](https://github.com/AlexxIT/go2rtc/issues/1600).
+
+```yaml
+streams:
+  creality_k2p: webrtc:http://192.168.1.123:8000/call/webrtc_local#format=creality
+```
+
+### go2rtc
+
+This format is only supported in go2rtc. Unlike WHEP, it supports asynchronous WebRTC connections and two-way audio.
+
+```yaml
+streams:
+  webrtc-go2rtc:    webrtc:ws://192.168.1.123:1984/api/ws?src=camera1
+```
+
+### Kinesis
+
+[`new in v1.6.1`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.6.1)
+
+Supports [Amazon Kinesis Video Streams](https://aws.amazon.com/kinesis/video-streams/), using WebRTC protocol. You need to specify the signaling WebSocket URL with all credentials in query params, `client_id` and `ice_servers` list in [JSON format](https://developer.mozilla.org/en-US/docs/Web/API/RTCIceServer).
+
+```yaml
+streams:
+  webrtc-kinesis:   webrtc:wss://...amazonaws.com/?...#format=kinesis#client_id=...#ice_servers=[{...},{...}]
+```
+
+**PS.** For `kinesis` sources, you can use [echo](../echo/README.md) to get connection params using `bash`, `python` or any other script language.
+
+### OpenIPC
+
+[`new in v1.7.0`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.7.0)
+
+Cameras on open-source [OpenIPC](https://openipc.org/) firmware.
+
+```yaml
+streams:
+  webrtc-openipc:   webrtc:ws://192.168.1.123/webrtc_ws#format=openipc#ice_servers=[{"urls":"stun:stun.kinesisvideo.eu-north-1.amazonaws.com:443"}]
+```
+
+### SwitchBot
+
+Support connection to [SwitchBot](https://us.switch-bot.com/) cameras that are based on Kinesis Video Streams. Specifically, this includes [Pan/Tilt Cam Plus 2K](https://us.switch-bot.com/pages/switchbot-pan-tilt-cam-plus-2k) and [Pan/Tilt Cam Plus 3K](https://us.switch-bot.com/pages/switchbot-pan-tilt-cam-plus-3k) and [Smart Video Doorbell](https://www.switchbot.jp/products/switchbot-smart-video-doorbell). `Outdoor Spotlight Cam 1080P`, `Outdoor Spotlight Cam 2K`, `Pan/Tilt Cam`, `Pan/Tilt Cam 2K`, `Indoor Cam` are based on Tuya, so this feature is not available.
+
+```yaml
+streams:
+  webrtc-switchbot: webrtc:wss://...amazonaws.com/?...#format=switchbot#resolution=hd#play_type=0#client_id=...#ice_servers=[{...},{...}]
+```
+
+### WHEP
+
+[WebRTC/WHEP](https://datatracker.ietf.org/doc/draft-murillo-whep/) is replaced by [WebRTC/WISH](https://datatracker.ietf.org/doc/charter-ietf-wish/02/) standard for WebRTC video/audio viewers. But it may already be supported in some third-party software. It is supported in go2rtc.
+
+```yaml
+streams:
+  webrtc-whep:      webrtc:http://192.168.1.123:1984/api/webrtc?src=camera1
+```
+
+### Wyze
+
+[`new in v1.6.1`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.6.1)
+
+Legacy method to connect to [Wyze](https://www.wyze.com/) cameras using WebRTC protocol via [docker-wyze-bridge](https://github.com/mrlt8/docker-wyze-bridge). For native P2P support without docker-wyze-bridge, see [Source: Wyze](../wyze/README.md).
+
+```yaml
+streams:
+  webrtc-wyze:      webrtc:http://192.168.1.123:5000/signaling/camera1?kvs#format=wyze
+```
+
+## WebRTC Server
+
+What you should know about WebRTC:
+
+- It's almost always a **direct [peer-to-peer](https://en.wikipedia.org/wiki/Peer-to-peer) connection** from your browser to the go2rtc app
+- When you use Home Assistant, Frigate, Nginx, Nabu Casa, Cloudflare, and other software, they are only **involved in establishing** the connection; they are **not involved in transferring** media data
+- WebRTC media cannot be transferred inside an HTTP connection
+- Usually, WebRTC uses random UDP ports on the client and server to establish a connection
+- Usually, WebRTC uses public [STUN](https://en.wikipedia.org/wiki/STUN) servers to establish a connection outside the LAN; these servers are only needed to establish a connection and are not involved in data transfer
+- Usually, WebRTC will automatically discover all of your local and public addresses and try to establish a connection
+
+If an external connection via STUN is used:
+
+- Uses [UDP hole punching](https://en.wikipedia.org/wiki/UDP_hole_punching) technology to bypass NAT even if you haven't opened your server to the world
+- For about 20% of users, the technology will not work because of the [Symmetric NAT](https://tomchen.github.io/symmetric-nat-test/)
+- UDP is not suitable for transmitting 2K and 4K high bit rate video over open networks because of the high loss rate:
+  - https://habr.com/ru/companies/flashphoner/articles/480006/
+  - https://www.youtube.com/watch?v=FXVg2ckuKfs
+
+### Configuration suggestions
+
+- 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
+
+- forward the port 8555 on your router (you can use the same 8555 port or any other as external port)
+- add your external IP address and external port to the YAML config
+
+```yaml
+webrtc:
+  candidates:
+    - 216.58.210.174:8555  # if you have a static public IP address
+```
+
+#### Dynamic public IP
+
+- forward the port 8555 on your router (you can use the 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:
+  candidates:
+    - stun:8555  # if you have a dynamic public IP address
+```
+
+#### Hard tech way 1. Own TCP-tunnel
+
+If you have a personal [VPS](https://en.wikipedia.org/wiki/Virtual_private_server), you can create a TCP tunnel and setup in the same way as "Static public IP". But use your VPS IP address in the YAML config.
+
+#### Hard tech way 2. Using TURN-server
+
+If you have personal [VPS](https://en.wikipedia.org/wiki/Virtual_private_server), you can install TURN server (e.g. [coturn](https://github.com/coturn/coturn), config [example](https://github.com/AlexxIT/WebRTC/wiki/Coturn-Example)).
+
+```yaml
+webrtc:
+  ice_servers:
+    - urls: [stun:stun.l.google.com:19302]
+    - urls: [turn:123.123.123.123:3478]
+      username: your_user
+      credential: your_pass
+```
+
+### Full configuration
+
+**Important!** This example is not for copy/pasting!
+
+```yaml
+webrtc:
+  # fix local TCP or UDP or both ports for WebRTC media
+  listen: ":8555"            # address of your local server
+
+  # add additional host candidates manually
+  # order is important, the first will have a higher priority
+  candidates:
+    - 216.58.210.174:8555    # if you have static public IP-address
+    - stun:8555              # if you have dynamic public IP-address
+    - home.duckdns.org:8555  # if you have domain
+
+  # add custom STUN and TURN servers
+  # use `ice_servers: []` to remove defaults and leave it empty
+  ice_servers:
+    - urls: [ stun:stun1.l.google.com:19302 ]
+    - urls: [ turn:123.123.123.123:3478 ]
+      username: your_user
+      credential: your_pass
+
+  # optional filter list for auto-discovery logic
+  # some settings only make sense if you don't specify a fixed UDP port
+  filters:
+    # list of host candidates from auto-discovery to be sent
+    # includes candidates from the `listen` option
+    # use `candidates: []` to remove all auto-discovery candidates
+    candidates: [ 192.168.1.123 ]
+
+    # enable localhost candidates
+    loopback: true
+
+    # list of network types to be used for the connection
+    # includes candidates from the `listen` option
+    networks: [ udp4, udp6, tcp4, tcp6 ]
+
+    # list of interfaces to be used for the connection
+    # includes interfaces from unspecified `listen` option (empty host)
+    interfaces: [ eno1 ]
+
+    # list of host IP addresses to be used for the connection
+    # includes IPs from unspecified `listen` option (empty host)
+    ips: [ 192.168.1.123 ]
+
+    # range for random UDP ports [min, max] to be used for connection
+    # not related to the `listen` option
+    udp_ports: [ 50000, 50100 ]
+```
+
+By default, go2rtc uses a **fixed TCP** port and **fixed UDP** ports for each **direct** WebRTC connection: `listen: ":8555"`.
+
+You can set a **fixed TCP** port and a **random UDP** port for all connections: `listen: ":8555/tcp"`.
+
+You can also disable the TCP port and leave only random UDP ports: `listen: ""`.
+
+### Configuration filters
+
+**Important!** By default, go2rtc excludes all Docker-like candidates (`172.16.0.0/12`). This cannot be disabled.
+
+Filters allow you to exclude unnecessary candidates. Extra candidates don't make your connection worse or better. But the wrong filter settings can break everything. Skip this setting if you don't understand it.
+
+For example, go2rtc is installed on the host system. And there are unnecessary interfaces. You can keep only the relevant via `interfaces` or `ips` options. You can also exclude IPv6 candidates if your server supports them but your home network does not.
+
+```yaml
+webrtc:
+  listen: ":8555/tcp"         # use fixed TCP port and random UDP ports
+  filters:
+    ips: [ 192.168.1.2 ]      # IP-address of your server
+    networks: [ udp4, tcp4 ]  # skip IPv6, if it's not supported for you
+```
+
+For example, go2rtc is inside a closed Docker container (e.g. [Frigate](https://frigate.video/)). You shouldn't filter Docker interfaces; otherwise, go2rtc won't be able to connect anywhere. But you can filter the Docker candidates because no one can connect to them.
+
+```yaml
+webrtc:
+  listen: ":8555"                   # use fixed TCP and UDP ports
+  candidates: [ 192.168.1.2:8555 ]  # add manual host candidate (use docker port forwarding)
+```
+
+## Streaming ingest
+
+### Ingest: Browser
+
+[`new in v1.3.0`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.3.0)
+
+You can turn the browser of any PC or mobile into an IP camera with support for video and two-way audio. Or even broadcast your PC screen:
+
+1. Create empty stream in the `go2rtc.yaml`
+2. Go to go2rtc WebUI
+3. Open `links` page for your stream
+4. Select `camera+microphone` or `display+speaker` option
+5. Open `webrtc` local page (your go2rtc **should work over HTTPS!**) or `share link` via [WebTorrent](../webtorrent/README.md) technology (work over HTTPS by default)
+
+### Ingest: WHIP
+
+[`new in v1.3.0`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.3.0)
+
+You can use **OBS Studio** or any other broadcast software with [WHIP](https://www.ietf.org/archive/id/draft-ietf-wish-whip-01.html) protocol support. This standard has not yet been approved. But you can download OBS Studio [dev version](https://github.com/obsproject/obs-studio/actions/runs/3969201209):
+
+- Settings > Stream > Service: WHIP > `http://192.168.1.123:1984/api/webrtc?dst=camera1`
+
+## Useful 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
diff --git a/installs_on_host/go2rtc/internal/webrtc/candidates.go b/installs_on_host/go2rtc/internal/webrtc/candidates.go
new file mode 100644
index 0000000..d378022
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/webrtc/candidates.go
@@ -0,0 +1,149 @@
+package webrtc
+
+import (
+	"net"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/api/ws"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/webrtc"
+	"github.com/AlexxIT/go2rtc/pkg/xnet"
+	pion "github.com/pion/webrtc/v4"
+)
+
+type Address struct {
+	host     string
+	Port     string
+	Network  string
+	Priority uint32
+}
+
+var stuns []string
+
+func (a *Address) Host() string {
+	if a.host == "stun" {
+		ip, err := webrtc.GetCachedPublicIP(stuns...)
+		if err != nil {
+			return ""
+		}
+		return ip.String()
+	}
+	return a.host
+}
+
+func (a *Address) Marshal() string {
+	if host := a.Host(); host != "" {
+		return webrtc.CandidateICE(a.Network, host, a.Port, a.Priority)
+	}
+	return ""
+}
+
+var addresses []*Address
+var filters webrtc.Filters
+
+func AddCandidate(network, address string) {
+	if network == "" {
+		AddCandidate("tcp", address)
+		AddCandidate("udp", address)
+		return
+	}
+
+	host, port, err := net.SplitHostPort(address)
+	if err != nil {
+		return
+	}
+
+	// start from 1, so manual candidates will be lower than built-in
+	// and every next candidate will have a lower priority
+	candidateIndex := 1 + len(addresses)
+
+	priority := webrtc.CandidateHostPriority(network, candidateIndex)
+	addresses = append(addresses, &Address{host, port, network, priority})
+}
+
+func GetCandidates() (candidates []string) {
+	for _, address := range addresses {
+		if candidate := address.Marshal(); candidate != "" {
+			candidates = append(candidates, candidate)
+		}
+	}
+	return
+}
+
+// FilterCandidate return true if candidate passed the check
+func FilterCandidate(candidate *pion.ICECandidate) bool {
+	if candidate == nil {
+		return false
+	}
+
+	// remove any Docker-like IP from candidates
+	if ip := net.ParseIP(candidate.Address); ip != nil && xnet.Docker.Contains(ip) {
+		return false
+	}
+
+	// host candidate should be in the hosts list
+	if candidate.Typ == pion.ICECandidateTypeHost && filters.Candidates != nil {
+		if !core.Contains(filters.Candidates, candidate.Address) {
+			return false
+		}
+	}
+
+	if filters.Networks != nil {
+		networkType := NetworkType(candidate.Protocol.String(), candidate.Address)
+		if !core.Contains(filters.Networks, networkType) {
+			return false
+		}
+	}
+
+	return true
+}
+
+// NetworkType convert tcp/udp network to tcp4/tcp6/udp4/udp6
+func NetworkType(network, host string) string {
+	if strings.IndexByte(host, ':') >= 0 {
+		return network + "6"
+	} else {
+		return network + "4"
+	}
+}
+
+func asyncCandidates(tr *ws.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")
+		}
+
+		// set variable for process candidates after this moment
+		ctx["webrtc"] = cons
+	})
+
+	for _, candidate := range GetCandidates() {
+		log.Trace().Str("candidate", candidate).Msg("[webrtc] config")
+		tr.Write(&ws.Message{Type: "webrtc/candidate", Value: candidate})
+	}
+}
+
+func candidateHandler(tr *ws.Transport, msg *ws.Message) error {
+	// 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
+}
diff --git a/installs_on_host/go2rtc/internal/webrtc/client.go b/installs_on_host/go2rtc/internal/webrtc/client.go
new file mode 100644
index 0000000..5fbf217
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/webrtc/client.go
@@ -0,0 +1,257 @@
+package webrtc
+
+import (
+	"encoding/base64"
+	"errors"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/internal/api/ws"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/webrtc"
+	"github.com/gorilla/websocket"
+	pion "github.com/pion/webrtc/v4"
+)
+
+// streamsHandler supports:
+//  1. WHEP:    webrtc:http://192.168.1.123:1984/api/webrtc?src=camera1
+//  2. go2rtc:  webrtc:ws://192.168.1.123:1984/api/ws?src=camera1
+//  3. Wyze:    webrtc:http://192.168.1.123:5000/signaling/camera1?kvs#format=wyze
+//  4. Kinesis: webrtc:wss://...amazonaws.com/?...#format=kinesis#client_id=...#ice_servers=[{...},{...}]
+func streamsHandler(rawURL string) (core.Producer, error) {
+	var query url.Values
+	if i := strings.IndexByte(rawURL, '#'); i > 0 {
+		query = streams.ParseQuery(rawURL[i+1:])
+		rawURL = rawURL[:i]
+	}
+
+	rawURL = rawURL[7:] // remove webrtc:
+	if i := strings.IndexByte(rawURL, ':'); i > 0 {
+		scheme := rawURL[:i]
+		format := query.Get("format")
+
+		switch scheme {
+		case "ws", "wss":
+			if format == "kinesis" {
+				// https://aws.amazon.com/kinesis/video-streams/
+				// https://docs.aws.amazon.com/kinesisvideostreams-webrtc-dg/latest/devguide/what-is-kvswebrtc.html
+				// https://github.com/orgs/awslabs/repositories?q=kinesis+webrtc
+				return kinesisClient(rawURL, query, "webrtc/kinesis", nil)
+			} else if format == "openipc" {
+				return openIPCClient(rawURL, query)
+			} else if format == "switchbot" {
+				return switchbotClient(rawURL, query)
+			} else {
+				return go2rtcClient(rawURL)
+			}
+
+		case "http", "https":
+			if format == "milestone" {
+				return milestoneClient(rawURL, query)
+			} else if format == "wyze" {
+				// https://github.com/mrlt8/docker-wyze-bridge
+				return wyzeClient(rawURL)
+			} else if format == "creality" {
+				return crealityClient(rawURL)
+			} else {
+				return whepClient(rawURL)
+			}
+		}
+	}
+	return nil, errors.New("unsupported url: " + rawURL)
+}
+
+// go2rtcClient can connect only to go2rtc server
+// ex: ws://localhost:1984/api/ws?src=camera1
+func go2rtcClient(url string) (core.Producer, error) {
+	// 1. Connect to signalign server
+	conn, _, err := Dial(url)
+	if err != nil {
+		return nil, err
+	}
+
+	// close websocket when we ready return Producer or connection error
+	defer conn.Close()
+
+	// 2. Create PeerConnection
+	pc, err := PeerConnection(true)
+	if err != nil {
+		return nil, err
+	}
+
+	defer func() {
+		if err != nil {
+			_ = pc.Close()
+		}
+	}()
+
+	// waiter will wait PC error or WS error or nil (connection OK)
+	var connState core.Waiter
+	var connMu sync.Mutex
+
+	prod := webrtc.NewConn(pc)
+	prod.Mode = core.ModeActiveProducer
+	prod.Protocol = "ws"
+	prod.URL = url
+	prod.Listen(func(msg any) {
+		switch msg := msg.(type) {
+		case *pion.ICECandidate:
+			s := msg.ToJSON().Candidate
+			log.Trace().Str("candidate", s).Msg("[webrtc] local ")
+			connMu.Lock()
+			_ = conn.WriteJSON(&ws.Message{Type: "webrtc/candidate", Value: s})
+			connMu.Unlock()
+
+		case pion.PeerConnectionState:
+			switch msg {
+			case pion.PeerConnectionStateConnecting:
+			case pion.PeerConnectionStateConnected:
+				connState.Done(nil)
+			default:
+				connState.Done(errors.New("webrtc: " + msg.String()))
+			}
+		}
+	})
+
+	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 := &ws.Message{Type: "webrtc/offer", Value: offer}
+	connMu.Lock()
+	_ = conn.WriteJSON(msg)
+	connMu.Unlock()
+
+	// 5. Get answer
+	if err = conn.ReadJSON(msg); err != nil {
+		return nil, err
+	}
+
+	if msg.Type != "webrtc/answer" {
+		err = errors.New("wrong answer: " + msg.String())
+		return nil, err
+	}
+
+	answer := msg.String()
+	if err = prod.SetAnswer(answer); err != nil {
+		return nil, err
+	}
+
+	// 6. Continue to receiving candidates
+	go func() {
+		var err error
+
+		for {
+			// receive data from remote
+			var msg ws.Message
+			if err = conn.ReadJSON(&msg); err != nil {
+				break
+			}
+
+			switch msg.Type {
+			case "webrtc/candidate":
+				if msg.Value != nil {
+					_ = prod.AddCandidate(msg.String())
+				}
+			}
+		}
+
+		connState.Done(err)
+	}()
+
+	if err = connState.Wait(); err != nil {
+		return nil, err
+	}
+
+	return prod, nil
+}
+
+// whepClient - support WebRTC-HTTP Egress Protocol (WHEP)
+// ex: http://localhost:1984/api/webrtc?src=camera1
+func whepClient(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.Mode = core.ModeActiveProducer
+	prod.Protocol = "http"
+	prod.URL = url
+
+	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))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", MimeSDP)
+
+	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
+}
+
+// Dial - websocket.Dial with Basic auth support
+func Dial(rawURL string) (*websocket.Conn, *http.Response, error) {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if u.User == nil {
+		return websocket.DefaultDialer.Dial(rawURL, nil)
+	}
+
+	user := u.User.Username()
+	pass, _ := u.User.Password()
+	u.User = nil
+
+	header := http.Header{
+		"Authorization": []string{
+			"Basic " + base64.StdEncoding.EncodeToString([]byte(user+":"+pass)),
+		},
+	}
+
+	return websocket.DefaultDialer.Dial(u.String(), header)
+}
diff --git a/installs_on_host/go2rtc/internal/webrtc/client_creality.go b/installs_on_host/go2rtc/internal/webrtc/client_creality.go
new file mode 100644
index 0000000..4618044
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/webrtc/client_creality.go
@@ -0,0 +1,152 @@
+package webrtc
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/webrtc"
+	"github.com/pion/sdp/v3"
+)
+
+// https://github.com/AlexxIT/go2rtc/issues/1600
+func crealityClient(url string) (core.Producer, error) {
+	pc, err := PeerConnection(true)
+	if err != nil {
+		return nil, err
+	}
+
+	prod := webrtc.NewConn(pc)
+	prod.FormatName = "webrtc/creality"
+	prod.Mode = core.ModeActiveProducer
+	prod.Protocol = "http"
+	prod.URL = url
+
+	medias := []*core.Media{
+		{Kind: core.KindVideo, Direction: core.DirectionRecvonly},
+	}
+
+	// TODO: return webrtc.SessionDescription
+	offer, err := prod.CreateCompleteOffer(medias)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Trace().Msgf("[webrtc] offer:\n%s", offer)
+
+	body, err := offerToB64(offer)
+	if err != nil {
+		return nil, err
+	}
+
+	req, err := http.NewRequest("POST", url, body)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "plain/text")
+
+	// TODO: change http.DefaultClient settings
+	client := http.Client{Timeout: time.Second * 5000}
+	defer client.CloseIdleConnections()
+
+	res, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	answer, err := answerFromB64(res.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Trace().Msgf("[webrtc] answer:\n%s", answer)
+
+	if answer, err = fixCrealitySDP(answer); err != nil {
+		return nil, err
+	}
+
+	if err = prod.SetAnswer(answer); err != nil {
+		return nil, err
+	}
+
+	return prod, nil
+}
+
+func offerToB64(sdp string) (io.Reader, error) {
+	// JS object
+	v := map[string]string{
+		"type": "offer",
+		"sdp":  sdp,
+	}
+
+	// bytes
+	b, err := json.Marshal(v)
+	if err != nil {
+		return nil, err
+	}
+
+	// base64, why? who knows...
+	s := base64.StdEncoding.EncodeToString(b)
+
+	return strings.NewReader(s), nil
+}
+
+func answerFromB64(r io.Reader) (string, error) {
+	// base64
+	b, err := io.ReadAll(r)
+	if err != nil {
+		return "", err
+	}
+
+	// bytes
+	if b, err = base64.StdEncoding.DecodeString(string(b)); err != nil {
+		return "", err
+	}
+
+	// JS object
+	var v map[string]string
+	if err = json.Unmarshal(b, &v); err != nil {
+		return "", err
+	}
+
+	// string "v=0..."
+	return v["sdp"], nil
+}
+
+func fixCrealitySDP(value string) (string, error) {
+	var sd sdp.SessionDescription
+	if err := sd.UnmarshalString(value); err != nil {
+		return "", err
+	}
+
+	md := sd.MediaDescriptions[0]
+
+	// important to skip first codec, because second codec will be used
+	skip := md.MediaName.Formats[0]
+	md.MediaName.Formats = md.MediaName.Formats[1:]
+
+	attrs := make([]sdp.Attribute, 0, len(md.Attributes))
+	for _, attr := range md.Attributes {
+		switch attr.Key {
+		case "fmtp", "rtpmap":
+			// important to skip fmtp with x-google, because this is second fmtp for same codec
+			// and pion library will fail parsing this SDP
+			if strings.HasPrefix(attr.Value, skip) || strings.Contains(attr.Value, "x-google") {
+				continue
+			}
+		}
+		attrs = append(attrs, attr)
+	}
+
+	md.Attributes = attrs
+
+	b, err := sd.Marshal()
+	if err != nil {
+		return "", err
+	}
+	return string(b), nil
+}
diff --git a/installs_on_host/go2rtc/internal/webrtc/kinesis.go b/installs_on_host/go2rtc/internal/webrtc/kinesis.go
new file mode 100644
index 0000000..8bfaeb9
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/webrtc/kinesis.go
@@ -0,0 +1,235 @@
+package webrtc
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/webrtc"
+	"github.com/gorilla/websocket"
+	pion "github.com/pion/webrtc/v4"
+)
+
+type kinesisRequest struct {
+	Action   string `json:"action"`
+	ClientID string `json:"recipientClientId"`
+	Payload  []byte `json:"messagePayload"`
+}
+
+func (k kinesisRequest) String() string {
+	return fmt.Sprintf("action=%s, payload=%s", k.Action, k.Payload)
+}
+
+type kinesisResponse struct {
+	Payload []byte `json:"messagePayload"`
+	Type    string `json:"messageType"`
+}
+
+func (k kinesisResponse) String() string {
+	return fmt.Sprintf("type=%s, payload=%s", k.Type, k.Payload)
+}
+
+func kinesisClient(
+	rawURL string, query url.Values, format string,
+	sdpOffer func(prod *webrtc.Conn, query url.Values) (any, error),
+) (core.Producer, error) {
+	// 1. Connect to signalign server
+	conn, _, err := websocket.DefaultDialer.Dial(rawURL, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// 2. Load ICEServers from query param (base64 json)
+	conf := pion.Configuration{}
+
+	if s := query.Get("ice_servers"); s != "" {
+		conf.ICEServers, err = webrtc.UnmarshalICEServers([]byte(s))
+		if err != nil {
+			log.Warn().Err(err).Caller().Send()
+		}
+	}
+
+	// close websocket when we ready return Producer or connection error
+	defer conn.Close()
+
+	// 3. Create Peer Connection
+	api, err := webrtc.NewAPI()
+	if err != nil {
+		return nil, err
+	}
+
+	pc, err := api.NewPeerConnection(conf)
+	if err != nil {
+		return nil, err
+	}
+
+	// protect from sending ICE candidate before Offer
+	var sendOffer core.Waiter
+
+	// protect from blocking on errors
+	defer sendOffer.Done(nil)
+
+	// waiter will wait PC error or WS error or nil (connection OK)
+	var connState core.Waiter
+
+	req := kinesisRequest{
+		ClientID: query.Get("client_id"),
+	}
+
+	prod := webrtc.NewConn(pc)
+	prod.FormatName = format
+	prod.Mode = core.ModeActiveProducer
+	prod.Protocol = "ws"
+	prod.URL = rawURL
+	prod.Listen(func(msg any) {
+		switch msg := msg.(type) {
+		case *pion.ICECandidate:
+			_ = sendOffer.Wait()
+
+			req.Action = "ICE_CANDIDATE"
+			req.Payload, _ = json.Marshal(msg.ToJSON())
+			if err = conn.WriteJSON(&req); err != nil {
+				connState.Done(err)
+				return
+			}
+
+			log.Trace().Msgf("[webrtc] kinesis send: %s", req)
+
+		case pion.PeerConnectionState:
+			switch msg {
+			case pion.PeerConnectionStateConnecting:
+			case pion.PeerConnectionStateConnected:
+				connState.Done(nil)
+			default:
+				connState.Done(errors.New("webrtc: " + msg.String()))
+			}
+		}
+	})
+
+	var payload any
+
+	if sdpOffer == nil {
+		medias := []*core.Media{
+			{Kind: core.KindVideo, Direction: core.DirectionRecvonly},
+			{Kind: core.KindAudio, Direction: core.DirectionRecvonly},
+		}
+
+		// 4. Create offer
+		var offer string
+		if offer, err = prod.CreateOffer(medias); err != nil {
+			return nil, err
+		}
+
+		// 5. Send offer
+		payload = pion.SessionDescription{
+			Type: pion.SDPTypeOffer,
+			SDP:  offer,
+		}
+	} else {
+		if payload, err = sdpOffer(prod, query); err != nil {
+			return nil, err
+		}
+	}
+
+	req.Action = "SDP_OFFER"
+	req.Payload, _ = json.Marshal(payload)
+	if err = conn.WriteJSON(req); err != nil {
+		return nil, err
+	}
+
+	log.Trace().Msgf("[webrtc] kinesis send: %s", req)
+
+	sendOffer.Done(nil)
+
+	go func() {
+		var err error
+
+		// will be closed when conn will be closed
+		for {
+			var res kinesisResponse
+			if err = conn.ReadJSON(&res); err != nil {
+				// some buggy messages from Amazon servers
+				if errors.Is(err, io.ErrUnexpectedEOF) {
+					continue
+				}
+				break
+			}
+
+			log.Trace().Msgf("[webrtc] kinesis recv: %s", res)
+
+			switch res.Type {
+			case "SDP_ANSWER":
+				// 6. Get answer
+				var sd pion.SessionDescription
+				if err = json.Unmarshal(res.Payload, &sd); err != nil {
+					break
+				}
+
+				if err = prod.SetAnswer(sd.SDP); err != nil {
+					break
+				}
+
+			case "ICE_CANDIDATE":
+				// 7. Continue to receiving candidates
+				var ci pion.ICECandidateInit
+				if err = json.Unmarshal(res.Payload, &ci); err != nil {
+					break
+				}
+
+				if err = prod.AddCandidate(ci.Candidate); err != nil {
+					break
+				}
+			}
+		}
+
+		connState.Done(err)
+	}()
+
+	if err = connState.Wait(); err != nil {
+		return nil, err
+	}
+
+	return prod, nil
+}
+
+type wyzeKVS struct {
+	ClientId string          `json:"ClientId"`
+	Cam      string          `json:"cam"`
+	Result   string          `json:"result"`
+	Servers  json.RawMessage `json:"servers"`
+	URL      string          `json:"signalingUrl"`
+}
+
+func wyzeClient(rawURL string) (core.Producer, error) {
+	client := http.Client{Timeout: 5 * time.Second}
+	res, err := client.Get(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	b, err := io.ReadAll(res.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	var kvs wyzeKVS
+	if err = json.Unmarshal(b, &kvs); err != nil {
+		return nil, err
+	}
+
+	if kvs.Result != "ok" {
+		return nil, errors.New("wyse: wrong result: " + kvs.Result)
+	}
+
+	query := url.Values{
+		"client_id":   []string{kvs.ClientId},
+		"ice_servers": []string{string(kvs.Servers)},
+	}
+
+	return kinesisClient(kvs.URL, query, "webrtc/wyze", nil)
+}
diff --git a/installs_on_host/go2rtc/internal/webrtc/milestone.go b/installs_on_host/go2rtc/internal/webrtc/milestone.go
new file mode 100644
index 0000000..fe1cedc
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/webrtc/milestone.go
@@ -0,0 +1,220 @@
+package webrtc
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/tcp"
+	"github.com/AlexxIT/go2rtc/pkg/webrtc"
+	pion "github.com/pion/webrtc/v4"
+)
+
+// This package handles the Milestone WebRTC session lifecycle, including authentication,
+// session creation, and session update with an SDP answer. It is designed to be used with
+// a specific URL format that encodes session parameters. For example:
+// webrtc:https://milestone-host/api#format=milestone#username=User#password=TestPassword#cameraId=a539f254-af05-4d67-a1bb-cd9b3c74d122
+//
+// https://github.com/milestonesys/mipsdk-samples-protocol/tree/main/WebRTC_JavaScript
+
+type milestoneAPI struct {
+	url       string
+	query     url.Values
+	token     string
+	sessionID string
+}
+
+func (m *milestoneAPI) GetToken() error {
+	data := url.Values{
+		"client_id":  {"GrantValidatorClient"},
+		"grant_type": {"password"},
+		"username":   m.query["username"],
+		"password":   m.query["password"],
+	}
+
+	req, err := http.NewRequest("POST", m.url+"/IDP/connect/token", strings.NewReader(data.Encode()))
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+	// support httpx protocol
+	res, err := tcp.Do(req)
+	if err != nil {
+		return err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != http.StatusOK {
+		return errors.New("milesone: authentication failed: " + res.Status)
+	}
+
+	var payload map[string]interface{}
+	if err = json.NewDecoder(res.Body).Decode(&payload); err != nil {
+		return err
+	}
+
+	token, ok := payload["access_token"].(string)
+	if !ok {
+		return errors.New("milesone: token not found in the response")
+	}
+
+	m.token = token
+
+	return nil
+}
+
+func parseFloat(s string) float64 {
+	if s == "" {
+		return 0
+	}
+	f, _ := strconv.ParseFloat(s, 64)
+	return f
+}
+
+func (m *milestoneAPI) GetOffer() (string, error) {
+	request := struct {
+		CameraId         string `json:"cameraId"`
+		StreamId         string `json:"streamId,omitempty"`
+		PlaybackTimeNode struct {
+			PlaybackTime string  `json:"playbackTime,omitempty"`
+			SkipGaps     bool    `json:"skipGaps,omitempty"`
+			Speed        float64 `json:"speed,omitempty"`
+		} `json:"playbackTimeNode,omitempty"`
+		//ICEServers []string `json:"iceServers,omitempty"`
+		//Resolution string   `json:"resolution,omitempty"`
+	}{
+		CameraId: m.query.Get("cameraId"),
+		StreamId: m.query.Get("streamId"),
+	}
+	request.PlaybackTimeNode.PlaybackTime = m.query.Get("playbackTime")
+	request.PlaybackTimeNode.SkipGaps = m.query.Has("skipGaps")
+	request.PlaybackTimeNode.Speed = parseFloat(m.query.Get("speed"))
+
+	data, err := json.Marshal(request)
+	if err != nil {
+		return "", err
+	}
+
+	req, err := http.NewRequest("POST", m.url+"/REST/v1/WebRTC/Session", bytes.NewBuffer(data))
+	if err != nil {
+		return "", err
+	}
+	req.Header.Set("Authorization", "Bearer "+m.token)
+	req.Header.Set("Content-Type", "application/json")
+
+	res, err := tcp.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != http.StatusOK {
+		return "", errors.New("milesone: create session: " + res.Status)
+	}
+
+	var response struct {
+		SessionId string `json:"sessionId"`
+		OfferSDP  string `json:"offerSDP"`
+	}
+	if err = json.NewDecoder(res.Body).Decode(&response); err != nil {
+		return "", err
+	}
+
+	var offer pion.SessionDescription
+	if err = json.Unmarshal([]byte(response.OfferSDP), &offer); err != nil {
+		return "", err
+	}
+
+	m.sessionID = response.SessionId
+
+	return offer.SDP, nil
+}
+
+func (m *milestoneAPI) SetAnswer(sdp string) error {
+	answer := pion.SessionDescription{
+		Type: pion.SDPTypeAnswer,
+		SDP:  sdp,
+	}
+	data, err := json.Marshal(answer)
+	if err != nil {
+		return err
+	}
+
+	request := struct {
+		AnswerSDP string `json:"answerSDP"`
+	}{
+		AnswerSDP: string(data),
+	}
+	if data, err = json.Marshal(request); err != nil {
+		return err
+	}
+
+	req, err := http.NewRequest("PATCH", m.url+"/REST/v1/WebRTC/Session/"+m.sessionID, bytes.NewBuffer(data))
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Authorization", "Bearer "+m.token)
+	req.Header.Set("Content-Type", "application/json")
+
+	res, err := tcp.Do(req)
+	if err != nil {
+		return err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != http.StatusOK {
+		return errors.New("milesone: patch session: " + res.Status)
+	}
+
+	return nil
+}
+
+func milestoneClient(rawURL string, query url.Values) (core.Producer, error) {
+	mc := &milestoneAPI{url: rawURL, query: query}
+	if err := mc.GetToken(); err != nil {
+		return nil, err
+	}
+
+	api, err := webrtc.NewAPI()
+	if err != nil {
+		return nil, err
+	}
+
+	conf := pion.Configuration{}
+	pc, err := api.NewPeerConnection(conf)
+	if err != nil {
+		return nil, err
+	}
+
+	prod := webrtc.NewConn(pc)
+	prod.FormatName = "webrtc/milestone"
+	prod.Mode = core.ModeActiveProducer
+	prod.Protocol = "http"
+	prod.URL = rawURL
+
+	offer, err := mc.GetOffer()
+	if err != nil {
+		return nil, err
+	}
+
+	if err = prod.SetOffer(offer); err != nil {
+		return nil, err
+	}
+
+	answer, err := prod.GetAnswer()
+	if err != nil {
+		return nil, err
+	}
+
+	if err = mc.SetAnswer(answer); err != nil {
+		return nil, err
+	}
+
+	return prod, nil
+}
diff --git a/installs_on_host/go2rtc/internal/webrtc/openipc.go b/installs_on_host/go2rtc/internal/webrtc/openipc.go
new file mode 100644
index 0000000..2f2db11
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/webrtc/openipc.go
@@ -0,0 +1,170 @@
+package webrtc
+
+import (
+	"encoding/json"
+	"errors"
+	"io"
+	"net/url"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/webrtc"
+	"github.com/gorilla/websocket"
+	pion "github.com/pion/webrtc/v4"
+)
+
+func openIPCClient(rawURL string, query url.Values) (core.Producer, error) {
+	// 1. Connect to signalign server
+	conn, _, err := websocket.DefaultDialer.Dial(rawURL, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// 2. Load ICEServers from query param (base64 json)
+	var conf pion.Configuration
+
+	if s := query.Get("ice_servers"); s != "" {
+		conf.ICEServers, err = webrtc.UnmarshalICEServers([]byte(s))
+		if err != nil {
+			log.Warn().Err(err).Caller().Send()
+		}
+	}
+
+	// close websocket when we ready return Producer or connection error
+	defer conn.Close()
+
+	// 3. Create Peer Connection
+	api, err := webrtc.NewAPI()
+	if err != nil {
+		return nil, err
+	}
+
+	pc, err := api.NewPeerConnection(conf)
+	if err != nil {
+		return nil, err
+	}
+
+	// protect from sending ICE candidate before Offer
+	var sendAnswer core.Waiter
+
+	// protect from blocking on errors
+	defer sendAnswer.Done(nil)
+
+	// waiter will wait PC error or WS error or nil (connection OK)
+	var connState core.Waiter
+
+	prod := webrtc.NewConn(pc)
+	prod.FormatName = "webrtc/openipc"
+	prod.Mode = core.ModeActiveProducer
+	prod.Protocol = "ws"
+	prod.URL = rawURL
+	prod.Listen(func(msg any) {
+		switch msg := msg.(type) {
+		case *pion.ICECandidate:
+			_ = sendAnswer.Wait()
+
+			req := openIPCReq{
+				Data: msg.ToJSON().Candidate,
+				Req:  "candidate",
+			}
+			if err = conn.WriteJSON(&req); err != nil {
+				connState.Done(err)
+				return
+			}
+
+			log.Trace().Msgf("[webrtc] openipc send: %s", req)
+
+		case pion.PeerConnectionState:
+			switch msg {
+			case pion.PeerConnectionStateConnecting:
+			case pion.PeerConnectionStateConnected:
+				connState.Done(nil)
+			default:
+				connState.Done(errors.New("webrtc: " + msg.String()))
+			}
+		}
+	})
+
+	go func() {
+		var err error
+
+		// will be closed when conn will be closed
+		for err == nil {
+			var rep openIPCReply
+			if err = conn.ReadJSON(&rep); err != nil {
+				// some buggy messages from Amazon servers
+				if errors.Is(err, io.ErrUnexpectedEOF) {
+					continue
+				}
+				break
+			}
+
+			log.Trace().Msgf("[webrtc] openipc recv: %s", rep)
+
+			switch rep.Reply {
+			case "webrtc_answer":
+				// 6. Get answer
+				var sd pion.SessionDescription
+				if err = json.Unmarshal(rep.Data, &sd); err != nil {
+					break
+				}
+
+				if err = prod.SetOffer(sd.SDP); err != nil {
+					break
+				}
+
+				var answer string
+				if answer, err = prod.GetAnswer(); err != nil {
+					break
+				}
+
+				req := openIPCReq{Data: answer, Req: "answer"}
+				if err = conn.WriteJSON(req); err != nil {
+					break
+				}
+
+				log.Trace().Msgf("[webrtc] kinesis send: %s", req)
+
+				sendAnswer.Done(nil)
+
+			case "webrtc_candidate":
+				// 7. Continue to receiving candidates
+				var ci pion.ICECandidateInit
+				if err = json.Unmarshal(rep.Data, &ci); err != nil {
+					break
+				}
+
+				if err = prod.AddCandidate(ci.Candidate); err != nil {
+					break
+				}
+			}
+		}
+
+		connState.Done(err)
+	}()
+
+	if err = connState.Wait(); err != nil {
+		return nil, err
+	}
+
+	return prod, nil
+}
+
+type openIPCReply struct {
+	Data  json.RawMessage `json:"data"`
+	Reply string          `json:"reply"`
+}
+
+func (r openIPCReply) String() string {
+	b, _ := json.Marshal(r)
+	return string(b)
+}
+
+type openIPCReq struct {
+	Data string `json:"data"`
+	Req  string `json:"req"`
+}
+
+func (r openIPCReq) String() string {
+	b, _ := json.Marshal(r)
+	return string(b)
+}
diff --git a/installs_on_host/go2rtc/internal/webrtc/server.go b/installs_on_host/go2rtc/internal/webrtc/server.go
new file mode 100644
index 0000000..48bd538
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/webrtc/server.go
@@ -0,0 +1,235 @@
+package webrtc
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"io"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/webrtc"
+	pion "github.com/pion/webrtc/v4"
+)
+
+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)
+		}
+
+	case "OPTIONS":
+		w.WriteHeader(http.StatusNoContent)
+
+	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) {
+	u := r.URL.Query().Get("src")
+	stream := streams.Get(u)
+	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
+		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
+
+	case "application/x-www-form-urlencoded":
+		if err := r.ParseForm(); err != nil {
+			log.Error().Err(err).Caller().Send()
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+		offerB64 := r.Form.Get("data")
+		b, err := base64.StdEncoding.DecodeString(offerB64)
+		if err != nil {
+			log.Error().Err(err).Caller().Send()
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+		offer = string(b)
+
+	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"
+	case MimeSDP:
+		desc = "webrtc/whep"
+	default:
+		desc = "webrtc/post"
+	}
+
+	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 "application/x-www-form-urlencoded":
+		w.Header().Set("Content-Type", mediaType)
+		answerB64 := base64.StdEncoding.EncodeToString([]byte(answer))
+		_, err = w.Write([]byte(answerB64))
+
+	case MimeSDP:
+		w.Header().Set("Content-Type", mediaType)
+		w.WriteHeader(http.StatusCreated)
+
+		_, err = w.Write([]byte(answer))
+
+	default:
+		w.Header().Set("Content-Type", mediaType)
+
+		_, 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 {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
+		return
+	}
+
+	// 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.Mode = core.ModePassiveProducer
+	prod.Protocol = "http"
+	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(GetCandidates(), FilterCandidate)
+	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)
+				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
+	}
+}
diff --git a/installs_on_host/go2rtc/internal/webrtc/switchbot.go b/installs_on_host/go2rtc/internal/webrtc/switchbot.go
new file mode 100644
index 0000000..6f72e55
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/webrtc/switchbot.go
@@ -0,0 +1,44 @@
+package webrtc
+
+import (
+	"net/url"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/webrtc"
+)
+
+func switchbotClient(rawURL string, query url.Values) (core.Producer, error) {
+	return kinesisClient(rawURL, query, "webrtc/switchbot", func(prod *webrtc.Conn, query url.Values) (any, error) {
+		medias := []*core.Media{
+			{Kind: core.KindVideo, Direction: core.DirectionRecvonly},
+		}
+
+		offer, err := prod.CreateOffer(medias)
+		if err != nil {
+			return nil, err
+		}
+
+		v := struct {
+			Type       string `json:"type"`
+			SDP        string `json:"sdp"`
+			Resolution int    `json:"resolution"`
+			PlayType   int    `json:"play_type"`
+		}{
+			Type: "offer",
+			SDP:  offer,
+		}
+
+		switch query.Get("resolution") {
+		case "hd":
+			v.Resolution = 0
+		case "sd":
+			v.Resolution = 1
+		case "auto":
+			v.Resolution = 2
+		}
+
+		v.PlayType = core.Atoi(query.Get("play_type")) // zero by default
+
+		return v, nil
+	})
+}
diff --git a/installs_on_host/go2rtc/internal/webrtc/webrtc.go b/installs_on_host/go2rtc/internal/webrtc/webrtc.go
new file mode 100644
index 0000000..2a5b4ad
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/webrtc/webrtc.go
@@ -0,0 +1,321 @@
+package webrtc
+
+import (
+	"errors"
+	"net"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/api/ws"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/webrtc"
+	pion "github.com/pion/webrtc/v4"
+	"github.com/rs/zerolog"
+)
+
+func Init() {
+	var cfg struct {
+		Mod struct {
+			Listen     string           `yaml:"listen"`
+			Candidates []string         `yaml:"candidates"`
+			IceServers []pion.ICEServer `yaml:"ice_servers"`
+			Filters    webrtc.Filters   `yaml:"filters"`
+		} `yaml:"webrtc"`
+	}
+
+	cfg.Mod.Listen = ":8555"
+	cfg.Mod.IceServers = []pion.ICEServer{
+		{URLs: []string{"stun:stun.cloudflare.com:3478", "stun:stun.l.google.com:19302"}},
+	}
+
+	app.LoadConfig(&cfg)
+
+	log = app.GetLogger("webrtc")
+
+	if log.Debug().Enabled() {
+		itfs, _ := net.Interfaces()
+		for _, itf := range itfs {
+			addrs, _ := itf.Addrs()
+			log.Debug().Msgf("[webrtc] interface %+v addrs %v", itf, addrs)
+		}
+	}
+
+	address, network, _ := strings.Cut(cfg.Mod.Listen, "/")
+	for _, candidate := range cfg.Mod.Candidates {
+		AddCandidate(network, candidate)
+
+		if strings.HasPrefix(candidate, "stun:") && stuns == nil {
+			for _, ice := range cfg.Mod.IceServers {
+				for _, url := range ice.URLs {
+					if strings.HasPrefix(url, "stun:") {
+						stuns = append(stuns, url[5:])
+					}
+				}
+			}
+		}
+	}
+
+	webrtc.OnNewListener = func(ln any) {
+		switch ln := ln.(type) {
+		case *net.TCPListener:
+			log.Info().Stringer("addr", ln.Addr()).Msg("[webrtc] listen tcp")
+		case *net.UDPConn:
+			log.Info().Stringer("addr", ln.LocalAddr()).Msg("[webrtc] listen udp")
+		}
+	}
+
+	var err error
+
+	// create pionAPI with custom codecs list and custom network settings
+	serverAPI, err = webrtc.NewServerAPI(network, address, &cfg.Mod.Filters)
+	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 != "" {
+		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)
+		}
+	}
+
+	// async WebRTC server (two API versions)
+	ws.HandleFunc("webrtc", asyncHandler)
+	ws.HandleFunc("webrtc/offer", asyncHandler)
+	ws.HandleFunc("webrtc/candidate", candidateHandler)
+
+	// sync WebRTC server (two API versions)
+	api.HandleFunc("api/webrtc", syncHandler)
+
+	// WebRTC client
+	streams.HandleFunc("webrtc", streamsHandler)
+}
+
+var serverAPI, clientAPI *pion.API
+
+var log zerolog.Logger
+
+var PeerConnection func(active bool) (*pion.PeerConnection, error)
+
+func asyncHandler(tr *ws.Transport, msg *ws.Message) (err error) {
+	var stream *streams.Stream
+	var mode core.Mode
+
+	query := tr.Request.URL.Query()
+	if name := query.Get("src"); name != "" {
+		stream, _ = streams.GetOrPatch(query)
+		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)
+	}
+
+	var offer struct {
+		Type       string           `json:"type"`
+		SDP        string           `json:"sdp"`
+		ICEServers []pion.ICEServer `json:"ice_servers"`
+	}
+
+	// V2 - json/object exchange, V1 - raw SDP exchange
+	apiV2 := msg.Type == "webrtc"
+
+	if apiV2 {
+		if err = msg.Unmarshal(&offer); err != nil {
+			return err
+		}
+	} else {
+		offer.SDP = msg.String()
+	}
+
+	// create new PeerConnection instance
+	var pc *pion.PeerConnection
+	if offer.ICEServers == nil {
+		pc, err = PeerConnection(false)
+	} else {
+		pc, err = serverAPI.NewPeerConnection(pion.Configuration{ICEServers: offer.ICEServers})
+	}
+	if err != nil {
+		log.Error().Err(err).Caller().Send()
+		return err
+	}
+
+	var sendAnswer core.Waiter
+
+	// protect from blocking on errors
+	defer sendAnswer.Done(nil)
+
+	conn := webrtc.NewConn(pc)
+	conn.Mode = mode
+	conn.Protocol = "ws"
+	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:
+			if !FilterCandidate(msg) {
+				return
+			}
+			_ = sendAnswer.Wait()
+
+			s := msg.ToJSON().Candidate
+			log.Trace().Str("candidate", s).Msg("[webrtc] local ")
+			tr.Write(&ws.Message{Type: "webrtc/candidate", Value: s})
+		}
+	})
+
+	log.Trace().Msgf("[webrtc] offer:\n%s", offer.SDP)
+
+	// 1. SetOffer, so we can get remote client codecs
+	if err = conn.SetOffer(offer.SDP); 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(&ws.Message{Type: "webrtc", Value: desc})
+	} else {
+		tr.Write(&ws.Message{Type: "webrtc/answer", Value: answer})
+	}
+
+	sendAnswer.Done(nil)
+
+	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.FormatName = desc
+	conn.UserAgent = userAgent
+	conn.Protocol = "http"
+	conn.Listen(func(msg any) {
+		switch msg := msg.(type) {
+		case pion.PeerConnectionState:
+			if msg != pion.PeerConnectionStateClosed {
+				return
+			}
+			if conn.Mode == core.ModePassiveConsumer {
+				stream.RemoveConsumer(conn)
+			} else {
+				stream.RemoveProducer(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
+	}
+
+	if IsConsumer(conn) {
+		conn.Mode = core.ModePassiveConsumer
+
+		// 2. AddConsumer, so we get new tracks
+		if err = stream.AddConsumer(conn); err != nil {
+			log.Warn().Err(err).Caller().Send()
+			_ = conn.Close()
+			return
+		}
+	} else {
+		conn.Mode = core.ModePassiveProducer
+
+		stream.AddProducer(conn)
+	}
+
+	answer, err = conn.GetCompleteAnswer(GetCandidates(), FilterCandidate)
+	log.Trace().Msgf("[webrtc] answer\n%s", answer)
+
+	if err != nil {
+		log.Error().Err(err).Caller().Send()
+	}
+
+	return
+}
+
+func IsConsumer(conn *webrtc.Conn) bool {
+	// if wants get video - consumer
+	for _, media := range conn.GetMedias() {
+		if media.Kind == core.KindVideo && media.Direction == core.DirectionSendonly {
+			return true
+		}
+	}
+	// if wants send video - producer
+	for _, media := range conn.GetMedias() {
+		if media.Kind == core.KindVideo && media.Direction == core.DirectionRecvonly {
+			return false
+		}
+	}
+	// if wants something - consumer
+	for _, media := range conn.GetMedias() {
+		if media.Direction == core.DirectionSendonly {
+			return true
+		}
+	}
+	return false
+}
diff --git a/installs_on_host/go2rtc/internal/webrtc/webrtc_test.go b/installs_on_host/go2rtc/internal/webrtc/webrtc_test.go
new file mode 100644
index 0000000..1f82a0a
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/webrtc/webrtc_test.go
@@ -0,0 +1,73 @@
+package webrtc
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/AlexxIT/go2rtc/internal/api/ws"
+	pion "github.com/pion/webrtc/v4"
+	"github.com/stretchr/testify/require"
+)
+
+func TestWebRTCAPIv1(t *testing.T) {
+	raw := `{"type":"webrtc/offer","value":"v=0\n..."}`
+	msg := new(ws.Message)
+	err := json.Unmarshal([]byte(raw), msg)
+	require.Nil(t, err)
+
+	require.Equal(t, "v=0\n...", msg.String())
+}
+
+func TestWebRTCAPIv2(t *testing.T) {
+	raw := `{"type":"webrtc","value":{"type":"offer","sdp":"v=0\n...","ice_servers":[{"urls":["stun:stun.l.google.com:19302"]}]}}`
+	msg := new(ws.Message)
+	err := json.Unmarshal([]byte(raw), msg)
+	require.Nil(t, err)
+
+	var offer struct {
+		Type       string           `json:"type"`
+		SDP        string           `json:"sdp"`
+		ICEServers []pion.ICEServer `json:"ice_servers"`
+	}
+	err = msg.Unmarshal(&offer)
+	require.Nil(t, err)
+
+	require.Equal(t, "offer", offer.Type)
+	require.Equal(t, "v=0\n...", offer.SDP)
+	require.Equal(t, "stun:stun.l.google.com:19302", offer.ICEServers[0].URLs[0])
+}
+
+func TestCrealitySDP(t *testing.T) {
+	sdp := `v=0
+o=- 1495799811084970 1495799811084970 IN IP4 0.0.0.0
+s=-
+t=0 0
+a=msid-semantic:WMS *
+a=group:BUNDLE 0
+m=video 9 UDP/TLS/RTP/SAVPF 96 98
+a=rtcp-fb:98 nack
+a=rtcp-fb:98 nack pli
+a=fmtp:96 profile-level-id=42e01f;level-asymmetry-allowed=1
+a=fmtp:98 profile-level-id=42e01f;packetization-mode=1;level-asymmetry-allowed=1
+a=fmtp:98 x-google-max-bitrate=6000;x-google-min-bitrate=2000;x-google-start-bitrate=4000
+a=rtpmap:96 H264/90000
+a=rtpmap:98 H264/90000
+a=ssrc:1 cname:pear
+c=IN IP4 0.0.0.0
+a=sendonly
+a=mid:0
+a=rtcp-mux
+a=ice-ufrag:7AVa
+a=ice-pwd:T+F/5y05Paw+mtG5Jrd8N3
+a=ice-options:trickle
+a=fingerprint:sha-256 A5:AB:C0:4E:29:5B:BD:3B:7D:88:24:6C:56:6B:2A:79:A3:76:99:35:57:75:AD:C8:5A:A6:34:20:88:1B:68:EF
+a=setup:passive
+a=candidate:1 1 UDP 2015363327 172.22.233.10 48929 typ host
+a=candidate:2 1 TCP 1015021823 172.22.233.10 0 typ host tcptype active
+a=candidate:3 1 TCP 1010827519 172.22.233.10 60677 typ host tcptype passive
+`
+	sdp, err := fixCrealitySDP(sdp)
+	require.Nil(t, err)
+	require.False(t, strings.Contains(sdp, "x-google-max-bitrate"))
+}
diff --git a/installs_on_host/go2rtc/internal/webtorrent/README.md b/installs_on_host/go2rtc/internal/webtorrent/README.md
new file mode 100644
index 0000000..1c9811a
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/webtorrent/README.md
@@ -0,0 +1,45 @@
+# WebTorrent
+
+> [!NOTE]
+> This section needs some improvement.
+
+## WebTorrent Client
+
+[`new in v1.3.0`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.3.0)
+
+This source can get a stream from another go2rtc via [WebTorrent](https://en.wikipedia.org/wiki/WebTorrent) protocol.
+
+### Client Configuration
+
+```yaml
+streams:
+  webtorrent1: webtorrent:?share=huofssuxaty00izc&pwd=k3l2j9djeg8v8r7e
+```
+
+## WebTorrent Server
+
+[`new in v1.3.0`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.3.0)
+
+This module supports:
+
+- Share any local stream via [WebTorrent](https://webtorrent.io/) technology
+- Get any [incoming stream](../webrtc/README.md#ingest-browser) from PC or mobile via [WebTorrent](https://webtorrent.io/) technology
+- Get any remote go2rtc source via [WebTorrent](https://webtorrent.io/) technology
+
+Securely and freely. You do not need to open a public access to the go2rtc server. But in some cases (Symmetric NAT), you may need to set up external access to [WebRTC module](../webrtc/README.md).
+
+To generate a sharing link or incoming link, go to the go2rtc WebUI (stream links page). This link is **temporary** and will stop working after go2rtc is restarted!
+
+### Server Configuration
+
+You can create permanent external links in the go2rtc config:
+
+```yaml
+webtorrent:
+  shares:
+    super-secret-share:  # share name, should be unique among all go2rtc users!
+      pwd: super-secret-password
+      src: rtsp-dahua1   # stream name from streams section
+```
+
+Link example: `https://go2rtc.org/webtorrent/#share=02SNtgjKXY&pwd=wznEQqznxW&media=video+audio`
diff --git a/installs_on_host/go2rtc/internal/webtorrent/init.go b/installs_on_host/go2rtc/internal/webtorrent/init.go
new file mode 100644
index 0000000..b1c25c7
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/webtorrent/init.go
@@ -0,0 +1,176 @@
+package webtorrent
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+	"net/url"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/internal/webrtc"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/webtorrent"
+	"github.com/rs/zerolog"
+)
+
+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, "webtorrent", "")
+		},
+	}
+
+	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.Source
+			for src, share := range shares {
+				pwd := srv.GetSharePwd(share)
+				source := fmt.Sprintf("webtorrent:?share=%s&pwd=%s", share, pwd)
+				items = append(items, &api.Source{ID: src, URL: source})
+			}
+			api.ResponseSources(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)
+		api.Response(w, data, api.MimeJSON)
+
+	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)
+}
diff --git a/installs_on_host/go2rtc/internal/webtorrent/tracker.go b/installs_on_host/go2rtc/internal/webtorrent/tracker.go
new file mode 100644
index 0000000..e504d80
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/webtorrent/tracker.go
@@ -0,0 +1,108 @@
+package webtorrent
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/AlexxIT/go2rtc/pkg/webtorrent"
+	"github.com/gorilla/websocket"
+)
+
+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))
+		}
+	}
+}
diff --git a/installs_on_host/go2rtc/internal/wyoming/README.md b/installs_on_host/go2rtc/internal/wyoming/README.md
new file mode 100644
index 0000000..ed02c9b
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/wyoming/README.md
@@ -0,0 +1,284 @@
+# Wyoming
+
+> [!NOTE]
+> The format is under development and does not yet work stably.
+
+This module provide [Wyoming Protocol](https://www.home-assistant.io/integrations/wyoming/) support to create local voice assistants using [Home Assistant](https://www.home-assistant.io/).
+
+- go2rtc can act as [Wyoming Satellite](https://github.com/rhasspy/wyoming-satellite)
+- go2rtc can act as [Wyoming External Microphone](https://github.com/rhasspy/wyoming-mic-external)
+- go2rtc can act as [Wyoming External Sound](https://github.com/rhasspy/wyoming-snd-external)
+- any supported audio source with PCM codec can be used as audio input
+- any supported two-way audio source with PCM codec can be used as audio output
+- any desktop/server microphone/speaker can be used as two-way audio source
+  - supported any OS via FFmpeg or any similar software
+  - supported Linux via alsa source
+- you can change the behavior using the built-in scripting engine
+
+## Typical Voice Pipeline
+
+1. Audio stream (MIC)
+   - any audio source with PCM codec support (include PCMA/PCMU)
+2. Voice Activity Detector (VAD)
+3. Wake Word (WAKE)
+   - [OpenWakeWord](https://www.home-assistant.io/voice_control/create_wake_word/)
+4. Speech-to-Text (STT)
+   - [Whisper](https://github.com/home-assistant/addons/blob/master/whisper/) 
+   - [Vosk](https://github.com/rhasspy/hassio-addons/blob/master/vosk/)
+5. Conversation agent (INTENT)
+   - [Home Assistant](https://www.home-assistant.io/integrations/conversation/)
+6. Text-to-speech (TTS)
+   - [Google Translate](https://www.home-assistant.io/integrations/google_translate/)
+   - [Piper](https://github.com/home-assistant/addons/blob/master/piper/)
+7. Audio stream (SND)
+   - any source with two-way audio (backchannel) and PCM codec support (include PCMA/PCMU)
+
+You can use a large number of different projects for WAKE, STT, INTENT and TTS thanks to the Home Assistant.
+
+And you can use a large number of different technologies for MIC and SND thanks to Go2rtc.
+
+## Configuration
+
+You can optionally specify WAKE service. So go2rtc will start transmitting audio to Home Assistant only after WAKE word. If the WAKE service cannot be connected to or not specified - go2rtc will pass all audio to Home Assistant. In this case WAKE service must be configured in your Voice Assistant pipeline.
+
+You can optionally specify VAD threshold. So go2rtc will start transmitting audio to WAKE service only after some audio noise.
+
+Your stream must support audio transmission in PCM codec (include PCMA/PCMU).
+
+```yaml
+wyoming:
+  stream_name_from_streams_section:
+    listen: :10700 
+    name: "My Satellite"                # optional name
+    wake_uri: tcp://192.168.1.23:10400  # optional WAKE service
+    vad_threshold: 1                    # optional VAD threshold (from 0.1 to 3.5)
+```
+
+Home Assistant -> Settings -> Integrations -> Add -> Wyoming Protocol -> Host + Port from `go2rtc.yaml`
+
+Select one or multiple wake words:
+```yaml
+wake_uri: tcp://192.168.1.23:10400?name=alexa_v0.1&name=hey_jarvis_v0.1&name=hey_mycroft_v0.1&name=hey_rhasspy_v0.1&name=ok_nabu_v0.1
+```
+
+## Events
+
+You can add wyoming event handling using the [expr](../expr/README.md) language. For example, to pronounce TTS on some media player from HA.
+
+Turn on the logs to see what kind of events happens.
+
+This is what the default scripts look like:
+
+```yaml
+wyoming:
+  script_example:
+    event:
+      run-satellite: Detect()
+      pause-satellite: Stop()
+      voice-stopped: Pause()
+      audio-stop: PlayAudio() && WriteEvent("played") && Detect()
+      error: Detect()
+      internal-run: WriteEvent("run-pipeline", '{"start_stage":"wake","end_stage":"tts"}') && Stream()
+      internal-detection: WriteEvent("run-pipeline", '{"start_stage":"asr","end_stage":"tts"}') && Stream()
+```
+
+Supported functions and variables:
+
+- `Detect()` - start the VAD and WAKE word detection process
+- `Stream()` - start transmission of audio data to the client (Home Assistant)
+- `Stop()` - stop and disconnect stream without disconnecting client (Home Assistant)
+- `Pause()` - temporary pause of audio transfer, without disconnecting the stream
+- `PlayAudio()` - playing the last audio that was sent from client (Home Assistant)
+- `WriteEvent(type, data)` - send event to client (Home Assistant)
+- `Sleep(duration)` - temporary script pause (ex. `Sleep('1.5s')`)
+- `PlayFile(path)` - play audio from `wav` file
+- `Type` - type (name) of event
+- `Data` - event data in JSON format (ex. `{"text":"how are you"}`)
+- also available other functions from [expr](../expr/README.md) module (ex. `fetch`)
+
+If you write a script for an event - the default action is no longer executed. You need to repeat the necessary steps yourself.
+
+In addition to the standard events, there are two additional events:
+
+- `internal-run` - called after `Detect()` when VAD detected, but WAKE service unavailable
+- `internal-detection` - called after `Detect()` when WAKE word detected
+
+**Example 1.** You want to play a sound file when a wake word detected (only `wav` supported):
+
+- `PlayFile` and `PlayAudio` functions are executed synchronously, the following steps will be executed only after they are completed
+
+```yaml
+wyoming:
+  script_example:
+    event:
+      internal-detection: PlayFile('/media/beep.wav') && WriteEvent("run-pipeline", '{"start_stage":"asr","end_stage":"tts"}') && Stream()
+```
+
+**Example 2.** You want to play TTS on a Home Assistant media player:
+
+Each event has a `Type` and `Data` in JSON format. You can use their values in scripts.
+
+- in the `synthesize` step, we get the value of the `text` and call the HA REST API
+- in the `audio-stop` step we get the duration of the TTS in seconds, wait for this time and start the pipeline again
+
+```yaml
+wyoming:
+  script_example:
+    event:
+      synthesize: |
+        let text = fromJSON(Data).text;
+        let token = 'eyJhbGci...';
+        fetch('http://localhost:8123/api/services/tts/speak', {
+          method: 'POST',
+          headers: {'Authorization': 'Bearer '+token,'Content-Type': 'application/json'},
+          body: toJSON({
+            entity_id: 'tts.google_translate_com',
+            media_player_entity_id: 'media_player.google_nest',
+            message: text,
+            language: 'en',
+          }),
+        }).ok
+      audio-stop: |
+        let timestamp = fromJSON(Data).timestamp;
+        let delay = string(timestamp)+'s';
+        Sleep(delay) && WriteEvent("played") && Detect()
+```
+
+## Config examples
+
+Satellite on Windows server using FFmpeg and FFplay.
+
+```yaml
+streams:
+  satellite_win:
+    - exec:ffmpeg -hide_banner -f dshow -i "audio=Microphone (High Definition Audio Device)" -c pcm_s16le -ar 16000 -ac 1 -f wav -
+    - exec:ffplay -hide_banner -nodisp -probesize 32 -f s16le -ar 22050 -#backchannel=1#audio=s16le/22050
+
+wyoming:
+  satellite_win:
+    listen: :10700
+    name: "Windows Satellite"
+    wake_uri: tcp://192.168.1.23:10400
+    vad_threshold: 1
+```
+
+Satellite on Dahua camera with two-way audio support.
+
+```yaml
+streams:
+  dahua_camera:
+    - rtsp://admin:password@192.168.1.123/cam/realmonitor?channel=1&subtype=1&unicast=true&proto=Onvif
+
+wyoming:
+  dahua_camera:
+    listen: :10700
+    name: "Dahua Satellite"
+    wake_uri: tcp://192.168.1.23:10400
+    vad_threshold: 1
+```
+
+Satellite on external wyoming Microphone and Sound.
+
+```yaml
+streams:
+  wyoming_external:
+     - wyoming://192.168.1.23:10600                # wyoming-mic-external
+     - wyoming://192.168.1.23:10601?backchannel=1  # wyoming-snd-external
+
+wyoming:
+   wyoming_external:
+    listen: :10700
+    name: "Wyoming Satellite"
+    wake_uri: tcp://192.168.1.23:10400
+    vad_threshold: 1
+```
+
+## Wyoming External Microphone and Sound
+
+Advanced users, who want to enjoy the [Wyoming Satellite](https://github.com/rhasspy/wyoming-satellite) project, can use go2rtc as a [Wyoming External Microphone](https://github.com/rhasspy/wyoming-mic-external) or [Wyoming External Sound](https://github.com/rhasspy/wyoming-snd-external).
+
+**go2rtc.yaml**
+
+```yaml
+streams:
+  wyoming_mic_external:
+    - exec:ffmpeg -hide_banner -f dshow -i "audio=Microphone (High Definition Audio Device)" -c pcm_s16le -ar 16000 -ac 1 -f wav -
+  wyoming_snd_external:
+    - exec:ffplay -hide_banner -nodisp -probesize 32 -f s16le -ar 22050 -#backchannel=1#audio=s16le/22050
+
+wyoming:
+  wyoming_mic_external:
+    listen: :10600
+    mode: mic
+  wyoming_snd_external:
+    listen: :10601
+    mode: snd
+```
+
+**docker-compose.yml**
+
+```yaml
+version: "3.8"
+services:
+  satellite:
+    build: wyoming-satellite  # https://github.com/rhasspy/wyoming-satellite
+    ports:
+      - "10700:10700"
+    command:
+      - "--name"
+      - "my satellite"
+      - "--mic-uri"
+      - "tcp://192.168.1.23:10600"
+      - "--snd-uri"
+      - "tcp://192.168.1.23:10601"
+      - "--debug"
+```
+
+## Wyoming External Source
+
+**go2rtc.yaml**
+
+```yaml
+streams:
+  wyoming_external:
+    - wyoming://192.168.1.23:10600
+    - wyoming://192.168.1.23:10601?backchannel=1
+```
+
+**docker-compose.yml**
+
+```yaml
+version: "3.8"
+services:
+   microphone:
+      build: wyoming-mic-external  # https://github.com/rhasspy/wyoming-mic-external
+      ports:
+         - "10600:10600"
+      devices:
+         - /dev/snd:/dev/snd
+      group_add:
+         - audio
+      command:
+         - "--device"
+         - "sysdefault"
+         - "--debug"
+   playback:
+      build: wyoming-snd-external  # https://github.com/rhasspy/wyoming-snd-external
+      ports:
+         - "10601:10601"
+      devices:
+         - /dev/snd:/dev/snd
+      group_add:
+         - audio
+      command:
+         - "--device"
+         - "sysdefault"
+         - "--debug"
+```
+
+## Debug
+
+```yaml
+log:
+  wyoming: trace
+```
diff --git a/installs_on_host/go2rtc/internal/wyoming/wyoming.go b/installs_on_host/go2rtc/internal/wyoming/wyoming.go
new file mode 100644
index 0000000..065275c
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/wyoming/wyoming.go
@@ -0,0 +1,106 @@
+package wyoming
+
+import (
+	"net"
+
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/wyoming"
+	"github.com/rs/zerolog"
+)
+
+func Init() {
+	streams.HandleFunc("wyoming", wyoming.Dial)
+
+	// server
+	var cfg struct {
+		Mod map[string]struct {
+			Listen       string            `yaml:"listen"`
+			Name         string            `yaml:"name"`
+			Mode         string            `yaml:"mode"`
+			Event        map[string]string `yaml:"event"`
+			WakeURI      string            `yaml:"wake_uri"`
+			VADThreshold float32           `yaml:"vad_threshold"`
+		} `yaml:"wyoming"`
+	}
+	app.LoadConfig(&cfg)
+
+	log = app.GetLogger("wyoming")
+
+	for name, cfg := range cfg.Mod {
+		stream := streams.Get(name)
+		if stream == nil {
+			log.Warn().Msgf("[wyoming] missing stream: %s", name)
+			continue
+		}
+
+		if cfg.Name == "" {
+			cfg.Name = name
+		}
+
+		srv := &wyoming.Server{
+			Name:         cfg.Name,
+			Event:        cfg.Event,
+			VADThreshold: int16(1000 * cfg.VADThreshold), // 1.0 => 1000
+			WakeURI:      cfg.WakeURI,
+			MicHandler: func(cons core.Consumer) error {
+				if err := stream.AddConsumer(cons); err != nil {
+					return err
+				}
+				// not best solution
+				if i, ok := cons.(interface{ OnClose(func()) }); ok {
+					i.OnClose(func() {
+						stream.RemoveConsumer(cons)
+					})
+				}
+				return nil
+			},
+			SndHandler: func(prod core.Producer) error {
+				return stream.Play(prod)
+			},
+			Trace: func(format string, v ...any) {
+				log.Trace().Msgf("[wyoming] "+format, v...)
+			},
+			Error: func(format string, v ...any) {
+				log.Error().Msgf("[wyoming] "+format, v...)
+			},
+		}
+		go serve(srv, cfg.Mode, cfg.Listen)
+	}
+}
+
+var log zerolog.Logger
+
+func serve(srv *wyoming.Server, mode, address string) {
+	ln, err := net.Listen("tcp", address)
+	if err != nil {
+		log.Warn().Err(err).Msgf("[wyoming] listen")
+	}
+
+	for {
+		conn, err := ln.Accept()
+		if err != nil {
+			return
+		}
+
+		go handle(srv, mode, conn)
+	}
+}
+
+func handle(srv *wyoming.Server, mode string, conn net.Conn) {
+	addr := conn.RemoteAddr()
+
+	log.Trace().Msgf("[wyoming] %s connected", addr)
+
+	switch mode {
+	case "mic":
+		srv.HandleMic(conn)
+	case "snd":
+		srv.HandleSnd(conn)
+	default:
+		srv.Handle(conn)
+	}
+
+	log.Trace().Msgf("[wyoming] %s disconnected", addr)
+}
diff --git a/installs_on_host/go2rtc/internal/wyze/README.md b/installs_on_host/go2rtc/internal/wyze/README.md
new file mode 100644
index 0000000..22b3d35
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/wyze/README.md
@@ -0,0 +1,108 @@
+# Wyze
+
+[`new in v1.9.14`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.9.14) by [@seydx](https://github.com/seydx)
+
+This source allows you to stream from [Wyze](https://wyze.com/) cameras using native P2P protocol without the Wyze app or SDK.
+
+**Important:**
+
+1. **Requires Wyze account**. You need to login once via the WebUI to load your cameras.
+2. **Requires firmware with DTLS**. Only cameras with DTLS-enabled firmware are supported.
+3. Internet access is only needed when loading cameras from your account. After that, all streaming is local P2P.
+4. Connection to the camera is local only (direct P2P to camera IP).
+
+**Features:**
+
+- H.264 and H.265 video codec support
+- AAC, G.711, PCM, and Opus audio codec support
+- Two-way audio (intercom) support
+- Resolution switching (HD/SD)
+
+## Setup
+
+1. Get your API Key from [Wyze Developer Portal](https://support.wyze.com/hc/en-us/articles/16129834216731)
+2. Go to go2rtc WebUI > Add > Wyze
+3. Enter your API ID, API Key, email, and password
+4. Select cameras to add - stream URLs are generated automatically
+
+**Example Config**
+
+```yaml
+wyze:
+  user@email.com:
+    api_id: "your-api-id"
+    api_key: "your-api-key"
+    password: "yourpassword"    # or MD5 triple-hash with "md5:" prefix
+
+streams:
+  wyze_cam: wyze://192.168.1.123?uid=WYZEUID1234567890AB&enr=xxx&mac=AABBCCDDEEFF&model=HL_CAM4&dtls=true
+```
+
+## Stream URL Format
+
+The stream URL is automatically generated when you add cameras via the WebUI:
+
+```
+wyze://[IP]?uid=[P2P_ID]&enr=[ENR]&mac=[MAC]&model=[MODEL]&subtype=[hd|sd]&dtls=true
+```
+
+| Parameter | Description                                     |
+|-----------|-------------------------------------------------|
+| `IP`      | Camera's local IP address                       |
+| `uid`     | P2P identifier (20 chars)                       |
+| `enr`     | Encryption key for DTLS                         |
+| `mac`     | Device MAC address                              |
+| `model`   | Camera model (e.g., HL_CAM4)                    |
+| `dtls`    | Enable DTLS encryption (default: true)          |
+| `subtype` | Camera resolution: `hd` or `sd` (default: `hd`) |
+
+## Configuration
+
+### Resolution
+
+You can change the camera's resolution using the `subtype` parameter:
+
+```yaml
+streams:
+  wyze_hd: wyze://...&subtype=hd
+  wyze_sd: wyze://...&subtype=sd
+```
+
+### Two-Way Audio
+
+Two-way audio (intercom) is supported automatically. When a consumer sends audio to the stream, it will be transmitted to the camera's speaker.
+
+## Camera Compatibility
+
+| Name                        | Model          | Firmware     | Protocol | Encryption | Codecs     |
+|-----------------------------|----------------|--------------|----------|------------|------------|
+| Wyze Cam v4                 | HL_CAM4        | 4.52.9.4188  | TUTK     | TransCode  | h264, aac  |
+|                             |                | 4.52.9.5332  | TUTK     | HMAC-SHA1  | h264, aac  |
+| Wyze Cam v3 Pro             |                |              | TUTK     |            |            |
+| Wyze Cam v3                 | WYZE_CAKP2JFUS | 4.36.14.3497 | TUTK     | TransCode  | h264, pcm  |
+| Wyze Cam v2                 | WYZEC1-JZ      | 4.9.9.3006   | TUTK     | TransCode  | h264, pcmu |
+| Wyze Cam v1                 |                |              | TUTK     |            |            |
+| Wyze Cam Pan v4             |                |              | Gwell*   |            |            |
+| Wyze Cam Pan v3             |                |              | TUTK     |            |            |
+| Wyze Cam Pan v2             |                |              | TUTK     |            |            |
+| Wyze Cam Pan v1             |                |              | TUTK     |            |            |
+| Wyze Cam OG                 |                |              | Gwell*   |            |            |
+| Wyze Cam OG Telephoto       |                |              | Gwell*   |            |            |
+| Wyze Cam OG (2025)          |                |              | Gwell*   |            |            |
+| Wyze Cam Outdoor v2         |                |              | TUTK     |            |            |
+| Wyze Cam Outdoor v1         |                |              | TUTK     |            |            |
+| Wyze Cam Floodlight Pro     |                |              | ?        |            |            |
+| Wyze Cam Floodlight v2      |                |              | TUTK     |            |            |
+| Wyze Cam Floodlight         |                |              | TUTK     |            |            |
+| Wyze Video Doorbell v2      | HL_DB2         | 4.51.3.4992  | TUTK     | TransCode  | h264, pcm  |
+| Wyze Video Doorbell v1      |                |              | TUTK     |            |            |
+| Wyze Video Doorbell Pro     |                |              | ?        |            |            |
+| Wyze Battery Video Doorbell |                |              | ?        |            |            |
+| Wyze Duo Cam Doorbell       |                |              | ?        |            |            |
+| Wyze Battery Cam Pro        |                |              | ?        |            |            |
+| Wyze Solar Cam Pan          |                |              | ?        |            |            |
+| Wyze Duo Cam Pan            |                |              | ?        |            |            |
+| Wyze Window Cam             |                |              | ?        |            |            |
+| Wyze Bulb Cam               |                |              | ?        |            |            |
+
+_* Gwell based protocols are not yet supported._
diff --git a/installs_on_host/go2rtc/internal/wyze/wyze.go b/installs_on_host/go2rtc/internal/wyze/wyze.go
new file mode 100644
index 0000000..982a16e
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/wyze/wyze.go
@@ -0,0 +1,202 @@
+package wyze
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/wyze"
+)
+
+type AccountConfig struct {
+	APIKey   string `yaml:"api_key"`
+	APIID    string `yaml:"api_id"`
+	Password string `yaml:"password"`
+}
+
+var accounts map[string]AccountConfig
+
+func Init() {
+	var v struct {
+		Cfg map[string]AccountConfig `yaml:"wyze"`
+	}
+	app.LoadConfig(&v)
+
+	accounts = v.Cfg
+
+	log := app.GetLogger("wyze")
+
+	streams.HandleFunc("wyze", func(rawURL string) (core.Producer, error) {
+		log.Debug().Msgf("wyze: dial %s", rawURL)
+		return wyze.NewProducer(rawURL)
+	})
+
+	api.HandleFunc("api/wyze", apiWyze)
+}
+
+func getCloud(email string) (*wyze.Cloud, error) {
+	cfg, ok := accounts[email]
+	if !ok {
+		return nil, fmt.Errorf("wyze: account not found: %s", email)
+	}
+
+	if cfg.APIKey == "" || cfg.APIID == "" {
+		return nil, fmt.Errorf("wyze: api_key and api_id required for account: %s", email)
+	}
+
+	cloud := wyze.NewCloud(cfg.APIKey, cfg.APIID)
+
+	if err := cloud.Login(email, cfg.Password); err != nil {
+		return nil, err
+	}
+
+	return cloud, nil
+}
+
+func apiWyze(w http.ResponseWriter, r *http.Request) {
+	switch r.Method {
+	case "GET":
+		apiDeviceList(w, r)
+	case "POST":
+		apiAuth(w, r)
+	}
+}
+
+func apiDeviceList(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+
+	email := query.Get("id")
+	if email == "" {
+		accountList := make([]string, 0, len(accounts))
+		for id := range accounts {
+			accountList = append(accountList, id)
+		}
+		api.ResponseJSON(w, accountList)
+		return
+	}
+
+	err := func() error {
+		cloud, err := getCloud(email)
+		if err != nil {
+			return err
+		}
+
+		cameras, err := cloud.GetCameraList()
+		if err != nil {
+			return err
+		}
+
+		var items []*api.Source
+		for _, cam := range cameras {
+			items = append(items, &api.Source{
+				Name: cam.Nickname,
+				Info: fmt.Sprintf("%s | %s | %s", cam.ProductModel, cam.MAC, cam.IP),
+				URL:  buildStreamURL(cam),
+			})
+		}
+
+		api.ResponseSources(w, items)
+		return nil
+	}()
+
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+func apiAuth(w http.ResponseWriter, r *http.Request) {
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	email := r.Form.Get("email")
+	password := r.Form.Get("password")
+	apiKey := r.Form.Get("api_key")
+	apiID := r.Form.Get("api_id")
+
+	if email == "" || password == "" || apiKey == "" || apiID == "" {
+		http.Error(w, "email, password, api_key and api_id required", http.StatusBadRequest)
+		return
+	}
+
+	// Try to login
+	cloud := wyze.NewCloud(apiKey, apiID)
+
+	if err := cloud.Login(email, password); err != nil {
+		// Check for MFA error
+		var authErr *wyze.AuthError
+		if ok := isAuthError(err, &authErr); ok {
+			w.Header().Set("Content-Type", api.MimeJSON)
+			w.WriteHeader(http.StatusUnauthorized)
+			_ = json.NewEncoder(w).Encode(authErr)
+			return
+		}
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	cfg := map[string]string{
+		"password": password,
+		"api_key":  apiKey,
+		"api_id":   apiID,
+	}
+
+	if err := app.PatchConfig([]string{"wyze", email}, cfg); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	if accounts == nil {
+		accounts = make(map[string]AccountConfig)
+	}
+	accounts[email] = AccountConfig{
+		APIKey:   apiKey,
+		APIID:    apiID,
+		Password: password,
+	}
+
+	cameras, err := cloud.GetCameraList()
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	var items []*api.Source
+	for _, cam := range cameras {
+		items = append(items, &api.Source{
+			Name: cam.Nickname,
+			Info: fmt.Sprintf("%s | %s | %s", cam.ProductModel, cam.MAC, cam.IP),
+			URL:  buildStreamURL(cam),
+		})
+	}
+
+	api.ResponseSources(w, items)
+}
+
+func buildStreamURL(cam *wyze.Camera) string {
+	query := url.Values{}
+	query.Set("uid", cam.P2PID)
+	query.Set("enr", cam.ENR)
+	query.Set("mac", cam.MAC)
+	query.Set("model", cam.ProductModel)
+
+	if cam.DTLS == 1 {
+		query.Set("dtls", "true")
+	}
+
+	return fmt.Sprintf("wyze://%s?%s", cam.IP, query.Encode())
+}
+
+func isAuthError(err error, target **wyze.AuthError) bool {
+	if e, ok := err.(*wyze.AuthError); ok {
+		*target = e
+		return true
+	}
+	return false
+}
diff --git a/installs_on_host/go2rtc/internal/xiaomi/README.md b/installs_on_host/go2rtc/internal/xiaomi/README.md
new file mode 100644
index 0000000..330183e
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/xiaomi/README.md
@@ -0,0 +1,64 @@
+# Xiaomi Mi Home
+
+[`new in v1.9.13`](https://github.com/AlexxIT/go2rtc/releases/tag/v1.9.13)
+
+This source allows you to view cameras from the [Xiaomi Mi Home](https://home.mi.com/) ecosystem.
+
+Since 2020, Xiaomi has introduced a unified protocol for cameras called `miss`. I think it means **Mi Secure Streaming**. Until this point, the camera protocols were in chaos. Almost every model had different authorization, encryption, command lists, and media packet formats.
+
+go2rtc supports two formats: `xiaomi/mess` and `xiaomi/legacy`.
+And multiple P2P protocols: `cs2+udp`, `cs2+tcp`, several versions of `tutk+udp`.
+
+Almost all cameras in the `xiaomi/mess` format and the `cs2` protocol work well.
+Older `xiaomi/legacy` format cameras may have support issues.
+The `tutk` protocol is the worst thing that's ever happened to the P2P world. It works terribly.
+
+**Important:**
+
+1. **Not all cameras are supported**. The list of supported cameras is collected in [this issue](https://github.com/AlexxIT/go2rtc/issues/1982).
+2. Each time you connect to the camera, you need Internet access to obtain encryption keys.
+3. Connection to the camera is local only.
+
+**Features:**
+
+- Multiple Xiaomi accounts supported
+- Cameras from multiple regions are supported for a single account
+- Two-way audio is supported
+- Cameras with multiple lenses are supported
+
+## Setup
+
+1. Go to go2rtc WebUI > Add > Xiaomi > Login with username and password
+2. Receive verification code by email or phone if required.
+3. Complete the captcha if required.
+4. If everything is OK, your account will be added, and you can load cameras from it.
+
+**Example**
+
+```yaml
+xiaomi:
+  1234567890: V1:***
+
+streams:
+  xiaomi1: xiaomi://1234567890:cn@192.168.1.123?did=9876543210&model=isa.camera.hlc7
+```
+
+## Configuration
+
+Quality in the `miss` protocol is specified by a number from 0 to 5. Usually 0 means auto, 1 - sd, 2 - hd.
+Go2rtc by default sets quality to 2. But some new cameras have HD quality at number 3.
+Old cameras may have broken codec settings at number 3, so this number should not be set for all cameras.
+
+You can change camera quality: `subtype=hd/sd/auto/0-5`.
+
+```yaml
+streams:
+  xiaomi1: xiaomi://***&subtype=sd
+```
+
+You can use a second channel for dual cameras: `channel=2`.
+
+```yaml
+streams:
+  xiaomi1: xiaomi://***&channel=2
+```
diff --git a/installs_on_host/go2rtc/internal/xiaomi/xiaomi.go b/installs_on_host/go2rtc/internal/xiaomi/xiaomi.go
new file mode 100644
index 0000000..1e57842
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/xiaomi/xiaomi.go
@@ -0,0 +1,362 @@
+package xiaomi
+
+import (
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/xiaomi"
+	"github.com/AlexxIT/go2rtc/pkg/xiaomi/crypto"
+	"github.com/rs/zerolog"
+)
+
+func Init() {
+	var v struct {
+		Cfg map[string]string `yaml:"xiaomi"`
+	}
+	app.LoadConfig(&v)
+
+	tokens = v.Cfg
+
+	log = app.GetLogger("xiaomi")
+
+	streams.HandleFunc("xiaomi", func(rawURL string) (core.Producer, error) {
+		u, err := url.Parse(rawURL)
+		if err != nil {
+			return nil, err
+		}
+
+		if u.User != nil {
+			rawURL, err = getCameraURL(u)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		log.Debug().Msgf("xiaomi: dial %s", rawURL)
+
+		return xiaomi.Dial(rawURL)
+	})
+
+	api.HandleFunc("api/xiaomi", apiXiaomi)
+}
+
+var log zerolog.Logger
+
+var tokens map[string]string
+var clouds map[string]*xiaomi.Cloud
+var cloudsMu sync.Mutex
+
+func getCloud(userID string) (*xiaomi.Cloud, error) {
+	cloudsMu.Lock()
+	defer cloudsMu.Unlock()
+
+	if cloud := clouds[userID]; cloud != nil {
+		return cloud, nil
+	}
+
+	cloud := xiaomi.NewCloud(AppXiaomiHome)
+	if err := cloud.LoginWithToken(userID, tokens[userID]); err != nil {
+		return nil, err
+	}
+	if clouds == nil {
+		clouds = map[string]*xiaomi.Cloud{userID: cloud}
+	} else {
+		clouds[userID] = cloud
+	}
+	return cloud, nil
+}
+
+func cloudRequest(userID, region, apiURL, params string) ([]byte, error) {
+	cloud, err := getCloud(userID)
+	if err != nil {
+		return nil, err
+	}
+	return cloud.Request(GetBaseURL(region), apiURL, params, nil)
+}
+
+func cloudUserRequest(user *url.Userinfo, apiURL, params string) ([]byte, error) {
+	userID := user.Username()
+	region, _ := user.Password()
+	return cloudRequest(userID, region, apiURL, params)
+}
+
+func getCameraURL(url *url.URL) (string, error) {
+	model := url.Query().Get("model")
+
+	// It is not known which models need to be awakened.
+	// Probably all the doorbells and all the battery cameras.
+	if strings.Contains(model, ".cateye.") {
+		_ = wakeUpCamera(url)
+	}
+
+	// The getMissURL request has a fallback to getP2PURL.
+	// But for known models we can save one request to the cloud.
+	if xiaomi.IsLegacy(model) {
+		return getLegacyURL(url)
+	}
+	return getMissURL(url)
+}
+
+func getLegacyURL(url *url.URL) (string, error) {
+	query := url.Query()
+
+	clientPublic, clientPrivate, err := crypto.GenerateKey()
+	if err != nil {
+		return "", err
+	}
+
+	params := fmt.Sprintf(`{"did":"%s","toSignAppData":"%x"}`, query.Get("did"), clientPublic)
+
+	userID := url.User.Username()
+	region, _ := url.User.Password()
+	res, err := cloudRequest(userID, region, "/device/devicepass", params)
+	if err != nil {
+		return "", err
+	}
+
+	var v struct {
+		UID       string `json:"p2p_id"`
+		Password  string `json:"password"`
+		PublicKey string `json:"p2p_dev_public_key"`
+		Sign      string `json:"signForAppData"`
+	}
+	if err = json.Unmarshal(res, &v); err != nil {
+		return "", err
+	}
+
+	query.Set("uid", v.UID)
+
+	if v.Sign != "" {
+		query.Set("client_public", hex.EncodeToString(clientPublic))
+		query.Set("client_private", hex.EncodeToString(clientPrivate))
+		query.Set("device_public", v.PublicKey)
+		query.Set("sign", v.Sign)
+	} else {
+		query.Set("password", v.Password)
+	}
+
+	url.RawQuery = query.Encode()
+	return url.String(), nil
+}
+
+func getMissURL(url *url.URL) (string, error) {
+	clientPublic, clientPrivate, err := crypto.GenerateKey()
+	if err != nil {
+		return "", err
+	}
+
+	query := url.Query()
+	params := fmt.Sprintf(
+		`{"app_pubkey":"%x","did":"%s","support_vendors":"TUTK_CS2_MTP"}`,
+		clientPublic, query.Get("did"),
+	)
+
+	res, err := cloudUserRequest(url.User, "/v2/device/miss_get_vendor", params)
+	if err != nil {
+		if strings.Contains(err.Error(), "no available vendor support") {
+			return getLegacyURL(url)
+		}
+		return "", err
+	}
+
+	var v struct {
+		Vendor struct {
+			ID     byte `json:"vendor"`
+			Params struct {
+				UID string `json:"p2p_id"`
+			} `json:"vendor_params"`
+		} `json:"vendor"`
+		PublicKey string `json:"public_key"`
+		Sign      string `json:"sign"`
+	}
+	if err = json.Unmarshal(res, &v); err != nil {
+		return "", err
+	}
+
+	query.Set("client_public", hex.EncodeToString(clientPublic))
+	query.Set("client_private", hex.EncodeToString(clientPrivate))
+	query.Set("device_public", v.PublicKey)
+	query.Set("sign", v.Sign)
+	query.Set("vendor", getVendorName(v.Vendor.ID))
+
+	if v.Vendor.ID == 1 {
+		query.Set("uid", v.Vendor.Params.UID)
+	}
+
+	url.RawQuery = query.Encode()
+	return url.String(), nil
+}
+
+func getVendorName(i byte) string {
+	switch i {
+	case 1:
+		return "tutk"
+	case 3:
+		return "agora"
+	case 4:
+		return "cs2"
+	case 6:
+		return "mtp"
+	}
+	return fmt.Sprintf("%d", i)
+}
+
+func wakeUpCamera(url *url.URL) error {
+	const params = `{"id":1,"method":"wakeup","params":{"video":"1"}}`
+	did := url.Query().Get("did")
+	_, err := cloudUserRequest(url.User, "/home/rpc/"+did, params)
+	return err
+}
+
+func apiXiaomi(w http.ResponseWriter, r *http.Request) {
+	switch r.Method {
+	case "GET":
+		apiDeviceList(w, r)
+	case "POST":
+		apiAuth(w, r)
+	}
+}
+
+func apiDeviceList(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+
+	user := query.Get("id")
+	if user == "" {
+		cloudsMu.Lock()
+		users := make([]string, 0, len(tokens))
+		for s := range tokens {
+			users = append(users, s)
+		}
+		cloudsMu.Unlock()
+
+		api.ResponseJSON(w, users)
+		return
+	}
+
+	err := func() error {
+		region := query.Get("region")
+		res, err := cloudRequest(user, region, "/v2/home/device_list_page", "{}")
+		if err != nil {
+			return err
+		}
+		var v struct {
+			List []*Device `json:"list"`
+		}
+
+		log.Trace().Str("user", user).Msgf("[xiaomi] devices list: %s", res)
+
+		if err = json.Unmarshal(res, &v); err != nil {
+			return err
+		}
+
+		var items []*api.Source
+
+		for _, device := range v.List {
+			if !device.HasCamera() {
+				continue
+			}
+			items = append(items, &api.Source{
+				Name: device.Name,
+				Info: fmt.Sprintf("ip: %s, mac: %s", device.IP, device.MAC),
+				URL:  fmt.Sprintf("xiaomi://%s:%s@%s?did=%s&model=%s", user, region, device.IP, device.Did, device.Model),
+			})
+		}
+
+		api.ResponseSources(w, items)
+		return nil
+	}()
+
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+type Device struct {
+	Did   string `json:"did"`
+	Name  string `json:"name"`
+	Model string `json:"model"`
+	MAC   string `json:"mac"`
+	IP    string `json:"localip"`
+}
+
+func (d *Device) HasCamera() bool {
+	return strings.Contains(d.Model, ".camera.") ||
+		strings.Contains(d.Model, ".cateye.") ||
+		strings.Contains(d.Model, ".feeder.")
+}
+
+var auth *xiaomi.Cloud
+
+func apiAuth(w http.ResponseWriter, r *http.Request) {
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	username := r.Form.Get("username")
+	password := r.Form.Get("password")
+	captcha := r.Form.Get("captcha")
+	verify := r.Form.Get("verify")
+
+	var err error
+
+	switch {
+	case username != "" || password != "":
+		auth = xiaomi.NewCloud(AppXiaomiHome)
+		err = auth.Login(username, password)
+	case captcha != "":
+		err = auth.LoginWithCaptcha(captcha)
+	case verify != "":
+		err = auth.LoginWithVerify(verify)
+	default:
+		http.Error(w, "wrong request", http.StatusBadRequest)
+		return
+	}
+
+	if err == nil {
+		userID, token := auth.UserToken()
+		auth = nil
+
+		cloudsMu.Lock()
+		if tokens == nil {
+			tokens = map[string]string{userID: token}
+		} else {
+			tokens[userID] = token
+		}
+		cloudsMu.Unlock()
+
+		err = app.PatchConfig([]string{"xiaomi", userID}, token)
+	}
+
+	if err != nil {
+		var login *xiaomi.LoginError
+		if errors.As(err, &login) {
+			w.Header().Set("Content-Type", api.MimeJSON)
+			w.WriteHeader(http.StatusUnauthorized)
+			_ = json.NewEncoder(w).Encode(err)
+			return
+		}
+
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+const AppXiaomiHome = "xiaomiio"
+
+func GetBaseURL(region string) string {
+	switch region {
+	case "de", "i2", "ru", "sg", "us":
+		return "https://" + region + ".api.io.mi.com/app"
+	}
+	return "https://api.io.mi.com/app"
+}
diff --git a/installs_on_host/go2rtc/internal/yandex/README.md b/installs_on_host/go2rtc/internal/yandex/README.md
new file mode 100644
index 0000000..69d4739
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/yandex/README.md
@@ -0,0 +1,22 @@
+# Yandex
+
+Source for receiving stream from new [Yandex IP camera](https://alice.yandex.ru/smart-home/security/ipcamera).
+
+## Get Yandex token
+
+1. Install HomeAssistant integration [YandexStation](https://github.com/AlexxIT/YandexStation).
+2. Copy token from HomeAssistant config folder: `/config/.storage/core.config_entries`, key: `"x_token"`.
+
+## Get device ID
+
+1. Open this link in any browser: https://iot.quasar.yandex.ru/m/v3/user/devices
+2. Copy ID of your camera, key: `"id"`.
+
+## Configuration
+
+```yaml
+streams:
+  yandex_stream: yandex:?x_token=XXXX&device_id=XXXX
+  yandex_snapshot: yandex:?x_token=XXXX&device_id=XXXX&snapshot
+  yandex_snapshot_custom_size: yandex:?x_token=XXXX&device_id=XXXX&snapshot=h=540
+```
diff --git a/installs_on_host/go2rtc/internal/yandex/goloom.go b/installs_on_host/go2rtc/internal/yandex/goloom.go
new file mode 100644
index 0000000..6bccb75
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/yandex/goloom.go
@@ -0,0 +1,152 @@
+package yandex
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/internal/webrtc"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	xwebrtc "github.com/AlexxIT/go2rtc/pkg/webrtc"
+	"github.com/google/uuid"
+	"github.com/gorilla/websocket"
+	pion "github.com/pion/webrtc/v4"
+)
+
+func goloomClient(serviceURL, serviceName, roomId, participantId, credentials string) (core.Producer, error) {
+	conn, _, err := websocket.DefaultDialer.Dial(serviceURL, nil)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		time.Sleep(time.Second)
+		_ = conn.Close()
+	}()
+
+	s := fmt.Sprintf(`{"hello": {
+"credentials":"%s","participantId":"%s","roomId":"%s","serviceName":"%s","sdkInitializationId":"%s",
+"capabilitiesOffer":{},"sendAudio":false,"sendSharing":false,"sendVideo":false,
+"sdkInfo":{"hwConcurrency":4,"implementation":"browser","version":"5.4.0"},
+"participantAttributes":{"description":"","name":"mike","role":"SPEAKER"},
+"participantMeta":{"description":"","name":"mike","role":"SPEAKER","sendAudio":false,"sendVideo":false}
+},"uid":"%s"}`,
+		credentials, participantId, roomId, serviceName,
+		uuid.NewString(), uuid.NewString(),
+	)
+
+	err = conn.WriteMessage(websocket.TextMessage, []byte(s))
+	if err != nil {
+		return nil, err
+	}
+
+	if _, _, err = conn.ReadMessage(); err != nil {
+		return nil, err
+	}
+
+	pc, err := webrtc.PeerConnection(true)
+	if err != nil {
+		return nil, err
+	}
+
+	prod := xwebrtc.NewConn(pc)
+	prod.FormatName = "yandex"
+	prod.Mode = core.ModeActiveProducer
+	prod.Protocol = "wss"
+
+	var connState core.Waiter
+
+	prod.Listen(func(msg any) {
+		switch msg := msg.(type) {
+		case pion.PeerConnectionState:
+			switch msg {
+			case pion.PeerConnectionStateConnecting:
+			case pion.PeerConnectionStateConnected:
+				connState.Done(nil)
+			default:
+				connState.Done(errors.New("webrtc: " + msg.String()))
+			}
+		}
+	})
+
+	go func() {
+		for {
+			var msg map[string]json.RawMessage
+			if err = conn.ReadJSON(&msg); err != nil {
+				return
+			}
+
+			for k, v := range msg {
+				switch k {
+				case "uid":
+					continue
+				case "serverHello":
+				case "subscriberSdpOffer":
+					var sdp subscriberSdp
+					if err = json.Unmarshal(v, &sdp); err != nil {
+						return
+					}
+					//log.Trace().Msgf("offer:\n%s", sdp.Sdp)
+					if err = prod.SetOffer(sdp.Sdp); err != nil {
+						return
+					}
+					if sdp.Sdp, err = prod.GetAnswer(); err != nil {
+						return
+					}
+					//log.Trace().Msgf("answer:\n%s", sdp.Sdp)
+
+					var raw []byte
+					if raw, err = json.Marshal(sdp); err != nil {
+						return
+					}
+					s = fmt.Sprintf(`{"uid":"%s","subscriberSdpAnswer":%s}`, uuid.NewString(), raw)
+					if err = conn.WriteMessage(websocket.TextMessage, []byte(s)); err != nil {
+						return
+					}
+				case "webrtcIceCandidate":
+					var candidate webrtcIceCandidate
+					if err = json.Unmarshal(v, &candidate); err != nil {
+						return
+					}
+					if err = prod.AddCandidate(candidate.Candidate); err != nil {
+						return
+					}
+				}
+				//log.Trace().Msgf("%s : %s", k, v)
+			}
+
+			if msg["ack"] != nil {
+				continue
+			}
+
+			s = fmt.Sprintf(`{"uid":%s,"ack":{"status":{"code":"OK"}}}`, msg["uid"])
+			if err = conn.WriteMessage(websocket.TextMessage, []byte(s)); err != nil {
+				return
+			}
+		}
+	}()
+
+	if err = connState.Wait(); err != nil {
+		return nil, err
+	}
+
+	s = fmt.Sprintf(`{"uid":"%s","setSlots":{"slots":[{"width":0,"height":0}],"audioSlotsCount":0,"key":1,"shutdownAllVideo":false,"withSelfView":false,"selfViewVisibility":"ON_LOADING_THEN_HIDE","gridConfig":{}}}`, uuid.NewString())
+	if err = conn.WriteMessage(websocket.TextMessage, []byte(s)); err != nil {
+		return nil, err
+	}
+
+	return prod, nil
+}
+
+type subscriberSdp struct {
+	PcSeq int    `json:"pcSeq"`
+	Sdp   string `json:"sdp"`
+}
+
+type webrtcIceCandidate struct {
+	PcSeq         int    `json:"pcSeq"`
+	Target        string `json:"target"`
+	Candidate     string `json:"candidate"`
+	SdpMid        string `json:"sdpMid"`
+	SdpMlineIndex int    `json:"sdpMlineIndex"`
+}
diff --git a/installs_on_host/go2rtc/internal/yandex/yandex.go b/installs_on_host/go2rtc/internal/yandex/yandex.go
new file mode 100644
index 0000000..05680b3
--- /dev/null
+++ b/installs_on_host/go2rtc/internal/yandex/yandex.go
@@ -0,0 +1,44 @@
+package yandex
+
+import (
+	"net/url"
+
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/yandex"
+)
+
+func Init() {
+	streams.HandleFunc("yandex", func(source string) (core.Producer, error) {
+		u, err := url.Parse(source)
+		if err != nil {
+			return nil, err
+		}
+
+		query := u.Query()
+		token := query.Get("x_token")
+
+		session, err := yandex.GetSession(token)
+		if err != nil {
+			return nil, err
+		}
+
+		deviceID := query.Get("device_id")
+
+		if query.Has("snapshot") {
+			rawURL, err := session.GetSnapshotURL(deviceID)
+			if err != nil {
+				return nil, err
+			}
+			rawURL += "/current.jpg?" + query.Get("snapshot") + "#header=Cookie:" + session.GetCookieString(rawURL)
+			return streams.GetProducer(rawURL)
+		}
+
+		room, err := session.WebrtcCreateRoom(deviceID)
+		if err != nil {
+			return nil, err
+		}
+
+		return goloomClient(room.ServiceUrl, room.ServiceName, room.RoomId, room.ParticipantId, room.Credentials)
+	})
+}
diff --git a/installs_on_host/go2rtc/main.go b/installs_on_host/go2rtc/main.go
new file mode 100644
index 0000000..00c059e
--- /dev/null
+++ b/installs_on_host/go2rtc/main.go
@@ -0,0 +1,125 @@
+package main
+
+import (
+	"slices"
+
+	"github.com/AlexxIT/go2rtc/internal/alsa"
+	"github.com/AlexxIT/go2rtc/internal/api"
+	"github.com/AlexxIT/go2rtc/internal/api/ws"
+	"github.com/AlexxIT/go2rtc/internal/app"
+	"github.com/AlexxIT/go2rtc/internal/bubble"
+	"github.com/AlexxIT/go2rtc/internal/debug"
+	"github.com/AlexxIT/go2rtc/internal/doorbird"
+	"github.com/AlexxIT/go2rtc/internal/dvrip"
+	"github.com/AlexxIT/go2rtc/internal/echo"
+	"github.com/AlexxIT/go2rtc/internal/eseecloud"
+	"github.com/AlexxIT/go2rtc/internal/exec"
+	"github.com/AlexxIT/go2rtc/internal/expr"
+	"github.com/AlexxIT/go2rtc/internal/ffmpeg"
+	"github.com/AlexxIT/go2rtc/internal/flussonic"
+	"github.com/AlexxIT/go2rtc/internal/gopro"
+	"github.com/AlexxIT/go2rtc/internal/hass"
+	"github.com/AlexxIT/go2rtc/internal/hls"
+	"github.com/AlexxIT/go2rtc/internal/homekit"
+	"github.com/AlexxIT/go2rtc/internal/http"
+	"github.com/AlexxIT/go2rtc/internal/isapi"
+	"github.com/AlexxIT/go2rtc/internal/ivideon"
+	"github.com/AlexxIT/go2rtc/internal/kasa"
+	"github.com/AlexxIT/go2rtc/internal/mjpeg"
+	"github.com/AlexxIT/go2rtc/internal/mp4"
+	"github.com/AlexxIT/go2rtc/internal/mpeg"
+	"github.com/AlexxIT/go2rtc/internal/multitrans"
+	"github.com/AlexxIT/go2rtc/internal/nest"
+	"github.com/AlexxIT/go2rtc/internal/ngrok"
+	"github.com/AlexxIT/go2rtc/internal/onvif"
+	"github.com/AlexxIT/go2rtc/internal/pinggy"
+	"github.com/AlexxIT/go2rtc/internal/ring"
+	"github.com/AlexxIT/go2rtc/internal/roborock"
+	"github.com/AlexxIT/go2rtc/internal/rtmp"
+	"github.com/AlexxIT/go2rtc/internal/rtsp"
+	"github.com/AlexxIT/go2rtc/internal/srtp"
+	"github.com/AlexxIT/go2rtc/internal/streams"
+	"github.com/AlexxIT/go2rtc/internal/tapo"
+	"github.com/AlexxIT/go2rtc/internal/tuya"
+	"github.com/AlexxIT/go2rtc/internal/v4l2"
+	"github.com/AlexxIT/go2rtc/internal/webrtc"
+	"github.com/AlexxIT/go2rtc/internal/webtorrent"
+	"github.com/AlexxIT/go2rtc/internal/wyoming"
+	"github.com/AlexxIT/go2rtc/internal/wyze"
+	"github.com/AlexxIT/go2rtc/internal/xiaomi"
+	"github.com/AlexxIT/go2rtc/internal/yandex"
+	"github.com/AlexxIT/go2rtc/pkg/shell"
+)
+
+func main() {
+	// version will be set later from -buildvcs info, this used only as fallback
+	app.Version = "1.9.14"
+
+	type module struct {
+		name string
+		init func()
+	}
+
+	modules := []module{
+		{"", app.Init},    // init config and logs
+		{"api", api.Init}, // init API before all others
+		{"ws", ws.Init},   // init WS API endpoint
+		{"", streams.Init},
+		// Main sources and servers
+		{"http", http.Init},     // rtsp source, HTTP server
+		{"rtsp", rtsp.Init},     // rtsp source, RTSP server
+		{"webrtc", webrtc.Init}, // webrtc source, WebRTC server
+		// Main API
+		{"mp4", mp4.Init},     // MP4 API
+		{"hls", hls.Init},     // HLS API
+		{"mjpeg", mjpeg.Init}, // MJPEG API
+		// Other sources and servers
+		{"hass", hass.Init},             // hass source, Hass API server
+		{"homekit", homekit.Init},       // homekit source, HomeKit server
+		{"onvif", onvif.Init},           // onvif source, ONVIF API server
+		{"rtmp", rtmp.Init},             // rtmp source, RTMP server
+		{"webtorrent", webtorrent.Init}, // webtorrent source, WebTorrent module
+		{"wyoming", wyoming.Init},
+		// Exec and script sources
+		{"echo", echo.Init},
+		{"exec", exec.Init},
+		{"expr", expr.Init},
+		{"ffmpeg", ffmpeg.Init},
+		// Hardware sources
+		{"alsa", alsa.Init},
+		{"v4l2", v4l2.Init},
+		// Other sources
+		{"bubble", bubble.Init},
+		{"doorbird", doorbird.Init},
+		{"dvrip", dvrip.Init},
+		{"eseecloud", eseecloud.Init},
+		{"flussonic", flussonic.Init},
+		{"gopro", gopro.Init},
+		{"isapi", isapi.Init},
+		{"ivideon", ivideon.Init},
+		{"kasa", kasa.Init},
+		{"mpegts", mpeg.Init},
+		{"multitrans", multitrans.Init},
+		{"nest", nest.Init},
+		{"ring", ring.Init},
+		{"roborock", roborock.Init},
+		{"tapo", tapo.Init},
+		{"tuya", tuya.Init},
+		{"wyze", wyze.Init},
+		{"xiaomi", xiaomi.Init},
+		{"yandex", yandex.Init},
+		// Helper modules
+		{"debug", debug.Init},
+		{"ngrok", ngrok.Init},
+		{"pinggy", pinggy.Init},
+		{"srtp", srtp.Init},
+	}
+
+	for _, m := range modules {
+		if app.Modules == nil || m.name == "" || slices.Contains(app.Modules, m.name) {
+			m.init()
+		}
+	}
+
+	shell.RunUntilSignal()
+}
diff --git a/installs_on_host/go2rtc/package.json b/installs_on_host/go2rtc/package.json
new file mode 100644
index 0000000..03377f4
--- /dev/null
+++ b/installs_on_host/go2rtc/package.json
@@ -0,0 +1,47 @@
+{
+  "devDependencies": {
+    "@types/node": "^25.2.0",
+    "eslint": "^9.39.2",
+    "eslint-plugin-html": "^8.1.4",
+    "vitepress": "^2.0.0-alpha.16"
+  },
+  "scripts": {
+    "docs:dev": "vitepress dev website --host",
+    "docs:build": "vitepress build website",
+    "docs:preview": "vitepress preview website"
+  },
+  "eslintConfig": {
+    "env": {
+      "browser": true,
+      "es6": true
+    },
+    "parserOptions": {
+      "ecmaVersion": 2017,
+      "sourceType": "module"
+    },
+    "rules": {
+      "no-var": "error",
+      "no-undef": "error",
+      "no-unused-vars": "warn",
+      "prefer-const": "error",
+      "quotes": [
+        "error",
+        "single"
+      ],
+      "semi": "error"
+    },
+    "plugins": [
+      "html"
+    ],
+    "overrides": [
+      {
+        "files": [
+          "*.html"
+        ],
+        "parserOptions": {
+          "sourceType": "script"
+        }
+      }
+    ]
+  }
+}
diff --git a/installs_on_host/go2rtc/pkg/README.md b/installs_on_host/go2rtc/pkg/README.md
new file mode 100644
index 0000000..89c1aa6
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/README.md
@@ -0,0 +1,114 @@
+# Notes
+
+go2rtc tries to name formats, protocols and codecs the same way they are named in FFmpeg.
+Some formats and protocols go2rtc supports exclusively. They have no equivalent in FFmpeg.
+
+## Producers (input)
+
+- The initiator of the connection can be go2rtc - **Source protocols**
+- The initiator of the connection can be an external program - **Ingress protocols**
+- Codecs can be incoming - **Receiver codecs**
+- Codecs can be outgoing (two way audio) - **Sender codecs**
+
+| Group      | Format       | Protocols       | Ingress | Receiver codecs                 | Sender codecs      | Example       |
+|------------|--------------|-----------------|---------|---------------------------------|---------------------|---------------|
+| Devices    | alsa         | pipe            |         |                                 | pcm                 | `alsa:`       |
+| Devices    | v4l2         | pipe            |         |                                 |                     | `v4l2:`       |
+| Files      | adts         | http, tcp, pipe | http    | aac                             |                     | `http:`       |
+| Files      | flv          | http, tcp, pipe | http    | h264, aac                       |                     | `http:`       |
+| Files      | h264         | http, tcp, pipe | http    | h264                            |                     | `http:`       |
+| Files      | hevc         | http, tcp, pipe | http    | hevc                            |                     | `http:`       |
+| Files      | hls          | http            |         | h264, h265, aac, opus           |                     | `http:`       |
+| Files      | mjpeg        | http, tcp, pipe | http    | mjpeg                           |                     | `http:`       |
+| Files      | mpegts       | http, tcp, pipe | http    | h264, hevc, aac, opus           |                     | `http:`       |
+| Files      | wav          | http, tcp, pipe | http    | pcm_alaw, pcm_mulaw             |                     | `http:`       |
+| Net (pub)  | mpjpeg       | http, tcp, pipe | http    | mjpeg                           |                     | `http:`       |
+| Net (pub)  | onvif        | rtsp            |         |                                 |                     | `onvif:`      |
+| Net (pub)  | rtmp         | rtmp            | rtmp    | h264, aac                       |                     | `rtmp:`       |
+| Net (pub)  | rtsp         | rtsp, ws        | rtsp    | h264, hevc, aac, pcm*, opus     | pcm*, opus          | `rtsp:`       |
+| Net (pub)  | webrtc*      | webrtc          | webrtc  | h264, pcm_alaw, pcm_mulaw, opus | pcm_alaw, pcm_mulaw | `webrtc:`     |
+| Net (pub)  | yuv4mpegpipe | http, tcp, pipe | http    | rawvideo                        |                     | `http:`       |
+| Net (priv) | bubble       | http            |         | h264, hevc, pcm_alaw            |                     | `bubble:`     |
+| Net (priv) | doorbird     | http            |         |                                 |                     | `doorbird:`   |
+| Net (priv) | dvrip        | tcp             |         | h264, hevc, pcm_alaw, pcm_mulaw | pcm_alaw            | `dvrip:`      |
+| Net (priv) | eseecloud    | http            |         |                                 |                     | `eseecloud:`  |
+| Net (priv) | gopro        | udp             |         | TODO                            |                     | `gopro:`      |
+| Net (priv) | hass         | webrtc          |         | TODO                            |                     | `hass:`       |
+| Net (priv) | homekit      | hap             |         | h264, eld*                      |                     | `homekit:`    |
+| Net (priv) | isapi        | http            |         |                                 | pcm_alaw, pcm_mulaw | `isapi:`      |
+| Net (priv) | kasa         | http            |         | h264, pcm_mulaw                 |                     | `kasa:`       |
+| Net (priv) | nest         | rtsp, webrtc    |         | TODO                            |                     | `nest:`       |
+| Net (priv) | ring         | webrtc          |         |                                 |                     | `ring:`       |
+| Net (priv) | roborock     | webrtc          |         | h264, opus                      | opus                | `roborock:`   |
+| Net (priv) | tapo         | http            |         | h264, pcma                      | pcm_alaw            | `tapo:`       |
+| Net (priv) | tuya         | webrtc          |         |                                 |                     | `tuya:`       |
+| Net (priv) | vigi         | http            |         |                                 |                     | `vigi:`       |
+| Net (priv) | webtorrent   | webrtc          | TODO    | TODO                            | TODO                | `webtorrent:` |
+| Net (priv) | xiaomi*      | cs2, tutk       |         |                                 |                     | `xiaomi:`     |
+| Services   | flussonic    | ws              |         |                                 |                     | `flussonic:`  |
+| Services   | ivideon      | ws              |         | h264                            |                     | `ivideon:`    |
+| Services   | yandex       | webrtc          |         |                                 |                     | `yandex:`     |
+| Other      | echo         | *               |         |                                 |                     | `echo:`       |
+| Other      | exec         | pipe, rtsp      |         |                                 |                     | `exec:`       |
+| Other      | expr         | *               |         |                                 |                     | `expr:`       |
+| Other      | ffmpeg       | pipe, rtsp      |         |                                 |                     | `ffmpeg:`     |
+| Other      | stdin        | pipe            |         |                                 | pcm_alaw, pcm_mulaw | `stdin:`      |
+
+- **eld** - rare variant of aac codec
+- **pcm** - pcm_alaw pcm_mulaw pcm_s16be pcm_s16le
+- **webrtc** - webrtc/kinesis, webrtc/openipc, webrtc/milestone, webrtc/wyze, webrtc/whep
+
+## Consumers (output)
+
+| Format       | Protocol | Send codecs                     | Recv codecs               | Example                               |
+|--------------|----------|---------------------------------|---------------------------|---------------------------------------|
+| adts         | http     | aac                             |                           | `GET /api/stream.adts`                |
+| ascii        | http     | mjpeg                           |                           | `GET /api/stream.ascii`               |
+| flv          | http     | h264, aac                       |                           | `GET /api/stream.flv`                 |
+| hls/mpegts   | http     | h264, hevc, aac                 |                           | `GET /api/stream.m3u8`                |
+| hls/fmp4     | http     | h264, hevc, aac, pcm*, opus     |                           | `GET /api/stream.m3u8?mp4`            |
+| homekit      | hap      | h264, opus                      |                           | Apple HomeKit app                     |
+| mjpeg        | ws       | mjpeg                           |                           | `{"type":"mjpeg"}` -> `/api/ws`       |
+| mpjpeg       | http     | mjpeg                           |                           | `GET /api/stream.mjpeg`               |
+| mp4          | http     | h264, hevc, aac, pcm*, opus     |                           | `GET /api/stream.mp4`                 |
+| mse/fmp4     | ws       | h264, hevc, aac, pcm*, opus     |                           | `{"type":"mse"}` -> `/api/ws`         |
+| mpegts       | http     | h264, hevc, aac                 |                           | `GET /api/stream.ts`                  |
+| rtmp         | rtmp     | h264, aac                       |                           | `rtmp://localhost:1935/{stream_name}` |
+| rtsp         | rtsp     | h264, hevc, aac, pcm*, opus     |                           | `rtsp://localhost:8554/{stream_name}` |
+| webrtc       | webrtc   | h264, pcm_alaw, pcm_mulaw, opus | pcm_alaw, pcm_mulaw, opus | `{"type":"webrtc"}` -> `/api/ws`      |
+| yuv4mpegpipe | http     | rawvideo                        |                           | `GET /api/stream.y4m`                 |
+
+- **pcm** - pcm_alaw pcm_mulaw pcm_s16be pcm_s16le
+
+## Snapshots
+
+| Format | Protocol | Send codecs | Example               |
+|--------|----------|-------------|-----------------------|
+| jpeg   | http     | mjpeg       | `GET /api/frame.jpeg` |
+| mp4    | http     | h264,hevc   | `GET /api/frame.mp4`  |
+
+## Developers
+
+**File naming:**
+
+- `pkg/{format}/producer.go` - producer for this format (also if support backchannel)
+- `pkg/{format}/consumer.go` - consumer for this format
+- `pkg/{format}/backchannel.go` - producer with only backchannel func
+
+**Mentioning modules:**
+
+- [`main.go`](../main.go)
+- [`README.md`](../README.md)
+- [`internal/README.md`](../internal/README.md)
+- [`website/.vitepress/config.js`](../website/.vitepress/config.js)
+- [`website/api/openapi.yaml`](../website/api/openapi.yaml)
+- [`www/schema.json`](../www/schema.json)
+
+## Useful links
+
+- https://www.wowza.com/blog/streaming-protocols
+- https://vimeo.com/blog/post/rtmp-stream/
+- https://sanjeev-pandey.medium.com/understanding-the-mpeg-4-moov-atom-pseudo-streaming-in-mp4-93935e1b9e9a
+- [Android Supported media formats](https://developer.android.com/guide/topics/media/media-formats)
+- [THEOplayer](https://www.theoplayer.com/test-your-stream-hls-dash-hesp)
+- [How Generate DTS/PTS](https://www.ramugedia.com/how-generate-dts-pts-from-elementary-stream)
diff --git a/installs_on_host/go2rtc/pkg/aac/README.md b/installs_on_host/go2rtc/pkg/aac/README.md
new file mode 100644
index 0000000..8e56a9a
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/aac/README.md
@@ -0,0 +1,20 @@
+## AAC-LD and AAC-ELD
+
+| Codec   | Rate  | QuickTime | ffmpeg | VLC |
+|---------|-------|-----------|--------|-----|
+| AAC-LD  | 8000  | yes       | no     | no  |
+| AAC-LD  | 16000 | yes       | no     | no  |
+| AAC-LD  | 22050 | yes       | yes    | no  |
+| AAC-LD  | 24000 | yes       | yes    | no  |
+| AAC-LD  | 32000 | yes       | yes    | no  |
+| AAC-ELD | 8000  | yes       | no     | no  |
+| AAC-ELD | 16000 | yes       | no     | no  |
+| AAC-ELD | 22050 | yes       | yes    | yes |
+| AAC-ELD | 24000 | yes       | yes    | yes |
+| AAC-ELD | 32000 | yes       | yes    | yes |
+
+## Useful links
+
+- [4.6.20 Enhanced Low Delay Codec](https://csclub.uwaterloo.ca/~ehashman/ISO14496-3-2009.pdf)
+- https://stackoverflow.com/questions/40014508/aac-adts-for-aacobject-eld-packets
+- https://code.videolan.org/videolan/vlc/-/blob/master/modules/packetizer/mpeg4audio.c
diff --git a/installs_on_host/go2rtc/pkg/aac/aac.go b/installs_on_host/go2rtc/pkg/aac/aac.go
new file mode 100644
index 0000000..dc961fc
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/aac/aac.go
@@ -0,0 +1,126 @@
+package aac
+
+import (
+	"encoding/hex"
+	"fmt"
+
+	"github.com/AlexxIT/go2rtc/pkg/bits"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+const (
+	TypeAACMain = 1
+	TypeAACLC   = 2  // Low Complexity
+	TypeAACLD   = 23 // Low Delay (48000, 44100, 32000, 24000, 22050)
+	TypeESCAPE  = 31
+	TypeAACELD  = 39 // Enhanced Low Delay
+
+	AUTime = 1024
+
+	// FMTP streamtype=5 - audio stream
+	FMTP = "streamtype=5;profile-level-id=1;mode=AAC-hbr;sizelength=13;indexlength=3;indexdeltalength=3;config="
+)
+
+var sampleRates = [16]uint32{
+	96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350,
+	0, 0, 0, // protection from request sampleRates[15]
+}
+
+func ConfigToCodec(conf []byte) *core.Codec {
+	// https://en.wikipedia.org/wiki/MPEG-4_Part_3#MPEG-4_Audio_Object_Types
+	rd := bits.NewReader(conf)
+
+	codec := &core.Codec{
+		FmtpLine:    FMTP + hex.EncodeToString(conf),
+		PayloadType: core.PayloadTypeRAW,
+	}
+
+	objType := rd.ReadBits(5)
+	if objType == TypeESCAPE {
+		objType = 32 + rd.ReadBits(6)
+	}
+
+	switch objType {
+	case TypeAACLC, TypeAACLD, TypeAACELD:
+		codec.Name = core.CodecAAC
+	default:
+		codec.Name = fmt.Sprintf("AAC-%X", objType)
+	}
+
+	if sampleRateIdx := rd.ReadBits8(4); sampleRateIdx < 0x0F {
+		codec.ClockRate = sampleRates[sampleRateIdx]
+	} else {
+		codec.ClockRate = rd.ReadBits(24)
+	}
+
+	codec.Channels = rd.ReadBits8(4)
+
+	return codec
+}
+
+func DecodeConfig(b []byte) (objType, sampleFreqIdx, channels byte, sampleRate uint32) {
+	rd := bits.NewReader(b)
+
+	objType = rd.ReadBits8(5)
+	if objType == 0b11111 {
+		objType = 32 + rd.ReadBits8(6)
+	}
+
+	sampleFreqIdx = rd.ReadBits8(4)
+	if sampleFreqIdx == 0b1111 {
+		sampleRate = rd.ReadBits(24)
+	} else {
+		sampleRate = sampleRates[sampleFreqIdx]
+	}
+
+	channels = rd.ReadBits8(4)
+	return
+}
+
+func EncodeConfig(objType byte, sampleRate uint32, channels byte, shortFrame bool) []byte {
+	wr := bits.NewWriter(nil)
+
+	if objType < TypeESCAPE {
+		wr.WriteBits8(objType, 5)
+	} else {
+		wr.WriteBits8(TypeESCAPE, 5)
+		wr.WriteBits8(objType-32, 6)
+	}
+
+	i := indexUint32(sampleRates[:], sampleRate)
+	if i >= 0 {
+		wr.WriteBits8(byte(i), 4)
+	} else {
+		wr.WriteBits8(0xF, 4)
+		wr.WriteBits(sampleRate, 24)
+	}
+
+	wr.WriteBits8(channels, 4)
+
+	switch objType {
+	case TypeAACLD:
+		// https://github.com/FFmpeg/FFmpeg/blob/67d392b97941bb51fb7af3a3c9387f5ab895fa46/libavcodec/aacdec_template.c#L841
+		wr.WriteBool(shortFrame)
+		wr.WriteBit(0)      // dependsOnCoreCoder
+		wr.WriteBit(0)      // extension_flag
+		wr.WriteBits8(0, 2) // ep_config
+	case TypeAACELD:
+		// https://github.com/FFmpeg/FFmpeg/blob/67d392b97941bb51fb7af3a3c9387f5ab895fa46/libavcodec/aacdec_template.c#L922
+		wr.WriteBool(shortFrame)
+		wr.WriteBits8(0, 3) // res_flags
+		wr.WriteBit(0)      // ldSbrPresentFlag
+		wr.WriteBits8(0, 4) // ELDEXT_TERM
+		wr.WriteBits8(0, 2) // ep_config
+	}
+
+	return wr.Bytes()
+}
+
+func indexUint32(s []uint32, v uint32) int {
+	for i := range s {
+		if v == s[i] {
+			return i
+		}
+	}
+	return -1
+}
diff --git a/installs_on_host/go2rtc/pkg/aac/aac_test.go b/installs_on_host/go2rtc/pkg/aac/aac_test.go
new file mode 100644
index 0000000..d1af6e5
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/aac/aac_test.go
@@ -0,0 +1,52 @@
+package aac
+
+import (
+	"encoding/hex"
+	"testing"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/stretchr/testify/require"
+)
+
+func TestConfigToCodec(t *testing.T) {
+	s := "profile-level-id=1;mode=AAC-hbr;sizelength=13;indexlength=3;indexdeltalength=3;config=F8EC3000"
+	s = core.Between(s, "config=", ";")
+	src, err := hex.DecodeString(s)
+	require.Nil(t, err)
+
+	codec := ConfigToCodec(src)
+	require.Equal(t, core.CodecAAC, codec.Name)
+	require.Equal(t, uint32(24000), codec.ClockRate)
+	require.Equal(t, uint16(1), codec.Channels)
+
+	dst := EncodeConfig(TypeAACELD, 24000, 1, true)
+	require.Equal(t, src, dst)
+}
+
+func TestADTS(t *testing.T) {
+	// FFmpeg MPEG-TS AAC (one packet)
+	s := "fff15080021ffc210049900219002380fff15080021ffc212049900219002380" //...
+	src, err := hex.DecodeString(s)
+	require.Nil(t, err)
+
+	codec := ADTSToCodec(src)
+	require.Equal(t, uint32(44100), codec.ClockRate)
+	require.Equal(t, uint16(2), codec.Channels)
+
+	size := ReadADTSSize(src)
+	require.Equal(t, uint16(16), size)
+
+	dst := CodecToADTS(codec)
+	WriteADTSSize(dst, size)
+
+	require.Equal(t, src[:len(dst)], dst)
+}
+
+func TestEncodeConfig(t *testing.T) {
+	conf := EncodeConfig(TypeAACLC, 48000, 1, false)
+	require.Equal(t, "1188", hex.EncodeToString(conf))
+	conf = EncodeConfig(TypeAACLC, 16000, 1, false)
+	require.Equal(t, "1408", hex.EncodeToString(conf))
+	conf = EncodeConfig(TypeAACLC, 8000, 1, false)
+	require.Equal(t, "1588", hex.EncodeToString(conf))
+}
diff --git a/installs_on_host/go2rtc/pkg/aac/adts.go b/installs_on_host/go2rtc/pkg/aac/adts.go
new file mode 100644
index 0000000..140b1ba
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/aac/adts.go
@@ -0,0 +1,148 @@
+package aac
+
+import (
+	"encoding/hex"
+
+	"github.com/AlexxIT/go2rtc/pkg/bits"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+)
+
+const ADTSHeaderSize = 7
+
+func ADTSHeaderLen(b []byte) int {
+	if HasCRC(b) {
+		return 9 // 7 bytes header + 2 bytes CRC
+	}
+	return ADTSHeaderSize
+}
+
+func IsADTS(b []byte) bool {
+	// AAAAAAAA AAAABCCD EEFFFFGH HHIJKLMM MMMMMMMM MMMOOOOO OOOOOOPP (QQQQQQQQ QQQQQQQQ)
+	// A	12	Syncword, all bits must be set to 1.
+	// C	2	Layer, always set to 0.
+	return len(b) >= ADTSHeaderSize && b[0] == 0xFF && b[1]&0b1111_0110 == 0xF0
+}
+
+func HasCRC(b []byte) bool {
+	// AAAAAAAA AAAABCCD EEFFFFGH HHIJKLMM MMMMMMMM MMMOOOOO OOOOOOPP (QQQQQQQQ QQQQQQQQ)
+	// D	1	Protection absence, set to 1 if there is no CRC and 0 if there is CRC.
+	return b[1]&0b1 == 0
+}
+
+func ADTSToCodec(b []byte) *core.Codec {
+	// 1. Check ADTS header
+	if !IsADTS(b) {
+		return nil
+	}
+
+	// 2. Decode ADTS params
+	// https://wiki.multimedia.cx/index.php/ADTS
+	rd := bits.NewReader(b)
+	_ = rd.ReadBits(12)              // Syncword, all bits must be set to 1
+	_ = rd.ReadBit()                 // MPEG Version, set to 0 for MPEG-4 and 1 for MPEG-2
+	_ = rd.ReadBits(2)               // Layer, always set to 0
+	_ = rd.ReadBit()                 // Protection absence, set to 1 if there is no CRC and 0 if there is CRC
+	objType := rd.ReadBits8(2) + 1   // Profile, the MPEG-4 Audio Object Type minus 1
+	sampleRateIdx := rd.ReadBits8(4) // MPEG-4 Sampling Frequency Index
+	_ = rd.ReadBit()                 // Private bit, guaranteed never to be used by MPEG, set to 0 when encoding, ignore when decoding
+	channels := rd.ReadBits8(3)      // MPEG-4 Channel Configuration
+
+	//_ = rd.ReadBit()    // Originality, set to 1 to signal originality of the audio and 0 otherwise
+	//_ = rd.ReadBit()    // Home, set to 1 to signal home usage of the audio and 0 otherwise
+	//_ = rd.ReadBit()    // Copyright ID bit
+	//_ = rd.ReadBit()    // Copyright ID start
+	//_ = rd.ReadBits(13) // Frame length
+	//_ = rd.ReadBits(11) // Buffer fullness
+	//_ = rd.ReadBits(2)  // Number of AAC frames (Raw Data Blocks) in ADTS frame minus 1
+	//_ = rd.ReadBits(16) // CRC check
+
+	// 3. Encode RTP config
+	wr := bits.NewWriter(nil)
+	wr.WriteBits8(objType, 5)
+	wr.WriteBits8(sampleRateIdx, 4)
+	wr.WriteBits8(channels, 4)
+	conf := wr.Bytes()
+
+	codec := &core.Codec{
+		Name:      core.CodecAAC,
+		ClockRate: sampleRates[sampleRateIdx],
+		Channels:  channels,
+		FmtpLine:  FMTP + hex.EncodeToString(conf),
+	}
+	return codec
+}
+
+func ReadADTSSize(b []byte) uint16 {
+	// AAAAAAAA AAAABCCD EEFFFFGH HHIJKLMM MMMMMMMM MMMOOOOO OOOOOOPP (QQQQQQQQ QQQQQQQQ)
+	_ = b[5] // bounds
+	return uint16(b[3]&0b11)<<11 | uint16(b[4])<<3 | uint16(b[5]>>5)
+}
+
+func WriteADTSSize(b []byte, size uint16) {
+	// AAAAAAAA AAAABCCD EEFFFFGH HHIJKLMM MMMMMMMM MMMOOOOO OOOOOOPP (QQQQQQQQ QQQQQQQQ)
+	_ = b[5] // bounds
+	b[3] |= byte(size >> (8 + 3))
+	b[4] = byte(size >> 3)
+	b[5] |= byte(size << 5)
+	return
+}
+
+func ADTSTimeSize(b []byte) uint32 {
+	var units uint32
+	for len(b) > ADTSHeaderSize {
+		auSize := ReadADTSSize(b)
+		b = b[auSize:]
+		units++
+	}
+	return units * AUTime
+}
+
+func CodecToADTS(codec *core.Codec) []byte {
+	s := core.Between(codec.FmtpLine, "config=", ";")
+	conf, err := hex.DecodeString(s)
+	if err != nil {
+		return nil
+	}
+
+	objType, sampleFreqIdx, channels, _ := DecodeConfig(conf)
+	profile := objType - 1
+
+	wr := bits.NewWriter(nil)
+	wr.WriteAllBits(1, 12)          // Syncword, all bits must be set to 1
+	wr.WriteBit(0)                  // MPEG Version, set to 0 for MPEG-4 and 1 for MPEG-2
+	wr.WriteBits8(0, 2)             // Layer, always set to 0
+	wr.WriteBit(1)                  // Protection absence, set to 1 if there is no CRC and 0 if there is CRC
+	wr.WriteBits8(profile, 2)       // Profile, the MPEG-4 Audio Object Type minus 1
+	wr.WriteBits8(sampleFreqIdx, 4) // MPEG-4 Sampling Frequency Index
+	wr.WriteBit(0)                  // Private bit, guaranteed never to be used by MPEG, set to 0 when encoding, ignore when decoding
+	wr.WriteBits8(channels, 3)      // MPEG-4 Channel Configuration
+	wr.WriteBit(0)                  // Originality, set to 1 to signal originality of the audio and 0 otherwise
+	wr.WriteBit(0)                  // Home, set to 1 to signal home usage of the audio and 0 otherwise
+	wr.WriteBit(0)                  // Copyright ID bit
+	wr.WriteBit(0)                  // Copyright ID start
+	wr.WriteBits16(0, 13)           // Frame length
+	wr.WriteAllBits(1, 11)          // Buffer fullness (variable bitrate)
+	wr.WriteBits8(0, 2)             // Number of AAC frames (Raw Data Blocks) in ADTS frame minus 1
+
+	return wr.Bytes()
+}
+
+func EncodeToADTS(codec *core.Codec, handler core.HandlerFunc) core.HandlerFunc {
+	adts := CodecToADTS(codec)
+
+	return func(packet *rtp.Packet) {
+		if !IsADTS(packet.Payload) {
+			b := make([]byte, ADTSHeaderSize+len(packet.Payload))
+			copy(b, adts)
+			copy(b[ADTSHeaderSize:], packet.Payload)
+			WriteADTSSize(b, uint16(len(b)))
+
+			clone := *packet
+			clone.Payload = b
+			handler(&clone)
+		} else {
+			handler(packet)
+		}
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/aac/consumer.go b/installs_on_host/go2rtc/pkg/aac/consumer.go
new file mode 100644
index 0000000..fc67d2a
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/aac/consumer.go
@@ -0,0 +1,59 @@
+package aac
+
+import (
+	"io"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+)
+
+type Consumer struct {
+	core.Connection
+	wr *core.WriteBuffer
+}
+
+func NewConsumer() *Consumer {
+	medias := []*core.Media{
+		{
+			Kind:      core.KindAudio,
+			Direction: core.DirectionSendonly,
+			Codecs: []*core.Codec{
+				{Name: core.CodecAAC},
+			},
+		},
+	}
+	wr := core.NewWriteBuffer(nil)
+	return &Consumer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "adts",
+			Medias:     medias,
+			Transport:  wr,
+		},
+		wr: wr,
+	}
+}
+
+func (c *Consumer) AddTrack(media *core.Media, codec *core.Codec, track *core.Receiver) error {
+	sender := core.NewSender(media, track.Codec)
+
+	sender.Handler = func(pkt *rtp.Packet) {
+		if n, err := c.wr.Write(pkt.Payload); err == nil {
+			c.Send += n
+		}
+	}
+
+	if track.Codec.IsRTP() {
+		sender.Handler = RTPToADTS(track.Codec, sender.Handler)
+	} else {
+		sender.Handler = EncodeToADTS(track.Codec, sender.Handler)
+	}
+
+	sender.HandleRTP(track)
+	c.Senders = append(c.Senders, sender)
+	return nil
+}
+
+func (c *Consumer) WriteTo(wr io.Writer) (int64, error) {
+	return c.wr.WriteTo(wr)
+}
diff --git a/installs_on_host/go2rtc/pkg/aac/producer.go b/installs_on_host/go2rtc/pkg/aac/producer.go
new file mode 100644
index 0000000..a2c73f9
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/aac/producer.go
@@ -0,0 +1,85 @@
+package aac
+
+import (
+	"bufio"
+	"errors"
+	"io"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+)
+
+type Producer struct {
+	core.Connection
+	rd *bufio.Reader
+}
+
+func Open(r io.Reader) (*Producer, error) {
+	rd := bufio.NewReader(r)
+
+	b, err := rd.Peek(ADTSHeaderSize)
+	if err != nil {
+		return nil, err
+	}
+
+	codec := ADTSToCodec(b)
+	if codec == nil {
+		return nil, errors.New("adts: wrong header")
+	}
+	codec.PayloadType = core.PayloadTypeRAW
+
+	medias := []*core.Media{
+		{
+			Kind:      core.KindAudio,
+			Direction: core.DirectionRecvonly,
+			Codecs:    []*core.Codec{codec},
+		},
+	}
+	return &Producer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "adts",
+			Medias:     medias,
+			Transport:  r,
+		},
+		rd: rd,
+	}, nil
+}
+
+func (c *Producer) Start() error {
+	for {
+		// read ADTS header
+		adts := make([]byte, ADTSHeaderSize)
+		if _, err := io.ReadFull(c.rd, adts); err != nil {
+			return err
+		}
+
+		auSize := ReadADTSSize(adts) - ADTSHeaderSize
+
+		if HasCRC(adts) {
+			// skip CRC after header
+			if _, err := c.rd.Discard(2); err != nil {
+				return err
+			}
+			auSize -= 2
+		}
+
+		// read AAC payload after header
+		payload := make([]byte, auSize)
+		if _, err := io.ReadFull(c.rd, payload); err != nil {
+			return err
+		}
+
+		c.Recv += int(auSize)
+
+		if len(c.Receivers) == 0 {
+			continue
+		}
+
+		pkt := &rtp.Packet{
+			Header:  rtp.Header{Timestamp: core.Now90000()},
+			Payload: payload,
+		}
+		c.Receivers[0].WriteRTP(pkt)
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/aac/rtp.go b/installs_on_host/go2rtc/pkg/aac/rtp.go
new file mode 100644
index 0000000..08846c0
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/aac/rtp.go
@@ -0,0 +1,154 @@
+package aac
+
+import (
+	"encoding/binary"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+)
+
+const RTPPacketVersionAAC = 0
+
+func RTPDepay(handler core.HandlerFunc) core.HandlerFunc {
+	var timestamp uint32
+
+	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
+		// https://datatracker.ietf.org/doc/html/rfc3640
+		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)
+
+		if len(packet.Payload) < int(2+headersSize) {
+			// In very rare cases noname cameras may send data not according to the standard
+			// https://github.com/AlexxIT/go2rtc/issues/1328
+			if IsADTS(packet.Payload) {
+				clone := *packet
+				clone.Version = RTPPacketVersionAAC
+				clone.Timestamp = timestamp
+				clone.Payload = clone.Payload[ADTSHeaderSize:]
+				handler(&clone)
+			}
+			return
+		}
+
+		headers := packet.Payload[2 : 2+headersSize]
+		units := packet.Payload[2+headersSize:]
+
+		for len(headers) >= 2 {
+			unitSize := binary.BigEndian.Uint16(headers) >> 3
+
+			if len(units) < int(unitSize) {
+				return
+			}
+
+			unit := units[:unitSize]
+
+			headers = headers[2:]
+			units = units[unitSize:]
+
+			timestamp += AUTime
+
+			clone := *packet
+			clone.Version = RTPPacketVersionAAC
+			clone.Timestamp = timestamp
+			if IsADTS(unit) {
+				clone.Payload = unit[ADTSHeaderSize:]
+			} else {
+				clone.Payload = unit
+			}
+			handler(&clone)
+		}
+	}
+}
+
+func RTPPay(handler core.HandlerFunc) core.HandlerFunc {
+	var seq uint16
+	var ts uint32
+
+	return func(packet *rtp.Packet) {
+		if packet.Version != RTPPacketVersionAAC {
+			handler(packet)
+			return
+		}
+
+		// support ONLY one unit in payload
+		auSize := uint16(len(packet.Payload))
+		// 2 bytes header size + 2 bytes first payload size
+		payload := make([]byte, 2+2+auSize)
+		payload[1] = 16 // header size in bits
+		binary.BigEndian.PutUint16(payload[2:], auSize<<3)
+		copy(payload[4:], packet.Payload)
+
+		clone := rtp.Packet{
+			Header: rtp.Header{
+				Version:        2,
+				Marker:         true,
+				SequenceNumber: seq,
+				Timestamp:      ts,
+			},
+			Payload: payload,
+		}
+		handler(&clone)
+
+		seq++
+		ts += AUTime
+	}
+}
+
+func ADTStoRTP(src []byte) (dst []byte) {
+	dst = make([]byte, 2) // header bytes
+	for i, n := 0, len(src)-ADTSHeaderSize; i < n; {
+		auSize := ReadADTSSize(src[i:])
+		dst = append(dst, byte(auSize>>5), byte(auSize<<3)) // size in bits
+		i += int(auSize)
+	}
+	hdrSize := uint16(len(dst) - 2)
+	binary.BigEndian.PutUint16(dst, hdrSize<<3) // size in bits
+	return append(dst, src...)
+}
+
+func RTPTimeSize(b []byte) uint32 {
+	// convert RTP header size to units count
+	units := binary.BigEndian.Uint16(b) >> 4
+	return uint32(units) * AUTime
+}
+
+func RTPToADTS(codec *core.Codec, handler core.HandlerFunc) core.HandlerFunc {
+	adts := CodecToADTS(codec)
+
+	return func(packet *rtp.Packet) {
+		src := packet.Payload
+		dst := make([]byte, 0, len(src))
+
+		headersSize := binary.BigEndian.Uint16(src) >> 3
+		headers := src[2 : 2+headersSize]
+		units := src[2+headersSize:]
+
+		for len(headers) > 0 {
+			unitSize := binary.BigEndian.Uint16(headers) >> 3
+			headers = headers[2:]
+			unit := units[:unitSize]
+			units = units[unitSize:]
+
+			if !IsADTS(unit) {
+				i := len(dst)
+				dst = append(dst, adts...)
+				WriteADTSSize(dst[i:], ADTSHeaderSize+uint16(len(unit)))
+			}
+
+			dst = append(dst, unit...)
+		}
+
+		clone := *packet
+		clone.Version = RTPPacketVersionAAC
+		clone.Payload = dst
+		handler(&clone)
+	}
+}
+
+func RTPToCodec(b []byte) *core.Codec {
+	hdrSize := binary.BigEndian.Uint16(b) / 8
+	return ADTSToCodec(b[2+hdrSize:])
+}
diff --git a/installs_on_host/go2rtc/pkg/aac/rtp_test.go b/installs_on_host/go2rtc/pkg/aac/rtp_test.go
new file mode 100644
index 0000000..c541b25
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/aac/rtp_test.go
@@ -0,0 +1,33 @@
+package aac
+
+import (
+	"encoding/hex"
+	"testing"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+	"github.com/stretchr/testify/require"
+)
+
+func TestBuggy_RTSP_AAC(t *testing.T) {
+	// https: //github.com/AlexxIT/go2rtc/issues/1328
+	payload, _ := hex.DecodeString("fff16080431ffc211ad4458aa309a1c0a8761a230502b7c74b2b5499252a010555e32e460128303c8ace4fd3260d654a424f7e7c65eddc96735fc6f1ac0edf94fdefa0e0bd6370da1c07b9c0e77a9d6e86b196a1ac7439dcafadcffcf6d89f60ac67f8884868e931383ad3e40cf5495470d1f606ef6f7624d285b951ebfa0e42641ab98f1371182b237d14f1bd16ad714fa2f1c6a7d23ebde7a0e34a2eca156a608a4caec49d9dca4b6fe2a09e9cdbf762c5b4148a3914abb7959c991228b0837b5988334b9fc18b8fac689b5ca1e4661573bbb8b253a86cae7ec14ace49969a9a76fd571ab6e650764cb59114d61dcedf07ac61b39e4ac66adebfd0d0ab45d518dd3c161049823f150864d977cf0855172ac8482e4b25fe911325d19617558c5405af74aff5492e4599bee53f2dbdf0503730af37078550f84c956b7ee89aae83c154fa2fa6e6792c5ddd5cd5cf6bb96bf055fee7f93bed59ffb039daee5ea7e5593cb194e9091e417c67d8f73026a6a6ae056e808f7c65c03d1b9197d3709ceb63bc7b979f7ba71df5e7c6395d99d6ea229000a6bc16fb4346d6b27d32f5d8d1200736d9366d59c0c9547210813b602473da9c46f9015bbb37594c1dd90cd6a36e96bd5d6a1445ab93c9e65505ec2c722bb4cc27a10600139a48c83594dde145253c386f6627d8c6e5102fe3828a590c709bc87f55b37e97d1ae72b017b09c6bb2c13299817bb45cc67318e10b6822075b97c6a03ec1c0")
+	packet := &rtp.Packet{
+		Header: rtp.Header{
+			Version:        2,
+			Marker:         true,
+			SequenceNumber: 36944,
+			Timestamp:      4217191328,
+			SSRC:           12892774,
+		},
+		Payload: payload,
+	}
+
+	var size int
+
+	RTPDepay(func(packet *core.Packet) {
+		size = len(packet.Payload)
+	})(packet)
+
+	require.Equal(t, len(payload), size+ADTSHeaderSize)
+}
diff --git a/installs_on_host/go2rtc/pkg/alsa/README.md b/installs_on_host/go2rtc/pkg/alsa/README.md
new file mode 100644
index 0000000..b644af1
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/alsa/README.md
@@ -0,0 +1,23 @@
+## Build
+
+```shell
+x86_64-linux-gnu-gcc -w -static asound_arch.c -o asound_amd64
+i686-linux-gnu-gcc -w -static asound_arch.c -o asound_i386
+aarch64-linux-gnu-gcc -w -static asound_arch.c -o asound_arm64
+arm-linux-gnueabihf-gcc -w -static asound_arch.c -o asound_arm
+mipsel-linux-gnu-gcc -w -static asound_arch.c -o asound_mipsle -D_TIME_BITS=32
+```
+
+## Useful links
+
+- https://github.com/torvalds/linux/blob/master/include/uapi/sound/asound.h
+- https://github.com/yobert/alsa
+- https://github.com/Narsil/alsa-go
+- https://github.com/alsa-project/alsa-lib
+- https://github.com/anisse/alsa
+- https://github.com/tinyalsa/tinyalsa
+
+**Broken pipe**
+
+- https://stackoverflow.com/questions/26545139/alsa-cannot-recovery-from-underrun-prepare-failed-broken-pipe
+- https://klipspringer.avadeaux.net/alsa-broken-pipe-errors/
diff --git a/installs_on_host/go2rtc/pkg/alsa/capture_linux.go b/installs_on_host/go2rtc/pkg/alsa/capture_linux.go
new file mode 100644
index 0000000..54a7d67
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/alsa/capture_linux.go
@@ -0,0 +1,90 @@
+package alsa
+
+import (
+	"github.com/AlexxIT/go2rtc/pkg/alsa/device"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/pcm"
+	"github.com/pion/rtp"
+)
+
+type Capture struct {
+	core.Connection
+	dev    *device.Device
+	closed core.Waiter
+}
+
+func newCapture(dev *device.Device) (*Capture, error) {
+	medias := []*core.Media{
+		{
+			Kind:      core.KindAudio,
+			Direction: core.DirectionRecvonly,
+			Codecs: []*core.Codec{
+				{Name: core.CodecPCML, ClockRate: 16000},
+			},
+		},
+	}
+	return &Capture{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "alsa",
+			Medias:     medias,
+			Transport:  dev,
+		},
+		dev: dev,
+	}, nil
+}
+
+func (c *Capture) Start() error {
+	dst := c.Medias[0].Codecs[0]
+	src := &core.Codec{
+		Name:      dst.Name,
+		ClockRate: c.dev.GetRateNear(dst.ClockRate),
+		Channels:  c.dev.GetChannelsNear(dst.Channels),
+	}
+
+	if err := c.dev.SetHWParams(device.SNDRV_PCM_FORMAT_S16_LE, src.ClockRate, src.Channels); err != nil {
+		return err
+	}
+
+	transcode := transcodeFunc(dst, src)
+	frameBytes := int(pcm.BytesPerFrame(src))
+
+	var ts uint32
+
+	// readBufferSize for 20ms interval
+	readBufferSize := 20 * frameBytes * int(src.ClockRate) / 1000
+	b := make([]byte, readBufferSize)
+	for {
+		n, err := c.dev.Read(b)
+		if err != nil {
+			return err
+		}
+
+		c.Recv += n
+
+		if len(c.Receivers) == 0 {
+			continue
+		}
+
+		pkt := &rtp.Packet{
+			Header: rtp.Header{
+				Version:   2,
+				Marker:    true,
+				Timestamp: ts,
+			},
+			Payload: transcode(b[:n]),
+		}
+		c.Receivers[0].WriteRTP(pkt)
+
+		ts += uint32(n / frameBytes)
+	}
+}
+
+func transcodeFunc(dst, src *core.Codec) func([]byte) []byte {
+	if dst.ClockRate == src.ClockRate && dst.Channels == src.Channels {
+		return func(b []byte) []byte {
+			return b
+		}
+	}
+	return pcm.Transcode(dst, src)
+}
diff --git a/installs_on_host/go2rtc/pkg/alsa/device/asound_32bit.go b/installs_on_host/go2rtc/pkg/alsa/device/asound_32bit.go
new file mode 100644
index 0000000..428c876
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/alsa/device/asound_32bit.go
@@ -0,0 +1,148 @@
+//go:build 386 || arm
+
+package device
+
+type unsigned_char = byte
+type signed_int = int32
+type unsigned_int = uint32
+type signed_long = int64
+type unsigned_long = uint64
+type __u32 = uint32
+type void__user = uintptr
+
+const (
+	SNDRV_PCM_STREAM_PLAYBACK = 0
+	SNDRV_PCM_STREAM_CAPTURE  = 1
+
+	SNDRV_PCM_ACCESS_MMAP_INTERLEAVED    = 0
+	SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED = 1
+	SNDRV_PCM_ACCESS_MMAP_COMPLEX        = 2
+	SNDRV_PCM_ACCESS_RW_INTERLEAVED      = 3
+	SNDRV_PCM_ACCESS_RW_NONINTERLEAVED   = 4
+
+	SNDRV_PCM_FORMAT_S8         = 0
+	SNDRV_PCM_FORMAT_U8         = 1
+	SNDRV_PCM_FORMAT_S16_LE     = 2
+	SNDRV_PCM_FORMAT_S16_BE     = 3
+	SNDRV_PCM_FORMAT_U16_LE     = 4
+	SNDRV_PCM_FORMAT_U16_BE     = 5
+	SNDRV_PCM_FORMAT_S24_LE     = 6
+	SNDRV_PCM_FORMAT_S24_BE     = 7
+	SNDRV_PCM_FORMAT_U24_LE     = 8
+	SNDRV_PCM_FORMAT_U24_BE     = 9
+	SNDRV_PCM_FORMAT_S32_LE     = 10
+	SNDRV_PCM_FORMAT_S32_BE     = 11
+	SNDRV_PCM_FORMAT_U32_LE     = 12
+	SNDRV_PCM_FORMAT_U32_BE     = 13
+	SNDRV_PCM_FORMAT_FLOAT_LE   = 14
+	SNDRV_PCM_FORMAT_FLOAT_BE   = 15
+	SNDRV_PCM_FORMAT_FLOAT64_LE = 16
+	SNDRV_PCM_FORMAT_FLOAT64_BE = 17
+	SNDRV_PCM_FORMAT_MU_LAW     = 20
+	SNDRV_PCM_FORMAT_A_LAW      = 21
+	SNDRV_PCM_FORMAT_MPEG       = 23
+
+	SNDRV_PCM_IOCTL_PVERSION      = 0x80044100
+	SNDRV_PCM_IOCTL_INFO          = 0x81204101
+	SNDRV_PCM_IOCTL_HW_REFINE     = 0xc25c4110
+	SNDRV_PCM_IOCTL_HW_PARAMS     = 0xc25c4111
+	SNDRV_PCM_IOCTL_SW_PARAMS     = 0xc0684113
+	SNDRV_PCM_IOCTL_PREPARE       = 0x00004140
+	SNDRV_PCM_IOCTL_WRITEI_FRAMES = 0x400c4150
+	SNDRV_PCM_IOCTL_READI_FRAMES  = 0x800c4151
+)
+
+type snd_pcm_info struct { // size 288
+	device           unsigned_int      // offset 0, size 4
+	subdevice        unsigned_int      // offset 4, size 4
+	stream           signed_int        // offset 8, size 4
+	card             signed_int        // offset 12, size 4
+	id               [64]unsigned_char // offset 16, size 64
+	name             [80]unsigned_char // offset 80, size 80
+	subname          [32]unsigned_char // offset 160, size 32
+	dev_class        signed_int        // offset 192, size 4
+	dev_subclass     signed_int        // offset 196, size 4
+	subdevices_count unsigned_int      // offset 200, size 4
+	subdevices_avail unsigned_int      // offset 204, size 4
+	pad1             [16]unsigned_char
+	reserved         [64]unsigned_char // offset 224, size 64
+}
+
+type snd_pcm_uframes_t = unsigned_long
+type snd_pcm_sframes_t = signed_long
+
+type snd_xferi struct { // size 12
+	result snd_pcm_sframes_t // offset 0, size 4
+	buf    void__user        // offset 4, size 4
+	frames snd_pcm_uframes_t // offset 8, size 4
+}
+
+const (
+	SNDRV_PCM_HW_PARAM_ACCESS     = 0
+	SNDRV_PCM_HW_PARAM_FORMAT     = 1
+	SNDRV_PCM_HW_PARAM_SUBFORMAT  = 2
+	SNDRV_PCM_HW_PARAM_FIRST_MASK = 0
+	SNDRV_PCM_HW_PARAM_LAST_MASK  = 2
+
+	SNDRV_PCM_HW_PARAM_SAMPLE_BITS    = 8
+	SNDRV_PCM_HW_PARAM_FRAME_BITS     = 9
+	SNDRV_PCM_HW_PARAM_CHANNELS       = 10
+	SNDRV_PCM_HW_PARAM_RATE           = 11
+	SNDRV_PCM_HW_PARAM_PERIOD_TIME    = 12
+	SNDRV_PCM_HW_PARAM_PERIOD_SIZE    = 13
+	SNDRV_PCM_HW_PARAM_PERIOD_BYTES   = 14
+	SNDRV_PCM_HW_PARAM_PERIODS        = 15
+	SNDRV_PCM_HW_PARAM_BUFFER_TIME    = 16
+	SNDRV_PCM_HW_PARAM_BUFFER_SIZE    = 17
+	SNDRV_PCM_HW_PARAM_BUFFER_BYTES   = 18
+	SNDRV_PCM_HW_PARAM_TICK_TIME      = 19
+	SNDRV_PCM_HW_PARAM_FIRST_INTERVAL = 8
+	SNDRV_PCM_HW_PARAM_LAST_INTERVAL  = 19
+
+	SNDRV_MASK_MAX = 256
+
+	SNDRV_PCM_TSTAMP_NONE   = 0
+	SNDRV_PCM_TSTAMP_ENABLE = 1
+)
+
+type snd_mask struct { // size 32
+	bits [(SNDRV_MASK_MAX + 31) / 32]__u32 // offset 0, size 32
+}
+
+type snd_interval struct { // size 12
+	min unsigned_int // offset 0, size 4
+	max unsigned_int // offset 4, size 4
+	bit unsigned_int
+}
+
+type snd_pcm_hw_params struct { // size 604
+	flags     unsigned_int                                                                           // offset 0, size 4
+	masks     [SNDRV_PCM_HW_PARAM_LAST_MASK - SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]snd_mask             // offset 4, size 96
+	mres      [5]snd_mask                                                                            // offset 100, size 160
+	intervals [SNDRV_PCM_HW_PARAM_LAST_INTERVAL - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1]snd_interval // offset 260, size 144
+	ires      [9]snd_interval                                                                        // offset 404, size 108
+	rmask     unsigned_int                                                                           // offset 512, size 4
+	cmask     unsigned_int                                                                           // offset 516, size 4
+	info      unsigned_int                                                                           // offset 520, size 4
+	msbits    unsigned_int                                                                           // offset 524, size 4
+	rate_num  unsigned_int                                                                           // offset 528, size 4
+	rate_den  unsigned_int                                                                           // offset 532, size 4
+	fifo_size snd_pcm_uframes_t                                                                      // offset 536, size 4
+	reserved  [64]unsigned_char                                                                      // offset 540, size 64
+}
+
+type snd_pcm_sw_params struct { // size 104
+	tstamp_mode       signed_int        // offset 0, size 4
+	period_step       unsigned_int      // offset 4, size 4
+	sleep_min         unsigned_int      // offset 8, size 4
+	avail_min         snd_pcm_uframes_t // offset 12, size 4
+	xfer_align        snd_pcm_uframes_t // offset 16, size 4
+	start_threshold   snd_pcm_uframes_t // offset 20, size 4
+	stop_threshold    snd_pcm_uframes_t // offset 24, size 4
+	silence_threshold snd_pcm_uframes_t // offset 28, size 4
+	silence_size      snd_pcm_uframes_t // offset 32, size 4
+	boundary          snd_pcm_uframes_t // offset 36, size 4
+	proto             unsigned_int      // offset 40, size 4
+	tstamp_type       unsigned_int      // offset 44, size 4
+	reserved          [56]unsigned_char // offset 48, size 56
+}
diff --git a/installs_on_host/go2rtc/pkg/alsa/device/asound_64bit.go b/installs_on_host/go2rtc/pkg/alsa/device/asound_64bit.go
new file mode 100644
index 0000000..14d0069
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/alsa/device/asound_64bit.go
@@ -0,0 +1,148 @@
+//go:build amd64 || arm64
+
+package device
+
+type unsigned_char = byte
+type signed_int = int32
+type unsigned_int = uint32
+type signed_long = int64
+type unsigned_long = uint64
+type __u32 = uint32
+type void__user = uintptr
+
+const (
+	SNDRV_PCM_STREAM_PLAYBACK = 0
+	SNDRV_PCM_STREAM_CAPTURE  = 1
+
+	SNDRV_PCM_ACCESS_MMAP_INTERLEAVED    = 0
+	SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED = 1
+	SNDRV_PCM_ACCESS_MMAP_COMPLEX        = 2
+	SNDRV_PCM_ACCESS_RW_INTERLEAVED      = 3
+	SNDRV_PCM_ACCESS_RW_NONINTERLEAVED   = 4
+
+	SNDRV_PCM_FORMAT_S8         = 0
+	SNDRV_PCM_FORMAT_U8         = 1
+	SNDRV_PCM_FORMAT_S16_LE     = 2
+	SNDRV_PCM_FORMAT_S16_BE     = 3
+	SNDRV_PCM_FORMAT_U16_LE     = 4
+	SNDRV_PCM_FORMAT_U16_BE     = 5
+	SNDRV_PCM_FORMAT_S24_LE     = 6
+	SNDRV_PCM_FORMAT_S24_BE     = 7
+	SNDRV_PCM_FORMAT_U24_LE     = 8
+	SNDRV_PCM_FORMAT_U24_BE     = 9
+	SNDRV_PCM_FORMAT_S32_LE     = 10
+	SNDRV_PCM_FORMAT_S32_BE     = 11
+	SNDRV_PCM_FORMAT_U32_LE     = 12
+	SNDRV_PCM_FORMAT_U32_BE     = 13
+	SNDRV_PCM_FORMAT_FLOAT_LE   = 14
+	SNDRV_PCM_FORMAT_FLOAT_BE   = 15
+	SNDRV_PCM_FORMAT_FLOAT64_LE = 16
+	SNDRV_PCM_FORMAT_FLOAT64_BE = 17
+	SNDRV_PCM_FORMAT_MU_LAW     = 20
+	SNDRV_PCM_FORMAT_A_LAW      = 21
+	SNDRV_PCM_FORMAT_MPEG       = 23
+
+	SNDRV_PCM_IOCTL_PVERSION      = 0x80044100
+	SNDRV_PCM_IOCTL_INFO          = 0x81204101
+	SNDRV_PCM_IOCTL_HW_REFINE     = 0xc2604110
+	SNDRV_PCM_IOCTL_HW_PARAMS     = 0xc2604111
+	SNDRV_PCM_IOCTL_SW_PARAMS     = 0xc0884113
+	SNDRV_PCM_IOCTL_PREPARE       = 0x00004140
+	SNDRV_PCM_IOCTL_WRITEI_FRAMES = 0x40184150
+	SNDRV_PCM_IOCTL_READI_FRAMES  = 0x80184151
+)
+
+type snd_pcm_info struct { // size 288
+	device           unsigned_int      // offset 0, size 4
+	subdevice        unsigned_int      // offset 4, size 4
+	stream           signed_int        // offset 8, size 4
+	card             signed_int        // offset 12, size 4
+	id               [64]unsigned_char // offset 16, size 64
+	name             [80]unsigned_char // offset 80, size 80
+	subname          [32]unsigned_char // offset 160, size 32
+	dev_class        signed_int        // offset 192, size 4
+	dev_subclass     signed_int        // offset 196, size 4
+	subdevices_count unsigned_int      // offset 200, size 4
+	subdevices_avail unsigned_int      // offset 204, size 4
+	pad1             [16]unsigned_char
+	reserved         [64]unsigned_char // offset 224, size 64
+}
+
+type snd_pcm_uframes_t = unsigned_long
+type snd_pcm_sframes_t = signed_long
+
+type snd_xferi struct { // size 24
+	result snd_pcm_sframes_t // offset 0, size 8
+	buf    void__user        // offset 8, size 8
+	frames snd_pcm_uframes_t // offset 16, size 8
+}
+
+const (
+	SNDRV_PCM_HW_PARAM_ACCESS     = 0
+	SNDRV_PCM_HW_PARAM_FORMAT     = 1
+	SNDRV_PCM_HW_PARAM_SUBFORMAT  = 2
+	SNDRV_PCM_HW_PARAM_FIRST_MASK = 0
+	SNDRV_PCM_HW_PARAM_LAST_MASK  = 2
+
+	SNDRV_PCM_HW_PARAM_SAMPLE_BITS    = 8
+	SNDRV_PCM_HW_PARAM_FRAME_BITS     = 9
+	SNDRV_PCM_HW_PARAM_CHANNELS       = 10
+	SNDRV_PCM_HW_PARAM_RATE           = 11
+	SNDRV_PCM_HW_PARAM_PERIOD_TIME    = 12
+	SNDRV_PCM_HW_PARAM_PERIOD_SIZE    = 13
+	SNDRV_PCM_HW_PARAM_PERIOD_BYTES   = 14
+	SNDRV_PCM_HW_PARAM_PERIODS        = 15
+	SNDRV_PCM_HW_PARAM_BUFFER_TIME    = 16
+	SNDRV_PCM_HW_PARAM_BUFFER_SIZE    = 17
+	SNDRV_PCM_HW_PARAM_BUFFER_BYTES   = 18
+	SNDRV_PCM_HW_PARAM_TICK_TIME      = 19
+	SNDRV_PCM_HW_PARAM_FIRST_INTERVAL = 8
+	SNDRV_PCM_HW_PARAM_LAST_INTERVAL  = 19
+
+	SNDRV_MASK_MAX = 256
+
+	SNDRV_PCM_TSTAMP_NONE   = 0
+	SNDRV_PCM_TSTAMP_ENABLE = 1
+)
+
+type snd_mask struct { // size 32
+	bits [(SNDRV_MASK_MAX + 31) / 32]__u32 // offset 0, size 32
+}
+
+type snd_interval struct { // size 12
+	min unsigned_int // offset 0, size 4
+	max unsigned_int // offset 4, size 4
+	bit unsigned_int
+}
+
+type snd_pcm_hw_params struct { // size 608
+	flags     unsigned_int                                                                           // offset 0, size 4
+	masks     [SNDRV_PCM_HW_PARAM_LAST_MASK - SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]snd_mask             // offset 4, size 96
+	mres      [5]snd_mask                                                                            // offset 100, size 160
+	intervals [SNDRV_PCM_HW_PARAM_LAST_INTERVAL - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1]snd_interval // offset 260, size 144
+	ires      [9]snd_interval                                                                        // offset 404, size 108
+	rmask     unsigned_int                                                                           // offset 512, size 4
+	cmask     unsigned_int                                                                           // offset 516, size 4
+	info      unsigned_int                                                                           // offset 520, size 4
+	msbits    unsigned_int                                                                           // offset 524, size 4
+	rate_num  unsigned_int                                                                           // offset 528, size 4
+	rate_den  unsigned_int                                                                           // offset 532, size 4
+	fifo_size snd_pcm_uframes_t                                                                      // offset 536, size 8
+	reserved  [64]unsigned_char                                                                      // offset 544, size 64
+}
+
+type snd_pcm_sw_params struct { // size 136
+	tstamp_mode       signed_int        // offset 0, size 4
+	period_step       unsigned_int      // offset 4, size 4
+	sleep_min         unsigned_int      // offset 8, size 4
+	avail_min         snd_pcm_uframes_t // offset 16, size 8
+	xfer_align        snd_pcm_uframes_t // offset 24, size 8
+	start_threshold   snd_pcm_uframes_t // offset 32, size 8
+	stop_threshold    snd_pcm_uframes_t // offset 40, size 8
+	silence_threshold snd_pcm_uframes_t // offset 48, size 8
+	silence_size      snd_pcm_uframes_t // offset 56, size 8
+	boundary          snd_pcm_uframes_t // offset 64, size 8
+	proto             unsigned_int      // offset 72, size 4
+	tstamp_type       unsigned_int      // offset 76, size 4
+	reserved          [56]unsigned_char // offset 80, size 56
+}
diff --git a/installs_on_host/go2rtc/pkg/alsa/device/asound_arch.c b/installs_on_host/go2rtc/pkg/alsa/device/asound_arch.c
new file mode 100644
index 0000000..902475a
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/alsa/device/asound_arch.c
@@ -0,0 +1,164 @@
+//go:build ignore
+#include <stdio.h>
+#include <stddef.h>
+#include <sys/ioctl.h>
+#include <sound/asound.h>
+
+#define print_line(text) printf("%s\n", text)
+#define print_hex_const(name) printf("\t%s = 0x%08lx\n", #name, name)
+#define print_int_const(con) printf("\t%s = %d\n", #con, con)
+
+#define print_struct_header(str) printf("type %s struct { // size %lu\n", #str, sizeof(struct str))
+#define print_struct_member(str, mem, typ) printf("\t%s %s // offset %lu, size %lu\n", #mem == "type" ? "typ" : #mem, typ, offsetof(struct str, mem), sizeof((struct str){0}.mem))
+
+// https://github.com/torvalds/linux/blob/master/include/uapi/sound/asound.h
+int main() {
+    print_line("package device\n");
+
+    print_line("type unsigned_char = byte");
+    print_line("type signed_int = int32");
+    print_line("type unsigned_int = uint32");
+    print_line("type signed_long = int64");
+    print_line("type unsigned_long = uint64");
+    print_line("type __u32 = uint32");
+    print_line("type void__user = uintptr\n");
+
+    print_line("const (");
+    print_int_const(SNDRV_PCM_STREAM_PLAYBACK);
+    print_int_const(SNDRV_PCM_STREAM_CAPTURE);
+	print_line("");
+	print_int_const(SNDRV_PCM_ACCESS_MMAP_INTERLEAVED);
+	print_int_const(SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED);
+	print_int_const(SNDRV_PCM_ACCESS_MMAP_COMPLEX);
+	print_int_const(SNDRV_PCM_ACCESS_RW_INTERLEAVED);
+	print_int_const(SNDRV_PCM_ACCESS_RW_NONINTERLEAVED);
+	print_line("");
+	print_int_const(SNDRV_PCM_FORMAT_S8);
+	print_int_const(SNDRV_PCM_FORMAT_U8);
+	print_int_const(SNDRV_PCM_FORMAT_S16_LE);
+	print_int_const(SNDRV_PCM_FORMAT_S16_BE);
+	print_int_const(SNDRV_PCM_FORMAT_U16_LE);
+	print_int_const(SNDRV_PCM_FORMAT_U16_BE);
+	print_int_const(SNDRV_PCM_FORMAT_S24_LE);
+	print_int_const(SNDRV_PCM_FORMAT_S24_BE);
+	print_int_const(SNDRV_PCM_FORMAT_U24_LE);
+	print_int_const(SNDRV_PCM_FORMAT_U24_BE);
+	print_int_const(SNDRV_PCM_FORMAT_S32_LE);
+	print_int_const(SNDRV_PCM_FORMAT_S32_BE);
+	print_int_const(SNDRV_PCM_FORMAT_U32_LE);
+	print_int_const(SNDRV_PCM_FORMAT_U32_BE);
+	print_int_const(SNDRV_PCM_FORMAT_FLOAT_LE);
+	print_int_const(SNDRV_PCM_FORMAT_FLOAT_BE);
+	print_int_const(SNDRV_PCM_FORMAT_FLOAT64_LE);
+	print_int_const(SNDRV_PCM_FORMAT_FLOAT64_BE);
+	print_int_const(SNDRV_PCM_FORMAT_MU_LAW);
+	print_int_const(SNDRV_PCM_FORMAT_A_LAW);
+	print_int_const(SNDRV_PCM_FORMAT_MPEG);
+	print_line("");
+    print_hex_const(SNDRV_PCM_IOCTL_PVERSION);        // A 0x00
+    print_hex_const(SNDRV_PCM_IOCTL_INFO);            // A 0x01
+    print_hex_const(SNDRV_PCM_IOCTL_HW_REFINE);       // A 0x10
+    print_hex_const(SNDRV_PCM_IOCTL_HW_PARAMS);       // A 0x11
+    print_hex_const(SNDRV_PCM_IOCTL_SW_PARAMS);       // A 0x13
+    print_hex_const(SNDRV_PCM_IOCTL_PREPARE);         // A 0x40
+    print_hex_const(SNDRV_PCM_IOCTL_WRITEI_FRAMES);   // A 0x50
+    print_hex_const(SNDRV_PCM_IOCTL_READI_FRAMES);    // A 0x51
+    print_line(")\n");
+
+	print_struct_header(snd_pcm_info);
+	print_struct_member(snd_pcm_info, device, "unsigned_int");
+	print_struct_member(snd_pcm_info, subdevice, "unsigned_int");
+	print_struct_member(snd_pcm_info, stream, "signed_int");
+	print_struct_member(snd_pcm_info, card, "signed_int");
+	print_struct_member(snd_pcm_info, id, "[64]unsigned_char");
+	print_struct_member(snd_pcm_info, name, "[80]unsigned_char");
+	print_struct_member(snd_pcm_info, subname, "[32]unsigned_char");
+	print_struct_member(snd_pcm_info, dev_class, "signed_int");
+	print_struct_member(snd_pcm_info, dev_subclass, "signed_int");
+	print_struct_member(snd_pcm_info, subdevices_count, "unsigned_int");
+	print_struct_member(snd_pcm_info, subdevices_avail, "unsigned_int");
+	print_line("\tpad1 [16]unsigned_char");
+	print_struct_member(snd_pcm_info, reserved, "[64]unsigned_char");
+	print_line("}\n");
+
+	print_line("type snd_pcm_uframes_t = unsigned_long");
+	print_line("type snd_pcm_sframes_t = signed_long\n");
+
+	print_struct_header(snd_xferi);
+	print_struct_member(snd_xferi, result, "snd_pcm_sframes_t");
+	print_struct_member(snd_xferi, buf, "void__user");
+	print_struct_member(snd_xferi, frames, "snd_pcm_uframes_t");
+	print_line("}\n");
+
+	print_line("const (");
+	print_int_const(SNDRV_PCM_HW_PARAM_ACCESS);
+	print_int_const(SNDRV_PCM_HW_PARAM_FORMAT);
+	print_int_const(SNDRV_PCM_HW_PARAM_SUBFORMAT);
+	print_int_const(SNDRV_PCM_HW_PARAM_FIRST_MASK);
+	print_int_const(SNDRV_PCM_HW_PARAM_LAST_MASK);
+	print_line("");
+	print_int_const(SNDRV_PCM_HW_PARAM_SAMPLE_BITS);
+	print_int_const(SNDRV_PCM_HW_PARAM_FRAME_BITS);
+	print_int_const(SNDRV_PCM_HW_PARAM_CHANNELS);
+	print_int_const(SNDRV_PCM_HW_PARAM_RATE);
+	print_int_const(SNDRV_PCM_HW_PARAM_PERIOD_TIME);
+	print_int_const(SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
+	print_int_const(SNDRV_PCM_HW_PARAM_PERIOD_BYTES);
+	print_int_const(SNDRV_PCM_HW_PARAM_PERIODS);
+	print_int_const(SNDRV_PCM_HW_PARAM_BUFFER_TIME);
+	print_int_const(SNDRV_PCM_HW_PARAM_BUFFER_SIZE);
+	print_int_const(SNDRV_PCM_HW_PARAM_BUFFER_BYTES);
+	print_int_const(SNDRV_PCM_HW_PARAM_TICK_TIME);
+	print_int_const(SNDRV_PCM_HW_PARAM_FIRST_INTERVAL);
+	print_int_const(SNDRV_PCM_HW_PARAM_LAST_INTERVAL);
+	print_line("");
+	print_int_const(SNDRV_MASK_MAX);
+	print_line("");
+	print_int_const(SNDRV_PCM_TSTAMP_NONE);
+	print_int_const(SNDRV_PCM_TSTAMP_ENABLE);
+	print_line(")\n");
+
+	print_struct_header(snd_mask);
+	print_struct_member(snd_mask, bits, "[(SNDRV_MASK_MAX+31)/32]__u32");
+	print_line("}\n");
+
+	print_struct_header(snd_interval);
+	print_struct_member(snd_interval, min, "unsigned_int");
+	print_struct_member(snd_interval, max, "unsigned_int");
+	print_line("\tbit unsigned_int");
+	print_line("}\n");
+
+	print_struct_header(snd_pcm_hw_params);
+	print_struct_member(snd_pcm_hw_params, flags, "unsigned_int");
+	print_struct_member(snd_pcm_hw_params, masks, "[SNDRV_PCM_HW_PARAM_LAST_MASK-SNDRV_PCM_HW_PARAM_FIRST_MASK+1]snd_mask");
+	print_struct_member(snd_pcm_hw_params, mres, "[5]snd_mask");
+	print_struct_member(snd_pcm_hw_params, intervals, "[SNDRV_PCM_HW_PARAM_LAST_INTERVAL-SNDRV_PCM_HW_PARAM_FIRST_INTERVAL+1]snd_interval");
+	print_struct_member(snd_pcm_hw_params, ires, "[9]snd_interval");
+	print_struct_member(snd_pcm_hw_params, rmask, "unsigned_int");
+	print_struct_member(snd_pcm_hw_params, cmask, "unsigned_int");
+	print_struct_member(snd_pcm_hw_params, info, "unsigned_int");
+	print_struct_member(snd_pcm_hw_params, msbits, "unsigned_int");
+	print_struct_member(snd_pcm_hw_params, rate_num, "unsigned_int");
+	print_struct_member(snd_pcm_hw_params, rate_den, "unsigned_int");
+	print_struct_member(snd_pcm_hw_params, fifo_size, "snd_pcm_uframes_t");
+	print_struct_member(snd_pcm_hw_params, reserved, "[64]unsigned_char");
+	print_line("}\n");
+
+	print_struct_header(snd_pcm_sw_params);
+	print_struct_member(snd_pcm_sw_params, tstamp_mode, "signed_int");
+	print_struct_member(snd_pcm_sw_params, period_step, "unsigned_int");
+	print_struct_member(snd_pcm_sw_params, sleep_min, "unsigned_int");
+	print_struct_member(snd_pcm_sw_params, avail_min, "snd_pcm_uframes_t");
+	print_struct_member(snd_pcm_sw_params, xfer_align, "snd_pcm_uframes_t");
+	print_struct_member(snd_pcm_sw_params, start_threshold, "snd_pcm_uframes_t");
+	print_struct_member(snd_pcm_sw_params, stop_threshold, "snd_pcm_uframes_t");
+	print_struct_member(snd_pcm_sw_params, silence_threshold, "snd_pcm_uframes_t");
+	print_struct_member(snd_pcm_sw_params, silence_size, "snd_pcm_uframes_t");
+	print_struct_member(snd_pcm_sw_params, boundary, "snd_pcm_uframes_t");
+	print_struct_member(snd_pcm_sw_params, proto, "unsigned_int");
+	print_struct_member(snd_pcm_sw_params, tstamp_type, "unsigned_int");
+	print_struct_member(snd_pcm_sw_params, reserved, "[56]unsigned_char");
+	print_line("}\n");
+
+	return 0;
+}
\ No newline at end of file
diff --git a/installs_on_host/go2rtc/pkg/alsa/device/asound_mipsle.go b/installs_on_host/go2rtc/pkg/alsa/device/asound_mipsle.go
new file mode 100644
index 0000000..743c89d
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/alsa/device/asound_mipsle.go
@@ -0,0 +1,146 @@
+package device
+
+type unsigned_char = byte
+type signed_int = int32
+type unsigned_int = uint32
+type signed_long = int64
+type unsigned_long = uint64
+type __u32 = uint32
+type void__user = uintptr
+
+const (
+	SNDRV_PCM_STREAM_PLAYBACK = 0
+	SNDRV_PCM_STREAM_CAPTURE  = 1
+
+	SNDRV_PCM_ACCESS_MMAP_INTERLEAVED    = 0
+	SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED = 1
+	SNDRV_PCM_ACCESS_MMAP_COMPLEX        = 2
+	SNDRV_PCM_ACCESS_RW_INTERLEAVED      = 3
+	SNDRV_PCM_ACCESS_RW_NONINTERLEAVED   = 4
+
+	SNDRV_PCM_FORMAT_S8         = 0
+	SNDRV_PCM_FORMAT_U8         = 1
+	SNDRV_PCM_FORMAT_S16_LE     = 2
+	SNDRV_PCM_FORMAT_S16_BE     = 3
+	SNDRV_PCM_FORMAT_U16_LE     = 4
+	SNDRV_PCM_FORMAT_U16_BE     = 5
+	SNDRV_PCM_FORMAT_S24_LE     = 6
+	SNDRV_PCM_FORMAT_S24_BE     = 7
+	SNDRV_PCM_FORMAT_U24_LE     = 8
+	SNDRV_PCM_FORMAT_U24_BE     = 9
+	SNDRV_PCM_FORMAT_S32_LE     = 10
+	SNDRV_PCM_FORMAT_S32_BE     = 11
+	SNDRV_PCM_FORMAT_U32_LE     = 12
+	SNDRV_PCM_FORMAT_U32_BE     = 13
+	SNDRV_PCM_FORMAT_FLOAT_LE   = 14
+	SNDRV_PCM_FORMAT_FLOAT_BE   = 15
+	SNDRV_PCM_FORMAT_FLOAT64_LE = 16
+	SNDRV_PCM_FORMAT_FLOAT64_BE = 17
+	SNDRV_PCM_FORMAT_MU_LAW     = 20
+	SNDRV_PCM_FORMAT_A_LAW      = 21
+	SNDRV_PCM_FORMAT_MPEG       = 23
+
+	SNDRV_PCM_IOCTL_PVERSION      = 0x40044100
+	SNDRV_PCM_IOCTL_INFO          = 0x41204101
+	SNDRV_PCM_IOCTL_HW_REFINE     = 0xc25c4110
+	SNDRV_PCM_IOCTL_HW_PARAMS     = 0xc25c4111
+	SNDRV_PCM_IOCTL_SW_PARAMS     = 0xc0684113
+	SNDRV_PCM_IOCTL_PREPARE       = 0x20004140
+	SNDRV_PCM_IOCTL_WRITEI_FRAMES = 0x800c4150
+	SNDRV_PCM_IOCTL_READI_FRAMES  = 0x400c4151
+)
+
+type snd_pcm_info struct { // size 288
+	device           unsigned_int      // offset 0, size 4
+	subdevice        unsigned_int      // offset 4, size 4
+	stream           signed_int        // offset 8, size 4
+	card             signed_int        // offset 12, size 4
+	id               [64]unsigned_char // offset 16, size 64
+	name             [80]unsigned_char // offset 80, size 80
+	subname          [32]unsigned_char // offset 160, size 32
+	dev_class        signed_int        // offset 192, size 4
+	dev_subclass     signed_int        // offset 196, size 4
+	subdevices_count unsigned_int      // offset 200, size 4
+	subdevices_avail unsigned_int      // offset 204, size 4
+	pad1             [16]unsigned_char
+	reserved         [64]unsigned_char // offset 224, size 64
+}
+
+type snd_pcm_uframes_t = unsigned_long
+type snd_pcm_sframes_t = signed_long
+
+type snd_xferi struct { // size 12
+	result snd_pcm_sframes_t // offset 0, size 4
+	buf    void__user        // offset 4, size 4
+	frames snd_pcm_uframes_t // offset 8, size 4
+}
+
+const (
+	SNDRV_PCM_HW_PARAM_ACCESS     = 0
+	SNDRV_PCM_HW_PARAM_FORMAT     = 1
+	SNDRV_PCM_HW_PARAM_SUBFORMAT  = 2
+	SNDRV_PCM_HW_PARAM_FIRST_MASK = 0
+	SNDRV_PCM_HW_PARAM_LAST_MASK  = 2
+
+	SNDRV_PCM_HW_PARAM_SAMPLE_BITS    = 8
+	SNDRV_PCM_HW_PARAM_FRAME_BITS     = 9
+	SNDRV_PCM_HW_PARAM_CHANNELS       = 10
+	SNDRV_PCM_HW_PARAM_RATE           = 11
+	SNDRV_PCM_HW_PARAM_PERIOD_TIME    = 12
+	SNDRV_PCM_HW_PARAM_PERIOD_SIZE    = 13
+	SNDRV_PCM_HW_PARAM_PERIOD_BYTES   = 14
+	SNDRV_PCM_HW_PARAM_PERIODS        = 15
+	SNDRV_PCM_HW_PARAM_BUFFER_TIME    = 16
+	SNDRV_PCM_HW_PARAM_BUFFER_SIZE    = 17
+	SNDRV_PCM_HW_PARAM_BUFFER_BYTES   = 18
+	SNDRV_PCM_HW_PARAM_TICK_TIME      = 19
+	SNDRV_PCM_HW_PARAM_FIRST_INTERVAL = 8
+	SNDRV_PCM_HW_PARAM_LAST_INTERVAL  = 19
+
+	SNDRV_MASK_MAX = 256
+
+	SNDRV_PCM_TSTAMP_NONE   = 0
+	SNDRV_PCM_TSTAMP_ENABLE = 1
+)
+
+type snd_mask struct { // size 32
+	bits [(SNDRV_MASK_MAX + 31) / 32]__u32 // offset 0, size 32
+}
+
+type snd_interval struct { // size 12
+	min unsigned_int // offset 0, size 4
+	max unsigned_int // offset 4, size 4
+	bit unsigned_int
+}
+
+type snd_pcm_hw_params struct { // size 604
+	flags     unsigned_int                                                                           // offset 0, size 4
+	masks     [SNDRV_PCM_HW_PARAM_LAST_MASK - SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]snd_mask             // offset 4, size 96
+	mres      [5]snd_mask                                                                            // offset 100, size 160
+	intervals [SNDRV_PCM_HW_PARAM_LAST_INTERVAL - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1]snd_interval // offset 260, size 144
+	ires      [9]snd_interval                                                                        // offset 404, size 108
+	rmask     unsigned_int                                                                           // offset 512, size 4
+	cmask     unsigned_int                                                                           // offset 516, size 4
+	info      unsigned_int                                                                           // offset 520, size 4
+	msbits    unsigned_int                                                                           // offset 524, size 4
+	rate_num  unsigned_int                                                                           // offset 528, size 4
+	rate_den  unsigned_int                                                                           // offset 532, size 4
+	fifo_size snd_pcm_uframes_t                                                                      // offset 536, size 4
+	reserved  [64]unsigned_char                                                                      // offset 540, size 64
+}
+
+type snd_pcm_sw_params struct { // size 104
+	tstamp_mode       signed_int        // offset 0, size 4
+	period_step       unsigned_int      // offset 4, size 4
+	sleep_min         unsigned_int      // offset 8, size 4
+	avail_min         snd_pcm_uframes_t // offset 12, size 4
+	xfer_align        snd_pcm_uframes_t // offset 16, size 4
+	start_threshold   snd_pcm_uframes_t // offset 20, size 4
+	stop_threshold    snd_pcm_uframes_t // offset 24, size 4
+	silence_threshold snd_pcm_uframes_t // offset 28, size 4
+	silence_size      snd_pcm_uframes_t // offset 32, size 4
+	boundary          snd_pcm_uframes_t // offset 36, size 4
+	proto             unsigned_int      // offset 40, size 4
+	tstamp_type       unsigned_int      // offset 44, size 4
+	reserved          [56]unsigned_char // offset 48, size 56
+}
diff --git a/installs_on_host/go2rtc/pkg/alsa/device/device_linux.go b/installs_on_host/go2rtc/pkg/alsa/device/device_linux.go
new file mode 100644
index 0000000..ecccc17
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/alsa/device/device_linux.go
@@ -0,0 +1,231 @@
+package device
+
+import (
+	"fmt"
+	"syscall"
+	"unsafe"
+)
+
+type Device struct {
+	fd   uintptr
+	path string
+
+	hwparams   snd_pcm_hw_params
+	frameBytes int // sample size * channels
+}
+
+func Open(path string) (*Device, error) {
+	// important to use nonblock because can get lock
+	fd, err := syscall.Open(path, syscall.O_RDWR|syscall.O_NONBLOCK, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	// important to remove nonblock because better to handle reads and writes
+	if err = syscall.SetNonblock(fd, false); err != nil {
+		return nil, err
+	}
+
+	d := &Device{fd: uintptr(fd), path: path}
+	d.init()
+
+	// load all supported formats, channels, rates, etc.
+	if err = ioctl(d.fd, SNDRV_PCM_IOCTL_HW_REFINE, &d.hwparams); err != nil {
+		_ = d.Close()
+		return nil, err
+	}
+
+	d.setMask(SNDRV_PCM_HW_PARAM_ACCESS, SNDRV_PCM_ACCESS_RW_INTERLEAVED)
+
+	return d, nil
+}
+
+func (d *Device) Close() error {
+	return syscall.Close(int(d.fd))
+}
+
+func (d *Device) IsCapture() bool {
+	// path: /dev/snd/pcmC0D0c, where p - playback, c - capture
+	return d.path[len(d.path)-1] == 'c'
+}
+
+type Info struct {
+	Card      int
+	Device    int
+	SubDevice int
+	Stream    int
+	ID        string
+	Name      string
+	SubName   string
+}
+
+func (d *Device) Info() (*Info, error) {
+	var info snd_pcm_info
+	if err := ioctl(d.fd, SNDRV_PCM_IOCTL_INFO, &info); err != nil {
+		return nil, err
+	}
+	return &Info{
+		Card:      int(info.card),
+		Device:    int(info.device),
+		SubDevice: int(info.subdevice),
+		Stream:    int(info.stream),
+		ID:        str(info.id[:]),
+		Name:      str(info.name[:]),
+		SubName:   str(info.subname[:]),
+	}, nil
+}
+
+func (d *Device) CheckFormat(format byte) bool {
+	return d.checkMask(SNDRV_PCM_HW_PARAM_FORMAT, uint32(format))
+}
+
+func (d *Device) ListFormats() (formats []byte) {
+	for i := byte(0); i <= 28; i++ {
+		if d.CheckFormat(i) {
+			formats = append(formats, i)
+		}
+	}
+	return
+}
+
+func (d *Device) RangeRates() (uint32, uint32) {
+	return d.getInterval(SNDRV_PCM_HW_PARAM_RATE)
+}
+
+func (d *Device) RangeChannels() (byte, byte) {
+	minCh, maxCh := d.getInterval(SNDRV_PCM_HW_PARAM_CHANNELS)
+	return byte(minCh), byte(maxCh)
+}
+
+func (d *Device) GetRateNear(rate uint32) uint32 {
+	r1, r2 := d.RangeRates()
+	if rate < r1 {
+		return r1
+	}
+	if rate > r2 {
+		return r2
+	}
+	return rate
+}
+
+func (d *Device) GetChannelsNear(channels byte) byte {
+	c1, c2 := d.RangeChannels()
+	if channels < c1 {
+		return c1
+	}
+	if channels > c2 {
+		return c2
+	}
+	return channels
+}
+
+const bufferSize = 4096
+
+func (d *Device) SetHWParams(format byte, rate uint32, channels byte) error {
+	d.setInterval(SNDRV_PCM_HW_PARAM_CHANNELS, uint32(channels))
+	d.setInterval(SNDRV_PCM_HW_PARAM_RATE, rate)
+	d.setMask(SNDRV_PCM_HW_PARAM_FORMAT, uint32(format))
+	//d.setMask(SNDRV_PCM_HW_PARAM_SUBFORMAT, 0)
+
+	// important for smooth playback
+	d.setInterval(SNDRV_PCM_HW_PARAM_BUFFER_SIZE, bufferSize)
+	//d.setInterval(SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 2000)
+
+	if err := ioctl(d.fd, SNDRV_PCM_IOCTL_HW_PARAMS, &d.hwparams); err != nil {
+		return fmt.Errorf("[alsa] set hw_params: %w", err)
+	}
+
+	_, i := d.getInterval(SNDRV_PCM_HW_PARAM_FRAME_BITS)
+	d.frameBytes = int(i / 8)
+
+	_, periods := d.getInterval(SNDRV_PCM_HW_PARAM_PERIODS)
+	_, periodSize := d.getInterval(SNDRV_PCM_HW_PARAM_PERIOD_SIZE)
+	threshold := snd_pcm_uframes_t(periods * periodSize) // same as bufferSize
+
+	swparams := snd_pcm_sw_params{
+		//tstamp_mode: SNDRV_PCM_TSTAMP_ENABLE,
+		period_step:    1,
+		avail_min:      1, // start as soon as possible
+		stop_threshold: threshold,
+	}
+
+	if d.IsCapture() {
+		swparams.start_threshold = 1
+	} else {
+		swparams.start_threshold = threshold
+	}
+
+	if err := ioctl(d.fd, SNDRV_PCM_IOCTL_SW_PARAMS, &swparams); err != nil {
+		return fmt.Errorf("[alsa] set sw_params: %w", err)
+	}
+
+	if err := ioctl(d.fd, SNDRV_PCM_IOCTL_PREPARE, nil); err != nil {
+		return fmt.Errorf("[alsa] prepare: %w", err)
+	}
+
+	return nil
+}
+
+func (d *Device) Write(b []byte) (n int, err error) {
+	xfer := &snd_xferi{
+		buf:    uintptr(unsafe.Pointer(&b[0])),
+		frames: snd_pcm_uframes_t(len(b) / d.frameBytes),
+	}
+	err = ioctl(d.fd, SNDRV_PCM_IOCTL_WRITEI_FRAMES, xfer)
+	if err == syscall.EPIPE {
+		// auto handle underrun state
+		// https://stackoverflow.com/questions/59396728/how-to-properly-handle-xrun-in-alsa-programming-when-playing-audio-with-snd-pcm
+		err = ioctl(d.fd, SNDRV_PCM_IOCTL_PREPARE, nil)
+	}
+	n = int(xfer.result) * d.frameBytes
+	return
+}
+
+func (d *Device) Read(b []byte) (n int, err error) {
+	xfer := &snd_xferi{
+		buf:    uintptr(unsafe.Pointer(&b[0])),
+		frames: snd_pcm_uframes_t(len(b) / d.frameBytes),
+	}
+	err = ioctl(d.fd, SNDRV_PCM_IOCTL_READI_FRAMES, xfer)
+	n = int(xfer.result) * d.frameBytes
+	return
+}
+
+func (d *Device) init() {
+	for i := range d.hwparams.masks {
+		d.hwparams.masks[i].bits[0] = 0xFFFFFFFF
+		d.hwparams.masks[i].bits[1] = 0xFFFFFFFF
+	}
+	for i := range d.hwparams.intervals {
+		d.hwparams.intervals[i].max = 0xFFFFFFFF
+	}
+
+	d.hwparams.rmask = 0xFFFFFFFF
+	d.hwparams.cmask = 0
+	d.hwparams.info = 0xFFFFFFFF
+}
+
+func (d *Device) setInterval(param, val uint32) {
+	d.hwparams.intervals[param-SNDRV_PCM_HW_PARAM_FIRST_INTERVAL].min = val
+	d.hwparams.intervals[param-SNDRV_PCM_HW_PARAM_FIRST_INTERVAL].max = val
+	d.hwparams.intervals[param-SNDRV_PCM_HW_PARAM_FIRST_INTERVAL].bit = 0b0100 // integer
+}
+
+func (d *Device) setIntervalMin(param, val uint32) {
+	d.hwparams.intervals[param-SNDRV_PCM_HW_PARAM_FIRST_INTERVAL].min = val
+}
+
+func (d *Device) getInterval(param uint32) (uint32, uint32) {
+	return d.hwparams.intervals[param-SNDRV_PCM_HW_PARAM_FIRST_INTERVAL].min,
+		d.hwparams.intervals[param-SNDRV_PCM_HW_PARAM_FIRST_INTERVAL].max
+}
+
+func (d *Device) setMask(mask, val uint32) {
+	d.hwparams.masks[mask].bits[0] = 0
+	d.hwparams.masks[mask].bits[1] = 0
+	d.hwparams.masks[mask].bits[val>>5] = 1 << (val & 0x1F)
+}
+
+func (d *Device) checkMask(mask, val uint32) bool {
+	return d.hwparams.masks[mask].bits[val>>5]&(1<<(val&0x1F)) > 0
+}
diff --git a/installs_on_host/go2rtc/pkg/alsa/device/ioctl_linux.go b/installs_on_host/go2rtc/pkg/alsa/device/ioctl_linux.go
new file mode 100644
index 0000000..1277a60
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/alsa/device/ioctl_linux.go
@@ -0,0 +1,26 @@
+package device
+
+import (
+	"bytes"
+	"reflect"
+	"syscall"
+)
+
+func ioctl(fd, req uintptr, arg any) error {
+	var ptr uintptr
+	if arg != nil {
+		ptr = reflect.ValueOf(arg).Pointer()
+	}
+	_, _, err := syscall.Syscall(syscall.SYS_IOCTL, fd, req, ptr)
+	if err != 0 {
+		return err
+	}
+	return nil
+}
+
+func str(b []byte) string {
+	if i := bytes.IndexByte(b, 0); i >= 0 {
+		return string(b[:i])
+	}
+	return string(b)
+}
diff --git a/installs_on_host/go2rtc/pkg/alsa/open_linux.go b/installs_on_host/go2rtc/pkg/alsa/open_linux.go
new file mode 100644
index 0000000..2e4c57b
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/alsa/open_linux.go
@@ -0,0 +1,44 @@
+package alsa
+
+import (
+	"errors"
+	"fmt"
+	"net/url"
+
+	"github.com/AlexxIT/go2rtc/pkg/alsa/device"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func Open(rawURL string) (core.Producer, error) {
+	// Example (ffmpeg source compatible):
+	// alsa:device?audio=/dev/snd/pcmC0D0p
+	// TODO: ?audio=default
+	// TODO: ?audio=hw:0,0
+	// TODO: &sample_rate=48000&channels=2
+	// TODO: &backchannel=1
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	path := u.Query().Get("audio")
+	dev, err := device.Open(path)
+	if err != nil {
+		return nil, err
+	}
+
+	if !dev.CheckFormat(device.SNDRV_PCM_FORMAT_S16_LE) {
+		_ = dev.Close()
+		return nil, errors.New("alsa: format S16LE not supported")
+	}
+
+	switch path[len(path)-1] {
+	case 'p': // playback
+		return newPlayback(dev)
+	case 'c': // capture
+		return newCapture(dev)
+	}
+
+	_ = dev.Close()
+	return nil, fmt.Errorf("alsa: unknown path: %s", path)
+}
diff --git a/installs_on_host/go2rtc/pkg/alsa/playback_linux.go b/installs_on_host/go2rtc/pkg/alsa/playback_linux.go
new file mode 100644
index 0000000..7fb214d
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/alsa/playback_linux.go
@@ -0,0 +1,84 @@
+package alsa
+
+import (
+	"fmt"
+
+	"github.com/AlexxIT/go2rtc/pkg/alsa/device"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/pcm"
+	"github.com/pion/rtp"
+)
+
+type Playback struct {
+	core.Connection
+	dev    *device.Device
+	closed core.Waiter
+}
+
+func newPlayback(dev *device.Device) (*Playback, error) {
+	medias := []*core.Media{
+		{
+			Kind:      core.KindAudio,
+			Direction: core.DirectionSendonly,
+			Codecs: []*core.Codec{
+				{Name: core.CodecPCML},                  // support ffmpeg producer (auto transcode)
+				{Name: core.CodecPCMA, ClockRate: 8000}, // support webrtc producer
+			},
+		},
+	}
+	return &Playback{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "alsa",
+			Medias:     medias,
+			Transport:  dev,
+		},
+		dev: dev,
+	}, nil
+}
+
+func (p *Playback) GetTrack(media *core.Media, codec *core.Codec) (*core.Receiver, error) {
+	return nil, core.ErrCantGetTrack
+}
+
+func (p *Playback) AddTrack(media *core.Media, codec *core.Codec, track *core.Receiver) error {
+	src := track.Codec
+	dst := &core.Codec{
+		Name:      core.CodecPCML,
+		ClockRate: p.dev.GetRateNear(src.ClockRate),
+		Channels:  p.dev.GetChannelsNear(src.Channels),
+	}
+	sender := core.NewSender(media, dst)
+
+	sender.Handler = func(pkt *rtp.Packet) {
+		if n, err := p.dev.Write(pkt.Payload); err == nil {
+			p.Send += n
+		}
+	}
+
+	if sender.Handler = pcm.TranscodeHandler(dst, src, sender.Handler); sender.Handler == nil {
+		return fmt.Errorf("alsa: can't convert %s to %s", src, dst)
+	}
+
+	// typical card support:
+	// - Formats: S16_LE, S32_LE
+	// - ClockRates: 8000 - 192000
+	// - Channels: 2 - 10
+	err := p.dev.SetHWParams(device.SNDRV_PCM_FORMAT_S16_LE, dst.ClockRate, byte(dst.Channels))
+	if err != nil {
+		return err
+	}
+
+	sender.HandleRTP(track)
+	p.Senders = append(p.Senders, sender)
+	return nil
+}
+
+func (p *Playback) Start() (err error) {
+	return p.closed.Wait()
+}
+
+func (p *Playback) Stop() error {
+	p.closed.Done(nil)
+	return p.Connection.Stop()
+}
diff --git a/installs_on_host/go2rtc/pkg/ascii/README.md b/installs_on_host/go2rtc/pkg/ascii/README.md
new file mode 100644
index 0000000..bc9ef9d
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/ascii/README.md
@@ -0,0 +1,6 @@
+## Useful links
+
+- https://en.wikipedia.org/wiki/ANSI_escape_code
+- https://paulbourke.net/dataformats/asciiart/
+- https://github.com/kutuluk/xterm-color-chart
+- https://github.com/hugomd/parrot.live
diff --git a/installs_on_host/go2rtc/pkg/ascii/ascii.go b/installs_on_host/go2rtc/pkg/ascii/ascii.go
new file mode 100644
index 0000000..6636e27
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/ascii/ascii.go
@@ -0,0 +1,173 @@
+package ascii
+
+import (
+	"bytes"
+	"fmt"
+	"image/jpeg"
+	"io"
+	"net/http"
+	"unicode/utf8"
+)
+
+func NewWriter(w io.Writer, foreground, background, text string) io.Writer {
+	// once clear screen
+	_, _ = w.Write([]byte(csiClear))
+
+	// every frame - move to home
+	a := &writer{wr: w, buf: []byte(csiHome)}
+
+	// https://en.wikipedia.org/wiki/ANSI_escape_code
+	switch foreground {
+	case "":
+	case "8":
+		a.color = func(r, g, b uint8) {
+			idx := xterm256color(r, g, b, 8)
+			a.appendEsc(fmt.Sprintf("\033[%dm", 30+idx))
+
+		}
+	case "256":
+		a.color = func(r, g, b uint8) {
+			idx := xterm256color(r, g, b, 255)
+			a.appendEsc(fmt.Sprintf("\033[38;5;%dm", idx))
+		}
+	case "rgb":
+		a.color = func(r, g, b uint8) {
+			a.appendEsc(fmt.Sprintf("\033[38;2;%d;%d;%dm", r, g, b))
+		}
+	default:
+		a.buf = append(a.buf, "\033["+foreground+"m"...)
+	}
+
+	switch background {
+	case "":
+	case "8":
+		a.color = func(r, g, b uint8) {
+			idx := xterm256color(r, g, b, 8)
+			a.appendEsc(fmt.Sprintf("\033[%dm", 40+idx))
+		}
+	case "256":
+		a.color = func(r, g, b uint8) {
+			idx := xterm256color(r, g, b, 255)
+			a.appendEsc(fmt.Sprintf("\033[48;5;%dm", idx))
+		}
+	case "rgb":
+		a.color = func(r, g, b uint8) {
+			a.appendEsc(fmt.Sprintf("\033[48;2;%d;%d;%dm", r, g, b))
+		}
+	default:
+		a.buf = append(a.buf, "\033["+background+"m"...)
+	}
+
+	a.pre = len(a.buf) // save prefix size
+
+	if len(text) == 1 {
+		// fast 1 symbol version
+		a.text = func(_, _, _ uint32) {
+			a.buf = append(a.buf, text[0])
+		}
+	} else {
+		switch text {
+		case "":
+			text = ` .::--~~==++**##%%$@` // default for empty text
+		case "block":
+			text = " ░░▒▒▓▓█" // https://en.wikipedia.org/wiki/Block_Elements
+		}
+
+		if runes := []rune(text); len(runes) != len(text) {
+			k := float32(len(runes)-1) / 255
+			a.text = func(r, g, b uint32) {
+				i := gray(r, g, b, k)
+				a.buf = utf8.AppendRune(a.buf, runes[i])
+			}
+		} else {
+			k := float32(len(text)-1) / 255
+			a.text = func(r, g, b uint32) {
+				i := gray(r, g, b, k)
+				a.buf = append(a.buf, text[i])
+			}
+		}
+	}
+
+	return a
+}
+
+type writer struct {
+	wr    io.Writer
+	buf   []byte
+	pre   int
+	esc   string
+	color func(r, g, b uint8)
+	text  func(r, g, b uint32)
+}
+
+// https://stackoverflow.com/questions/37774983/clearing-the-screen-by-printing-a-character
+const csiClear = "\033[2J"
+const csiHome = "\033[H"
+
+func (a *writer) Write(p []byte) (n int, err error) {
+	img, err := jpeg.Decode(bytes.NewReader(p))
+	if err != nil {
+		return 0, err
+	}
+
+	a.buf = a.buf[:a.pre] // restore prefix
+
+	w := img.Bounds().Dx()
+	h := img.Bounds().Dy()
+	for y := 0; y < h; y++ {
+		for x := 0; x < w; x++ {
+			r, g, b, _ := img.At(x, y).RGBA()
+			if a.color != nil {
+				a.color(uint8(r>>8), uint8(g>>8), uint8(b>>8))
+			}
+			a.text(r, g, b)
+		}
+		a.buf = append(a.buf, '\n')
+	}
+
+	a.appendEsc("\033[0m")
+
+	if _, err = a.wr.Write(a.buf); err != nil {
+		return 0, err
+	}
+
+	a.wr.(http.Flusher).Flush()
+
+	return len(p), nil
+}
+
+// appendEsc - append ESC code to buffer, and skip duplicates
+func (a *writer) appendEsc(s string) {
+	if a.esc != s {
+		a.esc = s
+		a.buf = append(a.buf, s...)
+	}
+}
+
+func gray(r, g, b uint32, k float32) uint8 {
+	gr := (19595*r + 38470*g + 7471*b + 1<<15) >> 24 // uint8
+	return uint8(float32(gr) * k)
+}
+
+const x256r = "\x00\x80\x00\x80\x00\x80\x00\xc0\x80\xff\x00\xff\x00\xff\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x5f\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\x87\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xaf\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xd7\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x08\x12\x1c\x26\x30\x3a\x44\x4e\x58\x60\x66\x76\x80\x8a\x94\x9e\xa8\xb2\xbc\xc6\xd0\xda\xe4\xee"
+const x256g = "\x00\x00\x80\x80\x00\x00\x80\xc0\x80\x00\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x5f\x5f\x5f\x5f\x5f\x5f\x87\x87\x87\x87\x87\x87\xaf\xaf\xaf\xaf\xaf\xaf\xd7\xd7\xd7\xd7\xd7\xd7\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x5f\x5f\x5f\x5f\x5f\x5f\x87\x87\x87\x87\x87\x87\xaf\xaf\xaf\xaf\xaf\xaf\xd7\xd7\xd7\xd7\xd7\xd7\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x5f\x5f\x5f\x5f\x5f\x5f\x87\x87\x87\x87\x87\x87\xaf\xaf\xaf\xaf\xaf\xaf\xd7\xd7\xd7\xd7\xd7\xd7\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x5f\x5f\x5f\x5f\x5f\x5f\x87\x87\x87\x87\x87\x87\xaf\xaf\xaf\xaf\xaf\xaf\xd7\xd7\xd7\xd7\xd7\xd7\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x5f\x5f\x5f\x5f\x5f\x5f\x87\x87\x87\x87\x87\x87\xaf\xaf\xaf\xaf\xaf\xaf\xd7\xd7\xd7\xd7\xd7\xd7\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x5f\x5f\x5f\x5f\x5f\x5f\x87\x87\x87\x87\x87\x87\xaf\xaf\xaf\xaf\xaf\xaf\xd7\xd7\xd7\xd7\xd7\xd7\xff\xff\xff\xff\xff\xff\x08\x12\x1c\x26\x30\x3a\x44\x4e\x58\x60\x66\x76\x80\x8a\x94\x9e\xa8\xb2\xbc\xc6\xd0\xda\xe4\xee"
+const x256b = "\x00\x00\x00\x00\x80\x80\x80\xc0\x80\x00\x00\x00\xff\xff\xff\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x00\x5f\x87\xaf\xd7\xff\x08\x12\x1c\x26\x30\x3a\x44\x4e\x58\x60\x66\x76\x80\x8a\x94\x9e\xa8\xb2\xbc\xc6\xd0\xda\xe4\xee"
+
+func xterm256color(r, g, b uint8, n int) (index uint8) {
+	best := uint16(0xFFFF)
+	for i := 0; i < n; i++ {
+		diff := sqDiff(r, x256r[i]) + sqDiff(g, x256g[i]) + sqDiff(b, x256b[i])
+		if diff < best {
+			best = diff
+			index = uint8(i)
+		}
+	}
+	return
+}
+
+// sqDiff - just like from image/color/color.go
+func sqDiff(x, y uint8) uint16 {
+	d := uint16(x - y)
+	//return d
+	return (d * d) >> 2
+}
diff --git a/installs_on_host/go2rtc/pkg/bits/reader.go b/installs_on_host/go2rtc/pkg/bits/reader.go
new file mode 100644
index 0000000..2a95740
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/bits/reader.go
@@ -0,0 +1,143 @@
+package bits
+
+type Reader struct {
+	EOF bool // if end of buffer raised during reading
+
+	buf  []byte // total buf
+	byte byte   // current byte
+	bits byte   // bits left in byte
+	pos  int    // current pos in buf
+}
+
+func NewReader(b []byte) *Reader {
+	return &Reader{buf: b}
+}
+
+//goland:noinspection GoStandardMethods
+func (r *Reader) ReadByte() byte {
+	if r.bits != 0 {
+		return r.ReadBits8(8)
+	}
+
+	if r.pos >= len(r.buf) {
+		r.EOF = true
+		return 0
+	}
+
+	b := r.buf[r.pos]
+	r.pos++
+	return b
+}
+
+func (r *Reader) ReadUint16() uint16 {
+	if r.bits != 0 {
+		return r.ReadBits16(16)
+	}
+	return uint16(r.ReadByte())<<8 | uint16(r.ReadByte())
+}
+
+func (r *Reader) ReadUint24() uint32 {
+	if r.bits != 0 {
+		return r.ReadBits(24)
+	}
+	return uint32(r.ReadByte())<<16 | uint32(r.ReadByte())<<8 | uint32(r.ReadByte())
+}
+
+func (r *Reader) ReadUint32() uint32 {
+	if r.bits != 0 {
+		return r.ReadBits(32)
+	}
+	return uint32(r.ReadByte())<<24 | uint32(r.ReadByte())<<16 | uint32(r.ReadByte())<<8 | uint32(r.ReadByte())
+}
+
+func (r *Reader) ReadBit() byte {
+	if r.bits == 0 {
+		r.byte = r.ReadByte()
+		r.bits = 7
+	} else {
+		r.bits--
+	}
+
+	return (r.byte >> r.bits) & 0b1
+}
+
+func (r *Reader) ReadBits(n byte) (res uint32) {
+	for i := n - 1; i != 255; i-- {
+		res |= uint32(r.ReadBit()) << i
+	}
+	return
+}
+
+func (r *Reader) ReadBits8(n byte) (res uint8) {
+	for i := n - 1; i != 255; i-- {
+		res |= r.ReadBit() << i
+	}
+	return
+}
+
+func (r *Reader) ReadBits16(n byte) (res uint16) {
+	for i := n - 1; i != 255; i-- {
+		res |= uint16(r.ReadBit()) << i
+	}
+	return
+}
+
+func (r *Reader) ReadBits64(n byte) (res uint64) {
+	for i := n - 1; i != 255; i-- {
+		res |= uint64(r.ReadBit()) << i
+	}
+	return
+}
+
+func (r *Reader) ReadFloat32() float64 {
+	i := r.ReadUint16()
+	f := r.ReadUint16()
+	return float64(i) + float64(f)/65536
+}
+
+func (r *Reader) ReadBytes(n int) (b []byte) {
+	if r.bits == 0 {
+		if r.pos+n > len(r.buf) {
+			r.EOF = true
+			return nil
+		}
+
+		b = r.buf[r.pos : r.pos+n]
+		r.pos += n
+	} else {
+		b = make([]byte, n)
+		for i := 0; i < n; i++ {
+			b[i] = r.ReadByte()
+		}
+	}
+
+	return
+}
+
+// ReadUEGolomb - ReadExponentialGolomb (unsigned)
+func (r *Reader) ReadUEGolomb() uint32 {
+	var size byte
+	for size = 0; size < 32; size++ {
+		if b := r.ReadBit(); b != 0 || r.EOF {
+			break
+		}
+	}
+	return r.ReadBits(size) + (1 << size) - 1
+}
+
+// ReadSEGolomb - ReadSignedExponentialGolomb
+func (r *Reader) ReadSEGolomb() int32 {
+	if b := r.ReadUEGolomb(); b%2 == 0 {
+		return -int32(b / 2)
+	} else {
+		return int32((b + 1) / 2)
+	}
+}
+
+func (r *Reader) Left() []byte {
+	return r.buf[r.pos:]
+}
+
+func (r *Reader) Pos() (int, byte) {
+	return r.pos - 1, r.bits
+}
diff --git a/installs_on_host/go2rtc/pkg/bits/writer.go b/installs_on_host/go2rtc/pkg/bits/writer.go
new file mode 100644
index 0000000..307166b
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/bits/writer.go
@@ -0,0 +1,95 @@
+package bits
+
+type Writer struct {
+	buf  []byte // total buf
+	byte *byte  // pointer to current byte
+	bits byte   // bits left in byte
+}
+
+func NewWriter(buf []byte) *Writer {
+	return &Writer{buf: buf}
+}
+
+//goland:noinspection GoStandardMethods
+func (w *Writer) WriteByte(b byte) {
+	if w.bits != 0 {
+		w.WriteBits8(b, 8)
+	}
+
+	w.buf = append(w.buf, b)
+}
+
+func (w *Writer) WriteBit(b byte) {
+	if w.bits == 0 {
+		w.buf = append(w.buf, 0)
+		w.byte = &w.buf[len(w.buf)-1]
+		w.bits = 7
+	} else {
+		w.bits--
+	}
+
+	*w.byte |= (b & 1) << w.bits
+}
+
+func (w *Writer) WriteBits(v uint32, n byte) {
+	for i := n - 1; i != 255; i-- {
+		w.WriteBit(byte(v>>i) & 0b1)
+	}
+}
+
+func (w *Writer) WriteBits16(v uint16, n byte) {
+	for i := n - 1; i != 255; i-- {
+		w.WriteBit(byte(v>>i) & 0b1)
+	}
+}
+
+func (w *Writer) WriteBits8(v, n byte) {
+	for i := n - 1; i != 255; i-- {
+		w.WriteBit((v >> i) & 0b1)
+	}
+}
+
+func (w *Writer) WriteAllBits(bit, n byte) {
+	for i := byte(0); i < n; i++ {
+		w.WriteBit(bit)
+	}
+}
+
+func (w *Writer) WriteBool(b bool) {
+	if b {
+		w.WriteBit(1)
+	} else {
+		w.WriteBit(0)
+	}
+}
+
+func (w *Writer) WriteUint16(v uint16) {
+	if w.bits != 0 {
+		w.WriteBits16(v, 16)
+	}
+
+	w.buf = append(w.buf, byte(v>>8), byte(v))
+}
+
+func (w *Writer) WriteBytes(bytes ...byte) {
+	if w.bits != 0 {
+		for _, b := range bytes {
+			w.WriteByte(b)
+		}
+	}
+
+	w.buf = append(w.buf, bytes...)
+}
+
+func (w *Writer) Bytes() []byte {
+	return w.buf
+}
+
+func (w *Writer) Len() int {
+	return len(w.buf)
+}
+
+func (w *Writer) Reset() {
+	w.buf = w.buf[:0]
+	w.bits = 0
+}
diff --git a/installs_on_host/go2rtc/pkg/bubble/client.go b/installs_on_host/go2rtc/pkg/bubble/client.go
new file mode 100644
index 0000000..7a71d55
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/bubble/client.go
@@ -0,0 +1,266 @@
+// Package bubble, because:
+// Request URL: /bubble/live?ch=0&stream=0
+// Response Conten-Type: video/bubble
+// https://github.com/Lynch234ok/lynch-git/blob/master/app_rebulid/src/bubble.c
+package bubble
+
+import (
+	"bufio"
+	"encoding/binary"
+	"errors"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264/annexb"
+	"github.com/AlexxIT/go2rtc/pkg/tcp"
+	"github.com/pion/rtp"
+)
+
+// Deprecated: should be rewritten to core.Connection
+type Client struct {
+	core.Listener
+
+	url  string
+	conn net.Conn
+
+	videoCodec string
+	channel    int
+	stream     int
+
+	r *bufio.Reader
+
+	medias    []*core.Media
+	receivers []*core.Receiver
+
+	videoTrack *core.Receiver
+	audioTrack *core.Receiver
+
+	recv int
+}
+
+func Dial(rawURL string) (*Client, error) {
+	client := &Client{url: rawURL}
+	if err := client.Dial(); err != nil {
+		return nil, err
+	}
+	return client, nil
+}
+
+const (
+	SyncByte    = 0xAA
+	PacketAuth  = 0x00
+	PacketMedia = 0x01
+	PacketStart = 0x0A
+)
+
+const Timeout = time.Second * 5
+
+func (c *Client) Dial() (err error) {
+	u, err := url.Parse(c.url)
+	if err != nil {
+		return
+	}
+
+	if c.conn, err = net.DialTimeout("tcp", u.Host, Timeout); err != nil {
+		return
+	}
+
+	if err = c.conn.SetDeadline(time.Now().Add(Timeout)); err != nil {
+		return
+	}
+
+	req := &tcp.Request{Method: "GET", URL: &url.URL{Path: u.Path, RawQuery: u.RawQuery}, Proto: "HTTP/1.1"}
+	if err = req.Write(c.conn); err != nil {
+		return
+	}
+
+	c.r = bufio.NewReader(c.conn)
+	res, err := tcp.ReadResponse(c.r)
+	if err != nil {
+		return
+	}
+
+	if res.StatusCode != http.StatusOK {
+		return errors.New("wrong response: " + res.Status)
+	}
+
+	// 1. Read 1024 bytes with XML, some cameras returns exact 1024, but some - 923
+	xml := make([]byte, 1024)
+	if _, err = c.r.Read(xml); err != nil {
+		return
+	}
+
+	// 2. Write size uint32 + unknown 4b + user 20b + pass 20b
+	b := make([]byte, 48)
+	binary.BigEndian.PutUint32(b, 44)
+
+	if u.User != nil {
+		copy(b[8:], u.User.Username())
+		pass, _ := u.User.Password()
+		copy(b[28:], pass)
+	} else {
+		copy(b[8:], "admin")
+	}
+
+	if err = c.Write(PacketAuth, 0x0E16C271, b); err != nil {
+		return
+	}
+
+	// 3. Read response
+	cmd, b, err := c.Read()
+	if err != nil {
+		return
+	}
+
+	if cmd != PacketAuth || len(b) != 44 || b[4] != 3 || b[8] != 1 {
+		return errors.New("wrong auth response")
+	}
+
+	// 4. Parse XML (from 1)
+	query := u.Query()
+
+	stream := query.Get("stream")
+	if stream != "" {
+		c.stream = core.Atoi(stream)
+	} else {
+		stream = "0"
+	}
+
+	// <bubble version="1.0" vin="1"><vin0 stream="2">
+	// <stream0 name="720p.264" size="2304x1296" x1="yes" x2="yes" x4="yes" />
+	// <stream1 name="360p.265" size="640x360" x1="yes" x2="yes" x4="yes" />
+	// <vin0>
+	// </bubble>
+	re := regexp.MustCompile("<stream" + stream + " [^>]+")
+	stream = re.FindString(string(xml))
+	if strings.Contains(stream, ".265") {
+		c.videoCodec = core.CodecH265
+	} else {
+		c.videoCodec = core.CodecH264
+	}
+
+	if ch := query.Get("ch"); ch != "" {
+		c.channel = core.Atoi(ch)
+	}
+
+	return
+}
+
+func (c *Client) Write(command byte, timestamp uint32, payload []byte) error {
+	if err := c.conn.SetWriteDeadline(time.Now().Add(Timeout)); err != nil {
+		return err
+	}
+
+	// 0xAA + size uint32 + cmd byte + ts uint32 + payload
+	b := make([]byte, 14+len(payload))
+	b[0] = SyncByte
+	binary.BigEndian.PutUint32(b[1:], uint32(5+len(payload)))
+	b[5] = command
+	binary.BigEndian.PutUint32(b[6:], timestamp)
+	copy(b[10:], payload)
+
+	_, err := c.conn.Write(b)
+	return err
+}
+
+func (c *Client) Read() (byte, []byte, error) {
+	if err := c.conn.SetReadDeadline(time.Now().Add(Timeout)); err != nil {
+		return 0, nil, err
+	}
+
+	// 0xAA + size uint32 + cmd byte + ts uint32 + payload
+	b := make([]byte, 10)
+	if _, err := io.ReadFull(c.r, b); err != nil {
+		return 0, nil, err
+	}
+
+	if b[0] != SyncByte {
+		return 0, nil, errors.New("wrong start byte")
+	}
+
+	size := binary.BigEndian.Uint32(b[1:])
+	payload := make([]byte, size-1-4)
+	if _, err := io.ReadFull(c.r, payload); err != nil {
+		return 0, nil, err
+	}
+
+	//timestamp := binary.BigEndian.Uint32(b[6:]) // in ms
+
+	return b[5], payload, nil
+}
+
+func (c *Client) Play() error {
+	// yeah, there's no mistake about the little endian
+	b := make([]byte, 16)
+	binary.LittleEndian.PutUint32(b, uint32(c.channel))
+	binary.LittleEndian.PutUint32(b[4:], uint32(c.stream))
+	binary.LittleEndian.PutUint32(b[8:], 1) // opened
+	return c.Write(PacketStart, 0x0E16C2DF, b)
+}
+
+func (c *Client) Handle() error {
+	var audioTS uint32
+
+	for {
+		cmd, b, err := c.Read()
+		if err != nil {
+			return err
+		}
+
+		c.recv += len(b)
+
+		if cmd != PacketMedia {
+			continue
+		}
+
+		// size uint32 + type 1b + channel 1b
+		// type = 1 for keyframe, 2 for other frame, 0 for audio
+
+		if b[4] > 0 {
+			if c.videoTrack == nil {
+				continue
+			}
+
+			pkt := &rtp.Packet{
+				Header: rtp.Header{
+					Timestamp: core.Now90000(),
+				},
+				Payload: annexb.EncodeToAVCC(b[6:]),
+			}
+			c.videoTrack.WriteRTP(pkt)
+		} else {
+			if c.audioTrack == nil {
+				continue
+			}
+
+			//binary.LittleEndian.Uint32(b[6:])          // entries (always 1)
+			//size := binary.LittleEndian.Uint32(b[10:]) // size
+			//mk := binary.LittleEndian.Uint64(b[14:]) // pts (uint64_t)
+			//binary.LittleEndian.Uint32(b[22:])         // gtime (time_t)
+			//name := b[26:34] // g711
+			//rate := binary.LittleEndian.Uint32(b[34:])  // sample rate
+			//width := binary.LittleEndian.Uint32(b[38:]) // samplewidth
+
+			pkt := &rtp.Packet{
+				Header: rtp.Header{
+					Version:   2,
+					Marker:    true,
+					Timestamp: audioTS,
+				},
+				Payload: b[6+36:],
+			}
+			audioTS += uint32(len(pkt.Payload))
+			c.audioTrack.WriteRTP(pkt)
+		}
+	}
+}
+
+func (c *Client) Close() error {
+	return c.conn.Close()
+}
diff --git a/installs_on_host/go2rtc/pkg/bubble/producer.go b/installs_on_host/go2rtc/pkg/bubble/producer.go
new file mode 100644
index 0000000..9fa18f2
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/bubble/producer.go
@@ -0,0 +1,80 @@
+package bubble
+
+import (
+	"encoding/json"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func (c *Client) GetMedias() []*core.Media {
+	if c.medias == nil {
+		c.medias = []*core.Media{
+			{
+				Kind:      core.KindVideo,
+				Direction: core.DirectionRecvonly,
+				Codecs: []*core.Codec{
+					{Name: c.videoCodec, ClockRate: 90000, PayloadType: core.PayloadTypeRAW},
+				},
+			},
+			{
+				Kind:      core.KindAudio,
+				Direction: core.DirectionRecvonly,
+				Codecs: []*core.Codec{
+					{Name: core.CodecPCMA, ClockRate: 8000, PayloadType: 8},
+				},
+			},
+		}
+	}
+
+	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
+		}
+	}
+
+	track := core.NewReceiver(media, codec)
+
+	switch media.Kind {
+	case core.KindVideo:
+		c.videoTrack = track
+	case core.KindAudio:
+		c.audioTrack = track
+	}
+
+	c.receivers = append(c.receivers, track)
+
+	return track, nil
+}
+
+func (c *Client) Start() error {
+	if err := c.Play(); err != nil {
+		return err
+	}
+	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.Connection{
+		ID:         core.ID(c),
+		FormatName: "bubble",
+		Protocol:   "http",
+		Medias:     c.medias,
+		Recv:       c.recv,
+		Receivers:  c.receivers,
+	}
+	if c.conn != nil {
+		info.RemoteAddr = c.conn.RemoteAddr().String()
+	}
+	return json.Marshal(info)
+}
diff --git a/installs_on_host/go2rtc/pkg/core/README.md b/installs_on_host/go2rtc/pkg/core/README.md
new file mode 100644
index 0000000..7f6faca
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/core/README.md
@@ -0,0 +1,40 @@
+## PCM
+
+**RTSP**
+
+- PayloadType=10 - L16/44100/2 - Linear PCM 16-bit big endian
+- PayloadType=11 - L16/44100/1 - Linear PCM 16-bit big endian
+
+https://en.wikipedia.org/wiki/RTP_payload_formats
+
+**Apple QuickTime**
+
+- `raw` - 16-bit data is stored in little endian format
+- `twos` - 16-bit data is stored in big endian format
+- `sowt` - 16-bit data is stored in little endian format
+- `in24` - denotes 24-bit, big endian
+- `in32` - denotes 32-bit, big endian
+- `fl32` - denotes 32-bit floating point PCM
+- `fl64` - denotes 64-bit floating point PCM
+- `alaw` - denotes A-law logarithmic PCM
+- `ulaw` - denotes mu-law logarithmic PCM
+
+https://wiki.multimedia.cx/index.php/PCM
+
+**FFmpeg RTSP**
+
+```
+pcm_s16be, 44100 Hz, stereo => 10
+pcm_s16be, 48000 Hz, stereo => 96 L16/48000/2
+pcm_s16be, 44100 Hz, mono   => 11
+
+pcm_s16le, 48000 Hz, stereo => 96 (b=AS:1536)
+pcm_s16le, 44100 Hz, stereo => 96 (b=AS:1411)
+pcm_s16le, 16000 Hz, stereo => 96 (b=AS:512)
+pcm_s16le, 8000 Hz, stereo  => 96 (b=AS:256)
+
+pcm_s16le, 48000 Hz, mono   => 96 (b=AS:768)
+pcm_s16le, 44100 Hz, mono   => 96 (b=AS:705)
+pcm_s16le, 16000 Hz, mono   => 96 (b=AS:256)
+pcm_s16le, 8000 Hz, mono    => 96 (b=AS:128)
+```
\ No newline at end of file
diff --git a/installs_on_host/go2rtc/pkg/core/codec.go b/installs_on_host/go2rtc/pkg/core/codec.go
new file mode 100644
index 0000000..11276bc
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/core/codec.go
@@ -0,0 +1,284 @@
+package core
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"strings"
+	"unicode"
+
+	"github.com/pion/sdp/v3"
+)
+
+type Codec struct {
+	Name        string // H264, PCMU, PCMA, opus...
+	ClockRate   uint32 // 90000, 8000, 16000...
+	Channels    uint8  // 0, 1, 2
+	FmtpLine    string
+	PayloadType uint8
+}
+
+// MarshalJSON - return FFprobe compatible output
+func (c *Codec) MarshalJSON() ([]byte, error) {
+	info := map[string]any{}
+	if name := FFmpegCodecName(c.Name); name != "" {
+		info["codec_name"] = name
+		info["codec_type"] = c.Kind()
+	}
+	if c.Name == CodecH264 {
+		profile, level := DecodeH264(c.FmtpLine)
+		if profile != "" {
+			info["profile"] = profile
+			info["level"] = level
+		}
+	}
+	if c.ClockRate != 0 && c.ClockRate != 90000 {
+		info["sample_rate"] = c.ClockRate
+	}
+	if c.Channels > 0 {
+		info["channels"] = c.Channels
+	}
+	return json.Marshal(info)
+}
+
+func FFmpegCodecName(name string) string {
+	switch name {
+	case CodecH264:
+		return "h264"
+	case CodecH265:
+		return "hevc"
+	case CodecJPEG:
+		return "mjpeg"
+	case CodecRAW:
+		return "rawvideo"
+	case CodecPCMA:
+		return "pcm_alaw"
+	case CodecPCMU:
+		return "pcm_mulaw"
+	case CodecPCM:
+		return "pcm_s16be"
+	case CodecPCML:
+		return "pcm_s16le"
+	case CodecAAC:
+		return "aac"
+	case CodecOpus:
+		return "opus"
+	case CodecVP8:
+		return "vp8"
+	case CodecVP9:
+		return "vp9"
+	case CodecAV1:
+		return "av1"
+	case CodecELD:
+		return "aac/eld"
+	case CodecFLAC:
+		return "flac"
+	case CodecMP3:
+		return "mp3"
+	}
+	return name
+}
+
+func (c *Codec) String() (s string) {
+	s = c.Name
+	if c.ClockRate != 0 && c.ClockRate != 90000 {
+		s += fmt.Sprintf("/%d", c.ClockRate)
+	}
+	if c.Channels > 0 {
+		s += fmt.Sprintf("/%d", c.Channels)
+	}
+	return
+}
+
+func (c *Codec) IsRTP() bool {
+	return c.PayloadType != PayloadTypeRAW
+}
+
+func (c *Codec) IsVideo() bool {
+	return c.Kind() == KindVideo
+}
+
+func (c *Codec) IsAudio() bool {
+	return c.Kind() == KindAudio
+}
+
+func (c *Codec) Kind() string {
+	return GetKind(c.Name)
+}
+
+func (c *Codec) PrintName() string {
+	switch c.Name {
+	case CodecAAC:
+		return "AAC"
+	case CodecPCM:
+		return "S16B"
+	case CodecPCML:
+		return "S16L"
+	}
+	return c.Name
+}
+
+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:]
+			}
+		}
+	}
+
+	switch c.Name {
+	case "PCM":
+		// https://www.reddit.com/r/Hikvision/comments/17elxex/comment/k642g2r/
+		// check pkg/rtsp/rtsp_test.go TestHikvisionPCM
+		c.Name = CodecPCML
+	case "":
+		// 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 "10":
+			c.Name = CodecPCM
+			c.ClockRate = 44100
+			c.Channels = 2
+		case "11":
+			c.Name = CodecPCM
+			c.ClockRate = 44100
+		case "14":
+			c.Name = CodecMP3
+			c.ClockRate = 90000 // it's not real sample rate
+		case "26":
+			c.Name = CodecJPEG
+			c.ClockRate = 90000
+		case "96", "97", "98":
+			if len(md.Bandwidth) == 0 {
+				c.Name = payloadType
+				break
+			}
+
+			// FFmpeg + RTSP + pcm_s16le = doesn't pass info about codec name and params
+			// so try to guess the codec based on bitrate
+			// https://github.com/AlexxIT/go2rtc/issues/523
+			switch md.Bandwidth[0].Bandwidth {
+			case 128:
+				c.ClockRate = 8000
+			case 256:
+				c.ClockRate = 16000
+			case 384:
+				c.ClockRate = 24000
+			case 512:
+				c.ClockRate = 32000
+			case 705:
+				c.ClockRate = 44100
+			case 768:
+				c.ClockRate = 48000
+			case 1411:
+				// default Windows DShow
+				c.ClockRate = 44100
+				c.Channels = 2
+			case 1536:
+				// default Linux ALSA
+				c.ClockRate = 48000
+				c.Channels = 2
+			default:
+				c.Name = payloadType
+				break
+			}
+
+			c.Name = CodecPCML
+		default:
+			c.Name = payloadType
+		}
+	}
+
+	return c
+}
+
+func DecodeH264(fmtp string) (profile string, level byte) {
+	if ps := Between(fmtp, "sprop-parameter-sets=", ","); ps != "" {
+		if sps, _ := base64.StdEncoding.DecodeString(ps); len(sps) >= 4 {
+			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])
+			}
+
+			level = sps[3]
+		}
+	}
+	return
+}
+
+func ParseCodecString(s string) *Codec {
+	var codec Codec
+
+	ss := strings.Split(s, "/")
+	switch strings.ToLower(ss[0]) {
+	case "pcm_s16be", "s16be", "pcm":
+		codec.Name = CodecPCM
+	case "pcm_s16le", "s16le", "pcml":
+		codec.Name = CodecPCML
+	case "pcm_alaw", "alaw", "pcma", "g711a":
+		codec.Name = CodecPCMA
+	case "pcm_mulaw", "mulaw", "pcmu", "g711u":
+		codec.Name = CodecPCMU
+	case "aac", "mpeg4-generic":
+		codec.Name = CodecAAC
+	case "opus":
+		codec.Name = CodecOpus
+	case "flac":
+		codec.Name = CodecFLAC
+	default:
+		return nil
+	}
+
+	if len(ss) >= 2 {
+		codec.ClockRate = uint32(Atoi(ss[1]))
+	}
+	if len(ss) >= 3 {
+		codec.Channels = uint8(Atoi(ss[2]))
+	}
+
+	return &codec
+}
diff --git a/installs_on_host/go2rtc/pkg/core/connection.go b/installs_on_host/go2rtc/pkg/core/connection.go
new file mode 100644
index 0000000..cc0f43e
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/core/connection.go
@@ -0,0 +1,144 @@
+package core
+
+import (
+	"io"
+	"net/http"
+	"reflect"
+	"sync/atomic"
+)
+
+func NewID() uint32 {
+	return id.Add(1)
+}
+
+// Deprecated: use NewID instead
+func ID(v any) uint32 {
+	p := uintptr(reflect.ValueOf(v).UnsafePointer())
+	return 0x8000_0000 | uint32(p)
+}
+
+var id atomic.Uint32
+
+type Info interface {
+	SetProtocol(string)
+	SetRemoteAddr(string)
+	SetSource(string)
+	SetURL(string)
+	WithRequest(*http.Request)
+	GetSource() string
+}
+
+// Connection just like webrtc.PeerConnection
+// - ID and RemoteAddr used for building Connection(s) graph
+// - FormatName, Protocol, RemoteAddr, Source, URL, SDP, UserAgent used for info about Connection
+// - FormatName and Protocol has FFmpeg compatible names
+// - Transport used for auto closing on Stop
+type Connection struct {
+	ID         uint32 `json:"id,omitempty"`
+	FormatName string `json:"format_name,omitempty"` // rtsp, webrtc, mp4, mjpeg, mpjpeg...
+	Protocol   string `json:"protocol,omitempty"`    // tcp, udp, http, ws, pipe...
+	RemoteAddr string `json:"remote_addr,omitempty"` // host:port other info
+	Source     string `json:"source,omitempty"`
+	URL        string `json:"url,omitempty"`
+	SDP        string `json:"sdp,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:"bytes_recv,omitempty"`
+	Send      int         `json:"bytes_send,omitempty"`
+
+	Transport any `json:"-"`
+}
+
+func (c *Connection) GetMedias() []*Media {
+	return c.Medias
+}
+
+func (c *Connection) GetTrack(media *Media, codec *Codec) (*Receiver, error) {
+	for _, receiver := range c.Receivers {
+		if receiver.Codec == codec {
+			return receiver, nil
+		}
+	}
+	receiver := NewReceiver(media, codec)
+	c.Receivers = append(c.Receivers, receiver)
+	return receiver, nil
+}
+
+func (c *Connection) Stop() error {
+	for _, receiver := range c.Receivers {
+		receiver.Close()
+	}
+	for _, sender := range c.Senders {
+		sender.Close()
+	}
+	if closer, ok := c.Transport.(io.Closer); ok {
+		return closer.Close()
+	}
+	return nil
+}
+
+// Deprecated:
+func (c *Connection) Codecs() []*Codec {
+	codecs := make([]*Codec, len(c.Senders))
+	for i, sender := range c.Senders {
+		codecs[i] = sender.Codec
+	}
+	return codecs
+}
+
+func (c *Connection) SetProtocol(s string) {
+	c.Protocol = s
+}
+
+func (c *Connection) SetRemoteAddr(s string) {
+	if c.RemoteAddr == "" {
+		c.RemoteAddr = s
+	} else {
+		c.RemoteAddr += " forwarded " + s
+	}
+}
+
+func (c *Connection) SetSource(s string) {
+	c.Source = s
+}
+
+func (c *Connection) SetURL(s string) {
+	c.URL = s
+}
+
+func (c *Connection) WithRequest(r *http.Request) {
+	if r.Header.Get("Upgrade") == "websocket" {
+		c.Protocol = "ws"
+	} else {
+		c.Protocol = "http"
+	}
+
+	c.RemoteAddr = r.RemoteAddr
+	if remote := r.Header.Get("X-Forwarded-For"); remote != "" {
+		c.RemoteAddr += " forwarded " + remote
+	}
+
+	c.UserAgent = r.UserAgent()
+}
+
+func (c *Connection) GetSource() string {
+	return c.Source
+}
+
+// Create like os.Create, init Consumer with existing Transport
+func Create(w io.Writer) (*Connection, error) {
+	return &Connection{Transport: w}, nil
+}
+
+// Open like os.Open, init Producer from existing Transport
+func Open(r io.Reader) (*Connection, error) {
+	return &Connection{Transport: r}, nil
+}
+
+// Dial like net.Dial, init Producer via Dialing
+func Dial(rawURL string) (*Connection, error) {
+	return &Connection{}, nil
+}
diff --git a/installs_on_host/go2rtc/pkg/core/core.go b/installs_on_host/go2rtc/pkg/core/core.go
new file mode 100644
index 0000000..9555ecf
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/core/core.go
@@ -0,0 +1,97 @@
+package core
+
+import "encoding/json"
+
+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
+	CodecRAW  = "RAW"
+
+	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 (big endian)
+
+	CodecPCML = "PCML" // Linear PCM (little endian)
+
+	CodecELD  = "ELD" // AAC-ELD
+	CodecFLAC = "FLAC"
+
+	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)
+
+	// Deprecated: rename to Run()
+	Start() error
+
+	// Deprecated: rename to Close()
+	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
+
+	// Deprecated: rename to Close()
+	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"
+}
+
+func (m Mode) MarshalJSON() ([]byte, error) {
+	return json.Marshal(m.String())
+}
diff --git a/installs_on_host/go2rtc/pkg/core/core_test.go b/installs_on_host/go2rtc/pkg/core/core_test.go
new file mode 100644
index 0000000..e7845ca
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/core/core_test.go
@@ -0,0 +1,134 @@
+package core
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+type producer struct {
+	Medias    []*Media
+	Receivers []*Receiver
+
+	id byte
+}
+
+func (p *producer) GetMedias() []*Media {
+	return p.Medias
+}
+
+func (p *producer) GetTrack(_ *Media, codec *Codec) (*Receiver, error) {
+	for _, receiver := range p.Receivers {
+		if receiver.Codec == codec {
+			return receiver, nil
+		}
+	}
+	receiver := NewReceiver(nil, codec)
+	p.Receivers = append(p.Receivers, receiver)
+	return receiver, nil
+}
+
+func (p *producer) Start() error {
+	pkt := &Packet{Payload: []byte{p.id}}
+	p.Receivers[0].Input(pkt)
+	return nil
+}
+
+func (p *producer) Stop() error {
+	for _, receiver := range p.Receivers {
+		receiver.Close()
+	}
+	return nil
+}
+
+type consumer struct {
+	Medias  []*Media
+	Senders []*Sender
+
+	cache chan byte
+}
+
+func (c *consumer) GetMedias() []*Media {
+	return c.Medias
+}
+
+func (c *consumer) AddTrack(_ *Media, _ *Codec, track *Receiver) error {
+	c.cache = make(chan byte, 1)
+	sender := NewSender(nil, track.Codec)
+	sender.Output = func(packet *Packet) {
+		c.cache <- packet.Payload[0]
+	}
+	sender.HandleRTP(track)
+	c.Senders = append(c.Senders, sender)
+	return nil
+}
+
+func (c *consumer) Stop() error {
+	for _, sender := range c.Senders {
+		sender.Close()
+	}
+	return nil
+}
+
+func (c *consumer) read() byte {
+	return <-c.cache
+}
+
+func TestName(t *testing.T) {
+	GetProducer := func(b byte) Producer {
+		return &producer{
+			Medias: []*Media{
+				{
+					Kind:      KindVideo,
+					Direction: DirectionRecvonly,
+					Codecs: []*Codec{
+						{Name: CodecH264},
+					},
+				},
+			},
+			id: b,
+		}
+	}
+
+	// stage1
+	prod1 := GetProducer(1)
+	cons2 := &consumer{}
+
+	media1 := prod1.GetMedias()[0]
+	track1, _ := prod1.GetTrack(media1, media1.Codecs[0])
+
+	_ = cons2.AddTrack(nil, nil, track1)
+
+	_ = prod1.Start()
+	require.Equal(t, byte(1), cons2.read())
+
+	// stage2
+	prod2 := GetProducer(2)
+	media2 := prod2.GetMedias()[0]
+	require.NotEqual(t, fmt.Sprintf("%p", media1), fmt.Sprintf("%p", media2))
+	track2, _ := prod2.GetTrack(media2, media2.Codecs[0])
+	track1.Replace(track2)
+
+	_ = prod1.Stop()
+
+	_ = prod2.Start()
+	require.Equal(t, byte(2), cons2.read())
+
+	// stage3
+	_ = prod2.Stop()
+}
+
+func TestStripUserinfo(t *testing.T) {
+	s := `streams:
+  test:
+    - ffmpeg:rtsp://username:password@10.1.2.3:554/stream1
+    - ffmpeg:rtsp://10.1.2.3:554/stream1@#video=copy
+`
+	s = StripUserinfo(s)
+	require.Equal(t, `streams:
+  test:
+    - ffmpeg:rtsp://***@10.1.2.3:554/stream1
+    - ffmpeg:rtsp://10.1.2.3:554/stream1@#video=copy
+`, s)
+}
diff --git a/installs_on_host/go2rtc/pkg/core/helpers.go b/installs_on_host/go2rtc/pkg/core/helpers.go
new file mode 100644
index 0000000..45bbd0d
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/core/helpers.go
@@ -0,0 +1,94 @@
+package core
+
+import (
+	"crypto/rand"
+	"runtime"
+	"strconv"
+	"strings"
+	"time"
+)
+
+const (
+	BufferSize      = 64 * 1024 // 64K
+	ConnDialTimeout = 5 * time.Second
+	ConnDeadline    = 5 * time.Second
+	ProbeTimeout    = 5 * time.Second
+)
+
+// Now90000 - timestamp for Video (clock rate = 90000 samples per second)
+func Now90000() uint32 {
+	return uint32(time.Duration(time.Now().UnixNano()) * 90000 / time.Second)
+}
+
+const symbols = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_"
+
+// RandString base10 - numbers, base16 - hex, base36 - digits+letters
+// base64 - URL safe symbols, base0 - crypto random
+func RandString(size, base byte) string {
+	b := make([]byte, size)
+	if _, err := rand.Read(b); err != nil {
+		panic(err)
+	}
+	if base == 0 {
+		return string(b)
+	}
+	for i := byte(0); i < size; i++ {
+		b[i] = symbols[b[i]%base]
+	}
+	return string(b)
+}
+
+func Before(s, sep string) string {
+	if i := strings.Index(s, sep); i > 0 {
+		return s[:i]
+	}
+	return s
+}
+
+func Between(s, sub1, sub2 string) string {
+	i := strings.Index(s, sub1)
+	if i < 0 {
+		return ""
+	}
+	s = s[i+len(sub1):]
+
+	if i = strings.Index(s, sub2); i >= 0 {
+		return s[:i]
+	}
+
+	return s
+}
+
+func Atoi(s string) (i int) {
+	if s != "" {
+		i, _ = strconv.Atoi(s)
+	}
+	return
+}
+
+// ParseByte - fast parsing string to byte function
+func ParseByte(s string) (b byte) {
+	for i, ch := range []byte(s) {
+		ch -= '0'
+		if ch > 9 {
+			return 0
+		}
+		if i > 0 {
+			b *= 10
+		}
+		b += ch
+	}
+	return
+}
+
+func Assert(ok bool) {
+	if !ok {
+		_, file, line, _ := runtime.Caller(1)
+		panic(file + ":" + strconv.Itoa(line))
+	}
+}
+
+func Caller() string {
+	_, file, line, _ := runtime.Caller(1)
+	return file + ":" + strconv.Itoa(line)
+}
diff --git a/installs_on_host/go2rtc/pkg/core/listener.go b/installs_on_host/go2rtc/pkg/core/listener.go
new file mode 100644
index 0000000..75d9202
--- /dev/null
+++ b/installs_on_host/go2rtc/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)
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/core/media.go b/installs_on_host/go2rtc/pkg/core/media.go
new file mode 100644
index 0000000..367d8cb
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/core/media.go
@@ -0,0 +1,211 @@
+package core
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/pion/sdp/v3"
+)
+
+// 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.String()
+
+		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 (m *Media) Equal(media *Media) bool {
+	if media.ID != "" {
+		return m.ID == media.ID
+	}
+	return m.String() == media.String()
+}
+
+func GetKind(name string) string {
+	switch name {
+	case CodecH264, CodecH265, CodecVP8, CodecVP9, CodecAV1, CodecJPEG, CodecRAW:
+		return KindVideo
+	case CodecPCMU, CodecPCMA, CodecAAC, CodecOpus, CodecG722, CodecMP3, CodecPCM, CodecPCML, CodecELD, CodecFLAC:
+		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]
+
+		switch codec.Name {
+		case CodecELD:
+			name = CodecAAC
+		case CodecPCML:
+			name = CodecPCM // beacuse we using pcm.LittleToBig for RTSP server
+		default:
+			name = codec.Name
+		}
+
+		md := &sdp.MediaDescription{
+			MediaName: sdp.MediaName{
+				Media:  media.Kind,
+				Protos: []string{"RTP", "AVP"},
+			},
+		}
+		md.WithCodec(codec.PayloadType, name, codec.ClockRate, uint16(codec.Channels), codec.FmtpLine)
+
+		if media.Direction != "" {
+			md.WithPropertyAttribute(media.Direction)
+		}
+
+		if media.ID != "" {
+			md.WithValueAttribute("control", media.ID)
+		}
+
+		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
+}
diff --git a/installs_on_host/go2rtc/pkg/core/media_test.go b/installs_on_host/go2rtc/pkg/core/media_test.go
new file mode 100644
index 0000000..f2f05e6
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/core/media_test.go
@@ -0,0 +1,64 @@
+package core
+
+import (
+	"fmt"
+	"net/url"
+	"testing"
+
+	"github.com/pion/sdp/v3"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+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: DirectionSendonly, 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)
+}
diff --git a/installs_on_host/go2rtc/pkg/core/node.go b/installs_on_host/go2rtc/pkg/core/node.go
new file mode 100644
index 0000000..a9959c3
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/core/node.go
@@ -0,0 +1,88 @@
+package core
+
+import (
+	"sync"
+
+	"github.com/pion/rtp"
+)
+
+//type Packet struct {
+//	Payload     []byte
+//	Timestamp   uint32 // PTS if DTS == 0 else DTS
+//	Composition uint32 // CTS = PTS-DTS (for support B-frames)
+//	Sequence    uint16
+//}
+
+type Packet = rtp.Packet
+
+// HandlerFunc - process input packets (just like http.HandlerFunc)
+type HandlerFunc func(packet *Packet)
+
+// Filter - a decorator for any HandlerFunc
+type Filter func(handler HandlerFunc) HandlerFunc
+
+// Node - Receiver or Sender or Filter (transform)
+type Node struct {
+	Codec  *Codec
+	Input  HandlerFunc
+	Output HandlerFunc
+
+	id     uint32
+	childs []*Node
+	parent *Node
+
+	mu sync.Mutex
+}
+
+func (n *Node) WithParent(parent *Node) *Node {
+	parent.AppendChild(n)
+	return n
+}
+
+func (n *Node) AppendChild(child *Node) {
+	n.mu.Lock()
+	n.childs = append(n.childs, child)
+	n.mu.Unlock()
+
+	child.parent = n
+}
+
+func (n *Node) RemoveChild(child *Node) {
+	n.mu.Lock()
+	for i, ch := range n.childs {
+		if ch == child {
+			n.childs = append(n.childs[:i], n.childs[i+1:]...)
+			break
+		}
+	}
+	n.mu.Unlock()
+}
+
+func (n *Node) Close() {
+	if parent := n.parent; parent != nil {
+		parent.RemoveChild(n)
+
+		if len(parent.childs) == 0 {
+			parent.Close()
+		}
+	} else {
+		for _, childs := range n.childs {
+			childs.Close()
+		}
+	}
+}
+
+func MoveNode(dst, src *Node) {
+	src.mu.Lock()
+	childs := src.childs
+	src.childs = nil
+	src.mu.Unlock()
+
+	dst.mu.Lock()
+	dst.childs = childs
+	dst.mu.Unlock()
+
+	for _, child := range childs {
+		child.parent = dst
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/core/readbuffer.go b/installs_on_host/go2rtc/pkg/core/readbuffer.go
new file mode 100644
index 0000000..960f187
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/core/readbuffer.go
@@ -0,0 +1,114 @@
+package core
+
+import (
+	"errors"
+	"io"
+)
+
+// ProbeSize
+// in my tests MPEG-TS 40Mbit/s 4K-video require more than 1MB for probe
+const ProbeSize = 5 * 1024 * 1024 // 5MB
+
+const (
+	BufferDisable       = 0
+	BufferDrainAndClear = -1
+)
+
+// ReadBuffer support buffering and Seek over buffer
+// positive BufferSize will enable buffering mode
+// Seek to negative offset will clear buffer
+// Seek with a positive BufferSize will continue buffering after the last read from the buffer
+// Seek with a negative BufferSize will clear buffer after the last read from the buffer
+// Read more than BufferSize will raise error
+type ReadBuffer struct {
+	io.Reader
+
+	BufferSize int
+
+	buf []byte
+	pos int
+}
+
+func NewReadBuffer(rd io.Reader) *ReadBuffer {
+	if rs, ok := rd.(*ReadBuffer); ok {
+		return rs
+	}
+	return &ReadBuffer{Reader: rd}
+}
+
+func (r *ReadBuffer) Read(p []byte) (n int, err error) {
+	// with zero buffer - read as usual
+	if r.BufferSize == BufferDisable {
+		return r.Reader.Read(p)
+	}
+
+	// if buffer not empty - read from it
+	if r.pos < len(r.buf) {
+		n = copy(p, r.buf[r.pos:])
+		r.pos += n
+		return
+	}
+
+	// with negative buffer - empty it and read as usual
+	if r.BufferSize < 0 {
+		r.BufferSize = BufferDisable
+		r.buf = nil
+		r.pos = 0
+
+		return r.Reader.Read(p)
+	}
+
+	n, err = r.Reader.Read(p)
+	if len(r.buf)+n > r.BufferSize {
+		return 0, errors.New("probe reader overflow")
+	}
+	r.buf = append(r.buf, p[:n]...)
+	r.pos += n
+	return
+}
+
+func (r *ReadBuffer) Close() error {
+	if closer, ok := r.Reader.(io.Closer); ok {
+		return closer.Close()
+	}
+	return nil
+}
+
+func (r *ReadBuffer) Seek(offset int64, whence int) (int64, error) {
+	var pos int
+	switch whence {
+	case io.SeekStart:
+		pos = int(offset)
+	case io.SeekCurrent:
+		pos = r.pos + int(offset)
+	case io.SeekEnd:
+		pos = len(r.buf) + int(offset)
+	}
+
+	// negative offset - empty buffer
+	if pos < 0 {
+		r.buf = nil
+		r.pos = 0
+	} else if pos >= len(r.buf) {
+		r.pos = len(r.buf)
+	} else {
+		r.pos = pos
+	}
+
+	return int64(r.pos), nil
+}
+
+func (r *ReadBuffer) Peek(n int) ([]byte, error) {
+	r.BufferSize = n
+	b := make([]byte, n)
+	if _, err := io.ReadAtLeast(r, b, n); err != nil {
+		return nil, err
+	}
+	r.Reset()
+	return b, nil
+}
+
+func (r *ReadBuffer) Reset() {
+	r.BufferSize = BufferDrainAndClear
+	r.pos = 0
+}
diff --git a/installs_on_host/go2rtc/pkg/core/readbuffer_test.go b/installs_on_host/go2rtc/pkg/core/readbuffer_test.go
new file mode 100644
index 0000000..0147217
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/core/readbuffer_test.go
@@ -0,0 +1,64 @@
+package core
+
+import (
+	"bytes"
+	"io"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestReadSeeker(t *testing.T) {
+	b := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
+	buf := bytes.NewReader(b)
+
+	rd := NewReadBuffer(buf)
+	rd.BufferSize = ProbeSize
+
+	// 1. Read to buffer
+	b = make([]byte, 3)
+	n, err := rd.Read(b)
+	require.Nil(t, err)
+	require.Equal(t, []byte{0, 1, 2}, b[:n])
+
+	// 2. Seek to start
+	_, err = rd.Seek(0, io.SeekStart)
+	require.Nil(t, err)
+
+	// 3. Read from buffer
+	b = make([]byte, 2)
+	n, err = rd.Read(b)
+	require.Nil(t, err)
+	require.Equal(t, []byte{0, 1}, b[:n])
+
+	// 4. Read from buffer
+	n, err = rd.Read(b)
+	require.Nil(t, err)
+	require.Equal(t, []byte{2}, b[:n])
+
+	// 5. Read to buffer
+	n, err = rd.Read(b)
+	require.Nil(t, err)
+	require.Equal(t, []byte{3, 4}, b[:n])
+
+	// 6. Seek to start
+	_, err = rd.Seek(0, io.SeekStart)
+	require.Nil(t, err)
+
+	// 7. Disable buffer
+	rd.BufferSize = -1
+
+	// 8. Read from buffer
+	b = make([]byte, 10)
+	n, err = rd.Read(b)
+	require.Nil(t, err)
+	require.Equal(t, []byte{0, 1, 2, 3, 4}, b[:n])
+
+	// 9. Direct read
+	n, err = rd.Read(b)
+	require.Nil(t, err)
+	require.Equal(t, []byte{5, 6, 7, 8, 9}, b[:n])
+
+	// 10. Check buffer empty
+	require.Nil(t, rd.buf)
+}
diff --git a/installs_on_host/go2rtc/pkg/core/slices.go b/installs_on_host/go2rtc/pkg/core/slices.go
new file mode 100644
index 0000000..747d813
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/core/slices.go
@@ -0,0 +1,43 @@
+package core
+
+// This code copied from go1.21 for backward support in go1.20.
+// We need to support go1.20 for Windows 7
+
+// Index returns the index of the first occurrence of v in s,
+// or -1 if not present.
+func Index[S ~[]E, E comparable](s S, v E) int {
+	for i := range s {
+		if v == s[i] {
+			return i
+		}
+	}
+	return -1
+}
+
+// Contains reports whether v is present in s.
+func Contains[S ~[]E, E comparable](s S, v E) bool {
+	return Index(s, v) >= 0
+}
+
+type Ordered interface {
+	~int | ~int8 | ~int16 | ~int32 | ~int64 |
+		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
+		~float32 | ~float64 |
+		~string
+}
+
+// Max returns the maximal value in x. It panics if x is empty.
+// For floating-point E, Max propagates NaNs (any NaN value in x
+// forces the output to be NaN).
+func Max[S ~[]E, E Ordered](x S) E {
+	if len(x) < 1 {
+		panic("slices.Max: empty list")
+	}
+	m := x[0]
+	for i := 1; i < len(x); i++ {
+		if x[i] > m {
+			m = x[i]
+		}
+	}
+	return m
+}
diff --git a/installs_on_host/go2rtc/pkg/core/track.go b/installs_on_host/go2rtc/pkg/core/track.go
new file mode 100644
index 0000000..f363a9f
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/core/track.go
@@ -0,0 +1,217 @@
+package core
+
+import (
+	"encoding/json"
+	"errors"
+
+	"github.com/pion/rtp"
+)
+
+var ErrCantGetTrack = errors.New("can't get track")
+
+type Receiver struct {
+	Node
+
+	// Deprecated: should be removed
+	Media *Media `json:"-"`
+	// Deprecated: should be removed
+	ID byte `json:"-"` // Channel for RTSP, PayloadType for MPEG-TS
+
+	Bytes   int `json:"bytes,omitempty"`
+	Packets int `json:"packets,omitempty"`
+}
+
+func NewReceiver(media *Media, codec *Codec) *Receiver {
+	r := &Receiver{
+		Node:  Node{id: NewID(), Codec: codec},
+		Media: media,
+	}
+	r.Input = func(packet *Packet) {
+		r.Bytes += len(packet.Payload)
+		r.Packets++
+		for _, child := range r.childs {
+			child.Input(packet)
+		}
+	}
+	return r
+}
+
+// Deprecated: should be removed
+func (r *Receiver) WriteRTP(packet *rtp.Packet) {
+	r.Input(packet)
+}
+
+// Deprecated: should be removed
+func (r *Receiver) Senders() []*Sender {
+	if len(r.childs) > 0 {
+		return []*Sender{{}}
+	} else {
+		return nil
+	}
+}
+
+// Deprecated: should be removed
+func (r *Receiver) Replace(target *Receiver) {
+	MoveNode(&target.Node, &r.Node)
+}
+
+func (r *Receiver) Close() {
+	r.Node.Close()
+}
+
+type Sender struct {
+	Node
+
+	// Deprecated:
+	Media *Media `json:"-"`
+	// Deprecated:
+	Handler HandlerFunc `json:"-"`
+
+	Bytes   int `json:"bytes,omitempty"`
+	Packets int `json:"packets,omitempty"`
+	Drops   int `json:"drops,omitempty"`
+
+	buf  chan *Packet
+	done chan struct{}
+}
+
+func NewSender(media *Media, codec *Codec) *Sender {
+	var bufSize uint16
+
+	if GetKind(codec.Name) == KindVideo {
+		if codec.IsRTP() {
+			// in my tests 40Mbit/s 4K-video can generate up to 1500 items
+			// for the h264.RTPDepay => RTPPay queue
+			bufSize = 4096
+		} else {
+			bufSize = 64
+		}
+	} else {
+		bufSize = 128
+	}
+
+	buf := make(chan *Packet, bufSize)
+	s := &Sender{
+		Node:  Node{id: NewID(), Codec: codec},
+		Media: media,
+		buf:   buf,
+	}
+	s.Input = func(packet *Packet) {
+		s.mu.Lock()
+		// unblock write to nil chan - OK, write to closed chan - panic
+		select {
+		case s.buf <- packet:
+			s.Bytes += len(packet.Payload)
+			s.Packets++
+		default:
+			s.Drops++
+		}
+		s.mu.Unlock()
+	}
+	s.Output = func(packet *Packet) {
+		s.Handler(packet)
+	}
+	return s
+}
+
+// Deprecated: should be removed
+func (s *Sender) HandleRTP(parent *Receiver) {
+	s.WithParent(parent)
+	s.Start()
+}
+
+// Deprecated: should be removed
+func (s *Sender) Bind(parent *Receiver) {
+	s.WithParent(parent)
+}
+
+func (s *Sender) WithParent(parent *Receiver) *Sender {
+	s.Node.WithParent(&parent.Node)
+	return s
+}
+
+func (s *Sender) Start() {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if s.buf == nil || s.done != nil {
+		return
+	}
+	s.done = make(chan struct{})
+
+	// pass buf directly so that it's impossible for buf to be nil
+	go func(buf chan *Packet) {
+		for packet := range buf {
+			s.Output(packet)
+		}
+		close(s.done)
+	}(s.buf)
+}
+
+func (s *Sender) Wait() {
+	if done := s.done; done != nil {
+		<-done
+	}
+}
+
+func (s *Sender) State() string {
+	if s.buf == nil {
+		return "closed"
+	}
+	if s.done == nil {
+		return "new"
+	}
+	return "connected"
+}
+
+func (s *Sender) Close() {
+	// close buffer if exists
+	s.mu.Lock()
+	if s.buf != nil {
+		close(s.buf) // exit from for range loop
+		s.buf = nil  // prevent writing to closed chan
+	}
+	s.mu.Unlock()
+
+	s.Node.Close()
+}
+
+func (r *Receiver) MarshalJSON() ([]byte, error) {
+	v := struct {
+		ID      uint32   `json:"id"`
+		Codec   *Codec   `json:"codec"`
+		Childs  []uint32 `json:"childs,omitempty"`
+		Bytes   int      `json:"bytes,omitempty"`
+		Packets int      `json:"packets,omitempty"`
+	}{
+		ID:      r.Node.id,
+		Codec:   r.Node.Codec,
+		Bytes:   r.Bytes,
+		Packets: r.Packets,
+	}
+	for _, child := range r.childs {
+		v.Childs = append(v.Childs, child.id)
+	}
+	return json.Marshal(v)
+}
+
+func (s *Sender) MarshalJSON() ([]byte, error) {
+	v := struct {
+		ID      uint32 `json:"id"`
+		Codec   *Codec `json:"codec"`
+		Parent  uint32 `json:"parent,omitempty"`
+		Bytes   int    `json:"bytes,omitempty"`
+		Packets int    `json:"packets,omitempty"`
+		Drops   int    `json:"drops,omitempty"`
+	}{
+		ID:      s.Node.id,
+		Codec:   s.Node.Codec,
+		Bytes:   s.Bytes,
+		Packets: s.Packets,
+		Drops:   s.Drops,
+	}
+	if s.parent != nil {
+		v.Parent = s.parent.id
+	}
+	return json.Marshal(v)
+}
diff --git a/installs_on_host/go2rtc/pkg/core/track_test.go b/installs_on_host/go2rtc/pkg/core/track_test.go
new file mode 100644
index 0000000..cf877d4
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/core/track_test.go
@@ -0,0 +1,53 @@
+package core
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestSenser(t *testing.T) {
+	recv := make(chan *Packet) // blocking receiver
+
+	sender := NewSender(nil, &Codec{})
+	sender.Output = func(packet *Packet) {
+		recv <- packet
+	}
+	require.Equal(t, "new", sender.State())
+
+	sender.Start()
+	require.Equal(t, "connected", sender.State())
+
+	sender.Input(&Packet{})
+	sender.Input(&Packet{})
+
+	require.Equal(t, 2, sender.Packets)
+	require.Equal(t, 0, sender.Drops)
+
+	// important to read one before close
+	// because goroutine in Start() can run with nil chan
+	// it's OK in real life, but bad for test
+	_, ok := <-recv
+	require.True(t, ok)
+
+	sender.Close()
+	require.Equal(t, "closed", sender.State())
+
+	sender.Input(&Packet{})
+
+	require.Equal(t, 2, sender.Packets)
+	require.Equal(t, 1, sender.Drops)
+
+	// read 2nd
+	_, ok = <-recv
+	require.True(t, ok)
+
+	// read 3rd
+	select {
+	case <-recv:
+		ok = true
+	default:
+		ok = false
+	}
+	require.False(t, ok)
+}
diff --git a/installs_on_host/go2rtc/pkg/core/waiter.go b/installs_on_host/go2rtc/pkg/core/waiter.go
new file mode 100644
index 0000000..c61e3be
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/core/waiter.go
@@ -0,0 +1,74 @@
+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
+	err   error
+}
+
+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() error {
+	w.mu.Lock()
+	// first wait auto start waiter
+	if w.state == 0 {
+		w.state++
+		w.WaitGroup.Add(1)
+	}
+	w.mu.Unlock()
+
+	w.WaitGroup.Wait()
+
+	return w.err
+}
+
+func (w *Waiter) Done(err error) {
+	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.err = err
+	}
+
+	w.mu.Unlock()
+}
+
+func (w *Waiter) WaitChan() <-chan error {
+	var ch chan error
+
+	w.mu.Lock()
+
+	if w.state >= 0 {
+		ch = make(chan error)
+		go func() {
+			ch <- w.Wait()
+		}()
+	}
+
+	w.mu.Unlock()
+
+	return ch
+}
diff --git a/installs_on_host/go2rtc/pkg/core/worker.go b/installs_on_host/go2rtc/pkg/core/worker.go
new file mode 100644
index 0000000..f013875
--- /dev/null
+++ b/installs_on_host/go2rtc/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:
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/core/writebuffer.go b/installs_on_host/go2rtc/pkg/core/writebuffer.go
new file mode 100644
index 0000000..50ad013
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/core/writebuffer.go
@@ -0,0 +1,114 @@
+package core
+
+import (
+	"bytes"
+	"io"
+	"net/http"
+	"sync"
+)
+
+// WriteBuffer by defaul Write(s) to bytes.Buffer.
+// But after WriteTo to new io.Writer - calls Reset.
+// Reset will flush current buffer data to new writer and starts to Write to new io.Writer
+// WriteTo will be locked until Write fails or Close will be called.
+type WriteBuffer struct {
+	io.Writer
+	err   error
+	mu    sync.Mutex
+	wg    sync.WaitGroup
+	state byte
+}
+
+func NewWriteBuffer(wr io.Writer) *WriteBuffer {
+	if wr == nil {
+		wr = bytes.NewBuffer(nil)
+	}
+	return &WriteBuffer{Writer: wr}
+}
+
+func (w *WriteBuffer) Write(p []byte) (n int, err error) {
+	w.mu.Lock()
+	if w.err != nil {
+		err = w.err
+	} else if n, err = w.Writer.Write(p); err != nil {
+		w.err = err
+		w.done()
+	} else if f, ok := w.Writer.(http.Flusher); ok {
+		f.Flush()
+	}
+	w.mu.Unlock()
+	return
+}
+
+func (w *WriteBuffer) WriteTo(wr io.Writer) (n int64, err error) {
+	w.Reset(wr)
+	w.wg.Wait()
+	return 0, w.err // TODO: fix counter
+}
+
+func (w *WriteBuffer) Close() error {
+	if closer, ok := w.Writer.(io.Closer); ok {
+		return closer.Close()
+	}
+	w.mu.Lock()
+	w.done()
+	w.mu.Unlock()
+	return nil
+}
+
+func (w *WriteBuffer) Reset(wr io.Writer) {
+	w.mu.Lock()
+	w.add()
+	if buf, ok := w.Writer.(*bytes.Buffer); ok && buf.Len() != 0 {
+		if _, err := io.Copy(wr, buf); err != nil {
+			w.err = err
+			w.done()
+		}
+	}
+	w.Writer = wr
+	w.mu.Unlock()
+}
+
+const (
+	none = iota
+	start
+	end
+)
+
+func (w *WriteBuffer) add() {
+	if w.state == none {
+		w.state = start
+		w.wg.Add(1)
+	}
+}
+
+func (w *WriteBuffer) done() {
+	if w.state == start {
+		w.state = end
+		w.wg.Done()
+	}
+}
+
+// OnceBuffer will catch only first message
+type OnceBuffer struct {
+	buf []byte
+}
+
+func (o *OnceBuffer) Write(p []byte) (n int, err error) {
+	if o.buf == nil {
+		o.buf = p
+	}
+	return 0, io.EOF
+}
+
+func (o *OnceBuffer) WriteTo(w io.Writer) (n int64, err error) {
+	return io.Copy(w, bytes.NewReader(o.buf))
+}
+
+func (o *OnceBuffer) Buffer() []byte {
+	return o.buf
+}
+
+func (o *OnceBuffer) Len() int {
+	return len(o.buf)
+}
diff --git a/installs_on_host/go2rtc/pkg/creds/README.md b/installs_on_host/go2rtc/pkg/creds/README.md
new file mode 100644
index 0000000..1909a20
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/creds/README.md
@@ -0,0 +1,7 @@
+# Credentials
+
+This module allows you to get variables:
+
+- from custom storage (ex. config file)
+- from [credential files](https://systemd.io/CREDENTIALS/)
+- from environment variables
diff --git a/installs_on_host/go2rtc/pkg/creds/creds.go b/installs_on_host/go2rtc/pkg/creds/creds.go
new file mode 100644
index 0000000..84bc275
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/creds/creds.go
@@ -0,0 +1,79 @@
+package creds
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+type Storage interface {
+	SetValue(name, value string) error
+	GetValue(name string) (string, bool)
+}
+
+var storage Storage
+
+func SetStorage(s Storage) {
+	storage = s
+}
+
+func SetValue(name, value string) error {
+	if storage == nil {
+		return errors.New("credentials: storage not initialized")
+	}
+	if err := storage.SetValue(name, value); err != nil {
+		return err
+	}
+	AddSecret(value)
+	return nil
+}
+
+func GetValue(name string) (value string, ok bool) {
+	value, ok = getValue(name)
+	AddSecret(value)
+	return
+}
+
+func getValue(name string) (string, bool) {
+	if storage != nil {
+		if value, ok := storage.GetValue(name); ok {
+			return value, true
+		}
+	}
+
+	if dir, ok := os.LookupEnv("CREDENTIALS_DIRECTORY"); ok {
+		if value, _ := os.ReadFile(filepath.Join(dir, name)); value != nil {
+			return strings.TrimSpace(string(value)), true
+		}
+	}
+
+	return os.LookupEnv(name)
+}
+
+// ReplaceVars - support format ${CAMERA_PASSWORD} and ${RTSP_USER:admin}
+func ReplaceVars(data []byte) []byte {
+	re := regexp.MustCompile(`\${([^}{]+)}`)
+	return re.ReplaceAllFunc(data, func(match []byte) []byte {
+		key := string(match[2 : len(match)-1])
+
+		var def string
+		var defok bool
+
+		if i := strings.IndexByte(key, ':'); i > 0 {
+			key, def = key[:i], key[i+1:]
+			defok = true
+		}
+
+		if value, ok := GetValue(key); ok {
+			return []byte(value)
+		}
+
+		if defok {
+			return []byte(def)
+		}
+
+		return match
+	})
+}
diff --git a/installs_on_host/go2rtc/pkg/creds/secrets.go b/installs_on_host/go2rtc/pkg/creds/secrets.go
new file mode 100644
index 0000000..95ab482
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/creds/secrets.go
@@ -0,0 +1,94 @@
+package creds
+
+import (
+	"io"
+	"net/http"
+	"regexp"
+	"slices"
+	"strings"
+	"sync"
+)
+
+func AddSecret(value string) {
+	if value == "" {
+		return
+	}
+
+	secretsMu.Lock()
+	defer secretsMu.Unlock()
+
+	if slices.Contains(secrets, value) {
+		return
+	}
+
+	secrets = append(secrets, value)
+	secretsReplacer = nil
+}
+
+var secrets []string
+var secretsMu sync.Mutex
+var secretsReplacer *strings.Replacer
+var userinfoRegexp *regexp.Regexp
+
+func getReplacer() *strings.Replacer {
+	secretsMu.Lock()
+	defer secretsMu.Unlock()
+
+	if secretsReplacer == nil {
+		oldnew := make([]string, 0, 2*len(secrets))
+		for _, s := range secrets {
+			oldnew = append(oldnew, s, "***")
+		}
+		secretsReplacer = strings.NewReplacer(oldnew...)
+	}
+
+	if userinfoRegexp == nil {
+		userinfoRegexp = regexp.MustCompile(`://[` + userinfo + `]+@`)
+	}
+
+	return secretsReplacer
+}
+
+// Uniform Resource Identifier (URI)
+// https://datatracker.ietf.org/doc/html/rfc3986
+const (
+	unreserved = `A-Za-z0-9-._~`
+	subdelims  = `!$&'()*+,;=`
+	userinfo   = unreserved + subdelims + `%:`
+)
+
+func SecretString(s string) string {
+	re := getReplacer()
+	s = userinfoRegexp.ReplaceAllString(s, `://***@`)
+	return re.Replace(s)
+}
+
+func SecretWrite(w io.Writer, s string) (n int, err error) {
+	re := getReplacer()
+	s = userinfoRegexp.ReplaceAllString(s, `://***@`)
+	return re.WriteString(w, s)
+}
+
+func SecretWriter(w io.Writer) io.Writer {
+	return &secretWriter{w}
+}
+
+type secretWriter struct {
+	w io.Writer
+}
+
+func (s *secretWriter) Write(b []byte) (int, error) {
+	return SecretWrite(s.w, string(b))
+}
+
+func SecretResponse(w http.ResponseWriter) http.ResponseWriter {
+	return &secretResponse{w}
+}
+
+type secretResponse struct {
+	http.ResponseWriter
+}
+
+func (s *secretResponse) Write(b []byte) (int, error) {
+	return SecretWrite(s.ResponseWriter, string(b))
+}
diff --git a/installs_on_host/go2rtc/pkg/creds/secrets_test.go b/installs_on_host/go2rtc/pkg/creds/secrets_test.go
new file mode 100644
index 0000000..83f1908
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/creds/secrets_test.go
@@ -0,0 +1,15 @@
+package creds
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestString(t *testing.T) {
+	AddSecret("admin")
+	AddSecret("pa$$word")
+
+	s := SecretString("rtsp://admin:pa$$word@192.168.1.123/stream1")
+	require.Equal(t, "rtsp://***:***@192.168.1.123/stream1", s)
+}
diff --git a/installs_on_host/go2rtc/pkg/debug/conn.go b/installs_on_host/go2rtc/pkg/debug/conn.go
new file mode 100644
index 0000000..6261cb7
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/debug/conn.go
@@ -0,0 +1,47 @@
+package debug
+
+import (
+	"bytes"
+	"math/rand"
+	"net"
+)
+
+type badConn struct {
+	net.Conn
+	delay int
+	buf   []byte
+}
+
+func NewBadConn(conn net.Conn) net.Conn {
+	return &badConn{Conn: conn}
+}
+
+const (
+	missChance  = 0.05
+	delayChance = 0.1
+)
+
+func (c *badConn) Read(b []byte) (n int, err error) {
+	if rand.Float32() < missChance {
+		if _, err = c.Conn.Read(b); err != nil {
+			return
+		}
+		//log.Printf("bad conn: miss")
+	}
+
+	if c.delay > 0 {
+		if c.delay--; c.delay == 0 {
+			n = copy(b, c.buf)
+			return
+		}
+	} else if rand.Float32() < delayChance {
+		if n, err = c.Conn.Read(b); err != nil {
+			return
+		}
+		c.delay = 1 + rand.Intn(5)
+		c.buf = bytes.Clone(b[:n])
+		//log.Printf("bad conn: delay %d", c.delay)
+	}
+
+	return c.Conn.Read(b)
+}
diff --git a/installs_on_host/go2rtc/pkg/debug/debug.go b/installs_on_host/go2rtc/pkg/debug/debug.go
new file mode 100644
index 0000000..ff6ccce
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/debug/debug.go
@@ -0,0 +1,58 @@
+package debug
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/pion/rtp"
+)
+
+func Logger(include func(packet *rtp.Packet) bool) func(packet *rtp.Packet) {
+	var lastTime = time.Now()
+	var lastTS uint32
+
+	var secCnt int
+	var secSize int
+	var secTS uint32
+	var secTime time.Time
+
+	return func(packet *rtp.Packet) {
+		if include != nil && !include(packet) {
+			return
+		}
+
+		now := time.Now()
+
+		fmt.Printf(
+			"%s: size=%6d ts=%10d type=%2d ssrc=%d seq=%5d mark=%t dts=%4d dtime=%3dms\n",
+			now.Format("15:04:05.000"),
+			len(packet.Payload), packet.Timestamp, packet.PayloadType, packet.SSRC, packet.SequenceNumber, packet.Marker,
+			packet.Timestamp-lastTS, now.Sub(lastTime).Milliseconds(),
+		)
+
+		lastTS = packet.Timestamp
+		lastTime = now
+
+		if secTS == 0 {
+			secTS = lastTS
+			secTime = now
+			return
+		}
+
+		if dt := now.Sub(secTime); dt > time.Second {
+			fmt.Printf(
+				"%s: size=%6d cnt=%d dts=%d dtime=%3dms\n",
+				now.Format("15:04:05.000"),
+				secSize, secCnt, lastTS-secTS, dt.Milliseconds(),
+			)
+
+			secCnt = 0
+			secSize = 0
+			secTS = lastTS
+			secTime = now
+		}
+
+		secCnt++
+		secSize += len(packet.Payload)
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/doorbird/backchannel.go b/installs_on_host/go2rtc/pkg/doorbird/backchannel.go
new file mode 100644
index 0000000..4d25222
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/doorbird/backchannel.go
@@ -0,0 +1,95 @@
+package doorbird
+
+import (
+	"fmt"
+	"net"
+	"net/url"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+)
+
+type Client struct {
+	core.Connection
+	conn net.Conn
+}
+
+func Dial(rawURL string) (*Client, error) {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	user := u.User.Username()
+	pass, _ := u.User.Password()
+
+	if u.Port() == "" {
+		u.Host += ":80"
+	}
+
+	conn, err := net.DialTimeout("tcp", u.Host, core.ConnDialTimeout)
+	if err != nil {
+		return nil, err
+	}
+
+	s := fmt.Sprintf("POST /bha-api/audio-transmit.cgi?http-user=%s&http-password=%s HTTP/1.0\r\n", user, pass) +
+		"Content-Type: audio/basic\r\n" +
+		"Content-Length: 9999999\r\n" +
+		"Connection: Keep-Alive\r\n" +
+		"Cache-Control: no-cache\r\n" +
+		"\r\n"
+
+	_ = conn.SetWriteDeadline(time.Now().Add(core.ConnDeadline))
+	if _, err = conn.Write([]byte(s)); err != nil {
+		return nil, err
+	}
+
+	medias := []*core.Media{
+		{
+			Kind:      core.KindAudio,
+			Direction: core.DirectionSendonly,
+			Codecs: []*core.Codec{
+				{Name: core.CodecPCMU, ClockRate: 8000},
+			},
+		},
+	}
+
+	return &Client{
+		core.Connection{
+			ID:         core.NewID(),
+			FormatName: "doorbird",
+			Protocol:   "http",
+			URL:        rawURL,
+			Medias:     medias,
+			Transport:  conn,
+		},
+		conn,
+	}, nil
+}
+
+func (c *Client) GetTrack(media *core.Media, codec *core.Codec) (*core.Receiver, error) {
+	return nil, core.ErrCantGetTrack
+}
+
+func (c *Client) AddTrack(media *core.Media, codec *core.Codec, track *core.Receiver) error {
+	sender := core.NewSender(media, track.Codec)
+
+	sender.Handler = func(pkt *rtp.Packet) {
+		_ = c.conn.SetWriteDeadline(time.Now().Add(core.ConnDeadline))
+		if n, err := c.conn.Write(pkt.Payload); err == nil {
+			c.Send += n
+		}
+	}
+
+	sender.HandleRTP(track)
+	c.Senders = append(c.Senders, sender)
+	return nil
+}
+
+func (c *Client) Start() (err error) {
+	// just block until c.conn closed
+	b := make([]byte, 1)
+	_, err = c.conn.Read(b)
+	return
+}
diff --git a/installs_on_host/go2rtc/pkg/dvrip/backchannel.go b/installs_on_host/go2rtc/pkg/dvrip/backchannel.go
new file mode 100644
index 0000000..0424e96
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/dvrip/backchannel.go
@@ -0,0 +1,79 @@
+package dvrip
+
+import (
+	"encoding/binary"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+)
+
+type Backchannel struct {
+	core.Connection
+	client *Client
+}
+
+func (c *Backchannel) GetTrack(media *core.Media, codec *core.Codec) (*core.Receiver, error) {
+	return nil, core.ErrCantGetTrack
+}
+
+func (c *Backchannel) Start() error {
+	if err := c.client.conn.SetReadDeadline(time.Time{}); err != nil {
+		return err
+	}
+
+	b := make([]byte, 4096)
+	for {
+		if _, err := c.client.rd.Read(b); err != nil {
+			return err
+		}
+	}
+}
+
+func (c *Backchannel) AddTrack(media *core.Media, _ *core.Codec, track *core.Receiver) error {
+	if err := c.client.Talk(); err != nil {
+		return err
+	}
+
+	const PacketSize = 320
+
+	buf := make([]byte, 8+PacketSize)
+	binary.BigEndian.PutUint32(buf, 0x1FA)
+
+	switch track.Codec.Name {
+	case core.CodecPCMU:
+		buf[4] = 10
+	case core.CodecPCMA:
+		buf[4] = 14
+	}
+
+	//for i, rate := range sampleRates {
+	//	if rate == track.Codec.ClockRate {
+	//		buf[5] = byte(i) + 1
+	//		break
+	//	}
+	//}
+	buf[5] = 2 // ClockRate=8000
+
+	binary.LittleEndian.PutUint16(buf[6:], PacketSize)
+
+	var payload []byte
+
+	sender := core.NewSender(media, track.Codec)
+	sender.Handler = func(packet *rtp.Packet) {
+		payload = append(payload, packet.Payload...)
+
+		for len(payload) >= PacketSize {
+			buf = append(buf[:8], payload[:PacketSize]...)
+			if n, err := c.client.WriteCmd(OPTalkData, buf); err != nil {
+				c.Send += n
+			}
+
+			payload = payload[PacketSize:]
+		}
+	}
+
+	sender.HandleRTP(track)
+	c.Senders = append(c.Senders, sender)
+	return nil
+}
diff --git a/installs_on_host/go2rtc/pkg/dvrip/client.go b/installs_on_host/go2rtc/pkg/dvrip/client.go
new file mode 100644
index 0000000..0b48545
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/dvrip/client.go
@@ -0,0 +1,247 @@
+package dvrip
+
+import (
+	"bufio"
+	"bytes"
+	"crypto/md5"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"net/url"
+	"time"
+)
+
+const (
+	Login          = 1000
+	OPMonitorClaim = 1413
+	OPMonitorStart = 1410
+	OPTalkClaim    = 1434
+	OPTalkStart    = 1430
+	OPTalkData     = 1432
+)
+
+type Client struct {
+	conn    net.Conn
+	session uint32
+	seq     uint32
+	stream  string
+
+	rd  io.Reader
+	buf []byte
+}
+
+func (c *Client) Dial(rawURL string) (err error) {
+	u, err := url.Parse(rawURL)
+	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
+	}
+
+	if query := u.Query(); query.Get("backchannel") != "1" {
+		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,
+		)
+	}
+
+	c.rd = bufio.NewReader(c.conn)
+
+	if u.User != nil {
+		pass, _ := u.User.Password()
+		return c.Login(u.User.Username(), pass)
+	} else {
+		return c.Login("admin", "admin")
+	}
+}
+
+func (c *Client) Close() error {
+	return c.conn.Close()
+}
+
+func (c *Client) Login(user, pass string) (err error) {
+	data := fmt.Sprintf(
+		`{"EncryptType":"MD5","LoginType":"DVRIP-Web","PassWord":"%s","UserName":"%s"}`+"\x0A\x00",
+		SofiaHash(pass), user,
+	)
+
+	if _, err = c.WriteCmd(Login, []byte(data)); err != nil {
+		return
+	}
+
+	_, err = c.ReadJSON()
+	return
+}
+
+func (c *Client) Play() error {
+	format := `{"Name":"OPMonitor","SessionID":"0x%08X","OPMonitor":{"Action":"%s","Parameter":%s}}` + "\x0A\x00"
+
+	data := fmt.Sprintf(format, c.session, "Claim", c.stream)
+	if _, err := c.WriteCmd(OPMonitorClaim, []byte(data)); err != nil {
+		return err
+	}
+	if _, err := c.ReadJSON(); err != nil {
+		return err
+	}
+
+	data = fmt.Sprintf(format, c.session, "Start", c.stream)
+	_, err := c.WriteCmd(OPMonitorStart, []byte(data))
+	return err
+}
+
+func (c *Client) Talk() error {
+	format := `{"Name":"OPTalk","SessionID":"0x%08X","OPTalk":{"Action":"%s","AudioFormat":{"EncodeType":"G711_ALAW"}}}` + "\x0A\x00"
+
+	data := fmt.Sprintf(format, c.session, "Claim")
+	if _, err := c.WriteCmd(OPTalkClaim, []byte(data)); err != nil {
+		return err
+	}
+	if _, err := c.ReadJSON(); err != nil {
+		return err
+	}
+
+	data = fmt.Sprintf(format, c.session, "Start")
+	_, err := c.WriteCmd(OPTalkStart, []byte(data))
+	return err
+}
+
+func (c *Client) WriteCmd(cmd uint16, payload []byte) (n int, 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(payload)))
+	b = append(b, payload...)
+
+	c.seq++
+
+	if err = c.conn.SetWriteDeadline(time.Now().Add(time.Second * 5)); err != nil {
+		return 0, err
+	}
+
+	return c.conn.Write(b)
+}
+
+func (c *Client) ReadChunk() (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.rd, b); err != nil {
+		return
+	}
+
+	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.rd, b); err != nil {
+		return
+	}
+
+	return
+}
+
+func (c *Client) ReadPacket() (pType byte, payload []byte, err error) {
+	var b []byte
+
+	// many cameras may split packet to multiple chunks
+	// some rare cameras may put multiple packets to single chunk
+	for len(c.buf) < 16 {
+		if b, err = c.ReadChunk(); err != nil {
+			return 0, nil, err
+		}
+		c.buf = append(c.buf, b...)
+	}
+
+	if !bytes.HasPrefix(c.buf, []byte{0, 0, 1}) {
+		return 0, nil, fmt.Errorf("dvrip: wrong packet: %0.16x", c.buf)
+	}
+
+	var size int
+
+	switch pType = c.buf[3]; pType {
+	case 0xFC, 0xFE:
+		size = int(binary.LittleEndian.Uint32(c.buf[12:])) + 16
+	case 0xFD: // PFrame
+		size = int(binary.LittleEndian.Uint32(c.buf[4:])) + 8
+	case 0xFA, 0xF9:
+		size = int(binary.LittleEndian.Uint16(c.buf[6:])) + 8
+	default:
+		return 0, nil, fmt.Errorf("dvrip: unknown packet type: %X", pType)
+	}
+
+	for len(c.buf) < size {
+		if b, err = c.ReadChunk(); err != nil {
+			return 0, nil, err
+		}
+		c.buf = append(c.buf, b...)
+	}
+
+	payload = c.buf[:size]
+	c.buf = c.buf[size:]
+
+	return
+}
+
+type Response map[string]any
+
+func (c *Client) ReadJSON() (res Response, err error) {
+	b, err := c.ReadChunk()
+	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 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)
+}
diff --git a/installs_on_host/go2rtc/pkg/dvrip/dvrip.go b/installs_on_host/go2rtc/pkg/dvrip/dvrip.go
new file mode 100644
index 0000000..c4980a8
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/dvrip/dvrip.go
@@ -0,0 +1,39 @@
+package dvrip
+
+import "github.com/AlexxIT/go2rtc/pkg/core"
+
+func Dial(url string) (core.Producer, error) {
+	client := &Client{}
+	if err := client.Dial(url); err != nil {
+		return nil, err
+	}
+
+	conn := core.Connection{
+		ID:         core.NewID(),
+		FormatName: "dvrip",
+		Protocol:   "tcp",
+		RemoteAddr: client.conn.RemoteAddr().String(),
+		Transport:  client.conn,
+	}
+
+	if client.stream != "" {
+		prod := &Producer{Connection: conn, client: client}
+		if err := prod.probe(); err != nil {
+			return nil, err
+		}
+		return prod, nil
+	} else {
+		conn.Medias = []*core.Media{
+			{
+				Kind:      core.KindAudio,
+				Direction: core.DirectionSendonly,
+				Codecs: []*core.Codec{
+					// leave only one codec here for better compatibility with cameras
+					// https://github.com/AlexxIT/go2rtc/issues/1111
+					{Name: core.CodecPCMA, ClockRate: 8000, PayloadType: 8},
+				},
+			},
+		}
+		return &Backchannel{Connection: conn, client: client}, nil
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/dvrip/producer.go b/installs_on_host/go2rtc/pkg/dvrip/producer.go
new file mode 100644
index 0000000..4f49da1
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/dvrip/producer.go
@@ -0,0 +1,262 @@
+package dvrip
+
+import (
+	"encoding/base64"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/h264/annexb"
+	"github.com/AlexxIT/go2rtc/pkg/h265"
+	"github.com/pion/rtp"
+)
+
+type Producer struct {
+	core.Connection
+
+	client *Client
+
+	video, audio *core.Receiver
+
+	videoTS  uint32
+	videoDT  uint32
+	audioTS  uint32
+	audioSeq uint16
+}
+
+func (c *Producer) Start() error {
+	for {
+		pType, b, err := c.client.ReadPacket()
+		if err != nil {
+			return err
+		}
+
+		//log.Printf("[DVR] type: %d, len: %d", dataType, len(b))
+
+		switch pType {
+		case 0xFC, 0xFE, 0xFD:
+			if c.video == nil {
+				continue
+			}
+
+			var payload []byte
+			if pType != 0xFD {
+				payload = b[16:] // iframe
+			} else {
+				payload = b[8:] // pframe
+			}
+
+			c.videoTS += c.videoDT
+
+			packet := &rtp.Packet{
+				Header:  rtp.Header{Timestamp: c.videoTS},
+				Payload: annexb.EncodeToAVCC(payload),
+			}
+
+			//log.Printf("[AVC] %v, len: %d, ts: %10d", h265.Types(payload), len(payload), packet.Timestamp)
+
+			c.video.WriteRTP(packet)
+
+		case 0xFA: // audio
+			if c.audio == nil {
+				continue
+			}
+
+			payload := b[8:]
+
+			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.audio.WriteRTP(packet)
+
+		case 0xF9: // unknown
+
+		default:
+			println(fmt.Sprintf("dvrip: unknown packet type: %d", pType))
+		}
+	}
+}
+
+func (c *Producer) probe() error {
+	if err := c.client.Play(); err != nil {
+		return err
+	}
+
+	rd := core.NewReadBuffer(c.client.rd)
+	rd.BufferSize = core.ProbeSize
+	defer func() {
+		c.client.buf = nil
+		rd.Reset()
+	}()
+
+	c.client.rd = rd
+
+	// some awful cameras has VERY rare keyframes
+	// so we wait video+audio for default probe time
+	// and wait anything for 15 seconds
+	timeoutBoth := time.Now().Add(core.ProbeTimeout)
+	timeoutAny := time.Now().Add(time.Second * 15)
+
+	for {
+		if now := time.Now(); now.Before(timeoutBoth) {
+			if c.video != nil && c.audio != nil {
+				return nil
+			}
+		} else if now.Before(timeoutAny) {
+			if c.video != nil || c.audio != nil {
+				return nil
+			}
+		} else {
+			return errors.New("dvrip: can't probe medias")
+		}
+
+		tag, b, err := c.client.ReadPacket()
+		if err != nil {
+			return err
+		}
+
+		switch tag {
+		case 0xFC, 0xFE: // video
+			if c.video != nil {
+				continue
+			}
+
+			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)
+
+			payload := annexb.EncodeToAVCC(b[16:])
+			c.addVideoTrack(b[4], payload)
+
+		case 0xFA: // audio
+			if c.audio != nil {
+				continue
+			}
+
+			// the exact value of the start TS does not matter
+			c.audioTS = c.videoTS
+
+			c.addAudioTrack(b[4], b[5])
+		}
+	}
+}
+
+func (c *Producer) addVideoTrack(mediaCode byte, payload []byte) {
+	var codec *core.Codec
+	switch mediaCode {
+	case 0x02, 0x12:
+		codec = &core.Codec{
+			Name:        core.CodecH264,
+			ClockRate:   90000,
+			PayloadType: core.PayloadTypeRAW,
+			FmtpLine:    h264.GetFmtpLine(payload),
+		}
+
+	case 0x03, 0x13, 0x43, 0x53:
+		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.video = core.NewReceiver(media, codec)
+	c.Receivers = append(c.Receivers, c.video)
+}
+
+var sampleRates = []uint32{4000, 8000, 11025, 16000, 20000, 22050, 32000, 44100, 48000}
+
+func (c *Producer) 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.audio = core.NewReceiver(media, codec)
+	c.Receivers = append(c.Receivers, c.audio)
+}
+
+//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:       c.Recv,
+//	}
+//	return json.Marshal(info)
+//}
diff --git a/installs_on_host/go2rtc/pkg/eseecloud/eseecloud.go b/installs_on_host/go2rtc/pkg/eseecloud/eseecloud.go
new file mode 100644
index 0000000..05209d2
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/eseecloud/eseecloud.go
@@ -0,0 +1,180 @@
+package eseecloud
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"io"
+	"net/http"
+	"regexp"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264/annexb"
+	"github.com/pion/rtp"
+)
+
+type Producer struct {
+	core.Connection
+	rd *core.ReadBuffer
+
+	videoPT, audioPT uint8
+}
+
+func Dial(rawURL string) (core.Producer, error) {
+	rawURL, _ = strings.CutPrefix(rawURL, "eseecloud")
+	res, err := http.Get("http" + rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	prod, err := Open(res.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	if info, ok := prod.(core.Info); ok {
+		info.SetProtocol("http")
+		info.SetURL(rawURL)
+	}
+
+	return prod, nil
+}
+
+func Open(r io.Reader) (core.Producer, error) {
+	prod := &Producer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "eseecloud",
+			Transport:  r,
+		},
+		rd: core.NewReadBuffer(r),
+	}
+
+	if err := prod.probe(); err != nil {
+		return nil, err
+	}
+
+	return prod, nil
+}
+
+func (p *Producer) probe() error {
+	b, err := p.rd.Peek(1024)
+	if err != nil {
+		return err
+	}
+
+	i := bytes.Index(b, []byte("\r\n\r\n"))
+	if i == -1 {
+		return io.EOF
+	}
+
+	b = make([]byte, i+4)
+	_, _ = p.rd.Read(b)
+
+	re := regexp.MustCompile(`m=(video|audio) (\d+) (\w+)/(\d+)\S*`)
+	for _, item := range re.FindAllStringSubmatch(string(b), 2) {
+		p.SDP += item[0] + "\n"
+
+		switch item[3] {
+		case "H264", "H265":
+			p.Medias = append(p.Medias, &core.Media{
+				Kind:      core.KindVideo,
+				Direction: core.DirectionRecvonly,
+				Codecs: []*core.Codec{
+					{
+						Name:        item[3],
+						ClockRate:   90000,
+						PayloadType: core.PayloadTypeRAW,
+					},
+				},
+			})
+			p.videoPT = byte(core.Atoi(item[2]))
+
+		case "G711":
+			p.Medias = append(p.Medias, &core.Media{
+				Kind:      core.KindAudio,
+				Direction: core.DirectionRecvonly,
+				Codecs: []*core.Codec{
+					{
+						Name:      core.CodecPCMA,
+						ClockRate: 8000,
+					},
+				},
+			})
+			p.audioPT = byte(core.Atoi(item[2]))
+		}
+	}
+
+	return nil
+}
+
+func (p *Producer) Start() error {
+	receivers := make(map[uint8]*core.Receiver)
+
+	for _, receiver := range p.Receivers {
+		switch receiver.Codec.Kind() {
+		case core.KindVideo:
+			receivers[p.videoPT] = receiver
+		case core.KindAudio:
+			receivers[p.audioPT] = receiver
+		}
+	}
+
+	for {
+		pkt, err := p.readPacket()
+		if err != nil {
+			return err
+		}
+
+		if recv := receivers[pkt.PayloadType]; recv != nil {
+			switch recv.Codec.Name {
+			case core.CodecH264, core.CodecH265:
+				// timestamp = seconds x 1000000
+				pkt = &rtp.Packet{
+					Header: rtp.Header{
+						Timestamp: uint32(uint64(pkt.Timestamp) * 90000 / 1000000),
+					},
+					Payload: annexb.EncodeToAVCC(pkt.Payload),
+				}
+			case core.CodecPCMA:
+				pkt = &rtp.Packet{
+					Header: rtp.Header{
+						Version:        2,
+						SequenceNumber: pkt.SequenceNumber,
+						Timestamp:      uint32(uint64(pkt.Timestamp) * 8000 / 1000000),
+					},
+					Payload: pkt.Payload,
+				}
+			}
+			recv.WriteRTP(pkt)
+		}
+	}
+}
+
+func (p *Producer) readPacket() (*core.Packet, error) {
+	b := make([]byte, 8)
+
+	if _, err := io.ReadFull(p.rd, b); err != nil {
+		return nil, err
+	}
+
+	if b[0] != '$' {
+		return nil, errors.New("eseecloud: wrong start byte")
+	}
+
+	size := binary.BigEndian.Uint32(b[4:])
+	b = make([]byte, size)
+	if _, err := io.ReadFull(p.rd, b); err != nil {
+		return nil, err
+	}
+
+	pkt := &core.Packet{}
+	if err := pkt.Unmarshal(b); err != nil {
+		return nil, err
+	}
+
+	p.Recv += int(size)
+
+	return pkt, nil
+}
diff --git a/installs_on_host/go2rtc/pkg/expr/expr.go b/installs_on_host/go2rtc/pkg/expr/expr.go
new file mode 100644
index 0000000..e82551b
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/expr/expr.go
@@ -0,0 +1,166 @@
+package expr
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/cookiejar"
+	"net/url"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/vm"
+)
+
+func newRequest(rawURL string, options map[string]any) (*http.Request, error) {
+	var method, contentType string
+	var rd io.Reader
+
+	// method from js fetch
+	if s, ok := options["method"].(string); ok {
+		method = s
+	} else {
+		method = "GET"
+	}
+
+	// params key from python requests
+	if kv, ok := options["params"].(map[string]any); ok {
+		rawURL += "?" + url.Values(kvToString(kv)).Encode()
+	}
+
+	// json key from python requests
+	// data key from python requests
+	// body key from js fetch
+	if v, ok := options["json"]; ok {
+		b, err := json.Marshal(v)
+		if err != nil {
+			return nil, err
+		}
+		contentType = "application/json"
+		rd = bytes.NewReader(b)
+	} else if kv, ok := options["data"].(map[string]any); ok {
+		contentType = "application/x-www-form-urlencoded"
+		rd = strings.NewReader(url.Values(kvToString(kv)).Encode())
+	} else if s, ok := options["body"].(string); ok {
+		rd = strings.NewReader(s)
+	}
+
+	req, err := http.NewRequest(method, rawURL, rd)
+	if err != nil {
+		return nil, err
+	}
+
+	if kv, ok := options["headers"].(map[string]any); ok {
+		req.Header = kvToString(kv)
+	}
+
+	if contentType != "" && req.Header.Get("Content-Type") == "" {
+		req.Header.Set("Content-Type", contentType)
+	}
+
+	return req, nil
+}
+
+func kvToString(kv map[string]any) map[string][]string {
+	dst := make(map[string][]string, len(kv))
+	for k, v := range kv {
+		dst[k] = []string{fmt.Sprintf("%v", v)}
+	}
+	return dst
+}
+
+func regExp(params ...any) (*regexp.Regexp, error) {
+	exp := params[0].(string)
+	if len(params) >= 2 {
+		// support:
+		//   i  case-insensitive (default false)
+		//   m  multi-line mode: ^ and $ match begin/end line (default false)
+		//   s  let . match \n (default false)
+		// https://pkg.go.dev/regexp/syntax
+		flags := params[1].(string)
+		exp = "(?" + flags + ")" + exp
+	}
+	return regexp.Compile(exp)
+}
+
+func Compile(input string) (*vm.Program, error) {
+	// support http sessions
+	jar, _ := cookiejar.New(nil)
+	client := http.Client{
+		Jar:     jar,
+		Timeout: 5 * time.Second,
+	}
+
+	return expr.Compile(
+		input,
+		expr.Function(
+			"fetch",
+			func(params ...any) (any, error) {
+				var req *http.Request
+				var err error
+
+				rawURL := params[0].(string)
+
+				if len(params) == 2 {
+					options := params[1].(map[string]any)
+					req, err = newRequest(rawURL, options)
+				} else {
+					req, err = http.NewRequest("GET", rawURL, nil)
+				}
+
+				if err != nil {
+					return nil, err
+				}
+
+				res, err := client.Do(req)
+				if err != nil {
+					return nil, err
+				}
+
+				b, _ := io.ReadAll(res.Body)
+
+				return map[string]any{
+					"ok":     res.StatusCode < 400,
+					"status": res.Status,
+					"text":   string(b),
+					"json": func() (v any) {
+						_ = json.Unmarshal(b, &v)
+						return
+					},
+				}, nil
+			},
+			//new(func(url string) map[string]any),
+			//new(func(url string, options map[string]any) map[string]any),
+		),
+		expr.Function(
+			"match",
+			func(params ...any) (any, error) {
+				re, err := regExp(params[1:]...)
+				if err != nil {
+					return nil, err
+				}
+				str := params[0].(string)
+				return re.FindStringSubmatch(str), nil
+			},
+			//new(func(str, expr string) []string),
+			//new(func(str, expr, flags string) []string),
+		),
+	)
+}
+
+func Eval(input string, env any) (any, error) {
+	program, err := Compile(input)
+	if err != nil {
+		return nil, err
+	}
+
+	return expr.Run(program, env)
+}
+
+func Run(program *vm.Program, env any) (any, error) {
+	return vm.Run(program, env)
+}
diff --git a/installs_on_host/go2rtc/pkg/expr/expr_test.go b/installs_on_host/go2rtc/pkg/expr/expr_test.go
new file mode 100644
index 0000000..096afcd
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/expr/expr_test.go
@@ -0,0 +1,17 @@
+package expr
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestMatchHost(t *testing.T) {
+	v, err := Eval(`
+let url = "rtsp://user:pass@192.168.1.123/cam/realmonitor?...";
+let host = match(url, "//[^/]+")[0][2:];
+host
+`, nil)
+	require.Nil(t, err)
+	require.Equal(t, "user:pass@192.168.1.123", v)
+}
diff --git a/installs_on_host/go2rtc/pkg/ffmpeg/README.md b/installs_on_host/go2rtc/pkg/ffmpeg/README.md
new file mode 100644
index 0000000..157cfdf
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/ffmpeg/README.md
@@ -0,0 +1,68 @@
+## FFplay output
+
+[FFplay](https://stackoverflow.com/questions/27778678/what-are-mv-fd-aq-vq-sq-and-f-in-a-video-stream) `7.11 A-V:  0.003 fd=   1 aq=   21KB vq=  321KB sq=    0B f=0/0`:
+
+- `7.11` - master clock, is the time from start of the stream/video
+- `A-V` - av_diff, difference between audio and video timestamps
+- `fd` - frames dropped
+- `aq` - audio queue (0 - no delay)
+- `vq` - video queue (0 - no delay)
+- `sq` - subtitle queue
+- `f` - timestamp error correction rate (Not 100% sure)
+
+`M-V`, `M-A` means video stream only, audio stream only respectively.
+
+## Devices Windows
+
+```
+>ffmpeg -hide_banner -f dshow -list_options true -i video="VMware Virtual USB Video Device"
+[dshow @ 0000025695e52900] DirectShow video device options (from video devices)
+[dshow @ 0000025695e52900]  Pin "Record" (alternative pin name "0")
+[dshow @ 0000025695e52900]   pixel_format=yuyv422  min s=1280x720 fps=1 max s=1280x720 fps=10
+[dshow @ 0000025695e52900]   pixel_format=yuyv422  min s=1280x720 fps=1 max s=1280x720 fps=10 (tv, bt470bg/bt709/unknown, topleft)
+[dshow @ 0000025695e52900]   pixel_format=nv12  min s=1280x720 fps=1 max s=1280x720 fps=23
+[dshow @ 0000025695e52900]   pixel_format=nv12  min s=1280x720 fps=1 max s=1280x720 fps=23 (tv, bt470bg/bt709/unknown, topleft)
+```
+
+## Devices Mac
+
+```
+% ./ffmpeg -hide_banner -f avfoundation -list_devices true -i ""
+[AVFoundation indev @ 0x7f8b1f504d80] AVFoundation video devices:
+[AVFoundation indev @ 0x7f8b1f504d80] [0] FaceTime HD Camera
+[AVFoundation indev @ 0x7f8b1f504d80] [1] Capture screen 0
+[AVFoundation indev @ 0x7f8b1f504d80] AVFoundation audio devices:
+[AVFoundation indev @ 0x7f8b1f504d80] [0] Soundflower (2ch)
+[AVFoundation indev @ 0x7f8b1f504d80] [1] Built-in Microphone
+[AVFoundation indev @ 0x7f8b1f504d80] [2] Soundflower (64ch)
+```
+
+## Devices Linux
+
+```
+# ffmpeg -hide_banner -f v4l2 -list_formats all -i /dev/video0
+[video4linux2,v4l2 @ 0x7f7de7c58bc0] Raw       :     yuyv422 :           YUYV 4:2:2 : 640x480 160x120 176x144 320x176 320x240 352x288 432x240 544x288 640x360 752x416 800x448 800x600 864x480 960x544 960x720 1024x576 1184x656 1280x720 1280x960
+[video4linux2,v4l2 @ 0x7f7de7c58bc0] Compressed:       mjpeg :          Motion-JPEG : 640x480 160x120 176x144 320x176 320x240 352x288 432x240 544x288 640x360 752x416 800x448 800x600 864x480 960x544 960x720 1024x576 1184x656 1280x720 1280x960
+```
+
+## TTS
+
+```yaml
+streams:
+  tts: ffmpeg:#input=-readrate 1 -readrate_initial_burst 0.001 -f lavfi -i "flite=text='1 2 3 4 5 6 7 8 9 0'"#audio=pcma
+```
+
+## Useful links
+
+- https://superuser.com/questions/564402/explanation-of-x264-tune
+- https://stackoverflow.com/questions/33624016/why-sliced-thread-affect-so-much-on-realtime-encoding-using-ffmpeg-x264
+- https://codec.fandom.com/ru/wiki/X264_-_описание_ключей_кодирования
+- https://html5test.com/
+- https://trac.ffmpeg.org/wiki/Capture/Webcam
+- https://trac.ffmpeg.org/wiki/DirectShow
+- https://stackoverflow.com/questions/53207692/libav-mjpeg-encoding-and-huffman-table
+- https://github.com/tuupola/esp_video/blob/master/README.md
+- https://github.com/leandromoreira/ffmpeg-libav-tutorial
+- https://www.reddit.com/user/VeritablePornocopium/comments/okw130/ffmpeg_with_libfdk_aac_for_windows_x64/
+- https://slhck.info/video/2017/02/24/vbr-settings.html
+- [HomeKit audio samples problem](https://superuser.com/questions/1290996/non-monotonous-dts-with-igndts-flag)
diff --git a/installs_on_host/go2rtc/pkg/ffmpeg/ffmpeg.go b/installs_on_host/go2rtc/pkg/ffmpeg/ffmpeg.go
new file mode 100644
index 0000000..a7ca71c
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/ffmpeg/ffmpeg.go
@@ -0,0 +1,123 @@
+package ffmpeg
+
+import (
+	"bytes"
+	"strconv"
+	"strings"
+)
+
+// correlation of libavformat versions with ffmpeg versions
+const (
+	Version50 = "59. 16"
+	Version51 = "59. 27"
+	Version60 = "60.  3"
+	Version61 = "60. 16"
+	Version70 = "61.  1"
+)
+
+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}
+	Version string   // libavformat version, it's more reliable than the ffmpeg version
+
+	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) HasFilters(filters ...string) bool {
+	for _, f1 := range a.Filters {
+		for _, f2 := range filters {
+			if strings.HasPrefix(f1, f2) {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+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(' ')
+	// starting from FFmpeg 6.1 readrate=1 has default initial bust 0.5 sec
+	// it might make us miss the first couple seconds of the file
+	if strings.HasPrefix(a.Input, "-re ") && a.Version >= Version61 {
+		b.WriteString("-readrate_initial_burst 0.001 ")
+	}
+	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 len(a.Filters) > 0 {
+		for i, filter := range a.Filters {
+			if i == 0 {
+				b.WriteString(` -vf "`)
+			} else {
+				b.WriteByte(',')
+			}
+			b.WriteString(filter)
+		}
+		b.WriteByte('"')
+	}
+
+	b.WriteByte(' ')
+	b.WriteString(a.Output)
+
+	return b.String()
+}
+
+func ParseVersion(b []byte) (ffmpeg string, libavformat string) {
+	if len(b) > 100 {
+		// ffmpeg version n7.0-30-g8b0fe91754-20240520 Copyright (c) 2000-2024 the FFmpeg developers
+		if i := bytes.IndexByte(b[15:], ' '); i > 0 {
+			ffmpeg = string(b[15 : 15+i])
+		}
+
+		// libavformat    60. 16.100 / 60. 16.100
+		if i := strings.Index(string(b), "libavformat"); i > 0 {
+			libavformat = string(b[i+15 : i+25])
+		}
+	}
+	return
+}
diff --git a/installs_on_host/go2rtc/pkg/flussonic/flussonic.go b/installs_on_host/go2rtc/pkg/flussonic/flussonic.go
new file mode 100644
index 0000000..70b6e9d
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/flussonic/flussonic.go
@@ -0,0 +1,176 @@
+package flussonic
+
+import (
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/pkg/aac"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/iso"
+	"github.com/gorilla/websocket"
+	"github.com/pion/rtp"
+)
+
+type Producer struct {
+	core.Connection
+	conn *websocket.Conn
+
+	videoTrackID, audioTrackID     uint32
+	videoTimeScale, audioTimeScale float32
+}
+
+func Dial(source string) (core.Producer, error) {
+	url, _ := strings.CutPrefix(source, "flussonic:")
+	conn, _, err := websocket.DefaultDialer.Dial(url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	prod := &Producer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "flussonic",
+			Protocol:   core.Before(url, ":"), // wss
+			RemoteAddr: conn.RemoteAddr().String(),
+			URL:        url,
+			Transport:  conn,
+		},
+		conn: conn,
+	}
+
+	if err = prod.probe(); err != nil {
+		_ = conn.Close()
+		return nil, err
+	}
+
+	return prod, nil
+}
+
+func (p *Producer) probe() error {
+	var init struct {
+		//Metadata struct {
+		//	Tracks []struct {
+		//		Width   int    `json:"width,omitempty"`
+		//		Height  int    `json:"height,omitempty"`
+		//		Fps     int    `json:"fps,omitempty"`
+		//		Content string `json:"content"`
+		//		TrackId string `json:"trackId"`
+		//		Bitrate int    `json:"bitrate"`
+		//	} `json:"tracks"`
+		//} `json:"metadata"`
+		Tracks []struct {
+			Content string `json:"content"`
+			Id      uint32 `json:"id"`
+			Payload []byte `json:"payload"`
+		} `json:"tracks"`
+		//Type string `json:"type"`
+	}
+
+	if err := p.conn.ReadJSON(&init); err != nil {
+		return err
+	}
+
+	var timeScale uint32
+
+	for _, track := range init.Tracks {
+		atoms, _ := iso.DecodeAtoms(track.Payload)
+		for _, atom := range atoms {
+			switch atom := atom.(type) {
+			case *iso.AtomMdhd:
+				timeScale = atom.TimeScale
+			case *iso.AtomVideo:
+				switch atom.Name {
+				case "avc1":
+					codec := h264.AVCCToCodec(atom.Config)
+					p.Medias = append(p.Medias, &core.Media{
+						Kind:      core.KindVideo,
+						Direction: core.DirectionRecvonly,
+						Codecs:    []*core.Codec{codec},
+					})
+					p.videoTrackID = track.Id
+					p.videoTimeScale = float32(codec.ClockRate) / float32(timeScale)
+				}
+			case *iso.AtomAudio:
+				switch atom.Name {
+				case "mp4a":
+					codec := aac.ConfigToCodec(atom.Config)
+					p.Medias = append(p.Medias, &core.Media{
+						Kind:      core.KindAudio,
+						Direction: core.DirectionRecvonly,
+						Codecs:    []*core.Codec{codec},
+					})
+					p.audioTrackID = track.Id
+					p.audioTimeScale = float32(codec.ClockRate) / float32(timeScale)
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
+func (p *Producer) Start() error {
+	if err := p.conn.WriteMessage(websocket.TextMessage, []byte("resume")); err != nil {
+		return err
+	}
+
+	receivers := make(map[uint32]*core.Receiver)
+	timeScales := make(map[uint32]float32)
+
+	for _, receiver := range p.Receivers {
+		switch receiver.Codec.Kind() {
+		case core.KindVideo:
+			receivers[p.videoTrackID] = receiver
+			timeScales[p.videoTrackID] = p.videoTimeScale
+		case core.KindAudio:
+			receivers[p.audioTrackID] = receiver
+			timeScales[p.audioTrackID] = p.audioTimeScale
+		}
+	}
+
+	ch := make(chan []byte, 10)
+	defer close(ch)
+
+	go func() {
+		for b := range ch {
+			atoms, err := iso.DecodeAtoms(b)
+			if err != nil {
+				continue
+			}
+
+			var trackID uint32
+			var decodeTime uint64
+
+			for _, atom := range atoms {
+				switch atom := atom.(type) {
+				case *iso.AtomTfhd:
+					trackID = atom.TrackID
+				case *iso.AtomTfdt:
+					decodeTime = atom.DecodeTime
+				case *iso.AtomMdat:
+					b = atom.Data
+				}
+			}
+
+			if recv := receivers[trackID]; recv != nil {
+				timestamp := uint32(float32(decodeTime) * timeScales[trackID])
+				packet := &rtp.Packet{
+					Header:  rtp.Header{Timestamp: timestamp},
+					Payload: b,
+				}
+				recv.WriteRTP(packet)
+			}
+		}
+	}()
+
+	for {
+		mType, b, err := p.conn.ReadMessage()
+		if err != nil {
+			return err
+		}
+		if mType == websocket.BinaryMessage {
+			p.Recv += len(b)
+			ch <- b
+		}
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/flv/amf/amf.go b/installs_on_host/go2rtc/pkg/flv/amf/amf.go
new file mode 100644
index 0000000..eae05fc
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/flv/amf/amf.go
@@ -0,0 +1,239 @@
+package amf
+
+import (
+	"encoding/binary"
+	"errors"
+	"math"
+)
+
+const (
+	TypeNumber byte = iota
+	TypeBoolean
+	TypeString
+	TypeObject
+	TypeNull      = 5
+	TypeEcmaArray = 8
+	TypeObjectEnd = 9
+)
+
+// AMF spec: http://download.macromedia.com/pub/labs/amf/amf0_spec_121207.pdf
+type AMF struct {
+	buf []byte
+	pos int
+}
+
+var ErrRead = errors.New("amf: read error")
+
+func NewReader(b []byte) *AMF {
+	return &AMF{buf: b}
+}
+
+func (a *AMF) ReadItems() ([]any, error) {
+	var items []any
+	for a.pos < len(a.buf) {
+		v, err := a.ReadItem()
+		if err != nil {
+			return nil, err
+		}
+		items = append(items, v)
+	}
+	return items, nil
+}
+
+func (a *AMF) ReadItem() (any, error) {
+	dataType, err := a.ReadByte()
+	if err != nil {
+		return nil, err
+	}
+
+	switch dataType {
+	case TypeNumber:
+		return a.ReadNumber()
+
+	case TypeBoolean:
+		b, err := a.ReadByte()
+		return b != 0, err
+
+	case TypeString:
+		return a.ReadString()
+
+	case TypeObject:
+		return a.ReadObject()
+
+	case TypeEcmaArray:
+		return a.ReadEcmaArray()
+
+	case TypeNull:
+		return nil, nil
+
+	case TypeObjectEnd:
+		return nil, nil
+	}
+
+	return nil, ErrRead
+}
+
+func (a *AMF) ReadByte() (byte, error) {
+	if a.pos >= len(a.buf) {
+		return 0, ErrRead
+	}
+
+	v := a.buf[a.pos]
+	a.pos++
+	return v, nil
+}
+
+func (a *AMF) ReadNumber() (float64, error) {
+	if a.pos+8 > len(a.buf) {
+		return 0, ErrRead
+	}
+
+	v := binary.BigEndian.Uint64(a.buf[a.pos : a.pos+8])
+	a.pos += 8
+	return math.Float64frombits(v), nil
+}
+
+func (a *AMF) ReadString() (string, error) {
+	if a.pos+2 > len(a.buf) {
+		return "", ErrRead
+	}
+
+	size := int(binary.BigEndian.Uint16(a.buf[a.pos:]))
+	a.pos += 2
+
+	if a.pos+size > len(a.buf) {
+		return "", ErrRead
+	}
+
+	s := string(a.buf[a.pos : a.pos+size])
+	a.pos += size
+
+	return s, nil
+}
+
+func (a *AMF) 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 *AMF) ReadEcmaArray() (map[string]any, error) {
+	if a.pos+4 > len(a.buf) {
+		return nil, ErrRead
+	}
+	a.pos += 4 // skip size
+
+	return a.ReadObject()
+}
+
+func NewWriter() *AMF {
+	return &AMF{}
+}
+
+func (a *AMF) Bytes() []byte {
+	return a.buf
+}
+
+func (a *AMF) WriteNumber(n float64) {
+	b := math.Float64bits(n)
+	a.buf = append(
+		a.buf, TypeNumber,
+		byte(b>>56), byte(b>>48), byte(b>>40), byte(b>>32),
+		byte(b>>24), byte(b>>16), byte(b>>8), byte(b),
+	)
+}
+
+func (a *AMF) WriteBool(b bool) {
+	if b {
+		a.buf = append(a.buf, TypeBoolean, 1)
+	} else {
+		a.buf = append(a.buf, TypeBoolean, 0)
+	}
+}
+
+func (a *AMF) WriteString(s string) {
+	n := len(s)
+	a.buf = append(a.buf, TypeString, byte(n>>8), byte(n))
+	a.buf = append(a.buf, s...)
+}
+
+func (a *AMF) WriteObject(obj map[string]any) {
+	a.buf = append(a.buf, TypeObject)
+	a.writeKV(obj)
+	a.buf = append(a.buf, 0, 0, TypeObjectEnd)
+}
+
+func (a *AMF) WriteEcmaArray(obj map[string]any) {
+	n := len(obj)
+	a.buf = append(a.buf, TypeEcmaArray, byte(n>>24), byte(n>>16), byte(n>>8), byte(n))
+	a.writeKV(obj)
+	a.buf = append(a.buf, 0, 0, TypeObjectEnd)
+}
+
+func (a *AMF) writeKV(obj map[string]any) {
+	for k, v := range obj {
+		n := len(k)
+		a.buf = append(a.buf, byte(n>>8), byte(n))
+		a.buf = append(a.buf, k...)
+
+		switch v := v.(type) {
+		case string:
+			a.WriteString(v)
+		case int:
+			a.WriteNumber(float64(v))
+		case uint16:
+			a.WriteNumber(float64(v))
+		case uint32:
+			a.WriteNumber(float64(v))
+		case float64:
+			a.WriteNumber(v)
+		case bool:
+			a.WriteBool(v)
+		default:
+			panic(v)
+		}
+	}
+}
+
+func (a *AMF) WriteNull() {
+	a.buf = append(a.buf, TypeNull)
+}
+
+func EncodeItems(items ...any) []byte {
+	a := &AMF{}
+	for _, item := range items {
+		switch v := item.(type) {
+		case float64:
+			a.WriteNumber(v)
+		case int:
+			a.WriteNumber(float64(v))
+		case string:
+			a.WriteString(v)
+		case map[string]any:
+			a.WriteObject(v)
+		case nil:
+			a.WriteNull()
+		default:
+			panic(v)
+		}
+	}
+	return a.Bytes()
+}
diff --git a/installs_on_host/go2rtc/pkg/flv/amf/amf_test.go b/installs_on_host/go2rtc/pkg/flv/amf/amf_test.go
new file mode 100644
index 0000000..81e506d
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/flv/amf/amf_test.go
@@ -0,0 +1,281 @@
+package amf
+
+import (
+	"encoding/hex"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewReader(t *testing.T) {
+	tests := []struct {
+		name   string
+		actual string
+		expect []any
+	}{
+		{
+			name:   "ffmpeg-http",
+			actual: "02000a6f6e4d65746144617461080000001000086475726174696f6e000000000000000000000577696474680040940000000000000006686569676874004086800000000000000d766964656f646174617261746500409e62770000000000096672616d6572617465004038000000000000000c766964656f636f646563696400401c000000000000000d617564696f646174617261746500405ea93000000000000f617564696f73616d706c65726174650040e5888000000000000f617564696f73616d706c6573697a65004030000000000000000673746572656f0101000c617564696f636f6465636964004024000000000000000b6d616a6f725f6272616e640200046d703432000d6d696e6f725f76657273696f6e020001300011636f6d70617469626c655f6272616e647302000c69736f6d617663316d7034320007656e636f64657202000c4c61766636302e352e313030000866696c6573697a65000000000000000000000009",
+			expect: []any{
+				"onMetaData",
+				map[string]any{
+					"compatible_brands": "isomavc1mp42",
+					"major_brand":       "mp42",
+					"minor_version":     "0",
+					"encoder":           "Lavf60.5.100",
+
+					"filesize": float64(0),
+					"duration": float64(0),
+
+					"videocodecid":  float64(7),
+					"width":         float64(1280),
+					"height":        float64(720),
+					"framerate":     float64(24),
+					"videodatarate": 1944.6162109375,
+
+					"audiocodecid":    float64(10),
+					"audiosamplerate": float64(44100),
+					"stereo":          true,
+					"audiosamplesize": float64(16),
+					"audiodatarate":   122.6435546875,
+				},
+			},
+		},
+		{
+			name:   "ffmpeg-file",
+			actual: "02000a6f6e4d65746144617461080000000800086475726174696f6e004000000000000000000577696474680040940000000000000006686569676874004086800000000000000d766964656f646174617261746500000000000000000000096672616d6572617465004039000000000000000c766964656f636f646563696400401c0000000000000007656e636f64657202000c4c61766636302e352e313030000866696c6573697a6500411f541400000000000009",
+			expect: []any{
+				"onMetaData",
+				map[string]any{
+					"encoder": "Lavf60.5.100",
+
+					"filesize": float64(513285),
+					"duration": float64(2),
+
+					"videocodecid":  float64(7),
+					"width":         float64(1280),
+					"height":        float64(720),
+					"framerate":     float64(25),
+					"videodatarate": float64(0),
+				},
+			},
+		},
+		{
+			name:   "reolink-1",
+			actual: "0200075f726573756c74003ff0000000000000030006666d7356657202000d464d532f332c302c312c313233000c6361706162696c697469657300403f0000000000000000090300056c6576656c0200067374617475730004636f646502001d4e6574436f6e6e656374696f6e2e436f6e6e6563742e53756363657373000b6465736372697074696f6e020015436f6e6e656374696f6e207375636365656465642e000e6f626a656374456e636f64696e67000000000000000000000009",
+			expect: []any{
+				"_result", float64(1),
+				map[string]any{
+					"capabilities": float64(31),
+					"fmsVer":       "FMS/3,0,1,123",
+				},
+				map[string]any{
+					"code":           "NetConnection.Connect.Success",
+					"description":    "Connection succeeded.",
+					"level":          "status",
+					"objectEncoding": float64(0),
+				},
+			},
+		},
+		{
+			name:   "reolink-2",
+			actual: "0200075f726573756c7400400000000000000005003ff0000000000000",
+			expect: []any{
+				"_result", float64(2), nil, float64(1),
+			},
+		},
+		{
+			name:   "reolink-3",
+			actual: "0200086f6e537461747573000000000000000000050300056c6576656c0200067374617475730004636f64650200144e657453747265616d2e506c61792e5374617274000b6465736372697074696f6e020015537461727420766964656f206f6e2064656d616e64000009",
+			expect: []any{
+				"onStatus", float64(0), nil,
+				map[string]any{
+					"code":        "NetStream.Play.Start",
+					"description": "Start video on demand",
+					"level":       "status",
+				},
+			},
+		},
+		{
+			name:   "reolink-4",
+			actual: "0200117c52746d7053616d706c6541636365737301010101",
+			expect: []any{
+				"|RtmpSampleAccess", true, true,
+			},
+		},
+		{
+			name:   "reolink-5",
+			actual: "02000a6f6e4d6574614461746103000577696474680040a4000000000000000668656967687400409e000000000000000c646973706c617957696474680040a4000000000000000d646973706c617948656967687400409e00000000000000086475726174696f6e000000000000000000000c766964656f636f646563696400401c000000000000000c617564696f636f6465636964004024000000000000000f617564696f73616d706c65726174650040cf40000000000000096672616d657261746500403e000000000000000009",
+			expect: []any{
+				"onMetaData",
+				map[string]any{
+					"duration": float64(0),
+
+					"videocodecid":  float64(7),
+					"width":         float64(2560),
+					"height":        float64(1920),
+					"displayWidth":  float64(2560),
+					"displayHeight": float64(1920),
+					"framerate":     float64(30),
+
+					"audiocodecid":    float64(10),
+					"audiosamplerate": float64(16000),
+				},
+			},
+		},
+		{
+			name:   "mediamtx",
+			actual: "02000d40736574446174614672616d6502000a6f6e4d6574614461746103000d766964656f6461746172617465000000000000000000000c766964656f636f646563696400401c000000000000000d617564696f6461746172617465000000000000000000000c617564696f636f6465636964004024000000000000000009",
+			expect: []any{
+				"@setDataFrame",
+				"onMetaData",
+				map[string]any{
+					"videocodecid":  float64(7),
+					"videodatarate": float64(0),
+					"audiocodecid":  float64(10),
+					"audiodatarate": float64(0),
+				},
+			},
+		},
+		{
+			name:   "mediamtx",
+			actual: "0200075f726573756c74003ff0000000000000030006666d7356657202000d4c4e5820392c302c3132342c32000c6361706162696c697469657300403f0000000000000000090300056c6576656c0200067374617475730004636f646502001d4e6574436f6e6e656374696f6e2e436f6e6e6563742e53756363657373000b6465736372697074696f6e020015436f6e6e656374696f6e207375636365656465642e000e6f626a656374456e636f64696e67000000000000000000000009",
+			expect: []any{
+				"_result", float64(1), map[string]any{
+					"capabilities": float64(31),
+					"fmsVer":       "LNX 9,0,124,2",
+				}, map[string]any{
+					"code":           "NetConnection.Connect.Success",
+					"description":    "Connection succeeded.",
+					"level":          "status",
+					"objectEncoding": float64(0),
+				},
+			},
+		},
+		{
+			name:   "mediamtx",
+			actual: "0200075f726573756c7400401000000000000005003ff0000000000000",
+			expect: []any{"_result", float64(4), any(nil), float64(1)},
+		},
+		{
+			name:   "mediamtx",
+			actual: "0200086f6e537461747573004014000000000000050300056c6576656c0200067374617475730004636f64650200144e657453747265616d2e506c61792e5265736574000b6465736372697074696f6e02000a706c6179207265736574000009",
+			expect: []any{
+				"onStatus", float64(5), any(nil), map[string]any{
+					"code":        "NetStream.Play.Reset",
+					"description": "play reset",
+					"level":       "status",
+				},
+			},
+		},
+		{
+			name:   "mediamtx",
+			actual: "0200086f6e537461747573004014000000000000050300056c6576656c0200067374617475730004636f64650200144e657453747265616d2e506c61792e5374617274000b6465736372697074696f6e02000a706c6179207374617274000009",
+			expect: []any{
+				"onStatus", float64(5), any(nil), map[string]any{
+					"code":        "NetStream.Play.Start",
+					"description": "play start",
+					"level":       "status",
+				},
+			},
+		},
+		{
+			name:   "mediamtx",
+			actual: "0200086f6e537461747573004014000000000000050300056c6576656c0200067374617475730004636f64650200144e657453747265616d2e446174612e5374617274000b6465736372697074696f6e02000a64617461207374617274000009",
+			expect: []any{
+				"onStatus", float64(5), any(nil), map[string]any{
+					"code":        "NetStream.Data.Start",
+					"description": "data start",
+					"level":       "status",
+				},
+			},
+		},
+		{
+			name:   "mediamtx",
+			actual: "0200086f6e537461747573004014000000000000050300056c6576656c0200067374617475730004636f646502001c4e657453747265616d2e506c61792e5075626c6973684e6f74696679000b6465736372697074696f6e02000e7075626c697368206e6f74696679000009",
+			expect: []any{
+				"onStatus", float64(5), any(nil), map[string]any{
+					"code":        "NetStream.Play.PublishNotify",
+					"description": "publish notify",
+					"level":       "status",
+				},
+			},
+		},
+		{
+			name:   "obs-connect",
+			actual: "020007636f6e6e656374003ff000000000000003000361707002000c617070312f73747265616d3100047479706502000a6e6f6e70726976617465000e737570706f727473476f4177617901010008666c61736856657202001f464d4c452f332e302028636f6d70617469626c653b20464d53632f312e3029000673776655726c02002272746d703a2f2f3139322e3136382e31302e3130312f617070312f73747265616d310005746355726c02002272746d703a2f2f3139322e3136382e31302e3130312f617070312f73747265616d31000009",
+			expect: []any{
+				"connect", float64(1),
+				map[string]any{
+					"app":            "app1/stream1",
+					"flashVer":       "FMLE/3.0 (compatible; FMSc/1.0)",
+					"supportsGoAway": true,
+					"swfUrl":         "rtmp://192.168.10.101/app1/stream1",
+					"tcUrl":          "rtmp://192.168.10.101/app1/stream1",
+					"type":           "nonprivate",
+				},
+			},
+		},
+		{
+			name:   "obs-key",
+			actual: "02000d72656c6561736553747265616d004000000000000000050200046b657931",
+			expect: []any{
+				"releaseStream", float64(2), nil, "key1",
+			},
+		},
+		{
+			name:   "obs",
+			actual: "02000d40736574446174614672616d6502000a6f6e4d65746144617461080000001400086475726174696f6e000000000000000000000866696c6553697a65000000000000000000000577696474680040840000000000000006686569676874004076800000000000000c766964656f636f646563696400401c000000000000000d766964656f64617461726174650040a388000000000000096672616d6572617465004039000000000000000c617564696f636f6465636964004024000000000000000d617564696f6461746172617465004064000000000000000f617564696f73616d706c65726174650040e5888000000000000f617564696f73616d706c6573697a65004030000000000000000d617564696f6368616e6e656c73004000000000000000000673746572656f01010003322e3101000003332e3101000003342e3001000003342e3101000003352e3101000003372e3101000007656e636f6465720200376f62732d6f7574707574206d6f64756c6520286c69626f62732076657273696f6e2032392e302e302d36322d6739303031323131663829000009",
+			expect: []any{
+				"@setDataFrame", "onMetaData", map[string]any{
+					"2.1":             false,
+					"3.1":             false,
+					"4.0":             false,
+					"4.1":             false,
+					"5.1":             false,
+					"7.1":             false,
+					"audiochannels":   float64(2),
+					"audiocodecid":    float64(10),
+					"audiodatarate":   float64(160),
+					"audiosamplerate": float64(44100),
+					"audiosamplesize": float64(16),
+					"duration":        float64(0),
+					"encoder":         "obs-output module (libobs version 29.0.0-62-g9001211f8)",
+					"fileSize":        float64(0),
+					"framerate":       float64(25),
+					"height":          float64(360),
+					"stereo":          true,
+					"videocodecid":    float64(7),
+					"videodatarate":   float64(2500),
+					"width":           float64(640),
+				},
+			},
+		},
+		{
+			name:   "telegram-2",
+			actual: "0200075f726573756c7400400000000000000005",
+			expect: []any{
+				"_result", float64(2), nil,
+			},
+		},
+		{
+			name:   "telegram-4",
+			actual: "0200075f726573756c7400401000000000000005003ff0000000000000",
+			expect: []any{
+				"_result", float64(4), nil, float64(1),
+			},
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			b, err := hex.DecodeString(test.actual)
+			require.Nil(t, err)
+
+			rd := NewReader(b)
+			v, err := rd.ReadItems()
+			require.Nil(t, err)
+
+			require.Equal(t, test.expect, v)
+		})
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/flv/consumer.go b/installs_on_host/go2rtc/pkg/flv/consumer.go
new file mode 100644
index 0000000..fe966bf
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/flv/consumer.go
@@ -0,0 +1,94 @@
+package flv
+
+import (
+	"io"
+
+	"github.com/AlexxIT/go2rtc/pkg/aac"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/pion/rtp"
+)
+
+type Consumer struct {
+	core.Connection
+	wr    *core.WriteBuffer
+	muxer *Muxer
+}
+
+func NewConsumer() *Consumer {
+	medias := []*core.Media{
+		{
+			Kind:      core.KindVideo,
+			Direction: core.DirectionSendonly,
+			Codecs: []*core.Codec{
+				{Name: core.CodecH264},
+			},
+		},
+		{
+			Kind:      core.KindAudio,
+			Direction: core.DirectionSendonly,
+			Codecs: []*core.Codec{
+				{Name: core.CodecAAC},
+			},
+		},
+	}
+	wr := core.NewWriteBuffer(nil)
+	return &Consumer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "flv",
+			Medias:     medias,
+			Transport:  wr,
+		},
+		wr:    wr,
+		muxer: &Muxer{},
+	}
+}
+
+func (c *Consumer) AddTrack(media *core.Media, codec *core.Codec, track *core.Receiver) error {
+	sender := core.NewSender(media, track.Codec)
+
+	switch track.Codec.Name {
+	case core.CodecH264:
+		payload := c.muxer.GetPayloader(track.Codec)
+
+		sender.Handler = func(pkt *rtp.Packet) {
+			b := payload(pkt)
+			if n, err := c.wr.Write(b); err == nil {
+				c.Send += n
+			}
+		}
+
+		if track.Codec.IsRTP() {
+			sender.Handler = h264.RTPDepay(track.Codec, sender.Handler)
+		} else {
+			sender.Handler = h264.RepairAVCC(track.Codec, sender.Handler)
+		}
+
+	case core.CodecAAC:
+		payload := c.muxer.GetPayloader(track.Codec)
+
+		sender.Handler = func(pkt *rtp.Packet) {
+			b := payload(pkt)
+			if n, err := c.wr.Write(b); err == nil {
+				c.Send += n
+			}
+		}
+
+		if track.Codec.IsRTP() {
+			sender.Handler = aac.RTPDepay(sender.Handler)
+		}
+	}
+
+	sender.HandleRTP(track)
+	c.Senders = append(c.Senders, sender)
+	return nil
+}
+
+func (c *Consumer) WriteTo(wr io.Writer) (int64, error) {
+	b := c.muxer.GetInit()
+	if _, err := wr.Write(b); err != nil {
+		return 0, err
+	}
+	return c.wr.WriteTo(wr)
+}
diff --git a/installs_on_host/go2rtc/pkg/flv/flv_test.go b/installs_on_host/go2rtc/pkg/flv/flv_test.go
new file mode 100644
index 0000000..389272b
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/flv/flv_test.go
@@ -0,0 +1,21 @@
+package flv
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestTimeToRTP(t *testing.T) {
+	// Reolink camera has 20 FPS
+	// Video timestamp increases by 50ms, SampleRate 90000, RTP timestamp increases by 4500
+	// Audio timestamp increases by 64ms, SampleRate 16000, RTP timestamp increases by 1024
+	frameN := 1
+	for i := 0; i < 32; i++ {
+		// 1000ms/(90000/4500) = 50ms
+		require.Equal(t, uint32(frameN*4500), TimeToRTP(uint32(frameN*50), 90000))
+		// 1000ms/(16000/1024) = 64ms
+		require.Equal(t, uint32(frameN*1024), TimeToRTP(uint32(frameN*64), 16000))
+		frameN *= 2
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/flv/muxer.go b/installs_on_host/go2rtc/pkg/flv/muxer.go
new file mode 100644
index 0000000..b04d898
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/flv/muxer.go
@@ -0,0 +1,174 @@
+package flv
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/flv/amf"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/pion/rtp"
+)
+
+type Muxer struct {
+	codecs []*core.Codec
+}
+
+const (
+	FlagsVideo = 0b001
+	FlagsAudio = 0b100
+)
+
+func (m *Muxer) GetInit() []byte {
+	b := []byte{
+		'F', 'L', 'V', // signature
+		1,          // version
+		0,          // flags (has video/audio)
+		0, 0, 0, 9, // header size
+		0, 0, 0, 0, // tag 0 size
+	}
+
+	obj := map[string]any{}
+
+	for _, codec := range m.codecs {
+		switch codec.Name {
+		case core.CodecH264:
+			b[4] |= FlagsVideo
+			obj["videocodecid"] = CodecH264
+
+		case core.CodecAAC:
+			b[4] |= FlagsAudio
+			obj["audiocodecid"] = CodecAAC
+			obj["audiosamplerate"] = codec.ClockRate
+			obj["audiosamplesize"] = 16
+			obj["stereo"] = codec.Channels == 2
+		}
+	}
+
+	data := amf.EncodeItems("@setDataFrame", "onMetaData", obj)
+	b = append(b, EncodeTag(TagData, 0, data)...)
+
+	for _, codec := range m.codecs {
+		switch codec.Name {
+		case core.CodecH264:
+			sps, pps := h264.GetParameterSet(codec.FmtpLine)
+			if len(sps) == 0 {
+				sps = []byte{0x67, 0x42, 0x00, 0x0a, 0xf8, 0x41, 0xa2}
+			} else {
+				h264.FixPixFmt(sps)
+			}
+			if len(pps) == 0 {
+				pps = []byte{0x68, 0xce, 0x38, 0x80}
+			}
+
+			config := h264.EncodeConfig(sps, pps)
+			video := append(encodeAVData(codec, 0), config...)
+			b = append(b, EncodeTag(TagVideo, 0, video)...)
+
+		case core.CodecAAC:
+			s := core.Between(codec.FmtpLine, "config=", ";")
+			config, _ := hex.DecodeString(s)
+			audio := append(encodeAVData(codec, 0), config...)
+			b = append(b, EncodeTag(TagAudio, 0, audio)...)
+		}
+	}
+
+	return b
+}
+
+func (m *Muxer) GetPayloader(codec *core.Codec) func(packet *rtp.Packet) []byte {
+	m.codecs = append(m.codecs, codec)
+
+	var ts0 uint32
+	var k = codec.ClockRate / 1000
+
+	switch codec.Name {
+	case core.CodecH264:
+		buf := encodeAVData(codec, 1)
+
+		return func(packet *rtp.Packet) []byte {
+			if h264.IsKeyframe(packet.Payload) {
+				buf[0] = 1<<4 | 7
+			} else {
+				buf[0] = 2<<4 | 7
+			}
+
+			buf = append(buf[:5], packet.Payload...) // reset buffer to previous place
+
+			if ts0 == 0 {
+				ts0 = packet.Timestamp
+			}
+
+			timeMS := (packet.Timestamp - ts0) / k
+			return EncodeTag(TagVideo, timeMS, buf)
+		}
+
+	case core.CodecAAC:
+		buf := encodeAVData(codec, 1)
+
+		return func(packet *rtp.Packet) []byte {
+			buf = append(buf[:2], packet.Payload...)
+
+			if ts0 == 0 {
+				ts0 = packet.Timestamp
+			}
+
+			timeMS := (packet.Timestamp - ts0) / k
+			return EncodeTag(TagAudio, timeMS, buf)
+		}
+	}
+
+	return nil
+}
+
+func EncodeTag(tagType byte, timeMS uint32, payload []byte) []byte {
+	payloadSize := uint32(len(payload))
+	tagSize := payloadSize + 11
+
+	b := make([]byte, tagSize+4)
+	b[0] = tagType
+	b[1] = byte(payloadSize >> 16)
+	b[2] = byte(payloadSize >> 8)
+	b[3] = byte(payloadSize)
+	b[4] = byte(timeMS >> 16)
+	b[5] = byte(timeMS >> 8)
+	b[6] = byte(timeMS)
+	b[7] = byte(timeMS >> 24)
+	copy(b[11:], payload)
+
+	binary.BigEndian.PutUint32(b[tagSize:], tagSize)
+	return b
+}
+
+func encodeAVData(codec *core.Codec, isFrame byte) []byte {
+	switch codec.Name {
+	case core.CodecH264:
+		return []byte{
+			1<<4 | 7, // keyframe + AVC
+			isFrame,  // 0 - config, 1 - frame
+			0, 0, 0,  // composition time = 0
+		}
+
+	case core.CodecAAC:
+		var b0 byte = 10 << 4 // AAC
+
+		switch codec.ClockRate {
+		case 11025:
+			b0 |= 1 << 2
+		case 22050:
+			b0 |= 2 << 2
+		case 44100:
+			b0 |= 3 << 2
+		}
+
+		b0 |= 1 << 1 // 16 bits
+
+		if codec.Channels == 2 {
+			b0 |= 1
+		}
+
+		return []byte{b0, isFrame} // 0 - config, 1 - frame
+	}
+
+	return nil
+}
diff --git a/installs_on_host/go2rtc/pkg/flv/producer.go b/installs_on_host/go2rtc/pkg/flv/producer.go
new file mode 100644
index 0000000..38c601d
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/flv/producer.go
@@ -0,0 +1,312 @@
+package flv
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"io"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/aac"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/h265"
+	"github.com/pion/rtp"
+)
+
+type Producer struct {
+	core.Connection
+	rd *core.ReadBuffer
+
+	video, audio *core.Receiver
+}
+
+func Open(rd io.Reader) (*Producer, error) {
+	prod := &Producer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "flv",
+			Transport:  rd,
+		},
+		rd: core.NewReadBuffer(rd),
+	}
+	if err := prod.probe(); err != nil {
+		return nil, err
+	}
+	return prod, nil
+}
+
+const (
+	Signature = "FLV"
+
+	TagAudio = 8
+	TagVideo = 9
+	TagData  = 18
+
+	CodecAAC = 10
+
+	CodecH264 = 7
+	CodecHEVC = 12
+)
+
+const (
+	PacketTypeAVCHeader = iota
+	PacketTypeAVCNALU
+	PacketTypeAVCEnd
+)
+
+const (
+	PacketTypeSequenceStart = iota
+	PacketTypeCodedFrames
+	PacketTypeSequenceEnd
+	PacketTypeCodedFramesX
+	PacketTypeMetadata
+	PacketTypeMPEG2TSSequenceStart
+)
+
+func (c *Producer) GetTrack(media *core.Media, codec *core.Codec) (*core.Receiver, error) {
+	receiver, _ := c.Connection.GetTrack(media, codec)
+	if media.Kind == core.KindVideo {
+		c.video = receiver
+	} else {
+		c.audio = receiver
+	}
+	return receiver, nil
+}
+
+func (c *Producer) Start() error {
+	for {
+		pkt, err := c.readPacket()
+		if err != nil {
+			return err
+		}
+
+		c.Recv += len(pkt.Payload)
+
+		switch pkt.PayloadType {
+		case TagAudio:
+			if c.audio == nil || pkt.Payload[1] == 0 {
+				continue
+			}
+
+			pkt.Timestamp = TimeToRTP(pkt.Timestamp, c.audio.Codec.ClockRate)
+			pkt.Payload = pkt.Payload[2:]
+			c.audio.WriteRTP(pkt)
+
+		case TagVideo:
+			if c.video == nil {
+				continue
+			}
+
+			if isExHeader(pkt.Payload) {
+				switch packetType := pkt.Payload[0] & 0b1111; packetType {
+				case PacketTypeCodedFrames:
+					// frame type 4b, packet type 4b, fourCC 32b, composition time 24b
+					pkt.Payload = pkt.Payload[8:]
+				case PacketTypeCodedFramesX:
+					// frame type 4b, packet type 4b, fourCC 32b
+					pkt.Payload = pkt.Payload[5:]
+				default:
+					continue
+				}
+			} else {
+				switch pkt.Payload[1] {
+				case PacketTypeAVCNALU:
+					// frame type 4b, codecID 4b, avc packet type 8b, composition time 24b
+					pkt.Payload = pkt.Payload[5:]
+				default:
+					continue
+				}
+			}
+
+			pkt.Timestamp = TimeToRTP(pkt.Timestamp, c.video.Codec.ClockRate)
+			c.video.WriteRTP(pkt)
+		}
+	}
+}
+
+func (c *Producer) probe() error {
+	if err := c.readHeader(); err != nil {
+		return err
+	}
+
+	c.rd.BufferSize = core.ProbeSize
+	defer c.rd.Reset()
+
+	// 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
+
+	// OpenIPC camera (on old firmwares) sends:
+	// 1. Empty video/audio flag
+	// 2. No MetaData packet
+	// 3. Sends a video packet in more than 3 seconds
+	waitVideo := true
+	waitAudio := true
+	timeout := time.Now().Add(time.Second * 5)
+
+	for (waitVideo || waitAudio) && time.Now().Before(timeout) {
+		pkt, err := c.readPacket()
+		if err != nil {
+			return err
+		}
+
+		//log.Printf("%d %0.20s", pkt.PayloadType, pkt.Payload)
+
+		switch pkt.PayloadType {
+		case TagAudio:
+			if !waitAudio {
+				continue
+			}
+
+			_ = pkt.Payload[1] // bounds
+
+			codecID := pkt.Payload[0] >> 4 // SoundFormat
+			_ = pkt.Payload[0] & 0b1100    // SoundRate
+			_ = pkt.Payload[0] & 0b0010    // SoundSize
+			_ = pkt.Payload[0] & 0b0001    // SoundType
+
+			if codecID != CodecAAC {
+				continue
+			}
+
+			if pkt.Payload[1] != 0 { // check if header
+				continue
+			}
+
+			codec := aac.ConfigToCodec(pkt.Payload[2:])
+			media := &core.Media{
+				Kind:      core.KindAudio,
+				Direction: core.DirectionRecvonly,
+				Codecs:    []*core.Codec{codec},
+			}
+			c.Medias = append(c.Medias, media)
+			waitAudio = false
+
+		case TagVideo:
+			if !waitVideo {
+				continue
+			}
+
+			var codec *core.Codec
+
+			if isExHeader(pkt.Payload) {
+				if string(pkt.Payload[1:5]) != "hvc1" {
+					continue
+				}
+
+				if packetType := pkt.Payload[0] & 0b1111; packetType != PacketTypeSequenceStart {
+					continue
+				}
+
+				codec = h265.ConfigToCodec(pkt.Payload[5:])
+			} else {
+				_ = pkt.Payload[0] >> 4 // FrameType
+
+				if packetType := pkt.Payload[1]; packetType != PacketTypeAVCHeader { // check if header
+					continue
+				}
+
+				switch codecID := pkt.Payload[0] & 0b1111; codecID {
+				case CodecH264:
+					codec = h264.ConfigToCodec(pkt.Payload[5:])
+				case CodecHEVC:
+					codec = h265.ConfigToCodec(pkt.Payload[5:])
+				default:
+					continue
+				}
+			}
+
+			media := &core.Media{
+				Kind:      core.KindVideo,
+				Direction: core.DirectionRecvonly,
+				Codecs:    []*core.Codec{codec},
+			}
+			c.Medias = append(c.Medias, media)
+			waitVideo = false
+
+		case TagData:
+			if !bytes.Contains(pkt.Payload, []byte("onMetaData")) {
+				continue
+			}
+			// Dahua cameras doesn't send videocodecid
+			if !bytes.Contains(pkt.Payload, []byte("videocodecid")) &&
+				!bytes.Contains(pkt.Payload, []byte("width")) &&
+				!bytes.Contains(pkt.Payload, []byte("framerate")) {
+				waitVideo = false
+			}
+			if !bytes.Contains(pkt.Payload, []byte("audiocodecid")) {
+				waitAudio = false
+			}
+		}
+	}
+
+	return nil
+}
+
+func (c *Producer) readHeader() error {
+	b := make([]byte, 9)
+	if _, err := io.ReadFull(c.rd, b); err != nil {
+		return err
+	}
+
+	if string(b[:3]) != Signature {
+		return errors.New("flv: wrong header")
+	}
+
+	_ = b[4] // flags (skip because unsupported by Reolink cameras)
+
+	if skip := binary.BigEndian.Uint32(b[5:]) - 9; skip > 0 {
+		if _, err := io.ReadFull(c.rd, make([]byte, skip)); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (c *Producer) readPacket() (*rtp.Packet, error) {
+	// https://rtmp.veriskope.com/pdf/video_file_format_spec_v10.pdf
+	b := make([]byte, 4+11)
+	if _, err := io.ReadFull(c.rd, b); err != nil {
+		return nil, err
+	}
+
+	b = b[4 : 4+11] // skip previous tag size
+
+	size := uint32(b[1])<<16 | uint32(b[2])<<8 | uint32(b[3])
+
+	pkt := &rtp.Packet{
+		Header: rtp.Header{
+			PayloadType: b[0],
+			Timestamp:   uint32(b[4])<<16 | uint32(b[5])<<8 | uint32(b[6]) | uint32(b[7])<<24,
+		},
+		Payload: make([]byte, size),
+	}
+
+	if _, err := io.ReadFull(c.rd, pkt.Payload); err != nil {
+		return nil, err
+	}
+
+	//log.Printf("[FLV] %d %.40x", pkt.PayloadType, pkt.Payload)
+
+	return pkt, nil
+}
+
+// TimeToRTP convert time in milliseconds to RTP time
+func TimeToRTP(timeMS, clockRate uint32) uint32 {
+	// for clockRates 90000, 16000, 8000, etc. - we can use:
+	//     return timeMS * (clockRate / 1000)
+	// but for clockRates 44100, 22050, 11025 - we should use:
+	return uint32(uint64(timeMS) * uint64(clockRate) / 1000)
+}
+
+func isExHeader(data []byte) bool {
+	return data[0]&0b1000_0000 != 0
+}
diff --git a/installs_on_host/go2rtc/pkg/gopro/discovery.go b/installs_on_host/go2rtc/pkg/gopro/discovery.go
new file mode 100644
index 0000000..19ed802
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/gopro/discovery.go
@@ -0,0 +1,43 @@
+package gopro
+
+import (
+	"net"
+	"net/http"
+	"regexp"
+)
+
+func Discovery() (urls []string) {
+	ints, err := net.Interfaces()
+	if err != nil {
+		return nil
+	}
+
+	// The socket address for USB connections is 172.2X.1YZ.51:8080
+	// https://gopro.github.io/OpenGoPro/http_2_0#socket-address
+	re := regexp.MustCompile(`^172\.2\d\.1\d\d\.`)
+
+	for _, itf := range ints {
+		addrs, err := itf.Addrs()
+		if err != nil {
+			continue
+		}
+
+		for _, addr := range addrs {
+			host := addr.String()
+			if !re.MatchString(host) {
+				continue
+			}
+
+			host = host[:11] + "51" // 172.2x.1xx.xxx
+			res, err := http.Get("http://" + host + ":8080/gopro/webcam/status")
+			if err != nil {
+				continue
+			}
+			_ = res.Body.Close()
+
+			urls = append(urls, host)
+		}
+	}
+
+	return
+}
diff --git a/installs_on_host/go2rtc/pkg/gopro/producer.go b/installs_on_host/go2rtc/pkg/gopro/producer.go
new file mode 100644
index 0000000..1873159
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/gopro/producer.go
@@ -0,0 +1,124 @@
+package gopro
+
+import (
+	"errors"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/mpegts"
+)
+
+func Dial(rawURL string) (*mpegts.Producer, error) {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	r := &listener{host: u.Host}
+
+	if err = r.command("/gopro/webcam/stop"); err != nil {
+		return nil, err
+	}
+
+	if err = r.listen(); err != nil {
+		return nil, err
+	}
+
+	if err = r.command("/gopro/webcam/start"); err != nil {
+		return nil, err
+	}
+
+	prod, err := mpegts.Open(r)
+	if err != nil {
+		return nil, err
+	}
+
+	prod.FormatName = "gopro"
+	prod.RemoteAddr = u.Host
+
+	return prod, nil
+}
+
+type listener struct {
+	conn    net.PacketConn
+	host    string
+	packet  []byte
+	packets chan []byte
+}
+
+func (r *listener) Read(p []byte) (n int, err error) {
+	if r.packet == nil {
+		var ok bool
+		if r.packet, ok = <-r.packets; !ok {
+			return 0, io.EOF // channel closed
+		}
+	}
+
+	n = copy(p, r.packet)
+
+	if n < len(r.packet) {
+		r.packet = r.packet[n:]
+	} else {
+		r.packet = nil
+	}
+
+	return
+}
+
+func (r *listener) Close() error {
+	return r.conn.Close()
+}
+
+func (r *listener) command(api string) error {
+	client := &http.Client{Timeout: 5 * time.Second}
+
+	res, err := client.Get("http://" + r.host + ":8080" + api)
+	if err != nil {
+		return err
+	}
+
+	_ = res.Body.Close()
+
+	if res.StatusCode != http.StatusOK {
+		return errors.New("gopro: wrong response: " + res.Status)
+	}
+
+	return nil
+}
+
+func (r *listener) listen() (err error) {
+	if r.conn, err = net.ListenPacket("udp4", ":8554"); err != nil {
+		return
+	}
+
+	r.packets = make(chan []byte, 1024)
+	go r.worker()
+
+	return
+}
+
+func (r *listener) worker() {
+	b := make([]byte, 1500)
+	for {
+		if err := r.conn.SetReadDeadline(time.Now().Add(3 * time.Second)); err != nil {
+			break
+		}
+
+		n, _, err := r.conn.ReadFrom(b)
+		if err != nil {
+			break
+		}
+
+		packet := make([]byte, n)
+		copy(packet, b)
+
+		r.packets <- packet
+	}
+
+	close(r.packets)
+
+	_ = r.command("/gopro/webcam/stop")
+}
diff --git a/installs_on_host/go2rtc/pkg/h264/README.md b/installs_on_host/go2rtc/pkg/h264/README.md
new file mode 100644
index 0000000..65c2363
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/h264/README.md
@@ -0,0 +1,16 @@
+# H264
+
+Payloader code taken from [pion](https://github.com/pion/rtp) library and changed to AVC packets support.
+
+## Useful Links
+
+- [RTP Payload Format for H.264 Video](https://datatracker.ietf.org/doc/html/rfc6184)
+- [The H264 Sequence parameter set](https://www.cardinalpeak.com/blog/the-h-264-sequence-parameter-set)
+- [H.264 Video Types (Microsoft)](https://docs.microsoft.com/en-us/windows/win32/directshow/h-264-video-types)
+- [Automatic Generation of H.264 Parameter Sets to Recover Video File Fragments](https://arxiv.org/pdf/2104.14522.pdf)
+- [Chromium sources](https://chromium.googlesource.com/external/webrtc/+/HEAD/common_video/h264)
+- [AVC levels](https://en.wikipedia.org/wiki/Advanced_Video_Coding#Levels)
+- [AVC profiles table](https://developer.mozilla.org/ru/docs/Web/Media/Formats/codecs_parameter)
+- [Supported Media for Google Cast](https://developers.google.com/cast/docs/media)
+- [Two stream formats, Annex-B, AVCC (H.264) and HVCC (H.265)](https://www.programmersought.com/article/3901815022/)
+- https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/producer-reference-nal.html
diff --git a/installs_on_host/go2rtc/pkg/h264/annexb/annexb.go b/installs_on_host/go2rtc/pkg/h264/annexb/annexb.go
new file mode 100644
index 0000000..26614a8
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/h264/annexb/annexb.go
@@ -0,0 +1,156 @@
+// Package annexb - universal for H264 and H265
+package annexb
+
+import (
+	"bytes"
+	"encoding/binary"
+)
+
+const StartCode = "\x00\x00\x00\x01"
+const startAUD = StartCode + "\x09\xF0"
+const startAUDstart = startAUD + StartCode
+
+// EncodeToAVCC
+//
+// FFmpeg MPEG-TS: 00000001 AUD 00000001 SPS 00000001 PPS 000001 IFrame
+// FFmpeg H264:    00000001 SPS 00000001 PPS 000001 IFrame 00000001 PFrame
+// Reolink:        000001 AUD 000001 VPS 00000001 SPS 00000001 PPS 00000001 IDR 00000001 IDR
+func EncodeToAVCC(annexb []byte) (avc []byte) {
+	var start int
+
+	avc = make([]byte, 0, len(annexb)+4) // init memory with little overhead
+
+	for i := 0; ; i++ {
+		var offset int
+
+		if i+3 < len(annexb) {
+			// search next separator
+			if annexb[i] == 0 && annexb[i+1] == 0 {
+				if annexb[i+2] == 1 {
+					offset = 3 // 00 00 01
+				} else if annexb[i+2] == 0 && annexb[i+3] == 1 {
+					offset = 4 // 00 00 00 01
+				} else {
+					continue
+				}
+			} else {
+				continue
+			}
+		} else {
+			i = len(annexb) // move i to data end
+		}
+
+		if start != 0 {
+			size := uint32(i - start)
+			avc = binary.BigEndian.AppendUint32(avc, size)
+			avc = append(avc, annexb[start:i]...)
+		}
+
+		// sometimes FFmpeg put separator at the end
+		if i += offset; i == len(annexb) {
+			break
+		}
+
+		if isAUD(annexb[i]) {
+			start = 0 // skip this NALU
+		} else {
+			start = i // save this position
+		}
+	}
+
+	return
+}
+
+func isAUD(b byte) bool {
+	const h264 = 9
+	const h265 = 35 << 1
+	return b&0b0001_1111 == h264 || b&0b0111_1110 == h265
+}
+
+func DecodeAVCC(b []byte, safeClone bool) []byte {
+	if safeClone {
+		b = bytes.Clone(b)
+	}
+	for i := 0; i < len(b); {
+		size := int(binary.BigEndian.Uint32(b[i:]))
+		b[i] = 0
+		b[i+1] = 0
+		b[i+2] = 0
+		b[i+3] = 1
+		i += 4 + size
+	}
+	return b
+}
+
+// DecodeAVCCWithAUD - AUD doesn't important for FFmpeg, but important for Safari
+func DecodeAVCCWithAUD(src []byte) []byte {
+	dst := make([]byte, len(startAUD)+len(src))
+	copy(dst, startAUD)
+	copy(dst[len(startAUD):], src)
+	DecodeAVCC(dst[len(startAUD):], false)
+	return dst
+}
+
+const (
+	h264PFrame = 1
+	h264IFrame = 5
+	h264SPS    = 7
+	h264PPS    = 8
+
+	h265VPS    = 32
+	h265PFrame = 1
+)
+
+// IndexFrame - get new frame start position in the AnnexB stream
+func IndexFrame(b []byte) int {
+	if len(b) < len(startAUDstart) {
+		return -1
+	}
+
+	for i := len(startAUDstart); ; {
+		if di := bytes.Index(b[i:], []byte(StartCode)); di < 0 {
+			break
+		} else {
+			i += di + 4 // move to NALU start
+		}
+
+		if i >= len(b) {
+			break
+		}
+
+		h264Type := b[i] & 0b1_1111
+		switch h264Type {
+		case h264PFrame, h264SPS:
+			return i - 4 // move to start code
+		case h264IFrame, h264PPS:
+			continue
+		}
+
+		h265Type := (b[i] >> 1) & 0b11_1111
+		switch h265Type {
+		case h265PFrame, h265VPS:
+			return i - 4 // move to start code
+		}
+	}
+
+	return -1
+}
+
+func FixAnnexBInAVCC(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
+}
diff --git a/installs_on_host/go2rtc/pkg/h264/annexb/annexb_test.go b/installs_on_host/go2rtc/pkg/h264/annexb/annexb_test.go
new file mode 100644
index 0000000..cbc382f
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/h264/annexb/annexb_test.go
@@ -0,0 +1,97 @@
+package annexb
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/hex"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func decode(s string) []byte {
+	b, _ := hex.DecodeString(strings.ReplaceAll(s, " ", ""))
+	return b
+}
+
+func naluTypes(avcc []byte) (types []byte) {
+	for {
+		types = append(types, avcc[4])
+
+		size := 4 + binary.BigEndian.Uint32(avcc)
+		if size < uint32(len(avcc)) {
+			avcc = avcc[size:]
+		} else {
+			break
+		}
+	}
+	return
+}
+
+func TestFFmpegH264(t *testing.T) {
+	// ffmpeg -re -i bbb.mp4 -c copy -f h264 -
+	s := "000000016764001fac2484014016ec0440000003004000000c23c60c92 0000000168ee32c8b0 00000165888080033ffef5f8454f32cb1bb4203f854dd69bc2ca91b2bce1fb3527440000030000030000030000030050999841d1afd324aea000000300000f600011c0001b40004e40011f0003b80010800059000238000be0005e000220001100000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300004041 00000001"
+	b := EncodeToAVCC(decode(s))
+	require.True(t, bytes.HasSuffix(b, []byte{0x40, 0x41}))
+	n := naluTypes(b)
+	require.Equal(t, []byte{0x67, 0x68, 0x65}, n)
+}
+
+func TestFFmpegMPEGTSH264(t *testing.T) {
+	// ffmpeg -re -i bbb.mp4 -c copy -f mpegts -
+	s := "00000001 09f0 000000016764001fac2484014016ec0440000003004000000c23c60c92 0000000168ee32c8b0 00000165888080033ffef5f8454f32cb1bb4203f854dd69bc2ca91b2bce1fb3527440000030000030000030000030050999841d1afd324aea000000300000f600011c0001b40004e40011f0003b80010800059000238000be0005e000220001100000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300000300004041"
+	b := EncodeToAVCC(decode(s))
+	n := naluTypes(b)
+	require.Equal(t, []byte{0x67, 0x68, 0x65}, n)
+}
+
+func TestFFmpegHEVC(t *testing.T) {
+	// ffmpeg -re -i bbb.mp4 -c libx265 -preset superfast -tune zerolatency -f hevc -
+	s := "0000000140010c01ffff01600000030090000003000003005dba0240 0000000142010101600000030090000003000003005da00280802d165bab930bc05a7080000003008000000c04 000000014401c1718312 0000014e0105ffffffffffffffffff2b2ca2de09b51747dbbb55a4fe7fc2fc4e7832363520286275696c642032303829202d20332e352b3131312d6330616631386464353a5b57696e646f77735d5b4743432031332e322e305d5b3634206269745d20386269742b31306269742b3132626974202d20482e3236352f4845564320636f646563202d20436f7079726967687420323031332d3230313820286329204d756c7469636f7265776172"
+	b := EncodeToAVCC(decode(s))
+	n := naluTypes(b)
+	require.Equal(t, []byte{0x40, 0x42, 0x44, 0x4e}, n)
+}
+
+func TestFFmpegHEVC2(t *testing.T) {
+	// ffmpeg -re -i bbb.mp4 -c libx265 -preset superfast -tune zerolatency -f hevc -
+	s := "0000000140010c01ffff01600000030090000003000003005dba0240 0000000142010101600000030090000003000003005da00280802d165bab930bc05a7080000003008000000c04 000000014401c1718312 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 0000012801adc2e5bca307b9ce6b18b5ad6a525294a6d117ffd3917322eebaeda718a0000003000003000003021207706824da718a00000300000300000300044408d5db4e31400000030000030000030012500c2725a000000300000300000300002a600e4880000003000003000003000019301180000003000003000003000007d400000300000300000300000300010b000003000003000003000003001810000003000003000003000003019100000300000300000300000d38000003000003000003000067c000000300000300000300025e000003000003000003000c58000003000003000003002b60000003000003000003007f80000003000003000003016300000300000300000303b2000003000003000006e400000300000300000e18000003000003000018d00000030000030000292000000300000300003ce00000030000030000030000030000030000bb80"
+	b := EncodeToAVCC(decode(s))
+	n := naluTypes(b)
+	require.Equal(t, []byte{0x40, 0x42, 0x44, 0x4e, 0x28}, n)
+}
+
+func TestFFmpegMPEGTSHEVC(t *testing.T) {
+	// ffmpeg -re -i bbb.mp4 -c libx265 -preset superfast -tune zerolatency -an -f mpegts -
+	s := "00000001460150 0000000140010c01ffff01600000030090000003000003005dba0240 0000000142010101600000030090000003000003005da00280802d165bab930bc05a7080000003008000000c04 000000014401c1718312 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 0000012801adc2e5bca307b9ce6b18b5ad6a525294a6d117ffd3917322eebaeda718a0000003000003000003021207706824da718a00000300000300000300044408d5db4e31400000030000030000030012500c2725a000000300000300000300002a600e4880000003000003000003000019301180000003000003000003000007d400000300000300000300000300010b000003000003000003000003001810000003000003000003000003019100000300000300000300000d38000003000003000003000067c000000300000300000300025e000003000003000003000c58000003000003000003002b60000003000003000003007f80000003000003000003016300000300000300000303b2000003000003000006e400000300000300000e18000003000003000018d00000030000030000292000000300000300003ce00000030000030000030000030000030000bb80"
+	b := EncodeToAVCC(decode(s))
+	n := naluTypes(b)
+	require.Equal(t, []byte{0x40, 0x42, 0x44, 0x4e, 0x28}, n)
+}
+
+func TestReolink(t *testing.T) {
+	s := "000001460150 00000140010C01FFFF01600000030000030000030000030096AC09 0000000142010101600000030000030000030000030096A001E020021C7F8AAD3BA24BB804000013D800018CE008 000000014401C072F0941E3648 000000012601"
+	b := EncodeToAVCC(decode(s))
+	n := naluTypes(b)
+	require.Equal(t, []byte{0x40, 0x42, 0x44, 0x26}, n)
+}
+
+func TestDahua(t *testing.T) {
+	s := "00000001460150 00000140010c01ffff01400000030000030000030000030099ac0900 0000000142010101400000030000030000030000030099a001402005a1fe5aee46c1ae550400 000000014401c073c04c9000 000000012601"
+	b := EncodeToAVCC(decode(s))
+	n := naluTypes(b)
+	require.Equal(t, []byte{0x40, 0x42, 0x44, 0x26}, n)
+}
+
+func TestUSB(t *testing.T) {
+	s := "00 00 00 01 67 4D 00 1F 8D 8D 40 28 02 DD 37 01 01 01 40 00 01 C2 00 00 57 E4 01 00 00 00 01 68 EE 3C 80 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01 65 88 80 00"
+	b := EncodeToAVCC(decode(s))
+	n := naluTypes(b)
+	require.Equal(t, []byte{0x67, 0x68, 0x65}, n)
+
+	s = "00 00 00 00 00 00 00 00 00 00 00 00 00 00 01 41 9A 00 4C"
+	b = EncodeToAVCC(decode(s))
+	n = naluTypes(b)
+	require.Equal(t, []byte{0x41}, n)
+}
diff --git a/installs_on_host/go2rtc/pkg/h264/avc.go b/installs_on_host/go2rtc/pkg/h264/avc.go
new file mode 100644
index 0000000..e6a294c
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/h264/avc.go
@@ -0,0 +1,122 @@
+package h264
+
+import (
+	"bytes"
+	"encoding/binary"
+)
+
+const forbiddenZeroBit = 0x80
+const nalUnitType = 0x1F
+
+// Deprecated: 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)
+}
diff --git a/installs_on_host/go2rtc/pkg/h264/avcc.go b/installs_on_host/go2rtc/pkg/h264/avcc.go
new file mode 100644
index 0000000..dd3a568
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/h264/avcc.go
@@ -0,0 +1,120 @@
+// Package h264 - AVCC format related functions
+package h264
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/binary"
+	"encoding/hex"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+)
+
+func RepairAVCC(codec *core.Codec, handler core.HandlerFunc) core.HandlerFunc {
+	sps, pps := GetParameterSet(codec.FmtpLine)
+	ps := JoinNALU(sps, pps)
+
+	return func(packet *rtp.Packet) {
+		// this can happen for FLV from FFmpeg
+		if NALUType(packet.Payload) == NALUTypeSEI {
+			size := int(binary.BigEndian.Uint32(packet.Payload)) + 4
+			packet.Payload = packet.Payload[size:]
+		}
+		if NALUType(packet.Payload) == NALUTypeIFrame {
+			packet.Payload = Join(ps, packet.Payload)
+		}
+		handler(packet)
+	}
+}
+
+func JoinNALU(nalus ...[]byte) (avcc []byte) {
+	var i, n int
+
+	for _, nalu := range nalus {
+		if i = len(nalu); i > 0 {
+			n += 4 + i
+		}
+	}
+
+	avcc = make([]byte, n)
+
+	n = 0
+	for _, nal := range nalus {
+		if i = len(nal); i > 0 {
+			binary.BigEndian.PutUint32(avcc[n:], uint32(i))
+			n += 4 + copy(avcc[n+4:], nal)
+		}
+	}
+
+	return
+}
+
+func SplitNALU(avcc []byte) [][]byte {
+	var nals [][]byte
+	for {
+		// get AVC length
+		size := int(binary.BigEndian.Uint32(avcc)) + 4
+
+		// check if multiple items in one packet
+		if size < len(avcc) {
+			nals = append(nals, avcc[:size])
+			avcc = avcc[size:]
+		} else {
+			nals = append(nals, avcc)
+			break
+		}
+	}
+	return nals
+}
+
+func NALUTypes(avcc []byte) []byte {
+	var types []byte
+	for {
+		types = append(types, NALUType(avcc))
+
+		size := 4 + int(binary.BigEndian.Uint32(avcc))
+		if size < len(avcc) {
+			avcc = avcc[size:]
+		} else {
+			break
+		}
+	}
+	return types
+}
+
+func AVCCToCodec(avcc []byte) *core.Codec {
+	buf := bytes.NewBufferString("packetization-mode=1")
+
+	for {
+		n := len(avcc)
+		if n < 4 {
+			break
+		}
+
+		size := 4 + int(binary.BigEndian.Uint32(avcc))
+		if n < size {
+			break
+		}
+
+		switch NALUType(avcc) {
+		case NALUTypeSPS:
+			buf.WriteString(";profile-level-id=")
+			buf.WriteString(hex.EncodeToString(avcc[5:8]))
+			buf.WriteString(";sprop-parameter-sets=")
+			buf.WriteString(base64.StdEncoding.EncodeToString(avcc[4:size]))
+		case NALUTypePPS:
+			buf.WriteString(",")
+			buf.WriteString(base64.StdEncoding.EncodeToString(avcc[4:size]))
+		}
+
+		avcc = avcc[size:]
+	}
+
+	return &core.Codec{
+		Name:        core.CodecH264,
+		ClockRate:   90000,
+		FmtpLine:    buf.String(),
+		PayloadType: core.PayloadTypeRAW,
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/h264/h264.go b/installs_on_host/go2rtc/pkg/h264/h264.go
new file mode 100644
index 0000000..1223953
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/h264/h264.go
@@ -0,0 +1,145 @@
+package h264
+
+import (
+	"encoding/base64"
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+const (
+	NALUTypePFrame = 1 // Coded slice of a non-IDR picture
+	NALUTypeIFrame = 5 // Coded slice of an IDR picture
+	NALUTypeSEI    = 6 // Supplemental enhancement information (SEI)
+	NALUTypeSPS    = 7 // Sequence parameter set
+	NALUTypePPS    = 8 // Picture parameter set
+	NALUTypeAUD    = 9 // Access unit delimiter
+)
+
+func NALUType(b []byte) byte {
+	return b[4] & 0x1F
+}
+
+// IsKeyframe - check if any NALU in one AU is Keyframe
+func IsKeyframe(b []byte) bool {
+	for {
+		switch NALUType(b) {
+		case NALUTypePFrame:
+			return false
+		case NALUTypeIFrame:
+			return true
+		}
+
+		size := int(binary.BigEndian.Uint32(b)) + 4
+		if size < len(b) {
+			b = b[size:]
+			continue
+		} else {
+			return false
+		}
+	}
+}
+
+func Join(ps, iframe []byte) []byte {
+	b := make([]byte, len(ps)+len(iframe))
+	i := copy(b, ps)
+	copy(b[i:], iframe)
+	return b
+}
+
+// https://developers.google.com/cast/docs/media
+const (
+	ProfileBaseline    = 0x42
+	ProfileMain        = 0x4D
+	ProfileHigh        = 0x64
+	CapabilityBaseline = 0xE0
+	CapabilityMain     = 0x40
+)
+
+// 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 {
+	// avc1.640029 - H.264 high 4.1 (Chromecast 1st and 2nd Gen)
+	profile := byte(ProfileHigh)
+	capab := byte(0)
+	level := byte(41)
+
+	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 len(conf) == 3 {
+			// sanitize profile, capab and level to supported values
+			switch conf[0] {
+			case ProfileBaseline, ProfileMain:
+				profile = conf[0]
+			}
+			switch conf[1] {
+			case CapabilityBaseline, CapabilityMain:
+				capab = conf[1]
+			}
+			switch conf[2] {
+			case 30, 31, 40:
+				level = conf[2]
+			}
+		}
+	}
+
+	return fmt.Sprintf("%02X%02X%02X", profile, capab, level)
+}
+
+func GetParameterSet(fmtp string) (sps, pps []byte) {
+	if fmtp == "" {
+		return
+	}
+
+	s := core.Between(fmtp, "sprop-parameter-sets=", ";")
+	if s == "" {
+		return
+	}
+
+	i := strings.IndexByte(s, ',')
+	if i < 0 {
+		return
+	}
+
+	sps, _ = base64.StdEncoding.DecodeString(s[:i])
+	pps, _ = base64.StdEncoding.DecodeString(s[i+1:])
+
+	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
+		}
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/h264/h264_test.go b/installs_on_host/go2rtc/pkg/h264/h264_test.go
new file mode 100644
index 0000000..9f02b62
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/h264/h264_test.go
@@ -0,0 +1,110 @@
+package h264
+
+import (
+	"encoding/base64"
+	"encoding/hex"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestDecodeConfig(t *testing.T) {
+	s := "01640033ffe1000c67640033ac1514a02800f19001000468ee3cb0"
+	src, err := hex.DecodeString(s)
+	require.Nil(t, err)
+
+	profile, sps, pps := DecodeConfig(src)
+	require.NotNil(t, profile)
+	require.NotNil(t, sps)
+	require.NotNil(t, pps)
+
+	dst := EncodeConfig(sps, pps)
+	require.Equal(t, src, dst)
+}
+
+func TestDecodeSPS(t *testing.T) {
+	s := "Z0IAMukAUAHjQgAAB9IAAOqcCAA=" // Amcrest AD410
+	b, err := base64.StdEncoding.DecodeString(s)
+	require.Nil(t, err)
+
+	sps := DecodeSPS(b)
+	require.Equal(t, uint16(2560), sps.Width())
+	require.Equal(t, uint16(1920), sps.Height())
+
+	s = "R00AKZmgHgCJ+WEAAAMD6AAATiCE" // Sonoff
+	b, err = base64.StdEncoding.DecodeString(s)
+	require.Nil(t, err)
+
+	sps = DecodeSPS(b)
+	require.Equal(t, uint16(1920), sps.Width())
+	require.Equal(t, uint16(1080), sps.Height())
+
+	s = "Z01AMqaAKAC1kAA=" // Dahua
+	b, err = base64.StdEncoding.DecodeString(s)
+	require.Nil(t, err)
+
+	sps = DecodeSPS(b)
+	require.Equal(t, uint16(2560), sps.Width())
+	require.Equal(t, uint16(1440), sps.Height())
+
+	s = "Z2QAM6wVFKAoAPGQ" // Reolink
+	b, err = base64.StdEncoding.DecodeString(s)
+	require.Nil(t, err)
+
+	sps = DecodeSPS(b)
+	require.Equal(t, uint16(2560), sps.Width())
+	require.Equal(t, uint16(1920), sps.Height())
+
+	s = "Z2QAKKwa0AoAt03AQEBQAAADABAAAAMB6PFCKg==" // TP-Link
+	b, err = base64.StdEncoding.DecodeString(s)
+	require.Nil(t, err)
+
+	sps = DecodeSPS(b)
+	require.Equal(t, uint16(1280), sps.Width())
+	require.Equal(t, uint16(720), sps.Height())
+
+	s = "Z2QAFqwa0BQF/yzcBAQFAAADAAEAAAMAHo8UIqA=" // TP-Link sub
+	b, err = base64.StdEncoding.DecodeString(s)
+	require.Nil(t, err)
+
+	sps = DecodeSPS(b)
+	require.Equal(t, uint16(640), sps.Width())
+	require.Equal(t, uint16(360), sps.Height())
+}
+
+func TestGetProfileLevelID(t *testing.T) {
+	// OpenIPC https://github.com/OpenIPC
+	s := "profile-level-id=0033e7; packetization-mode=1; "
+	profile := GetProfileLevelID(s)
+	require.Equal(t, "640029", profile)
+
+	// Eufy T8400 https://github.com/AlexxIT/go2rtc/issues/155
+	s = "packetization-mode=1;profile-level-id=276400"
+	profile = GetProfileLevelID(s)
+	require.Equal(t, "640029", profile)
+}
+
+func TestDecodeSPS2(t *testing.T) {
+	s := "6764001fad84010c20086100430802184010c200843b50740932"
+	b, err := hex.DecodeString(s)
+	require.Nil(t, err)
+
+	sps := DecodeSPS(b)
+	require.Equal(t, uint16(928), sps.Width())
+	require.Equal(t, uint16(576), sps.Height())
+
+	s = "Z2QAHq2EAQwgCGEAQwgCGEAQwgCEO1BQF/yzcBAQFAAAD6AAAXcCEA==" // unknown
+	b, err = base64.StdEncoding.DecodeString(s)
+	require.Nil(t, err)
+
+	sps = DecodeSPS(b)
+	require.Equal(t, uint16(640), sps.Width())
+	require.Equal(t, uint16(360), sps.Height())
+}
+
+func TestAVCCToCodec(t *testing.T) {
+	s := "000000196764001fac2484014016ec0440000003004000000c23c60c920000000568ee32c8b0000000d365"
+	b, _ := hex.DecodeString(s)
+	codec := AVCCToCodec(b)
+	require.Equal(t, "packetization-mode=1;profile-level-id=64001f;sprop-parameter-sets=Z2QAH6wkhAFAFuwEQAAAAwBAAAAMI8YMkg==,aO4yyLA=", codec.FmtpLine)
+}
diff --git a/installs_on_host/go2rtc/pkg/h264/mpeg4.go b/installs_on_host/go2rtc/pkg/h264/mpeg4.go
new file mode 100644
index 0000000..c49e0e8
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/h264/mpeg4.go
@@ -0,0 +1,101 @@
+// Package h264 - MPEG4 format related functions
+package h264
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/binary"
+	"encoding/hex"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+// DecodeConfig - extract profile, SPS and PPS from MPEG4 config
+func DecodeConfig(conf []byte) (profile []byte, sps []byte, pps []byte) {
+	if len(conf) < 6 || conf[0] != 1 {
+		return
+	}
+
+	profile = conf[1:4]
+
+	count := conf[5] & 0x1F
+	conf = conf[6:]
+	for i := byte(0); i < count; i++ {
+		if len(conf) < 2 {
+			return
+		}
+		size := 2 + int(binary.BigEndian.Uint16(conf))
+		if len(conf) < size {
+			return
+		}
+		if sps == nil {
+			sps = conf[2:size]
+		}
+		conf = conf[size:]
+	}
+
+	count = conf[0]
+	conf = conf[1:]
+	for i := byte(0); i < count; i++ {
+		if len(conf) < 2 {
+			return
+		}
+		size := 2 + int(binary.BigEndian.Uint16(conf))
+		if len(conf) < size {
+			return
+		}
+		if pps == nil {
+			pps = conf[2:size]
+		}
+		conf = conf[size:]
+	}
+
+	return
+}
+
+func EncodeConfig(sps, pps []byte) []byte {
+	spsSize := uint16(len(sps))
+	ppsSize := uint16(len(pps))
+
+	buf := make([]byte, 5+3+spsSize+3+ppsSize)
+	buf[0] = 1
+	copy(buf[1:], sps[1:4]) // profile
+	buf[4] = 3 | 0xFC       // ? LengthSizeMinusOne
+
+	b := buf[5:]
+	_ = b[3]
+	b[0] = 1 | 0xE0 // ? sps count
+	binary.BigEndian.PutUint16(b[1:], spsSize)
+	copy(b[3:], sps)
+
+	b = buf[5+3+spsSize:]
+	_ = b[3]
+	b[0] = 1 // pps count
+	binary.BigEndian.PutUint16(b[1:], ppsSize)
+	copy(b[3:], pps)
+
+	return buf
+}
+
+func ConfigToCodec(conf []byte) *core.Codec {
+	buf := bytes.NewBufferString("packetization-mode=1")
+
+	profile, sps, pps := DecodeConfig(conf)
+	if profile != nil {
+		buf.WriteString(";profile-level-id=")
+		buf.WriteString(hex.EncodeToString(profile))
+	}
+	if sps != nil && pps != nil {
+		buf.WriteString(";sprop-parameter-sets=")
+		buf.WriteString(base64.StdEncoding.EncodeToString(sps))
+		buf.WriteString(",")
+		buf.WriteString(base64.StdEncoding.EncodeToString(pps))
+	}
+
+	return &core.Codec{
+		Name:        core.CodecH264,
+		ClockRate:   90000,
+		FmtpLine:    buf.String(),
+		PayloadType: core.PayloadTypeRAW,
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/h264/payloader.go b/installs_on_host/go2rtc/pkg/h264/payloader.go
new file mode 100644
index 0000000..efc8998
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/h264/payloader.go
@@ -0,0 +1,195 @@
+package h264
+
+import "encoding/binary"
+
+// Payloader payloads H264 packets
+type Payloader struct {
+	IsAVC     bool
+	stapANalu []byte
+}
+
+const (
+	stapaNALUType  = 24
+	fuaNALUType    = 28
+	fubNALUType    = 29
+	spsNALUType    = 7
+	ppsNALUType    = 8
+	audNALUType    = 9
+	fillerNALUType = 12
+
+	fuaHeaderSize = 2
+	//stapaHeaderSize     = 1
+	//stapaNALULengthSize = 2
+
+	naluTypeBitmask   = 0x1F
+	naluRefIdcBitmask = 0x60
+	//fuStartBitmask    = 0x80
+	//fuEndBitmask      = 0x40
+
+	outputStapAHeader = 0x78
+)
+
+//func annexbNALUStartCode() []byte { return []byte{0x00, 0x00, 0x00, 0x01} }
+
+func EmitNalus(nals []byte, isAVC bool, emit func([]byte)) {
+	if !isAVC {
+		nextInd := func(nalu []byte, start int) (indStart int, indLen int) {
+			zeroCount := 0
+
+			for i, b := range nalu[start:] {
+				if b == 0 {
+					zeroCount++
+					continue
+				} else if b == 1 {
+					if zeroCount >= 2 {
+						return start + i - zeroCount, zeroCount + 1
+					}
+				}
+				zeroCount = 0
+			}
+			return -1, -1
+		}
+
+		nextIndStart, nextIndLen := nextInd(nals, 0)
+		if nextIndStart == -1 {
+			emit(nals)
+		} else {
+			for nextIndStart != -1 {
+				prevStart := nextIndStart + nextIndLen
+				nextIndStart, nextIndLen = nextInd(nals, prevStart)
+				if nextIndStart != -1 {
+					emit(nals[prevStart:nextIndStart])
+				} else {
+					// Emit until end of stream, no end indicator found
+					emit(nals[prevStart:])
+				}
+			}
+		}
+	} else {
+		for {
+			n := uint32(len(nals))
+			if n < 4 {
+				break
+			}
+			end := 4 + binary.BigEndian.Uint32(nals)
+			if n < end {
+				break
+			}
+			emit(nals[4:end])
+			nals = nals[end:]
+		}
+	}
+}
+
+// Payload fragments a H264 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
+	}
+
+	EmitNalus(payload, p.IsAVC, func(nalu []byte) {
+		if len(nalu) == 0 {
+			return
+		}
+
+		naluType := nalu[0] & naluTypeBitmask
+		naluRefIdc := nalu[0] & naluRefIdcBitmask
+
+		switch naluType {
+		case audNALUType, fillerNALUType:
+			return
+		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
+		}
+
+		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
+		if len(nalu) <= int(mtu) {
+			out := make([]byte, len(nalu))
+			copy(out, nalu)
+			payloads = append(payloads, out)
+			return
+		}
+
+		// FU-A
+		maxFragmentSize := int(mtu) - fuaHeaderSize
+
+		// The FU payload consists of fragments of the payload of the fragmented
+		// NAL unit so that if the fragmentation unit payloads of consecutive
+		// FUs are sequentially concatenated, the payload of the fragmented NAL
+		// unit can be reconstructed.  The NAL unit type octet of the fragmented
+		// NAL unit is not included as such in the fragmentation unit payload,
+		// 	but rather the information of the NAL unit type octet of the
+		// fragmented NAL unit is conveyed in the F and NRI fields of the FU
+		// indicator octet of the fragmentation unit and in the type field of
+		// the FU header.  An FU payload MAY have any number of octets and MAY
+		// be empty.
+
+		naluData := nalu
+		// According to the RFC, the first octet is skipped due to redundant information
+		naluDataIndex := 1
+		naluDataLength := len(nalu) - naluDataIndex
+		naluDataRemaining := naluDataLength
+
+		if min(maxFragmentSize, naluDataRemaining) <= 0 {
+			return
+		}
+
+		for naluDataRemaining > 0 {
+			currentFragmentSize := min(maxFragmentSize, naluDataRemaining)
+			out := make([]byte, fuaHeaderSize+currentFragmentSize)
+
+			// +---------------+
+			// |0|1|2|3|4|5|6|7|
+			// +-+-+-+-+-+-+-+-+
+			// |F|NRI|  Type   |
+			// +---------------+
+			out[0] = fuaNALUType
+			out[0] |= naluRefIdc
+
+			// +---------------+
+			// |0|1|2|3|4|5|6|7|
+			// +-+-+-+-+-+-+-+-+
+			// |S|E|R|  Type   |
+			// +---------------+
+
+			out[1] = naluType
+			if naluDataRemaining == naluDataLength {
+				// Set start bit
+				out[1] |= 1 << 7
+			} else if naluDataRemaining-currentFragmentSize == 0 {
+				// Set end bit
+				out[1] |= 1 << 6
+			}
+
+			copy(out[fuaHeaderSize:], naluData[naluDataIndex:naluDataIndex+currentFragmentSize])
+			payloads = append(payloads, out)
+
+			naluDataRemaining -= currentFragmentSize
+			naluDataIndex += currentFragmentSize
+		}
+	})
+
+	return payloads
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
diff --git a/installs_on_host/go2rtc/pkg/h264/rtp.go b/installs_on_host/go2rtc/pkg/h264/rtp.go
new file mode 100644
index 0000000..bb5fe47
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/h264/rtp.go
@@ -0,0 +1,137 @@
+package h264
+
+import (
+	"encoding/binary"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264/annexb"
+	"github.com/pion/rtp"
+	"github.com/pion/rtp/codecs"
+)
+
+const RTPPacketVersionAVC = 0
+
+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(codec.FmtpLine)
+	ps := JoinNALU(sps, pps)
+
+	buf := make([]byte, 0, 512*1024) // 512K
+
+	return func(packet *rtp.Packet) {
+		//log.Printf("[RTP] codec: %s, nalu: %2d, size: %6d, ts: %10d, pt: %2d, ssrc: %d, seq: %d, %v", 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
+		}
+
+		// Memory overflow protection. Can happen if we miss a lot of packets with the marker.
+		// https://github.com/AlexxIT/go2rtc/issues/675
+		if len(buf) > 5*1024*1024 {
+			buf = buf[: 0 : 512*1024]
+		}
+
+		// 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
+			}
+		}
+
+		if len(buf) == 0 {
+			for {
+				// Amcrest IP4M-1051: 9, 7, 8, 6, 28...
+				// Amcrest IP4M-1051: 9, 6, 1
+				switch NALUType(payload) {
+				case NALUTypeIFrame:
+					// fix IFrame without SPS,PPS
+					buf = append(buf, ps...)
+				case NALUTypeSEI, NALUTypeAUD:
+					// fix ffmpeg with transcoding first frame
+					i := int(4 + binary.BigEndian.Uint32(payload))
+
+					// check if only one NAL (fix ffmpeg transcoding for Reolink RLC-510A)
+					if i == len(payload) {
+						return
+					}
+
+					payload = payload[i:]
+					continue
+				case NALUTypePFrame, NALUTypeSPS, NALUTypePPS: // pass
+				default:
+					return // skip any unknown NAL unit type
+				}
+				break
+			}
+		}
+
+		// 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 have a 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
+			payload = annexb.FixAnnexBInAVCC(payload)
+		}
+
+		//log.Printf("[AVC] %v, len: %d, ts: %10d, seq: %d", NALUTypes(payload), len(payload), packet.Timestamp, packet.SequenceNumber)
+
+		clone := *packet
+		clone.Version = RTPPacketVersionAVC
+		clone.Payload = payload
+		handler(&clone)
+	}
+}
+
+func RTPPay(mtu uint16, handler core.HandlerFunc) core.HandlerFunc {
+	if mtu == 0 {
+		mtu = 1472
+	}
+
+	payloader := &Payloader{IsAVC: true}
+	sequencer := rtp.NewRandomSequencer()
+	mtu -= 12 // rtp.Header size
+
+	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,
+			}
+			handler(&clone)
+		}
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/h264/sps.go b/installs_on_host/go2rtc/pkg/h264/sps.go
new file mode 100644
index 0000000..1ac7394
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/h264/sps.go
@@ -0,0 +1,366 @@
+package h264
+
+import (
+	"fmt"
+
+	"github.com/AlexxIT/go2rtc/pkg/bits"
+)
+
+// http://www.itu.int/rec/T-REC-H.264
+// https://webrtc.googlesource.com/src/+/refs/heads/main/common_video/h264/sps_parser.cc
+
+//goland:noinspection GoSnakeCaseUsage
+type SPS struct {
+	profile_idc uint8
+	profile_iop uint8
+	level_idc   uint8
+
+	seq_parameter_set_id uint32
+
+	chroma_format_idc                    uint32
+	separate_colour_plane_flag           byte
+	bit_depth_luma_minus8                uint32
+	bit_depth_chroma_minus8              uint32
+	qpprime_y_zero_transform_bypass_flag byte
+	seq_scaling_matrix_present_flag      byte
+
+	log2_max_frame_num_minus4             uint32
+	pic_order_cnt_type                    uint32
+	log2_max_pic_order_cnt_lsb_minus4     uint32
+	delta_pic_order_always_zero_flag      byte
+	offset_for_non_ref_pic                int32
+	offset_for_top_to_bottom_field        int32
+	num_ref_frames_in_pic_order_cnt_cycle uint32
+	num_ref_frames                        uint32
+	gaps_in_frame_num_value_allowed_flag  byte
+
+	pic_width_in_mbs_minus_1        uint32
+	pic_height_in_map_units_minus_1 uint32
+	frame_mbs_only_flag             byte
+	mb_adaptive_frame_field_flag    byte
+	direct_8x8_inference_flag       byte
+
+	frame_cropping_flag      byte
+	frame_crop_left_offset   uint32
+	frame_crop_right_offset  uint32
+	frame_crop_top_offset    uint32
+	frame_crop_bottom_offset uint32
+
+	vui_parameters_present_flag    byte
+	aspect_ratio_info_present_flag byte
+	aspect_ratio_idc               byte
+	sar_width                      uint16
+	sar_height                     uint16
+
+	overscan_info_present_flag byte
+	overscan_appropriate_flag  byte
+
+	video_signal_type_present_flag byte
+	video_format                   uint8
+	video_full_range_flag          byte
+
+	colour_description_present_flag byte
+	colour_description              uint32
+
+	chroma_loc_info_present_flag        byte
+	chroma_sample_loc_type_top_field    uint32
+	chroma_sample_loc_type_bottom_field uint32
+
+	timing_info_present_flag byte
+	num_units_in_tick        uint32
+	time_scale               uint32
+	fixed_frame_rate_flag    byte
+}
+
+func (s *SPS) Width() uint16 {
+	width := 16 * (s.pic_width_in_mbs_minus_1 + 1)
+	crop := 2 * (s.frame_crop_left_offset + s.frame_crop_right_offset)
+	return uint16(width - crop)
+}
+
+func (s *SPS) Height() uint16 {
+	height := 16 * (s.pic_height_in_map_units_minus_1 + 1)
+	crop := 2 * (s.frame_crop_top_offset + s.frame_crop_bottom_offset)
+	if s.frame_mbs_only_flag == 0 {
+		height *= 2
+	}
+	return uint16(height - crop)
+}
+
+func DecodeSPS(sps []byte) *SPS {
+	// https://developer.ridgerun.com/wiki/index.php/H264_Analysis_Tools
+	// ffmpeg -i file.h264 -c copy -bsf:v trace_headers -f null -
+	r := bits.NewReader(sps)
+
+	hdr := r.ReadByte()
+	if hdr&0x1F != NALUTypeSPS {
+		return nil
+	}
+
+	s := &SPS{
+		profile_idc:          r.ReadByte(),
+		profile_iop:          r.ReadByte(),
+		level_idc:            r.ReadByte(),
+		seq_parameter_set_id: r.ReadUEGolomb(),
+	}
+
+	switch s.profile_idc {
+	case 100, 110, 122, 244, 44, 83, 86, 118, 128, 138, 139, 134, 135:
+		n := byte(8)
+
+		s.chroma_format_idc = r.ReadUEGolomb()
+		if s.chroma_format_idc == 3 {
+			s.separate_colour_plane_flag = r.ReadBit()
+			n = 12
+		}
+
+		s.bit_depth_luma_minus8 = r.ReadUEGolomb()
+		s.bit_depth_chroma_minus8 = r.ReadUEGolomb()
+		s.qpprime_y_zero_transform_bypass_flag = r.ReadBit()
+
+		s.seq_scaling_matrix_present_flag = r.ReadBit()
+		if s.seq_scaling_matrix_present_flag != 0 {
+			for i := byte(0); i < n; i++ {
+				//goland:noinspection GoSnakeCaseUsage
+				seq_scaling_list_present_flag := r.ReadBit()
+				if seq_scaling_list_present_flag != 0 {
+					if i < 6 {
+						s.scaling_list(r, 16)
+					} else {
+						s.scaling_list(r, 64)
+					}
+				}
+			}
+		}
+	}
+
+	s.log2_max_frame_num_minus4 = r.ReadUEGolomb()
+
+	s.pic_order_cnt_type = r.ReadUEGolomb()
+	switch s.pic_order_cnt_type {
+	case 0:
+		s.log2_max_pic_order_cnt_lsb_minus4 = r.ReadUEGolomb()
+	case 1:
+		s.delta_pic_order_always_zero_flag = r.ReadBit()
+		s.offset_for_non_ref_pic = r.ReadSEGolomb()
+		s.offset_for_top_to_bottom_field = r.ReadSEGolomb()
+
+		s.num_ref_frames_in_pic_order_cnt_cycle = r.ReadUEGolomb()
+		for i := uint32(0); i < s.num_ref_frames_in_pic_order_cnt_cycle; i++ {
+			_ = r.ReadSEGolomb() // offset_for_ref_frame[i]
+		}
+	}
+
+	s.num_ref_frames = r.ReadUEGolomb()
+	s.gaps_in_frame_num_value_allowed_flag = r.ReadBit()
+
+	s.pic_width_in_mbs_minus_1 = r.ReadUEGolomb()
+	s.pic_height_in_map_units_minus_1 = r.ReadUEGolomb()
+
+	s.frame_mbs_only_flag = r.ReadBit()
+	if s.frame_mbs_only_flag == 0 {
+		s.mb_adaptive_frame_field_flag = r.ReadBit()
+	}
+
+	s.direct_8x8_inference_flag = r.ReadBit()
+
+	s.frame_cropping_flag = r.ReadBit()
+	if s.frame_cropping_flag != 0 {
+		s.frame_crop_left_offset = r.ReadUEGolomb()
+		s.frame_crop_right_offset = r.ReadUEGolomb()
+		s.frame_crop_top_offset = r.ReadUEGolomb()
+		s.frame_crop_bottom_offset = r.ReadUEGolomb()
+	}
+
+	s.vui_parameters_present_flag = r.ReadBit()
+	if s.vui_parameters_present_flag != 0 {
+		s.aspect_ratio_info_present_flag = r.ReadBit()
+		if s.aspect_ratio_info_present_flag != 0 {
+			s.aspect_ratio_idc = r.ReadByte()
+			if s.aspect_ratio_idc == 255 {
+				s.sar_width = r.ReadUint16()
+				s.sar_height = r.ReadUint16()
+			}
+		}
+
+		s.overscan_info_present_flag = r.ReadBit()
+		if s.overscan_info_present_flag != 0 {
+			s.overscan_appropriate_flag = r.ReadBit()
+		}
+
+		s.video_signal_type_present_flag = r.ReadBit()
+		if s.video_signal_type_present_flag != 0 {
+			s.video_format = r.ReadBits8(3)
+			s.video_full_range_flag = r.ReadBit()
+
+			s.colour_description_present_flag = r.ReadBit()
+			if s.colour_description_present_flag != 0 {
+				s.colour_description = r.ReadUint24()
+			}
+		}
+
+		s.chroma_loc_info_present_flag = r.ReadBit()
+		if s.chroma_loc_info_present_flag != 0 {
+			s.chroma_sample_loc_type_top_field = r.ReadUEGolomb()
+			s.chroma_sample_loc_type_bottom_field = r.ReadUEGolomb()
+		}
+
+		s.timing_info_present_flag = r.ReadBit()
+		if s.timing_info_present_flag != 0 {
+			s.num_units_in_tick = r.ReadUint32()
+			s.time_scale = r.ReadUint32()
+			s.fixed_frame_rate_flag = r.ReadBit()
+		}
+		//...
+	}
+
+	if r.EOF {
+		return nil
+	}
+
+	return s
+}
+
+//goland:noinspection GoSnakeCaseUsage
+func (s *SPS) scaling_list(r *bits.Reader, sizeOfScalingList int) {
+	lastScale := int32(8)
+	nextScale := int32(8)
+	for j := 0; j < sizeOfScalingList; j++ {
+		if nextScale != 0 {
+			delta_scale := r.ReadSEGolomb()
+			nextScale = (lastScale + delta_scale + 256) % 256
+		}
+		if nextScale != 0 {
+			lastScale = nextScale
+		}
+	}
+}
+
+func (s *SPS) Profile() string {
+	switch s.profile_idc {
+	case 0x42:
+		return "Baseline"
+	case 0x4D:
+		return "Main"
+	case 0x58:
+		return "Extended"
+	case 0x64:
+		return "High"
+	}
+	return fmt.Sprintf("0x%02X", s.profile_idc)
+}
+
+func (s *SPS) PixFmt() string {
+	if s.bit_depth_luma_minus8 == 0 {
+		switch s.chroma_format_idc {
+		case 1:
+			if s.video_full_range_flag == 1 {
+				return "yuvj420p"
+			}
+			return "yuv420p"
+		case 2:
+			return "yuv422p"
+		case 3:
+			return "yuv444p"
+		}
+	}
+	return ""
+}
+
+func (s *SPS) String() string {
+	return fmt.Sprintf(
+		"%s %d.%d, %s, %dx%d",
+		s.Profile(), s.level_idc/10, s.level_idc%10, s.PixFmt(), s.Width(), s.Height(),
+	)
+}
+
+// FixPixFmt - change yuvj420p to yuv420p in SPS
+// same as "-c:v copy -bsf:v h264_metadata=video_full_range_flag=0"
+func FixPixFmt(sps []byte) {
+	r := bits.NewReader(sps)
+
+	_ = r.ReadByte()
+
+	profile := r.ReadByte()
+	_ = r.ReadByte()
+	_ = r.ReadByte()
+	_ = r.ReadUEGolomb()
+
+	switch profile {
+	case 100, 110, 122, 244, 44, 83, 86, 118, 128, 138, 139, 134, 135:
+		n := byte(8)
+
+		if r.ReadUEGolomb() == 3 {
+			_ = r.ReadBit()
+			n = 12
+		}
+
+		_ = r.ReadUEGolomb()
+		_ = r.ReadUEGolomb()
+		_ = r.ReadBit()
+
+		if r.ReadBit() != 0 {
+			for i := byte(0); i < n; i++ {
+				if r.ReadBit() != 0 {
+					return // skip
+				}
+			}
+		}
+	}
+
+	_ = r.ReadUEGolomb()
+
+	switch r.ReadUEGolomb() {
+	case 0:
+		_ = r.ReadUEGolomb()
+	case 1:
+		_ = r.ReadBit()
+		_ = r.ReadSEGolomb()
+		_ = r.ReadSEGolomb()
+
+		n := r.ReadUEGolomb()
+		for i := uint32(0); i < n; i++ {
+			_ = r.ReadSEGolomb()
+		}
+	}
+
+	_ = r.ReadUEGolomb()
+	_ = r.ReadBit()
+
+	_ = r.ReadUEGolomb()
+	_ = r.ReadUEGolomb()
+
+	if r.ReadBit() == 0 {
+		_ = r.ReadBit()
+	}
+
+	_ = r.ReadBit()
+
+	if r.ReadBit() != 0 {
+		_ = r.ReadUEGolomb()
+		_ = r.ReadUEGolomb()
+		_ = r.ReadUEGolomb()
+		_ = r.ReadUEGolomb()
+	}
+
+	if r.ReadBit() != 0 {
+		if r.ReadBit() != 0 {
+			if r.ReadByte() == 255 {
+				_ = r.ReadUint16()
+				_ = r.ReadUint16()
+			}
+		}
+
+		if r.ReadBit() != 0 {
+			_ = r.ReadBit()
+		}
+
+		if r.ReadBit() != 0 {
+			_ = r.ReadBits8(3)
+			if r.ReadBit() == 1 {
+				pos, bit := r.Pos()
+				sps[pos] &= ^byte(1 << bit)
+			}
+		}
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/h265/README.md b/installs_on_host/go2rtc/pkg/h265/README.md
new file mode 100644
index 0000000..a021c9d
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/h265/README.md
@@ -0,0 +1,8 @@
+# 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
+- [Add initial support for WebRTC HEVC](https://trac.webkit.org/changeset/259452/webkit)
diff --git a/installs_on_host/go2rtc/pkg/h265/avc.go b/installs_on_host/go2rtc/pkg/h265/avc.go
new file mode 100644
index 0000000..8bab9a1
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/h265/avc.go
@@ -0,0 +1,54 @@
+package h265
+
+import "github.com/AlexxIT/go2rtc/pkg/h264"
+
+const forbiddenZeroBit = 0x80
+const nalUnitType = 0x3F
+
+// Deprecated: 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 = h264.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
+		}
+
+		nalType := (octet >> 1) & nalUnitType
+		if startPos >= 0 {
+			switch nalType {
+			case NALUTypeVPS, NALUTypePFrame:
+				if annexb[i-4] == 0 {
+					return h264.DecodeAnnexB(annexb[startPos : i-4]), i - 4
+				} else {
+					return h264.DecodeAnnexB(annexb[startPos : i-3]), i - 3
+				}
+			}
+		} else {
+			switch nalType {
+			case NALUTypeVPS, NALUTypePFrame:
+				if i >= 4 && annexb[i-4] == 0 {
+					startPos = i - 4
+				} else {
+					startPos = i - 3
+				}
+			}
+		}
+	}
+
+	return nil, 0
+}
diff --git a/installs_on_host/go2rtc/pkg/h265/avcc.go b/installs_on_host/go2rtc/pkg/h265/avcc.go
new file mode 100644
index 0000000..9c257a1
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/h265/avcc.go
@@ -0,0 +1,61 @@
+// Package h265 - AVCC format related functions
+package h265
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/binary"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/pion/rtp"
+)
+
+func RepairAVCC(codec *core.Codec, handler core.HandlerFunc) core.HandlerFunc {
+	vds, sps, pps := GetParameterSet(codec.FmtpLine)
+	ps := h264.JoinNALU(vds, sps, pps)
+
+	return func(packet *rtp.Packet) {
+		switch NALUType(packet.Payload) {
+		case NALUTypeIFrame, NALUTypeIFrame2, NALUTypeIFrame3:
+			clone := *packet
+			clone.Payload = h264.Join(ps, packet.Payload)
+			handler(&clone)
+		default:
+			handler(packet)
+		}
+	}
+}
+
+func AVCCToCodec(avcc []byte) *core.Codec {
+	buf := bytes.NewBufferString("profile-id=1")
+
+	for {
+		size := 4 + int(binary.BigEndian.Uint32(avcc))
+
+		switch NALUType(avcc) {
+		case NALUTypeVPS:
+			buf.WriteString(";sprop-vps=")
+			buf.WriteString(base64.StdEncoding.EncodeToString(avcc[4:size]))
+		case NALUTypeSPS:
+			buf.WriteString(";sprop-sps=")
+			buf.WriteString(base64.StdEncoding.EncodeToString(avcc[4:size]))
+		case NALUTypePPS:
+			buf.WriteString(";sprop-pps=")
+			buf.WriteString(base64.StdEncoding.EncodeToString(avcc[4:size]))
+		}
+
+		if size < len(avcc) {
+			avcc = avcc[size:]
+		} else {
+			break
+		}
+	}
+
+	return &core.Codec{
+		Name:        core.CodecH265,
+		ClockRate:   90000,
+		FmtpLine:    buf.String(),
+		PayloadType: core.PayloadTypeRAW,
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/h265/h265_test.go b/installs_on_host/go2rtc/pkg/h265/h265_test.go
new file mode 100644
index 0000000..278e09a
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/h265/h265_test.go
@@ -0,0 +1,30 @@
+package h265
+
+import (
+	"encoding/base64"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestDecodeSPS(t *testing.T) {
+	s := "QgEBAWAAAAMAAAMAAAMAAAMAmaAAoAgBaH+KrTuiS7/8AAQABbAgApMuADN/mAE="
+	b, err := base64.StdEncoding.DecodeString(s)
+	require.Nil(t, err)
+
+	sps := DecodeSPS(b)
+	require.NotNil(t, sps)
+	require.Equal(t, uint16(5120), sps.Width())
+	require.Equal(t, uint16(1440), sps.Height())
+}
+
+func TestDecodeSPS2(t *testing.T) {
+	s := "QgEBIUAAAAMAkAAAAwAAAwCWoAUCAWlnpbkShc1AQIC4QAAAAwBAAAAFFEn/eEAOpgAV+V8IBBA="
+	b, err := base64.StdEncoding.DecodeString(s)
+	require.Nil(t, err)
+
+	sps := DecodeSPS(b)
+	require.NotNil(t, sps)
+	require.Equal(t, uint16(640), sps.Width())
+	require.Equal(t, uint16(360), sps.Height())
+}
diff --git a/installs_on_host/go2rtc/pkg/h265/helper.go b/installs_on_host/go2rtc/pkg/h265/helper.go
new file mode 100644
index 0000000..c2ad94d
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/h265/helper.go
@@ -0,0 +1,76 @@
+package h265
+
+import (
+	"encoding/base64"
+	"encoding/binary"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+const (
+	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 {
+	return (b[4] >> 1) & 0x3F
+}
+
+func IsKeyframe(b []byte) bool {
+	for {
+		switch NALUType(b) {
+		case NALUTypePFrame:
+			return false
+		case NALUTypeIFrame, NALUTypeIFrame2, NALUTypeIFrame3:
+			return true
+		}
+
+		size := int(binary.BigEndian.Uint32(b)) + 4
+		if size < len(b) {
+			b = b[size:]
+			continue
+		} else {
+			return false
+		}
+	}
+}
+
+func Types(data []byte) []byte {
+	var types []byte
+	for {
+		types = append(types, NALUType(data))
+
+		size := 4 + int(binary.BigEndian.Uint32(data))
+		if size < len(data) {
+			data = data[size:]
+		} else {
+			break
+		}
+	}
+	return types
+}
+
+func GetParameterSet(fmtp string) (vps, sps, pps []byte) {
+	if fmtp == "" {
+		return
+	}
+
+	s := core.Between(fmtp, "sprop-vps=", ";")
+	vps, _ = base64.StdEncoding.DecodeString(s)
+
+	s = core.Between(fmtp, "sprop-sps=", ";")
+	sps, _ = base64.StdEncoding.DecodeString(s)
+
+	s = core.Between(fmtp, "sprop-pps=", ";")
+	pps, _ = base64.StdEncoding.DecodeString(s)
+
+	return
+}
diff --git a/installs_on_host/go2rtc/pkg/h265/mpeg4.go b/installs_on_host/go2rtc/pkg/h265/mpeg4.go
new file mode 100644
index 0000000..e06d083
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/h265/mpeg4.go
@@ -0,0 +1,98 @@
+// Package h265 - MPEG4 format related functions
+package h265
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/binary"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func DecodeConfig(conf []byte) (profile, vps, sps, pps []byte) {
+	profile = conf[1:4]
+
+	b := conf[23:]
+	if binary.BigEndian.Uint16(b[1:]) != 1 {
+		return
+	}
+	vpsSize := binary.BigEndian.Uint16(b[3:])
+	vps = b[5 : 5+vpsSize]
+
+	b = conf[23+5+vpsSize:]
+	if binary.BigEndian.Uint16(b[1:]) != 1 {
+		return
+	}
+	spsSize := binary.BigEndian.Uint16(b[3:])
+	sps = b[5 : 5+spsSize]
+
+	b = conf[23+5+vpsSize+5+spsSize:]
+	if binary.BigEndian.Uint16(b[1:]) != 1 {
+		return
+	}
+	ppsSize := binary.BigEndian.Uint16(b[3:])
+	pps = b[5 : 5+ppsSize]
+
+	return
+}
+
+func EncodeConfig(vps, sps, pps []byte) []byte {
+	vpsSize := uint16(len(vps))
+	spsSize := uint16(len(sps))
+	ppsSize := uint16(len(pps))
+
+	buf := make([]byte, 23+5+vpsSize+5+spsSize+5+ppsSize)
+
+	buf[0] = 1
+	copy(buf[1:], sps[3:6]) // profile
+	buf[21] = 3             // ?
+	buf[22] = 3             // ?
+
+	b := buf[23:]
+	_ = b[5]
+	b[0] = (vps[0] >> 1) & 0x3F
+	binary.BigEndian.PutUint16(b[1:], 1) // VPS count
+	binary.BigEndian.PutUint16(b[3:], vpsSize)
+	copy(b[5:], vps)
+
+	b = buf[23+5+vpsSize:]
+	_ = b[5]
+	b[0] = (sps[0] >> 1) & 0x3F
+	binary.BigEndian.PutUint16(b[1:], 1) // SPS count
+	binary.BigEndian.PutUint16(b[3:], spsSize)
+	copy(b[5:], sps)
+
+	b = buf[23+5+vpsSize+5+spsSize:]
+	_ = b[5]
+	b[0] = (pps[0] >> 1) & 0x3F
+	binary.BigEndian.PutUint16(b[1:], 1) // PPS count
+	binary.BigEndian.PutUint16(b[3:], ppsSize)
+	copy(b[5:], pps)
+
+	return buf
+}
+
+func ConfigToCodec(conf []byte) *core.Codec {
+	buf := bytes.NewBufferString("profile-id=1")
+
+	_, vps, sps, pps := DecodeConfig(conf)
+	if vps != nil {
+		buf.WriteString(";sprop-vps=")
+		buf.WriteString(base64.StdEncoding.EncodeToString(vps))
+	}
+	if sps != nil {
+		buf.WriteString(";sprop-sps=")
+		buf.WriteString(base64.StdEncoding.EncodeToString(sps))
+	}
+	if pps != nil {
+		buf.WriteString(";sprop-pps=")
+		buf.WriteString(base64.StdEncoding.EncodeToString(pps))
+	}
+
+	return &core.Codec{
+		Name:        core.CodecH265,
+		ClockRate:   90000,
+		FmtpLine:    buf.String(),
+		PayloadType: core.PayloadTypeRAW,
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/h265/payloader.go b/installs_on_host/go2rtc/pkg/h265/payloader.go
new file mode 100644
index 0000000..e488411
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/h265/payloader.go
@@ -0,0 +1,301 @@
+package h265
+
+import (
+	"encoding/binary"
+	"math"
+
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+)
+
+//
+// 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
+}
diff --git a/installs_on_host/go2rtc/pkg/h265/rtp.go b/installs_on_host/go2rtc/pkg/h265/rtp.go
new file mode 100644
index 0000000..9c571ec
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/h265/rtp.go
@@ -0,0 +1,221 @@
+package h265
+
+import (
+	"encoding/binary"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/pion/rtp"
+)
+
+func RTPDepay(codec *core.Codec, handler core.HandlerFunc) core.HandlerFunc {
+	vps, sps, pps := GetParameterSet(codec.FmtpLine)
+	ps := h264.JoinNALU(vps, sps, pps)
+
+	buf := make([]byte, 0, 512*1024) // 512K
+	var nuStart int
+	var seqNum uint16
+
+	return func(packet *rtp.Packet) {
+		data := packet.Payload
+		if len(data) < 3 {
+			return
+		}
+
+		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)
+
+		// 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
+			}
+		}
+
+		// when we collect data into one buffer, we need to make sure
+		// that all of it falls into the same sequence
+		if len(buf) > 0 && packet.SequenceNumber-seqNum != 1 {
+			//log.Printf("broken H265 sequence")
+			buf = buf[:0] // drop data
+			return
+		}
+
+		seqNum = packet.SequenceNumber
+
+		if nuType == NALUTypeFU {
+			switch data[2] >> 6 {
+			case 0b10: // 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
+			case 0b00: // continue
+				if len(buf) == 0 {
+					//log.Printf("broken H265 fragment")
+					return
+				}
+
+				buf = append(buf, data[3:]...)
+				return
+			case 0b01: // end
+				if len(buf) == 0 {
+					//log.Printf("broken H265 fragment")
+					return
+				}
+
+				buf = append(buf, data[3:]...)
+
+				if nuStart > len(buf)+4 {
+					//log.Printf("broken H265 fragment")
+					buf = buf[:0] // drop data
+					return
+				}
+
+				binary.BigEndian.PutUint32(buf[nuStart:], uint32(len(buf)-nuStart-4))
+			case 0b11: // wrong RFC 7798 realisation from OpenIPC project
+				// A non-fragmented NAL unit MUST NOT be transmitted in one FU; i.e.,
+				// the Start bit and End bit must not both be set to 1 in the same FU
+				// header.
+				nuType = data[2] & 0x3F
+				buf = binary.BigEndian.AppendUint32(buf, uint32(len(data))-1) // NAL unit size
+				buf = append(buf, (data[0]&0x81)|(nuType<<1), data[1])
+				buf = append(buf, data[3:]...)
+			}
+		} else {
+			buf = binary.BigEndian.AppendUint32(buf, uint32(len(data))) // NAL unit size
+			buf = append(buf, data...)
+		}
+
+		// 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 {
+	if mtu == 0 {
+		mtu = 1472
+	}
+
+	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,
+			}
+			handler(&clone)
+		}
+	}
+}
+
+// SafariPay - generate Safari friendly payload for H265
+// https://github.com/AlexxIT/Blog/issues/5
+func SafariPay(mtu uint16, handler core.HandlerFunc) core.HandlerFunc {
+	sequencer := rtp.NewRandomSequencer()
+	size := int(mtu - 12) // rtp.Header size
+
+	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
+				}
+			}
+
+			i += size
+		}
+
+		// rtp.Packet payload
+		b := make([]byte, 1, size)
+		size-- // minus header byte
+
+		for au != nil {
+			b[0] = start
+
+			if start > 1 {
+				start -= 2
+			}
+
+			if len(au) > size {
+				b = append(b, au[:size]...)
+				au = au[size:]
+			} else {
+				b = append(b, au...)
+				au = nil
+			}
+
+			clone := rtp.Packet{
+				Header: rtp.Header{
+					Version:        2,
+					Marker:         au == nil,
+					SequenceNumber: sequencer.NextSequenceNumber(),
+					Timestamp:      packet.Timestamp,
+				},
+				Payload: b,
+			}
+			handler(&clone)
+
+			b = b[:1] // clear buffer
+		}
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/h265/sps.go b/installs_on_host/go2rtc/pkg/h265/sps.go
new file mode 100644
index 0000000..5f61363
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/h265/sps.go
@@ -0,0 +1,126 @@
+package h265
+
+import (
+	"bytes"
+
+	"github.com/AlexxIT/go2rtc/pkg/bits"
+)
+
+// http://www.itu.int/rec/T-REC-H.265
+
+//goland:noinspection GoSnakeCaseUsage
+type SPS struct {
+	sps_video_parameter_set_id   uint8
+	sps_max_sub_layers_minus1    uint8
+	sps_temporal_id_nesting_flag byte
+
+	general_profile_space               uint8
+	general_tier_flag                   byte
+	general_profile_idc                 uint8
+	general_profile_compatibility_flags uint32
+
+	general_level_idc              uint8
+	sub_layer_profile_present_flag []byte
+	sub_layer_level_present_flag   []byte
+
+	sps_seq_parameter_set_id   uint32
+	chroma_format_idc          uint32
+	separate_colour_plane_flag byte
+
+	pic_width_in_luma_samples  uint32
+	pic_height_in_luma_samples uint32
+}
+
+func (s *SPS) Width() uint16 {
+	return uint16(s.pic_width_in_luma_samples)
+}
+
+func (s *SPS) Height() uint16 {
+	return uint16(s.pic_height_in_luma_samples)
+}
+
+func DecodeSPS(nalu []byte) *SPS {
+	rbsp := bytes.ReplaceAll(nalu[2:], []byte{0, 0, 3}, []byte{0, 0})
+
+	r := bits.NewReader(rbsp)
+	s := &SPS{}
+
+	s.sps_video_parameter_set_id = r.ReadBits8(4)
+	s.sps_max_sub_layers_minus1 = r.ReadBits8(3)
+	s.sps_temporal_id_nesting_flag = r.ReadBit()
+
+	if !s.profile_tier_level(r) {
+		return nil
+	}
+
+	s.sps_seq_parameter_set_id = r.ReadUEGolomb()
+	s.chroma_format_idc = r.ReadUEGolomb()
+	if s.chroma_format_idc == 3 {
+		s.separate_colour_plane_flag = r.ReadBit()
+	}
+
+	s.pic_width_in_luma_samples = r.ReadUEGolomb()
+	s.pic_height_in_luma_samples = r.ReadUEGolomb()
+
+	//...
+
+	if r.EOF {
+		return nil
+	}
+
+	return s
+}
+
+// profile_tier_level supports ONLY general_profile_idc == 1
+// over variants very complicated...
+//
+//goland:noinspection GoSnakeCaseUsage
+func (s *SPS) profile_tier_level(r *bits.Reader) bool {
+	s.general_profile_space = r.ReadBits8(2)
+	s.general_tier_flag = r.ReadBit()
+	s.general_profile_idc = r.ReadBits8(5)
+
+	s.general_profile_compatibility_flags = r.ReadBits(32)
+	_ = r.ReadBits64(48) // other flags
+
+	if s.general_profile_idc != 1 {
+		return false
+	}
+
+	s.general_level_idc = r.ReadBits8(8)
+
+	s.sub_layer_profile_present_flag = make([]byte, s.sps_max_sub_layers_minus1)
+	s.sub_layer_level_present_flag = make([]byte, s.sps_max_sub_layers_minus1)
+
+	for i := byte(0); i < s.sps_max_sub_layers_minus1; i++ {
+		s.sub_layer_profile_present_flag[i] = r.ReadBit()
+		s.sub_layer_level_present_flag[i] = r.ReadBit()
+	}
+
+	if s.sps_max_sub_layers_minus1 > 0 {
+		for i := s.sps_max_sub_layers_minus1; i < 8; i++ {
+			_ = r.ReadBits8(2) // reserved_zero_2bits
+		}
+	}
+
+	for i := byte(0); i < s.sps_max_sub_layers_minus1; i++ {
+		if s.sub_layer_profile_present_flag[i] != 0 {
+			_ = r.ReadBits8(2)                      // sub_layer_profile_space
+			_ = r.ReadBit()                         // sub_layer_tier_flag
+			sub_layer_profile_idc := r.ReadBits8(5) // sub_layer_profile_idc
+
+			_ = r.ReadBits(32)   // sub_layer_profile_compatibility_flag
+			_ = r.ReadBits64(48) // other flags
+
+			if sub_layer_profile_idc != 1 {
+				return false
+			}
+		}
+
+		if s.sub_layer_level_present_flag[i] != 0 {
+			_ = r.ReadBits8(8)
+		}
+	}
+
+	return true
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/README.md b/installs_on_host/go2rtc/pkg/hap/README.md
new file mode 100644
index 0000000..9d7fbf5
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/README.md
@@ -0,0 +1,54 @@
+# Home Accessory Protocol
+
+> PS. Character = Characteristic
+
+**Device** - HomeKit end device (swith, camera, etc)
+
+- mDNS name: `MyCamera._hap._tcp.local.`
+- DeviceID - mac-like: `0E:AA:CE:2B:35:71`
+- HomeKit device is described by:
+  - one or more `Accessories` - has `AID` and `Services`  
+  - `Services` - has `IID`, `Type` and `Characters`  
+  - `Characters` - has `IID`, `Type`, `Format` and `Value`
+
+**Client** - HomeKit client (iPhone, iPad, MacBook or opensource library)
+
+- ClientID - static random UUID
+- ClientPublic/ClientPrivate - static random 32 byte keypair
+- can pair with Device (exchange ClientID/ClientPublic, ServerID/ServerPublic using Pin)
+- can auth to Device using ClientPrivate
+- holding persistant Secure connection to device
+- can read device Accessories
+- can read and write device Characters
+- can subscribe on device Characters change (Event)
+
+**Server** - HomeKit server (soft on end device or opensource library)
+
+- ServerID - same as DeviceID (using for Client auth)
+- ServerPublic/ServerPrivate - static random 32 byte keypair
+
+## AAC ELD 
+
+Requires ffmpeg built with `--enable-libfdk-aac`
+
+```
+-acodec libfdk_aac -aprofile aac_eld 
+```
+
+| SampleRate | RTPTime | constantDuration   | objectType   |
+|------------|---------|--------------------|--------------|
+| 8000       | 60      | =8000/1000*60=480  | 39 (AAC ELD) |
+| 16000      | 30      | =16000/1000*30=480 | 39 (AAC ELD) |
+| 24000      | 20      | =24000/1000*20=480 | 39 (AAC ELD) |
+| 16000      | 60      | =16000/1000*60=960 | 23 (AAC LD)  |
+| 24000      | 40      | =24000/1000*40=960 | 23 (AAC LD)  |
+
+## Useful links
+
+- https://github.com/apple/HomeKitADK/blob/master/Documentation/crypto.md
+- https://github.com/apple/HomeKitADK/blob/master/HAP/HAPPairingPairSetup.c
+- [Extracting HomeKit Pairing Keys](https://pvieito.com/2019/12/extract-homekit-pairing-keys)
+- [HAP in AirPlay2 receiver](https://github.com/openairplay/airplay2-receiver/blob/master/ap2/pairing/hap.py)
+- [HomeKit Secure Video Unofficial Specification](https://github.com/Supereg/secure-video-specification)
+- [Homebridge Camera FFmpeg](https://sunoo.github.io/homebridge-camera-ffmpeg/configs/)
+- https://github.com/ljezny/Particle-HAP/blob/master/HAP-Specification-Non-Commercial-Version.pdf
\ No newline at end of file
diff --git a/installs_on_host/go2rtc/pkg/hap/accessory.go b/installs_on_host/go2rtc/pkg/hap/accessory.go
new file mode 100644
index 0000000..c659a24
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/accessory.go
@@ -0,0 +1,176 @@
+package hap
+
+import (
+	"fmt"
+	"strconv"
+)
+
+const (
+	FormatString = "string"
+	FormatBool   = "bool"
+	FormatFloat  = "float"
+	FormatUInt8  = "uint8"
+	FormatUInt16 = "uint16"
+	FormatUInt32 = "uint32"
+	FormatInt32  = "int32"
+	FormatUInt64 = "uint64"
+	FormatData   = "data"
+	FormatTLV8   = "tlv8"
+
+	UnitPercentage = "percentage"
+)
+
+var PR = []string{"pr"}
+var PW = []string{"pw"}
+var PRPW = []string{"pr", "pw"}
+var EVPRPW = []string{"ev", "pr", "pw"}
+var EVPR = []string{"ev", "pr"}
+
+type Accessory struct {
+	AID      uint8      `json:"aid"` // 150 unique accessories per bridge
+	Services []*Service `json:"services"`
+}
+
+func (a *Accessory) InitIID() {
+	serviceN := map[string]byte{}
+	for _, service := range a.Services {
+		if len(service.Type) > 3 {
+			panic(service.Type)
+		}
+
+		n := serviceN[service.Type] + 1
+		serviceN[service.Type] = n
+
+		if n > 15 {
+			panic(n)
+		}
+
+		// ServiceID   = ANSSS000
+		s := fmt.Sprintf("%x%x%03s000", a.AID, n, service.Type)
+		service.IID, _ = strconv.ParseUint(s, 16, 64)
+
+		for _, character := range service.Characters {
+			if len(character.Type) > 3 {
+				panic(character.Type)
+			}
+
+			// CharacterID = ANSSSCCC
+			character.IID, _ = strconv.ParseUint(character.Type, 16, 64)
+			character.IID += service.IID
+		}
+	}
+}
+
+func (a *Accessory) GetService(servType string) *Service {
+	for _, serv := range a.Services {
+		if serv.Type == servType {
+			return serv
+		}
+	}
+	return nil
+}
+
+func (a *Accessory) GetCharacter(charType string) *Character {
+	for _, serv := range a.Services {
+		for _, char := range serv.Characters {
+			if char.Type == charType {
+				return char
+			}
+		}
+	}
+	return nil
+}
+
+func (a *Accessory) GetCharacterByID(iid uint64) *Character {
+	for _, serv := range a.Services {
+		for _, char := range serv.Characters {
+			if char.IID == iid {
+				return char
+			}
+		}
+	}
+	return nil
+}
+
+type Service struct {
+	Desc string `json:"description,omitempty"`
+
+	Type       string       `json:"type"`
+	IID        uint64       `json:"iid"`
+	Primary    bool         `json:"primary,omitempty"`
+	Characters []*Character `json:"characteristics"`
+	Linked     []int        `json:"linked,omitempty"`
+}
+
+func (s *Service) GetCharacter(charType string) *Character {
+	for _, char := range s.Characters {
+		if char.Type == charType {
+			return char
+		}
+	}
+	return nil
+}
+
+func ServiceAccessoryInformation(manuf, model, name, serial, firmware string) *Service {
+	return &Service{
+		Type: "3E", // AccessoryInformation
+		Characters: []*Character{
+			{
+				Type:   "14",
+				Format: FormatBool,
+				Perms:  PW,
+				//Descr:  "Identify",
+			}, {
+				Type:   "20",
+				Format: FormatString,
+				Value:  manuf,
+				Perms:  PR,
+				//Descr:  "Manufacturer",
+				//MaxLen: 64,
+			}, {
+				Type:   "21",
+				Format: FormatString,
+				Value:  model,
+				Perms:  PR,
+				//Descr:  "Model",
+				//MaxLen: 64,
+			}, {
+				Type:   "23",
+				Format: FormatString,
+				Value:  name,
+				Perms:  PR,
+				//Descr:  "Name",
+				//MaxLen: 64,
+			}, {
+				Type:   "30",
+				Format: FormatString,
+				Value:  serial,
+				Perms:  PR,
+				//Descr:  "Serial Number",
+				//MaxLen: 64,
+			}, {
+				Type:   "52",
+				Format: FormatString,
+				Value:  firmware,
+				Perms:  PR,
+				//Descr:  "Firmware Revision",
+			},
+		},
+	}
+}
+
+func ServiceHAPProtocolInformation() *Service {
+	return &Service{
+		Type: "A2", // 'HAPProtocolInformation'
+		Characters: []*Character{
+			{
+				Type:   "37",
+				Format: FormatString,
+				Value:  "1.1.0",
+				Perms:  PR,
+				//Descr:  "Version",
+				//MaxLen: 64,
+			},
+		},
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/camera/README.md b/installs_on_host/go2rtc/pkg/hap/camera/README.md
new file mode 100644
index 0000000..c6c6f23
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/camera/README.md
@@ -0,0 +1,3 @@
+## Useful links
+
+- https://github.com/bauer-andreas/secure-video-specification
diff --git a/installs_on_host/go2rtc/pkg/hap/camera/accessory.go b/installs_on_host/go2rtc/pkg/hap/camera/accessory.go
new file mode 100644
index 0000000..3772449
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/camera/accessory.go
@@ -0,0 +1,149 @@
+package camera
+
+import (
+	"github.com/AlexxIT/go2rtc/pkg/hap"
+	"github.com/AlexxIT/go2rtc/pkg/hap/tlv8"
+)
+
+func NewAccessory(manuf, model, name, serial, firmware string) *hap.Accessory {
+	acc := &hap.Accessory{
+		AID: hap.DeviceAID,
+		Services: []*hap.Service{
+			hap.ServiceAccessoryInformation(manuf, model, name, serial, firmware),
+			ServiceCameraRTPStreamManagement(),
+			//hap.ServiceHAPProtocolInformation(),
+			ServiceMicrophone(),
+		},
+	}
+	acc.InitIID()
+	return acc
+}
+
+func ServiceMicrophone() *hap.Service {
+	return &hap.Service{
+		Type: "112", // 'Microphone'
+		Characters: []*hap.Character{
+			{
+				Type:   "11A",
+				Format: hap.FormatBool,
+				Value:  0,
+				Perms:  hap.EVPRPW,
+				//Descr:  "Mute",
+			},
+			//{
+			//	Type:   "119",
+			//	Format: hap.FormatUInt8,
+			//	Value:  100,
+			//	Perms:  hap.EVPRPW,
+			//	//Descr:    "Volume",
+			//	//Unit:     hap.UnitPercentage,
+			//	//MinValue: 0,
+			//	//MaxValue: 100,
+			//	//MinStep:  1,
+			//},
+		},
+	}
+}
+
+func ServiceCameraRTPStreamManagement() *hap.Service {
+	val120, _ := tlv8.MarshalBase64(StreamingStatus{
+		Status: StreamingStatusAvailable,
+	})
+	val114, _ := tlv8.MarshalBase64(SupportedVideoStreamConfiguration{
+		Codecs: []VideoCodecConfiguration{
+			{
+				CodecType: VideoCodecTypeH264,
+				CodecParams: []VideoCodecParameters{
+					{
+						ProfileID: []byte{VideoCodecProfileMain},
+						Level:     []byte{VideoCodecLevel31, VideoCodecLevel40},
+					},
+				},
+				VideoAttrs: []VideoCodecAttributes{
+					{Width: 1920, Height: 1080, Framerate: 30},
+					{Width: 1280, Height: 720, Framerate: 30}, // important for iPhones
+					{Width: 320, Height: 240, Framerate: 15},  // apple watch
+				},
+			},
+		},
+	})
+	val115, _ := tlv8.MarshalBase64(SupportedAudioStreamConfiguration{
+		Codecs: []AudioCodecConfiguration{
+			{
+				CodecType: AudioCodecTypeOpus,
+				CodecParams: []AudioCodecParameters{
+					{
+						Channels:    1,
+						BitrateMode: AudioCodecBitrateVariable,
+						SampleRate:  []byte{AudioCodecSampleRate16Khz},
+					},
+				},
+			},
+		},
+		ComfortNoiseSupport: 0,
+	})
+	val116, _ := tlv8.MarshalBase64(SupportedRTPConfiguration{
+		SRTPCryptoType: []byte{CryptoAES_CM_128_HMAC_SHA1_80},
+	})
+
+	service := &hap.Service{
+		Type: "110", // 'CameraRTPStreamManagement'
+		Characters: []*hap.Character{
+			{
+				Type:   TypeStreamingStatus,
+				Format: hap.FormatTLV8,
+				Value:  val120,
+				Perms:  hap.EVPR,
+				//Descr:  "Streaming Status",
+			},
+			{
+				Type:   TypeSupportedVideoStreamConfiguration,
+				Format: hap.FormatTLV8,
+				Value:  val114,
+				Perms:  hap.PR,
+				//Descr:  "Supported Video Stream Configuration",
+			},
+			{
+				Type:   TypeSupportedAudioStreamConfiguration,
+				Format: hap.FormatTLV8,
+				Value:  val115,
+				Perms:  hap.PR,
+				//Descr:  "Supported Audio Stream Configuration",
+			},
+			{
+				Type:   TypeSupportedRTPConfiguration,
+				Format: hap.FormatTLV8,
+				Value:  val116,
+				Perms:  hap.PR,
+				//Descr:  "Supported RTP Configuration",
+			},
+			{
+				Type:   "B0",
+				Format: hap.FormatUInt8,
+				Value:  1,
+				Perms:  hap.EVPRPW,
+				//Descr:    "Active",
+				//MinValue: 0,
+				//MaxValue: 1,
+				//MinStep:  1,
+				//ValidVal: []any{0, 1},
+			},
+			{
+				Type:   TypeSelectedStreamConfiguration,
+				Format: hap.FormatTLV8,
+				Value:  "", // important empty
+				Perms:  hap.PRPW,
+				//Descr:  "Selected RTP Stream Configuration",
+			},
+			{
+				Type:   TypeSetupEndpoints,
+				Format: hap.FormatTLV8,
+				Value:  "", // important empty
+				Perms:  hap.PRPW,
+				//Descr:  "Setup Endpoints",
+			},
+		},
+	}
+
+	return service
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/camera/accessory_test.go b/installs_on_host/go2rtc/pkg/hap/camera/accessory_test.go
new file mode 100644
index 0000000..53c99a4
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/camera/accessory_test.go
@@ -0,0 +1,254 @@
+package camera
+
+import (
+	"encoding/base64"
+	"strings"
+	"testing"
+
+	"github.com/AlexxIT/go2rtc/pkg/hap"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNilCharacter(t *testing.T) {
+	var res SetupEndpoints
+	char := &hap.Character{}
+	err := char.ReadTLV8(&res)
+	require.NotNil(t, err)
+	require.NotNil(t, strings.Contains(err.Error(), "can't read value"))
+}
+
+type testTLV8 struct {
+	name    string
+	value   string
+	actual  any
+	expect  any
+	noequal bool
+}
+
+func (test testTLV8) run(t *testing.T) {
+	if test.actual == nil {
+		return
+	}
+
+	src := &hap.Character{Value: test.value, Format: hap.FormatTLV8}
+	err := src.ReadTLV8(test.actual)
+	require.Nil(t, err)
+
+	require.Equal(t, test.expect, test.actual)
+
+	dst := &hap.Character{Format: hap.FormatTLV8}
+	err = dst.Write(test.actual)
+	require.Nil(t, err)
+
+	a, _ := base64.StdEncoding.DecodeString(test.value)
+	b, _ := base64.StdEncoding.DecodeString(dst.Value.(string))
+	t.Logf("%x\n", a)
+	t.Logf("%x\n", b)
+
+	if !test.noequal {
+		require.Equal(t, test.value, dst.Value)
+	}
+}
+
+func TestAqaraG3(t *testing.T) {
+	tests := []testTLV8{
+		{
+			name:   "120",
+			value:  "AQEA",
+			actual: &StreamingStatus{},
+			expect: &StreamingStatus{
+				Status: StreamingStatusAvailable,
+			},
+		},
+		{
+			name:   "114",
+			value:  "AaoBAQACEQEBAQIBAAAAAgECAwEABAEAAwsBAoAHAgI4BAMBHgAAAwsBAgAFAgLQAgMBHgAAAwsBAoACAgJoAQMBHgAAAwsBAuABAgIOAQMBHgAAAwsBAkABAgK0AAMBHgAAAwsBAgAFAgLAAwMBHgAAAwsBAgAEAgIAAwMBHgAAAwsBAoACAgLgAQMBHgAAAwsBAuABAgJoAQMBHgAAAwsBAkABAgLwAAMBHg==",
+			actual: &SupportedVideoStreamConfiguration{},
+			expect: &SupportedVideoStreamConfiguration{
+				Codecs: []VideoCodecConfiguration{
+					{
+						CodecType: VideoCodecTypeH264,
+						CodecParams: []VideoCodecParameters{
+							{
+								ProfileID:  []byte{VideoCodecProfileMain},
+								Level:      []byte{VideoCodecLevel31, VideoCodecLevel40},
+								CVOEnabled: []byte{0},
+							},
+						},
+						VideoAttrs: []VideoCodecAttributes{
+							{Width: 1920, Height: 1080, Framerate: 30},
+							{Width: 1280, Height: 720, Framerate: 30},
+							{Width: 640, Height: 360, Framerate: 30},
+							{Width: 480, Height: 270, Framerate: 30},
+							{Width: 320, Height: 180, Framerate: 30},
+							{Width: 1280, Height: 960, Framerate: 30},
+							{Width: 1024, Height: 768, Framerate: 30},
+							{Width: 640, Height: 480, Framerate: 30},
+							{Width: 480, Height: 360, Framerate: 30},
+							{Width: 320, Height: 240, Framerate: 30},
+						},
+					},
+				},
+			},
+		},
+		{
+			name:   "115",
+			value:  "AQ4BAQICCQEBAQIBAAMBAQIBAA==",
+			actual: &SupportedAudioStreamConfiguration{},
+			expect: &SupportedAudioStreamConfiguration{
+				Codecs: []AudioCodecConfiguration{
+					{
+						CodecType: AudioCodecTypeAACELD,
+						CodecParams: []AudioCodecParameters{
+							{
+								Channels:    1,
+								BitrateMode: AudioCodecBitrateVariable,
+								SampleRate:  []byte{AudioCodecSampleRate16Khz},
+							},
+						},
+					},
+				},
+				ComfortNoiseSupport: 0,
+			},
+		},
+		{
+			name:   "116",
+			value:  "AgEAAAACAQEAAAIBAg==",
+			actual: &SupportedRTPConfiguration{},
+			expect: &SupportedRTPConfiguration{
+				SRTPCryptoType: []byte{CryptoAES_CM_128_HMAC_SHA1_80, CryptoAES_CM_256_HMAC_SHA1_80, CryptoDisabled},
+			},
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, test.run)
+	}
+}
+
+func TestHomebridge(t *testing.T) {
+	tests := []testTLV8{
+		{
+			name:   "114",
+			value:  "AcUBAQACHQEBAAAAAQEBAAABAQICAQAAAAIBAQAAAgECAwEAAwsBAkABAgK0AAMBHgAAAwsBAkABAgLwAAMBDwAAAwsBAkABAgLwAAMBHgAAAwsBAuABAgIOAQMBHgAAAwsBAuABAgJoAQMBHgAAAwsBAoACAgJoAQMBHgAAAwsBAoACAgLgAQMBHgAAAwsBAgAFAgLQAgMBHgAAAwsBAgAFAgLAAwMBHgAAAwsBAoAHAgI4BAMBHgAAAwsBAkAGAgKwBAMBHg==",
+			actual: &SupportedVideoStreamConfiguration{},
+			expect: &SupportedVideoStreamConfiguration{
+				Codecs: []VideoCodecConfiguration{
+					{
+						CodecType: VideoCodecTypeH264,
+						CodecParams: []VideoCodecParameters{
+							{
+								ProfileID: []byte{VideoCodecProfileConstrainedBaseline, VideoCodecProfileMain, VideoCodecProfileHigh},
+								Level:     []byte{VideoCodecLevel31, VideoCodecLevel32, VideoCodecLevel40},
+							},
+						},
+						VideoAttrs: []VideoCodecAttributes{
+
+							{Width: 320, Height: 180, Framerate: 30},
+							{Width: 320, Height: 240, Framerate: 15},
+							{Width: 320, Height: 240, Framerate: 30},
+							{Width: 480, Height: 270, Framerate: 30},
+							{Width: 480, Height: 360, Framerate: 30},
+							{Width: 640, Height: 360, Framerate: 30},
+							{Width: 640, Height: 480, Framerate: 30},
+							{Width: 1280, Height: 720, Framerate: 30},
+							{Width: 1280, Height: 960, Framerate: 30},
+							{Width: 1920, Height: 1080, Framerate: 30},
+							{Width: 1600, Height: 1200, Framerate: 30},
+						},
+					},
+				},
+			},
+		},
+		{
+			name:   "116",
+			value:  "AgEA",
+			actual: &SupportedRTPConfiguration{},
+			expect: &SupportedRTPConfiguration{
+				SRTPCryptoType: []byte{CryptoAES_CM_128_HMAC_SHA1_80},
+			},
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, test.run)
+	}
+}
+
+func TestScrypted(t *testing.T) {
+	tests := []testTLV8{
+		{
+			name:   "114",
+			value:  "AVIBAQACEwEBAQIBAAAAAgEBAAACAQIDAQADCwECAA8CAnAIAwEeAAADCwECgAcCAjgEAwEeAAADCwECAAUCAtACAwEeAAADCwECQAECAvAAAwEP",
+			actual: &SupportedVideoStreamConfiguration{},
+			expect: &SupportedVideoStreamConfiguration{
+				Codecs: []VideoCodecConfiguration{
+					{
+						CodecType: VideoCodecTypeH264,
+						CodecParams: []VideoCodecParameters{
+							{
+								ProfileID: []byte{VideoCodecProfileMain},
+								Level:     []byte{VideoCodecLevel31, VideoCodecLevel32, VideoCodecLevel40},
+							},
+						},
+						VideoAttrs: []VideoCodecAttributes{
+							{Width: 3840, Height: 2160, Framerate: 30},
+							{Width: 1920, Height: 1080, Framerate: 30},
+							{Width: 1280, Height: 720, Framerate: 30},
+							{Width: 320, Height: 240, Framerate: 15},
+						},
+					},
+				},
+			},
+		},
+		{
+			name:   "115",
+			value:  "AScBAQMCIgEBAQIBAAMBAAAAAwEAAAADAQEAAAMBAQAAAwECAAADAQICAQA=",
+			actual: &SupportedAudioStreamConfiguration{},
+			expect: &SupportedAudioStreamConfiguration{
+				Codecs: []AudioCodecConfiguration{
+					{
+						CodecType: AudioCodecTypeOpus,
+						CodecParams: []AudioCodecParameters{
+							{
+								Channels:    1,
+								BitrateMode: AudioCodecBitrateVariable,
+								SampleRate: []byte{
+									AudioCodecSampleRate8Khz, AudioCodecSampleRate8Khz,
+									AudioCodecSampleRate16Khz, AudioCodecSampleRate16Khz,
+									AudioCodecSampleRate24Khz, AudioCodecSampleRate24Khz,
+								},
+							},
+						},
+					},
+				},
+				ComfortNoiseSupport: 0,
+			},
+		},
+		{
+			name:   "116",
+			value:  "AgEAAAACAQI=",
+			actual: &SupportedRTPConfiguration{},
+			expect: &SupportedRTPConfiguration{
+				SRTPCryptoType: []byte{CryptoAES_CM_128_HMAC_SHA1_80, CryptoDisabled},
+			},
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, test.run)
+	}
+}
+
+func TestHass(t *testing.T) {
+	tests := []testTLV8{
+		{
+			name:  "114",
+			value: "AdABAQACFQMBAAEBAAEBAQEBAgIBAAIBAQIBAgMMAQJAAQICtAADAg8AAwwBAkABAgLwAAMCDwADDAECQAECArQAAwIeAAMMAQJAAQIC8AADAh4AAwwBAuABAgIOAQMCHgADDAEC4AECAmgBAwIeAAMMAQKAAgICaAEDAh4AAwwBAoACAgLgAQMCHgADDAECAAQCAkACAwIeAAMMAQIABAICAAMDAh4AAwwBAgAFAgLQAgMCHgADDAECAAUCAsADAwIeAAMMAQKABwICOAQDAh4A",
+		},
+		{
+			name:  "115",
+			value: "AQ4BAQMCCQEBAQIBAAMBAgEOAQEDAgkBAQECAQADAQECAQA=",
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, test.run)
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/camera/ch114_supported_video.go b/installs_on_host/go2rtc/pkg/hap/camera/ch114_supported_video.go
new file mode 100644
index 0000000..ec70dc6
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/camera/ch114_supported_video.go
@@ -0,0 +1,46 @@
+package camera
+
+const TypeSupportedVideoStreamConfiguration = "114"
+
+type SupportedVideoStreamConfiguration struct {
+	Codecs []VideoCodecConfiguration `tlv8:"1"`
+}
+
+type VideoCodecConfiguration struct {
+	CodecType   byte                   `tlv8:"1"`
+	CodecParams []VideoCodecParameters `tlv8:"2"`
+	VideoAttrs  []VideoCodecAttributes `tlv8:"3"`
+	RTPParams   []RTPParams            `tlv8:"4"`
+}
+
+//goland:noinspection ALL
+const (
+	VideoCodecTypeH264 = 0
+
+	VideoCodecProfileConstrainedBaseline = 0
+	VideoCodecProfileMain                = 1
+	VideoCodecProfileHigh                = 2
+
+	VideoCodecLevel31 = 0
+	VideoCodecLevel32 = 1
+	VideoCodecLevel40 = 2
+
+	VideoCodecPacketizationModeNonInterleaved = 0
+
+	VideoCodecCvoNotSuppported = 0
+	VideoCodecCvoSuppported    = 1
+)
+
+type VideoCodecParameters struct {
+	ProfileID         []byte `tlv8:"1"` // 0 - baseline, 1 - main, 2 - high
+	Level             []byte `tlv8:"2"` // 0 - 3.1, 1 - 3.2, 2 - 4.0
+	PacketizationMode byte   `tlv8:"3"` // only 0 - non interleaved
+	CVOEnabled        []byte `tlv8:"4"` // 0 - not supported, 1 - supported
+	CVOID             []byte `tlv8:"5"` // ID for CVO RTP extensio
+}
+
+type VideoCodecAttributes struct {
+	Width     uint16 `tlv8:"1"`
+	Height    uint16 `tlv8:"2"`
+	Framerate uint8  `tlv8:"3"`
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/camera/ch115_supported_audio.go b/installs_on_host/go2rtc/pkg/hap/camera/ch115_supported_audio.go
new file mode 100644
index 0000000..f7ba9b4
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/camera/ch115_supported_audio.go
@@ -0,0 +1,46 @@
+package camera
+
+const TypeSupportedAudioStreamConfiguration = "115"
+
+type SupportedAudioStreamConfiguration struct {
+	Codecs              []AudioCodecConfiguration `tlv8:"1"`
+	ComfortNoiseSupport byte                      `tlv8:"2"`
+}
+
+//goland:noinspection ALL
+const (
+	AudioCodecTypePCMU   = 0
+	AudioCodecTypePCMA   = 1
+	AudioCodecTypeAACELD = 2
+	AudioCodecTypeOpus   = 3
+	AudioCodecTypeMSBC   = 4
+	AudioCodecTypeAMR    = 5
+	AudioCodecTypeARMWB  = 6
+
+	AudioCodecBitrateVariable = 0
+	AudioCodecBitrateConstant = 1
+
+	AudioCodecSampleRate8Khz  = 0
+	AudioCodecSampleRate16Khz = 1
+	AudioCodecSampleRate24Khz = 2
+
+	RTPTimeAACELD8  = 60 // 8000/1000*60=480
+	RTPTimeAACELD16 = 30 // 16000/1000*30=480
+	RTPTimeAACELD24 = 20 // 24000/1000*20=480
+	RTPTimeAACLD16  = 60 // 16000/1000*60=960
+	RTPTimeAACLD24  = 40 // 24000/1000*40=960
+)
+
+type AudioCodecConfiguration struct {
+	CodecType    byte                   `tlv8:"1"`
+	CodecParams  []AudioCodecParameters `tlv8:"2"`
+	RTPParams    []RTPParams            `tlv8:"3"`
+	ComfortNoise []byte                 `tlv8:"4"`
+}
+
+type AudioCodecParameters struct {
+	Channels    uint8   `tlv8:"1"`
+	BitrateMode byte    `tlv8:"2"` // 0 - variable, 1 - constant
+	SampleRate  []byte  `tlv8:"3"` // 0 - 8000, 1 - 16000, 2 - 24000
+	RTPTime     []uint8 `tlv8:"4"` // 20, 30, 40, 60
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/camera/ch116_supported_rtp.go b/installs_on_host/go2rtc/pkg/hap/camera/ch116_supported_rtp.go
new file mode 100644
index 0000000..f0ca0db
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/camera/ch116_supported_rtp.go
@@ -0,0 +1,14 @@
+package camera
+
+const TypeSupportedRTPConfiguration = "116"
+
+//goland:noinspection ALL
+const (
+	CryptoAES_CM_128_HMAC_SHA1_80 = 0
+	CryptoAES_CM_256_HMAC_SHA1_80 = 1
+	CryptoDisabled                = 2
+)
+
+type SupportedRTPConfiguration struct {
+	SRTPCryptoType []byte `tlv8:"2"`
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/camera/ch117_selected_stream.go b/installs_on_host/go2rtc/pkg/hap/camera/ch117_selected_stream.go
new file mode 100644
index 0000000..d94ba96
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/camera/ch117_selected_stream.go
@@ -0,0 +1,32 @@
+package camera
+
+const TypeSelectedStreamConfiguration = "117"
+
+type SelectedStreamConfiguration struct {
+	Control    SessionControl          `tlv8:"1"`
+	VideoCodec VideoCodecConfiguration `tlv8:"2"`
+	AudioCodec AudioCodecConfiguration `tlv8:"3"`
+}
+
+//goland:noinspection ALL
+const (
+	SessionCommandEnd         = 0
+	SessionCommandStart       = 1
+	SessionCommandSuspend     = 2
+	SessionCommandResume      = 3
+	SessionCommandReconfigure = 4
+)
+
+type SessionControl struct {
+	SessionID string `tlv8:"1"`
+	Command   byte   `tlv8:"2"`
+}
+
+type RTPParams struct {
+	PayloadType             uint8    `tlv8:"1"`
+	SSRC                    uint32   `tlv8:"2"`
+	MaxBitrate              uint16   `tlv8:"3"`
+	RTCPInterval            float32  `tlv8:"4"`
+	MaxMTU                  []uint16 `tlv8:"5"`
+	ComfortNoisePayloadType []uint8  `tlv8:"6"`
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/camera/ch118_setup_endpoints.go b/installs_on_host/go2rtc/pkg/hap/camera/ch118_setup_endpoints.go
new file mode 100644
index 0000000..e0f426c
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/camera/ch118_setup_endpoints.go
@@ -0,0 +1,33 @@
+package camera
+
+const TypeSetupEndpoints = "118"
+
+type SetupEndpointsRequest struct {
+	SessionID   string          `tlv8:"1"`
+	Address     Address         `tlv8:"3"`
+	VideoCrypto SRTPCryptoSuite `tlv8:"4"`
+	AudioCrypto SRTPCryptoSuite `tlv8:"5"`
+}
+
+type SetupEndpointsResponse struct {
+	SessionID   string          `tlv8:"1"`
+	Status      byte            `tlv8:"2"`
+	Address     Address         `tlv8:"3"`
+	VideoCrypto SRTPCryptoSuite `tlv8:"4"`
+	AudioCrypto SRTPCryptoSuite `tlv8:"5"`
+	VideoSSRC   uint32          `tlv8:"6"`
+	AudioSSRC   uint32          `tlv8:"7"`
+}
+
+type Address struct {
+	IPVersion    byte   `tlv8:"1"`
+	IPAddr       string `tlv8:"2"`
+	VideoRTPPort uint16 `tlv8:"3"`
+	AudioRTPPort uint16 `tlv8:"4"`
+}
+
+type SRTPCryptoSuite struct {
+	CryptoSuite byte   `tlv8:"1"`
+	MasterKey   string `tlv8:"2"` // 16 (AES_CM_128) or 32 (AES_256_CM)
+	MasterSalt  string `tlv8:"3"` // 14 byte
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/camera/ch120_streaming_status.go b/installs_on_host/go2rtc/pkg/hap/camera/ch120_streaming_status.go
new file mode 100644
index 0000000..e617df2
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/camera/ch120_streaming_status.go
@@ -0,0 +1,14 @@
+package camera
+
+const TypeStreamingStatus = "120"
+
+type StreamingStatus struct {
+	Status byte `tlv8:"1"`
+}
+
+//goland:noinspection ALL
+const (
+	StreamingStatusAvailable   = 0
+	StreamingStatusInUse       = 1
+	StreamingStatusUnavailable = 2
+)
diff --git a/installs_on_host/go2rtc/pkg/hap/camera/ch130_data_stream_transport.go b/installs_on_host/go2rtc/pkg/hap/camera/ch130_data_stream_transport.go
new file mode 100644
index 0000000..808f822
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/camera/ch130_data_stream_transport.go
@@ -0,0 +1,11 @@
+package camera
+
+const TypeSupportedDataStreamTransportConfiguration = "130"
+
+type SupportedDataStreamTransportConfiguration struct {
+	Configs []TransferTransportConfiguration `tlv8:"1"`
+}
+
+type TransferTransportConfiguration struct {
+	TransportType byte `tlv8:"1"`
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/camera/ch131_data_stream.go b/installs_on_host/go2rtc/pkg/hap/camera/ch131_data_stream.go
new file mode 100644
index 0000000..4f4ab49
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/camera/ch131_data_stream.go
@@ -0,0 +1,17 @@
+package camera
+
+const TypeSetupDataStreamTransport = "131"
+
+type SetupDataStreamTransportRequest struct {
+	SessionCommandType byte   `tlv8:"1"`
+	TransportType      byte   `tlv8:"2"`
+	ControllerKeySalt  string `tlv8:"3"`
+}
+
+type SetupDataStreamTransportResponse struct {
+	Status                         byte `tlv8:"1"`
+	TransportTypeSessionParameters struct {
+		TCPListeningPort uint16 `tlv8:"1"`
+	} `tlv8:"2"`
+	AccessoryKeySalt string `tlv8:"3"`
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/camera/ch205.go b/installs_on_host/go2rtc/pkg/hap/camera/ch205.go
new file mode 100644
index 0000000..431db7b
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/camera/ch205.go
@@ -0,0 +1,18 @@
+package camera
+
+const TypeSupportedCameraRecordingConfiguration = "205"
+
+type SupportedCameraRecordingConfiguration struct {
+	PrebufferLength              uint32 `tlv8:"1"`
+	EventTriggerOptions          uint64 `tlv8:"2"`
+	MediaContainerConfigurations `tlv8:"3"`
+}
+
+type MediaContainerConfigurations struct {
+	MediaContainerType       uint8 `tlv8:"1"`
+	MediaContainerParameters `tlv8:"2"`
+}
+
+type MediaContainerParameters struct {
+	FragmentLength uint32 `tlv8:"1"`
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/camera/ch206.go b/installs_on_host/go2rtc/pkg/hap/camera/ch206.go
new file mode 100644
index 0000000..89219fa
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/camera/ch206.go
@@ -0,0 +1,20 @@
+package camera
+
+const TypeSupportedVideoRecordingConfiguration = "206"
+
+type SupportedVideoRecordingConfiguration struct {
+	CodecConfigs []VideoRecordingCodecConfiguration `tlv8:"1"`
+}
+
+type VideoRecordingCodecConfiguration struct {
+	CodecType   uint8                         `tlv8:"1"`
+	CodecParams VideoRecordingCodecParameters `tlv8:"2"`
+	CodecAttrs  VideoCodecAttributes          `tlv8:"3"`
+}
+
+type VideoRecordingCodecParameters struct {
+	ProfileID      uint8  `tlv8:"1"`
+	Level          uint8  `tlv8:"2"`
+	Bitrate        uint32 `tlv8:"3"`
+	IFrameInterval uint32 `tlv8:"4"`
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/camera/ch207.go b/installs_on_host/go2rtc/pkg/hap/camera/ch207.go
new file mode 100644
index 0000000..5d38992
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/camera/ch207.go
@@ -0,0 +1,19 @@
+package camera
+
+const TypeSupportedAudioRecordingConfiguration = "207"
+
+type SupportedAudioRecordingConfiguration struct {
+	CodecConfigs []AudioRecordingCodecConfiguration `tlv8:"1"`
+}
+
+type AudioRecordingCodecConfiguration struct {
+	CodecType   byte                            `tlv8:"1"`
+	CodecParams []AudioRecordingCodecParameters `tlv8:"2"`
+}
+
+type AudioRecordingCodecParameters struct {
+	Channels        uint8    `tlv8:"1"`
+	BitrateMode     []byte   `tlv8:"2"`
+	SampleRate      []byte   `tlv8:"3"`
+	MaxAudioBitrate []uint32 `tlv8:"4"`
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/camera/ch209.go b/installs_on_host/go2rtc/pkg/hap/camera/ch209.go
new file mode 100644
index 0000000..c51359f
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/camera/ch209.go
@@ -0,0 +1,9 @@
+package camera
+
+const TypeSelectedCameraRecordingConfiguration = "209"
+
+type SelectedCameraRecordingConfiguration struct {
+	GeneralConfig SupportedCameraRecordingConfiguration `tlv8:"1"`
+	VideoConfig   SupportedVideoRecordingConfiguration  `tlv8:"2"`
+	AudioConfig   SupportedAudioRecordingConfiguration  `tlv8:"3"`
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/camera/stream.go b/installs_on_host/go2rtc/pkg/hap/camera/stream.go
new file mode 100644
index 0000000..bda6792
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/camera/stream.go
@@ -0,0 +1,184 @@
+package camera
+
+import (
+	"errors"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/hap"
+	"github.com/AlexxIT/go2rtc/pkg/srtp"
+)
+
+type Stream struct {
+	id      string
+	client  *hap.Client
+	service *hap.Service
+}
+
+func NewStream(
+	client *hap.Client, videoCodec *VideoCodecConfiguration, audioCodec *AudioCodecConfiguration,
+	videoSession, audioSession *srtp.Session, bitrate int,
+) (*Stream, error) {
+	stream := &Stream{
+		id:     core.RandString(16, 0),
+		client: client,
+	}
+
+	if err := stream.GetFreeStream(); err != nil {
+		return nil, err
+	}
+
+	if err := stream.ExchangeEndpoints(videoSession, audioSession); err != nil {
+		return nil, err
+	}
+
+	if bitrate != 0 {
+		bitrate /= 1024 // convert bps to kbps
+	} else {
+		bitrate = 4096 // default kbps for general FullHD camera
+	}
+
+	videoCodec.RTPParams = []RTPParams{
+		{
+			PayloadType:  99,
+			SSRC:         videoSession.Local.SSRC,
+			MaxBitrate:   uint16(bitrate), // iPhone query 299Kbps, iPad/AppleTV query 802Kbps
+			RTCPInterval: 0.5,
+			MaxMTU:       []uint16{1378},
+		},
+	}
+	audioCodec.RTPParams = []RTPParams{
+		{
+			PayloadType:  110,
+			SSRC:         audioSession.Local.SSRC,
+			MaxBitrate:   24, // any iDevice query 24Kbps (this is OK for 16KHz and 1 channel)
+			RTCPInterval: 5,
+
+			ComfortNoisePayloadType: []uint8{13},
+		},
+	}
+	audioCodec.ComfortNoise = []byte{0}
+
+	config := &SelectedStreamConfiguration{
+		Control: SessionControl{
+			SessionID: stream.id,
+			Command:   SessionCommandStart,
+		},
+		VideoCodec: *videoCodec,
+		AudioCodec: *audioCodec,
+	}
+
+	if err := stream.SetStreamConfig(config); err != nil {
+		return nil, err
+	}
+
+	return stream, nil
+}
+
+// GetFreeStream search free streaming service.
+// Usual every HomeKit camera can stream only to two clients simultaniosly.
+// So it has two similar services for streaming.
+func (s *Stream) GetFreeStream() error {
+	acc, err := s.client.GetFirstAccessory()
+	if err != nil {
+		return err
+	}
+
+	for _, srv := range acc.Services {
+		for _, char := range srv.Characters {
+			if char.Type == TypeStreamingStatus {
+				var status StreamingStatus
+				if err = char.ReadTLV8(&status); err != nil {
+					return err
+				}
+
+				if status.Status == StreamingStatusAvailable {
+					s.service = srv
+					return nil
+				}
+			}
+		}
+	}
+
+	return errors.New("hap: no free streams")
+}
+
+func (s *Stream) ExchangeEndpoints(videoSession, audioSession *srtp.Session) error {
+	req := SetupEndpointsRequest{
+		SessionID: s.id,
+		Address: Address{
+			IPVersion:    0,
+			IPAddr:       videoSession.Local.Addr,
+			VideoRTPPort: videoSession.Local.Port,
+			AudioRTPPort: audioSession.Local.Port,
+		},
+		VideoCrypto: SRTPCryptoSuite{
+			MasterKey:  string(videoSession.Local.MasterKey),
+			MasterSalt: string(videoSession.Local.MasterSalt),
+		},
+		AudioCrypto: SRTPCryptoSuite{
+			MasterKey:  string(audioSession.Local.MasterKey),
+			MasterSalt: string(audioSession.Local.MasterSalt),
+		},
+	}
+
+	char := s.service.GetCharacter(TypeSetupEndpoints)
+	if err := char.Write(&req); err != nil {
+		return err
+	}
+	if err := s.client.PutCharacters(char); err != nil {
+		return err
+	}
+
+	var res SetupEndpointsResponse
+	if err := s.client.GetCharacter(char); err != nil {
+		return err
+	}
+	if err := char.ReadTLV8(&res); err != nil {
+		return err
+	}
+
+	videoSession.Remote = &srtp.Endpoint{
+		Addr:       res.Address.IPAddr,
+		Port:       res.Address.VideoRTPPort,
+		MasterKey:  []byte(res.VideoCrypto.MasterKey),
+		MasterSalt: []byte(res.VideoCrypto.MasterSalt),
+		SSRC:       res.VideoSSRC,
+	}
+
+	audioSession.Remote = &srtp.Endpoint{
+		Addr:       res.Address.IPAddr,
+		Port:       res.Address.AudioRTPPort,
+		MasterKey:  []byte(res.AudioCrypto.MasterKey),
+		MasterSalt: []byte(res.AudioCrypto.MasterSalt),
+		SSRC:       res.AudioSSRC,
+	}
+
+	return nil
+}
+
+func (s *Stream) SetStreamConfig(config *SelectedStreamConfiguration) error {
+	char := s.service.GetCharacter(TypeSelectedStreamConfiguration)
+	if err := char.Write(config); err != nil {
+		return err
+	}
+	if err := s.client.PutCharacters(char); err != nil {
+		return err
+	}
+
+	return s.client.GetCharacter(char)
+}
+
+func (s *Stream) Close() error {
+	config := &SelectedStreamConfiguration{
+		Control: SessionControl{
+			SessionID: s.id,
+			Command:   SessionCommandEnd,
+		},
+	}
+
+	char := s.service.GetCharacter(TypeSelectedStreamConfiguration)
+	if err := char.Write(config); err != nil {
+		return err
+	}
+	return s.client.PutCharacters(char)
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/chacha20poly1305/chacha20poly1305.go b/installs_on_host/go2rtc/pkg/hap/chacha20poly1305/chacha20poly1305.go
new file mode 100644
index 0000000..27a35d4
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/chacha20poly1305/chacha20poly1305.go
@@ -0,0 +1,51 @@
+package chacha20poly1305
+
+import (
+	"errors"
+
+	"golang.org/x/crypto/chacha20poly1305"
+)
+
+var ErrInvalidParams = errors.New("chacha20poly1305: invalid params")
+
+// Decrypt - decrypt without verify
+func Decrypt(key32 []byte, nonce8 string, ciphertext []byte) ([]byte, error) {
+	return DecryptAndVerify(key32, nil, []byte(nonce8), ciphertext, nil)
+}
+
+// Encrypt - encrypt without seal
+func Encrypt(key32 []byte, nonce8 string, plaintext []byte) ([]byte, error) {
+	return EncryptAndSeal(key32, nil, []byte(nonce8), plaintext, nil)
+}
+
+func DecryptAndVerify(key32, dst, nonce8, ciphertext, verify []byte) ([]byte, error) {
+	if len(key32) != chacha20poly1305.KeySize || len(nonce8) != 8 {
+		return nil, ErrInvalidParams
+	}
+
+	aead, err := chacha20poly1305.New(key32)
+	if err != nil {
+		return nil, err
+	}
+
+	nonce := make([]byte, chacha20poly1305.NonceSize)
+	copy(nonce[4:], nonce8)
+
+	return aead.Open(dst, nonce, ciphertext, verify)
+}
+
+func EncryptAndSeal(key32, dst, nonce8, plaintext, verify []byte) ([]byte, error) {
+	if len(key32) != chacha20poly1305.KeySize || len(nonce8) != 8 {
+		return nil, ErrInvalidParams
+	}
+
+	aead, err := chacha20poly1305.New(key32)
+	if err != nil {
+		return nil, err
+	}
+
+	nonce := make([]byte, chacha20poly1305.NonceSize)
+	copy(nonce[4:], nonce8)
+
+	return aead.Seal(dst, nonce, plaintext, verify), nil
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/character.go b/installs_on_host/go2rtc/pkg/hap/character.go
new file mode 100644
index 0000000..afa321e
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/character.go
@@ -0,0 +1,149 @@
+package hap
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+
+	"github.com/AlexxIT/go2rtc/pkg/hap/tlv8"
+)
+
+// Character - Aqara props order
+// Value should be omit for PW
+// Value may be empty for PR
+type Character struct {
+	Desc string `json:"description,omitempty"`
+
+	IID    uint64   `json:"iid"`
+	Type   string   `json:"type"`
+	Format string   `json:"format"`
+	Value  any      `json:"value,omitempty"`
+	Perms  []string `json:"perms"`
+
+	//MaxLen   int    `json:"maxLen,omitempty"`
+	//Unit     string `json:"unit,omitempty"`
+	//MinValue any    `json:"minValue,omitempty"`
+	//MaxValue any    `json:"maxValue,omitempty"`
+	//MinStep  any    `json:"minStep,omitempty"`
+	//ValidVal []any  `json:"valid-values,omitempty"`
+
+	listeners map[io.Writer]bool
+}
+
+func (c *Character) AddListener(w io.Writer) {
+	// TODO: sync.Mutex
+	if c.listeners == nil {
+		c.listeners = map[io.Writer]bool{}
+	}
+	c.listeners[w] = true
+}
+
+func (c *Character) RemoveListener(w io.Writer) {
+	delete(c.listeners, w)
+
+	if len(c.listeners) == 0 {
+		c.listeners = nil
+	}
+}
+
+func (c *Character) NotifyListeners(ignore io.Writer) error {
+	if c.listeners == nil {
+		return nil
+	}
+
+	data, err := c.GenerateEvent()
+	if err != nil {
+		return err
+	}
+
+	for w := range c.listeners {
+		if w == ignore {
+			continue
+		}
+		if _, err = w.Write(data); err != nil {
+			// error not a problem - just remove listener
+			c.RemoveListener(w)
+		}
+	}
+
+	return nil
+}
+
+// GenerateEvent with raw HTTP headers
+func (c *Character) GenerateEvent() (data []byte, err error) {
+	v := JSONCharacters{
+		Value: []JSONCharacter{
+			{AID: DeviceAID, IID: c.IID, Value: c.Value},
+		},
+	}
+	if data, err = json.Marshal(v); err != nil {
+		return
+	}
+
+	res := http.Response{
+		StatusCode:    http.StatusOK,
+		ProtoMajor:    1,
+		ProtoMinor:    0,
+		Header:        http.Header{"Content-Type": []string{MimeJSON}},
+		ContentLength: int64(len(data)),
+		Body:          io.NopCloser(bytes.NewReader(data)),
+	}
+
+	buf := bytes.NewBuffer([]byte{0})
+	if err = res.Write(buf); err != nil {
+		return
+	}
+	copy(buf.Bytes(), "EVENT")
+
+	return buf.Bytes(), err
+}
+
+// Set new value and NotifyListeners
+func (c *Character) Set(v any) (err error) {
+	if err = c.Write(v); err != nil {
+		return
+	}
+	return c.NotifyListeners(nil)
+}
+
+// Write new value with right format
+func (c *Character) Write(v any) (err error) {
+	switch c.Format {
+	case "tlv8":
+		c.Value, err = tlv8.MarshalBase64(v)
+
+	case "bool":
+		switch v := v.(type) {
+		case bool:
+			c.Value = v
+		case float64:
+			c.Value = v != 0
+		}
+	}
+	return
+}
+
+// ReadTLV8 value to right struct
+func (c *Character) ReadTLV8(v any) (err error) {
+	if s, ok := c.Value.(string); ok {
+		return tlv8.UnmarshalBase64(s, v)
+	}
+	return fmt.Errorf("hap: can't read value: %v", v)
+}
+
+func (c *Character) ReadBool() (bool, error) {
+	if v, ok := c.Value.(bool); ok {
+		return v, nil
+	}
+	return false, fmt.Errorf("hap: can't read value: %v", c.Value)
+}
+
+func (c *Character) String() string {
+	data, err := json.Marshal(c)
+	if err != nil {
+		return "ERROR"
+	}
+	return string(data)
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/client.go b/installs_on_host/go2rtc/pkg/hap/client.go
new file mode 100644
index 0000000..ed4faa0
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/client.go
@@ -0,0 +1,375 @@
+package hap
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/hap/chacha20poly1305"
+	"github.com/AlexxIT/go2rtc/pkg/hap/curve25519"
+	"github.com/AlexxIT/go2rtc/pkg/hap/ed25519"
+	"github.com/AlexxIT/go2rtc/pkg/hap/hkdf"
+	"github.com/AlexxIT/go2rtc/pkg/hap/tlv8"
+	"github.com/AlexxIT/go2rtc/pkg/mdns"
+)
+
+const (
+	ConnDialTimeout = time.Second * 3
+	ConnDeadline    = time.Second * 3
+)
+
+// Client for HomeKit. DevicePublic can be null.
+type Client struct {
+	DeviceAddress string // including port
+	DeviceID      string // aka. Accessory
+	DevicePublic  []byte
+	ClientID      string // aka. Controller
+	ClientPrivate []byte
+
+	OnEvent func(res *http.Response)
+	//Output  func(msg any)
+
+	Conn   net.Conn
+	reader *bufio.Reader
+
+	res chan *http.Response
+	err error
+}
+
+func Dial(rawURL string) (*Client, error) {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	query := u.Query()
+	c := &Client{
+		DeviceAddress: u.Host,
+		DeviceID:      query.Get("device_id"),
+		DevicePublic:  DecodeKey(query.Get("device_public")),
+		ClientID:      query.Get("client_id"),
+		ClientPrivate: DecodeKey(query.Get("client_private")),
+	}
+
+	if err = c.Dial(); err != nil {
+		return nil, err
+	}
+
+	return c, nil
+}
+
+func (c *Client) ClientPublic() []byte {
+	return c.ClientPrivate[32:]
+}
+
+func (c *Client) URL() string {
+	return fmt.Sprintf(
+		"homekit://%s?device_id=%s&device_public=%16x&client_id=%s&client_private=%32x",
+		c.DeviceAddress, c.DeviceID, c.DevicePublic, c.ClientID, c.ClientPrivate,
+	)
+}
+
+func (c *Client) DeviceHost() string {
+	if i := strings.IndexByte(c.DeviceAddress, ':'); i > 0 {
+		return c.DeviceAddress[:i]
+	}
+	return c.DeviceAddress
+}
+
+func (c *Client) Dial() (err error) {
+	if len(c.ClientID) == 0 || len(c.ClientPrivate) == 0 {
+		return errors.New("hap: can't dial witout client_id or client_private")
+	}
+
+	// update device address (host and/or port) before dial
+	_ = mdns.QueryOrDiscovery(c.DeviceHost(), mdns.ServiceHAP, func(entry *mdns.ServiceEntry) bool {
+		if entry.Complete() && entry.Info["id"] == c.DeviceID {
+			c.DeviceAddress = entry.Addr()
+			return true
+		}
+		return false
+	})
+
+	// TODO: close conn on error
+	if c.Conn, err = net.DialTimeout("tcp", c.DeviceAddress, ConnDialTimeout); err != nil {
+		return
+	}
+
+	c.reader = bufio.NewReader(c.Conn)
+
+	// STEP M1: send our session public to device
+	sessionPublic, sessionPrivate := curve25519.GenerateKeyPair()
+
+	// 1. Send sessionPublic
+	plainM1 := struct {
+		PublicKey string `tlv8:"3"`
+		State     byte   `tlv8:"6"`
+	}{
+		PublicKey: string(sessionPublic),
+		State:     StateM1,
+	}
+	res, err := c.Post(PathPairVerify, MimeTLV8, tlv8.MarshalReader(plainM1))
+	if err != nil {
+		return
+	}
+
+	// STEP M2: unpack deviceID from response
+	var cipherM2 struct {
+		PublicKey     string `tlv8:"3"`
+		EncryptedData string `tlv8:"5"`
+		State         byte   `tlv8:"6"`
+	}
+	if err = tlv8.UnmarshalReader(res.Body, res.ContentLength, &cipherM2); err != nil {
+		return err
+	}
+	if cipherM2.State != StateM2 {
+		return newResponseError(plainM1, cipherM2)
+	}
+
+	// 1. generate session shared key
+	sessionShared, err := curve25519.SharedSecret(sessionPrivate, []byte(cipherM2.PublicKey))
+	if err != nil {
+		return
+	}
+
+	sessionKey, err := hkdf.Sha512(
+		sessionShared, "Pair-Verify-Encrypt-Salt", "Pair-Verify-Encrypt-Info",
+	)
+	if err != nil {
+		return
+	}
+
+	// 2. decrypt M2 response with session key
+	b, err := chacha20poly1305.Decrypt(sessionKey, "PV-Msg02", []byte(cipherM2.EncryptedData))
+	if err != nil {
+		return
+	}
+
+	// 3. unpack payload from TLV8
+	var plainM2 struct {
+		Identifier string `tlv8:"1"`
+		Signature  string `tlv8:"10"`
+	}
+	if err = tlv8.Unmarshal(b, &plainM2); err != nil {
+		return
+	}
+
+	// 4. verify signature for M2 response with device public
+	// device session + device id + our session
+	if c.DevicePublic != nil {
+		b = Append(cipherM2.PublicKey, plainM2.Identifier, sessionPublic)
+		if !ed25519.ValidateSignature(c.DevicePublic, b, []byte(plainM2.Signature)) {
+			return errors.New("hap: ValidateSignature")
+		}
+	}
+
+	// STEP M3: send our clientID to device
+	// 1. generate signature with our private key
+	// (our session + our ID + device session)
+	b = Append(sessionPublic, c.ClientID, cipherM2.PublicKey)
+	if b, err = ed25519.Signature(c.ClientPrivate, b); err != nil {
+		return
+	}
+
+	// 2. generate payload
+	plainM3 := struct {
+		Identifier string `tlv8:"1"`
+		Signature  string `tlv8:"10"`
+	}{
+		Identifier: c.ClientID,
+		Signature:  string(b),
+	}
+	if b, err = tlv8.Marshal(plainM3); err != nil {
+		return
+	}
+
+	// 4. encrypt payload with session key
+	if b, err = chacha20poly1305.Encrypt(sessionKey, "PV-Msg03", b); err != nil {
+		return
+	}
+
+	// 4. generate request
+	cipherM3 := struct {
+		EncryptedData string `tlv8:"5"`
+		State         byte   `tlv8:"6"`
+	}{
+		State:         StateM3,
+		EncryptedData: string(b),
+	}
+	if res, err = c.Post(PathPairVerify, MimeTLV8, tlv8.MarshalReader(cipherM3)); err != nil {
+		return
+	}
+
+	// STEP M4. Read response
+	var plainM4 struct {
+		State byte `tlv8:"6"`
+	}
+	if err = tlv8.UnmarshalReader(res.Body, res.ContentLength, &plainM4); err != nil {
+		return
+	}
+	if plainM4.State != StateM4 {
+		return newResponseError(cipherM3, plainM4)
+	}
+
+	rw := bufio.NewReadWriter(c.reader, bufio.NewWriter(c.Conn))
+
+	// like tls.Client wrapper over net.Conn
+	if c.Conn, err = NewConn(c.Conn, rw, sessionShared, true); err != nil {
+		return
+	}
+	// new reader for new conn
+	c.reader = bufio.NewReader(c.Conn)
+
+	return
+}
+
+func (c *Client) Close() error {
+	if c.Conn == nil {
+		return nil
+	}
+	return c.Conn.Close()
+}
+
+func (c *Client) eventsReader() {
+	c.res = make(chan *http.Response)
+
+	for {
+		var res *http.Response
+		if res, c.err = ReadResponse(c.reader, nil); c.err != nil {
+			break
+		}
+
+		var body []byte
+		if body, c.err = io.ReadAll(res.Body); c.err != nil {
+			break
+		}
+
+		res.Body = io.NopCloser(bytes.NewReader(body))
+
+		if res.Proto != ProtoEvent {
+			c.res <- res
+		} else if c.OnEvent != nil {
+			c.OnEvent(res)
+		}
+	}
+
+	close(c.res)
+}
+
+func (c *Client) GetAccessories() ([]*Accessory, error) {
+	res, err := c.Get(PathAccessories)
+	if err != nil {
+		return nil, err
+	}
+
+	var v JSONAccessories
+	if err = json.NewDecoder(res.Body).Decode(&v); err != nil {
+		return nil, err
+	}
+
+	return v.Value, nil
+}
+
+func (c *Client) GetFirstAccessory() (*Accessory, error) {
+	accs, err := c.GetAccessories()
+	if err != nil {
+		return nil, err
+	}
+	if len(accs) == 0 {
+		return nil, errors.New("hap: GetAccessories zero answer")
+	}
+	return accs[0], nil
+}
+
+func (c *Client) GetCharacters(query string) ([]JSONCharacter, error) {
+	res, err := c.Get(PathCharacteristics + "?id=" + query)
+	if err != nil {
+		return nil, err
+	}
+
+	data, err := io.ReadAll(res.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	var v JSONCharacters
+	if err = json.Unmarshal(data, &v); err != nil {
+		return nil, err
+	}
+	return v.Value, nil
+}
+
+func (c *Client) GetCharacter(char *Character) error {
+	query := fmt.Sprintf("%d.%d", DeviceAID, char.IID)
+	chars, err := c.GetCharacters(query)
+	if err != nil {
+		return err
+	}
+	char.Value = chars[0].Value
+	return nil
+}
+
+func (c *Client) PutCharacters(characters ...*Character) error {
+	var v JSONCharacters
+	for i, char := range characters {
+		v.Value = append(v.Value, JSONCharacter{
+			AID:   1,
+			IID:   char.IID,
+			Value: char.Value,
+		})
+		characters[i] = char
+	}
+	body, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+
+	res, err := c.Put(PathCharacteristics, MimeJSON, bytes.NewReader(body))
+	if err != nil {
+		return err
+	}
+
+	_, _ = io.ReadAll(res.Body) // important to "clear" body
+
+	return nil
+}
+
+func (c *Client) GetImage(width, height int) ([]byte, error) {
+	s := fmt.Sprintf(
+		`{"image-width":%d,"image-height":%d,"resource-type":"image","reason":0}`,
+		width, height,
+	)
+	res, err := c.Post(PathResource, MimeJSON, bytes.NewBufferString(s))
+	if err != nil {
+		return nil, err
+	}
+	return io.ReadAll(res.Body)
+}
+
+func (c *Client) LocalIP() string {
+	if c.Conn == nil {
+		return ""
+	}
+	addr := c.Conn.LocalAddr().(*net.TCPAddr)
+	return addr.IP.String()
+}
+
+func DecodeKey(s string) []byte {
+	if s == "" {
+		return nil
+	}
+	data, err := hex.DecodeString(s)
+	if err != nil {
+		return nil
+	}
+	return data
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/client_http.go b/installs_on_host/go2rtc/pkg/hap/client_http.go
new file mode 100644
index 0000000..7f8314f
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/client_http.go
@@ -0,0 +1,101 @@
+package hap
+
+import (
+	"bufio"
+	"errors"
+	"io"
+	"net/http"
+)
+
+const (
+	MimeTLV8 = "application/pairing+tlv8"
+	MimeJSON = "application/hap+json"
+
+	PathPairSetup       = "/pair-setup"
+	PathPairVerify      = "/pair-verify"
+	PathPairings        = "/pairings"
+	PathAccessories     = "/accessories"
+	PathCharacteristics = "/characteristics"
+	PathResource        = "/resource"
+)
+
+func (c *Client) Do(req *http.Request) (*http.Response, error) {
+	if err := req.Write(c.Conn); err != nil {
+		return nil, err
+	}
+	if c.res != nil {
+		return <-c.res, c.err
+	}
+	return http.ReadResponse(c.reader, req)
+}
+
+func (c *Client) Request(method, path, contentType string, body io.Reader) (*http.Response, error) {
+	req, err := http.NewRequest(method, "http://"+c.DeviceAddress+path, body)
+	if err != nil {
+		return nil, err
+	}
+
+	if contentType != "" {
+		req.Header.Set("Content-Type", contentType)
+	}
+
+	res, err := c.Do(req)
+	if err == nil && res.StatusCode >= http.StatusBadRequest {
+		err = errors.New("hap: wrong http status: " + res.Status)
+	}
+
+	return res, err
+}
+
+func (c *Client) Get(path string) (*http.Response, error) {
+	return c.Request("GET", path, "", nil)
+}
+
+func (c *Client) Post(path, contentType string, body io.Reader) (*http.Response, error) {
+	return c.Request("POST", path, contentType, body)
+}
+
+func (c *Client) Put(path, contentType string, body io.Reader) (*http.Response, error) {
+	return c.Request("PUT", path, contentType, body)
+}
+
+const ProtoEvent = "EVENT/1.0"
+
+func ReadResponse(r *bufio.Reader, req *http.Request) (*http.Response, error) {
+	b, err := r.Peek(9)
+	if err != nil {
+		return nil, err
+	}
+
+	if string(b) != ProtoEvent {
+		return http.ReadResponse(r, req)
+	}
+
+	copy(b, "HTTP/1.1 ")
+
+	res, err := http.ReadResponse(r, req)
+	if err != nil {
+		return nil, err
+	}
+
+	res.Proto = ProtoEvent
+
+	return res, nil
+}
+
+func WriteEvent(w io.Writer, res *http.Response) error {
+	return res.Write(&eventWriter{w: w})
+}
+
+type eventWriter struct {
+	w    io.Writer
+	done bool
+}
+
+func (e *eventWriter) Write(p []byte) (n int, err error) {
+	if !e.done {
+		p = append([]byte("EVENT/1.0"), p[8:]...)
+		e.done = true
+	}
+	return e.w.Write(p)
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/client_pairing.go b/installs_on_host/go2rtc/pkg/hap/client_pairing.go
new file mode 100644
index 0000000..f253783
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/client_pairing.go
@@ -0,0 +1,403 @@
+package hap
+
+import (
+	"bufio"
+	"crypto/sha512"
+	"errors"
+	"net"
+	"net/url"
+
+	"github.com/AlexxIT/go2rtc/pkg/hap/chacha20poly1305"
+	"github.com/AlexxIT/go2rtc/pkg/hap/ed25519"
+	"github.com/AlexxIT/go2rtc/pkg/hap/hkdf"
+	"github.com/AlexxIT/go2rtc/pkg/hap/tlv8"
+	"github.com/tadglines/go-pkgs/crypto/srp"
+)
+
+// Pair homekit
+func Pair(rawURL string) (*Client, error) {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	query := u.Query()
+
+	c := &Client{
+		DeviceAddress: u.Host,
+		DeviceID:      query.Get("device_id"),
+		ClientID:      query.Get("client_id"),
+		ClientPrivate: DecodeKey(query.Get("client_private")),
+	}
+
+	if c.ClientID == "" {
+		c.ClientID = GenerateUUID()
+	}
+	if c.ClientPrivate == nil {
+		c.ClientPrivate = GenerateKey()
+	}
+
+	if err = c.Pair(query.Get("feature"), query.Get("pin")); err != nil {
+		return nil, err
+	}
+
+	return c, nil
+}
+
+func Unpair(rawURL string) error {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return err
+	}
+
+	query := u.Query()
+	conn := &Client{
+		DeviceAddress: u.Host,
+		DeviceID:      query.Get("device_id"),
+		DevicePublic:  DecodeKey(query.Get("device_public")),
+		ClientID:      query.Get("client_id"),
+		ClientPrivate: DecodeKey(query.Get("client_private")),
+	}
+
+	if err = conn.Dial(); err != nil {
+		return err
+	}
+
+	defer conn.Close()
+
+	if err = conn.ListPairings(); err != nil {
+		return err
+	}
+
+	return conn.DeletePairing(conn.ClientID)
+}
+
+func (c *Client) Pair(feature, pin string) (err error) {
+	if pin, err = SanitizePin(pin); err != nil {
+		return err
+	}
+
+	c.Conn, err = net.DialTimeout("tcp", c.DeviceAddress, ConnDialTimeout)
+	if err != nil {
+		return
+	}
+
+	c.reader = bufio.NewReader(c.Conn)
+
+	// STEP M1. Send HELLO
+	plainM1 := struct {
+		Method byte `tlv8:"0"`
+		State  byte `tlv8:"6"`
+	}{
+		Method: MethodPair,
+		State:  StateM1,
+	}
+	if feature == "1" {
+		plainM1.Method = MethodPairMFi // ff=1 => method=1, ff=2 => method=0
+	}
+	res, err := c.Post(PathPairSetup, MimeTLV8, tlv8.MarshalReader(plainM1))
+	if err != nil {
+		return
+	}
+
+	// STEP M2. Read Device Salt and session PublicKey
+	var plainM2 struct {
+		Salt       string `tlv8:"2"`
+		SessionKey string `tlv8:"3"` // server public key, aka session.B
+		State      byte   `tlv8:"6"`
+		Error      byte   `tlv8:"7"`
+	}
+	if err = tlv8.UnmarshalReader(res.Body, res.ContentLength, &plainM2); err != nil {
+		return
+	}
+	if plainM2.State != StateM2 {
+		return newResponseError(plainM1, plainM2)
+	}
+	if plainM2.Error != 0 {
+		return newPairingError(plainM2.Error)
+	}
+
+	// STEP M3. Generate SRP Session using pin
+	username := []byte("Pair-Setup")
+
+	// Stanford Secure Remote Password (SRP) / Password Authenticated Key Exchange (PAKE)
+	pake, err := srp.NewSRP("rfc5054.3072", sha512.New, keyDerivativeFuncRFC2945(username))
+	if err != nil {
+		return
+	}
+
+	pake.SaltLength = 16
+
+	// username: "Pair-Setup", password: PIN (with dashes)
+	session := pake.NewClientSession(username, []byte(pin))
+
+	sessionShared, err := session.ComputeKey([]byte(plainM2.Salt), []byte(plainM2.SessionKey))
+	if err != nil {
+		return
+	}
+
+	// STEP M3. Send request
+	plainM3 := struct {
+		SessionKey string `tlv8:"3"`
+		Proof      string `tlv8:"4"`
+		State      byte   `tlv8:"6"`
+	}{
+		SessionKey: string(session.GetA()), // client public key, aka session.A
+		Proof:      string(session.ComputeAuthenticator()),
+		State:      StateM3,
+	}
+	if res, err = c.Post(PathPairSetup, MimeTLV8, tlv8.MarshalReader(plainM3)); err != nil {
+		return
+	}
+
+	// STEP M4. Read response
+	var plainM4 struct {
+		Proof string `tlv8:"4"` // server proof
+		State byte   `tlv8:"6"`
+		Error byte   `tlv8:"7"`
+
+		EncryptedData string `tlv8:"5"` // skip EncryptedData validation (for MFi devices)
+	}
+	if err = tlv8.UnmarshalReader(res.Body, res.ContentLength, &plainM4); err != nil {
+		return
+	}
+	if plainM4.State != StateM4 {
+		return newResponseError(plainM3, plainM4)
+	}
+	if plainM4.Error != 0 {
+		return newPairingError(plainM4.Error)
+	}
+
+	// STEP M4. Verify response
+	if !session.VerifyServerAuthenticator([]byte(plainM4.Proof)) {
+		return errors.New("hap: VerifyServerAuthenticator")
+	}
+
+	// STEP M5. Generate signature
+	localSign, err := hkdf.Sha512(
+		sessionShared, "Pair-Setup-Controller-Sign-Salt", "Pair-Setup-Controller-Sign-Info",
+	)
+	if err != nil {
+		return
+	}
+
+	b := Append(localSign, c.ClientID, c.ClientPublic())
+	signature, err := ed25519.Signature(c.ClientPrivate, b)
+	if err != nil {
+		return
+	}
+
+	// STEP M5. Generate payload
+	plainM5 := struct {
+		Identifier string `tlv8:"1"`
+		PublicKey  string `tlv8:"3"`
+		Signature  string `tlv8:"10"`
+	}{
+		Identifier: c.ClientID,
+		PublicKey:  string(c.ClientPublic()),
+		Signature:  string(signature),
+	}
+	if b, err = tlv8.Marshal(plainM5); err != nil {
+		return
+	}
+
+	// STEP M5. Encrypt payload
+	encryptKey, err := hkdf.Sha512(
+		sessionShared, "Pair-Setup-Encrypt-Salt", "Pair-Setup-Encrypt-Info",
+	)
+	if err != nil {
+		return
+	}
+
+	if b, err = chacha20poly1305.Encrypt(encryptKey, "PS-Msg05", b); err != nil {
+		return
+	}
+
+	// STEP M5. Send request
+	cipherM5 := struct {
+		EncryptedData string `tlv8:"5"`
+		State         byte   `tlv8:"6"`
+	}{
+		EncryptedData: string(b),
+		State:         StateM5,
+	}
+	if res, err = c.Post(PathPairSetup, MimeTLV8, tlv8.MarshalReader(cipherM5)); err != nil {
+		return
+	}
+
+	// STEP M6. Read response
+	cipherM6 := struct {
+		EncryptedData string `tlv8:"5"`
+		State         byte   `tlv8:"6"`
+		Error         byte   `tlv8:"7"`
+	}{}
+	if err = tlv8.UnmarshalReader(res.Body, res.ContentLength, &cipherM6); err != nil {
+		return
+	}
+	if cipherM6.State != StateM6 || cipherM6.Error != 0 {
+		return newResponseError(plainM5, cipherM6)
+	}
+
+	// STEP M6. Decrypt payload
+	b, err = chacha20poly1305.Decrypt(encryptKey, "PS-Msg06", []byte(cipherM6.EncryptedData))
+	if err != nil {
+		return
+	}
+
+	plainM6 := struct {
+		Identifier string `tlv8:"1"`
+		PublicKey  string `tlv8:"3"`
+		Signature  string `tlv8:"10"`
+	}{}
+	if err = tlv8.Unmarshal(b, &plainM6); err != nil {
+		return
+	}
+
+	// STEP M6. Verify payload
+	remoteSign, err := hkdf.Sha512(
+		sessionShared, "Pair-Setup-Accessory-Sign-Salt", "Pair-Setup-Accessory-Sign-Info",
+	)
+	if err != nil {
+		return
+	}
+
+	b = Append(remoteSign, plainM6.Identifier, plainM6.PublicKey)
+	if !ed25519.ValidateSignature([]byte(plainM6.PublicKey), b, []byte(plainM6.Signature)) {
+		return errors.New("hap: ValidateSignature")
+	}
+
+	if c.DeviceID != plainM6.Identifier {
+		return errors.New("hap: wrong DeviceID: " + plainM6.Identifier)
+	}
+
+	c.DevicePublic = []byte(plainM6.PublicKey)
+
+	return nil
+}
+
+func (c *Client) ListPairings() error {
+	plainM1 := struct {
+		Method byte `tlv8:"0"`
+		State  byte `tlv8:"6"`
+	}{
+		Method: MethodListPairings,
+		State:  StateM1,
+	}
+	res, err := c.Post(PathPairings, MimeTLV8, tlv8.MarshalReader(plainM1))
+	if err != nil {
+		return err
+	}
+
+	// TODO: don't know how to fix array of items
+	var plainM2 struct {
+		Identifier string `tlv8:"1"`
+		PublicKey  string `tlv8:"3"`
+		State      byte   `tlv8:"6"`
+		Permission byte   `tlv8:"11"`
+	}
+	if err = tlv8.UnmarshalReader(res.Body, res.ContentLength, &plainM2); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c *Client) PairingsAdd(clientID string, clientPublic []byte, admin bool) error {
+	plainM1 := struct {
+		Method     byte   `tlv8:"0"`
+		Identifier string `tlv8:"1"`
+		PublicKey  string `tlv8:"3"`
+		State      byte   `tlv8:"6"`
+		Permission byte   `tlv8:"11"`
+	}{
+		Method:     MethodAddPairing,
+		Identifier: clientID,
+		PublicKey:  string(clientPublic),
+		State:      StateM1,
+		Permission: PermissionUser,
+	}
+	if admin {
+		plainM1.Permission = PermissionAdmin
+	}
+	res, err := c.Post(PathPairings, MimeTLV8, tlv8.MarshalReader(plainM1))
+	if err != nil {
+		return err
+	}
+
+	var plainM2 struct {
+		State   byte `tlv8:"6"`
+		Unknown byte `tlv8:"7"`
+	}
+	if err = tlv8.UnmarshalReader(res.Body, res.ContentLength, &plainM2); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c *Client) DeletePairing(id string) error {
+	plainM1 := struct {
+		Method     byte   `tlv8:"0"`
+		Identifier string `tlv8:"1"`
+		State      byte   `tlv8:"6"`
+	}{
+		Method:     MethodDeletePairing,
+		Identifier: id,
+		State:      StateM1,
+	}
+	res, err := c.Post(PathPairings, MimeTLV8, tlv8.MarshalReader(plainM1))
+	if err != nil {
+		return err
+	}
+
+	var plainM2 struct {
+		State byte `tlv8:"6"`
+	}
+	if err = tlv8.UnmarshalReader(res.Body, res.ContentLength, &plainM2); err != nil {
+		return err
+	}
+	if plainM2.State != StateM2 {
+		return newResponseError(plainM1, plainM2)
+	}
+
+	return nil
+}
+
+func newPairingError(code byte) error {
+	var text string
+	// https://github.com/apple/HomeKitADK/blob/fb201f98f5fdc7fef6a455054f08b59cca5d1ec8/HAP/HAPPairing.h#L89
+	switch code {
+	case 1:
+		text = "Generic error to handle unexpected errors"
+	case 2:
+		text = "Setup code or signature verification failed"
+	case 3:
+		text = "Client must look at the retry delay TLV item and wait that many seconds before retrying"
+	case 4:
+		text = "Server cannot accept any more pairings"
+	case 5:
+		text = "Server reached its maximum number of authentication attempts"
+	case 6:
+		text = "Server pairing method is unavailable"
+	case 7:
+		text = "Server is busy and cannot accept a pairing request at this time"
+	default:
+		text = "Unknown pairing error"
+	}
+	return errors.New("hap: " + text)
+}
+
+func keyDerivativeFuncRFC2945(username []byte) srp.KeyDerivationFunc {
+	return func(salt, password []byte) []byte {
+		h1 := sha512.New()
+		h1.Write(username)
+		h1.Write([]byte(":"))
+		h1.Write(password)
+
+		h2 := sha512.New()
+		h2.Write(salt)
+		h2.Write(h1.Sum(nil))
+
+		return h2.Sum(nil)
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/conn.go b/installs_on_host/go2rtc/pkg/hap/conn.go
new file mode 100644
index 0000000..2b039dc
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/conn.go
@@ -0,0 +1,173 @@
+package hap
+
+import (
+	"bufio"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"io"
+	"net"
+	"sync"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/hap/chacha20poly1305"
+	"github.com/AlexxIT/go2rtc/pkg/hap/hkdf"
+)
+
+type Conn struct {
+	conn net.Conn
+	rw   *bufio.ReadWriter
+	wmu  sync.Mutex
+
+	encryptKey []byte
+	decryptKey []byte
+	encryptCnt uint64
+	decryptCnt uint64
+
+	//ClientID  string
+	SharedKey []byte
+
+	recv int
+	send int
+}
+
+func (c *Conn) MarshalJSON() ([]byte, error) {
+	conn := core.Connection{
+		ID:         core.ID(c),
+		FormatName: "homekit",
+		Protocol:   "hap",
+		RemoteAddr: c.conn.RemoteAddr().String(),
+		Recv:       c.recv,
+		Send:       c.send,
+	}
+	return json.Marshal(conn)
+}
+
+func NewConn(conn net.Conn, rw *bufio.ReadWriter, sharedKey []byte, isClient bool) (*Conn, error) {
+	key1, err := hkdf.Sha512(sharedKey, "Control-Salt", "Control-Read-Encryption-Key")
+	if err != nil {
+		return nil, err
+	}
+
+	key2, err := hkdf.Sha512(sharedKey, "Control-Salt", "Control-Write-Encryption-Key")
+	if err != nil {
+		return nil, err
+	}
+
+	c := &Conn{
+		conn: conn,
+		rw:   rw,
+
+		SharedKey: sharedKey,
+	}
+
+	if isClient {
+		c.encryptKey, c.decryptKey = key2, key1
+	} else {
+		c.encryptKey, c.decryptKey = key1, key2
+	}
+
+	return c, nil
+}
+
+const (
+	// packetSizeMax is the max length of encrypted packets
+	packetSizeMax = 0x400
+
+	VerifySize = 2
+	NonceSize  = 8
+	Overhead   = 16 // chacha20poly1305.Overhead
+)
+
+func (c *Conn) Read(b []byte) (n int, err error) {
+	if cap(b) < packetSizeMax {
+		return 0, errors.New("hap: read buffer is too small")
+	}
+
+	verify := make([]byte, VerifySize) // verify = plain message size
+	if _, err = io.ReadFull(c.rw, verify); err != nil {
+		return
+	}
+
+	n = int(binary.LittleEndian.Uint16(verify))
+
+	ciphertext := make([]byte, n+Overhead)
+	if _, err = io.ReadFull(c.rw, ciphertext); err != nil {
+		return
+	}
+
+	nonce := make([]byte, NonceSize)
+	binary.LittleEndian.PutUint64(nonce, c.decryptCnt)
+	c.decryptCnt++
+
+	_, err = chacha20poly1305.DecryptAndVerify(c.decryptKey, b[:0], nonce, ciphertext, verify)
+
+	c.recv += n
+	return
+}
+
+func (c *Conn) Write(b []byte) (n int, err error) {
+	c.wmu.Lock()
+	defer c.wmu.Unlock()
+
+	buf := make([]byte, 0, packetSizeMax+Overhead)
+	nonce := make([]byte, NonceSize)
+	verify := make([]byte, VerifySize)
+
+	for len(b) > 0 {
+		size := len(b)
+		if size > packetSizeMax {
+			size = packetSizeMax
+		}
+
+		binary.LittleEndian.PutUint16(verify, uint16(size))
+		if _, err = c.rw.Write(verify); err != nil {
+			return
+		}
+
+		binary.LittleEndian.PutUint64(nonce, c.encryptCnt)
+		c.encryptCnt++
+
+		_, err = chacha20poly1305.EncryptAndSeal(c.encryptKey, buf, nonce, b[:size], verify)
+		if err != nil {
+			return
+		}
+
+		if _, err = c.rw.Write(buf[:size+Overhead]); err != nil {
+			return
+		}
+
+		b = b[size:]
+		n += size
+	}
+
+	err = c.rw.Flush()
+
+	c.send += n
+	return
+}
+
+func (c *Conn) Close() error {
+	return c.conn.Close()
+}
+
+func (c *Conn) LocalAddr() net.Addr {
+	return c.conn.LocalAddr()
+}
+
+func (c *Conn) RemoteAddr() net.Addr {
+	return c.conn.RemoteAddr()
+}
+
+func (c *Conn) SetDeadline(t time.Time) error {
+	return c.conn.SetDeadline(t)
+}
+
+func (c *Conn) SetReadDeadline(t time.Time) error {
+	return c.conn.SetReadDeadline(t)
+}
+
+func (c *Conn) SetWriteDeadline(t time.Time) error {
+	return c.conn.SetWriteDeadline(t)
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/curve25519/curve25519.go b/installs_on_host/go2rtc/pkg/hap/curve25519/curve25519.go
new file mode 100644
index 0000000..f73f76d
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/curve25519/curve25519.go
@@ -0,0 +1,18 @@
+package curve25519
+
+import (
+	"crypto/rand"
+
+	"golang.org/x/crypto/curve25519"
+)
+
+func GenerateKeyPair() ([]byte, []byte) {
+	var publicKey, privateKey [32]byte
+	_, _ = rand.Read(privateKey[:])
+	curve25519.ScalarBaseMult(&publicKey, &privateKey)
+	return publicKey[:], privateKey[:]
+}
+
+func SharedSecret(privateKey, otherPublicKey []byte) ([]byte, error) {
+	return curve25519.X25519(privateKey, otherPublicKey)
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/ed25519/ed25519.go b/installs_on_host/go2rtc/pkg/hap/ed25519/ed25519.go
new file mode 100644
index 0000000..646ce26
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/ed25519/ed25519.go
@@ -0,0 +1,24 @@
+package ed25519
+
+import (
+	"crypto/ed25519"
+	"errors"
+)
+
+var ErrInvalidParams = errors.New("ed25519: invalid params")
+
+func ValidateSignature(key, data, signature []byte) bool {
+	if len(key) != ed25519.PublicKeySize || len(signature) != ed25519.SignatureSize {
+		return false
+	}
+
+	return ed25519.Verify(key, data, signature)
+}
+
+func Signature(key, data []byte) ([]byte, error) {
+	if len(key) != ed25519.PrivateKeySize {
+		return nil, ErrInvalidParams
+	}
+
+	return ed25519.Sign(key, data), nil
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/hds/hds.go b/installs_on_host/go2rtc/pkg/hap/hds/hds.go
new file mode 100644
index 0000000..0e29991
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/hds/hds.go
@@ -0,0 +1,176 @@
+// Package hds - HomeKit Data Stream
+package hds
+
+import (
+	"bufio"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"io"
+	"net"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/hap"
+	"github.com/AlexxIT/go2rtc/pkg/hap/chacha20poly1305"
+	"github.com/AlexxIT/go2rtc/pkg/hap/hkdf"
+)
+
+func NewConn(conn net.Conn, key []byte, salt string, controller bool) (*Conn, error) {
+	writeKey, err := hkdf.Sha512(key, salt, "HDS-Write-Encryption-Key")
+	if err != nil {
+		return nil, err
+	}
+
+	readKey, err := hkdf.Sha512(key, salt, "HDS-Read-Encryption-Key")
+	if err != nil {
+		return nil, err
+	}
+
+	c := &Conn{
+		conn: conn,
+		rd:   bufio.NewReaderSize(conn, 32*1024),
+		wr:   bufio.NewWriterSize(conn, 32*1024),
+	}
+
+	if controller {
+		c.decryptKey, c.encryptKey = readKey, writeKey
+	} else {
+		c.decryptKey, c.encryptKey = writeKey, readKey
+	}
+
+	return c, nil
+}
+
+type Conn struct {
+	conn net.Conn
+
+	rd *bufio.Reader
+	wr *bufio.Writer
+
+	decryptKey []byte
+	encryptKey []byte
+	decryptCnt uint64
+	encryptCnt uint64
+
+	recv int
+	send int
+}
+
+func (c *Conn) MarshalJSON() ([]byte, error) {
+	conn := core.Connection{
+		ID:         core.ID(c),
+		FormatName: "homekit",
+		Protocol:   "hds",
+		RemoteAddr: c.conn.RemoteAddr().String(),
+		Recv:       c.recv,
+		Send:       c.send,
+	}
+	return json.Marshal(conn)
+}
+
+func (c *Conn) read() (b []byte, err error) {
+	verify := make([]byte, 4)
+	if _, err = io.ReadFull(c.rd, verify); err != nil {
+		return
+	}
+
+	n := int(binary.BigEndian.Uint32(verify) & 0xFFFFFF)
+
+	ciphertext := make([]byte, n+hap.Overhead)
+	if _, err = io.ReadFull(c.rd, ciphertext); err != nil {
+		return
+	}
+
+	nonce := make([]byte, hap.NonceSize)
+	binary.LittleEndian.PutUint64(nonce, c.decryptCnt)
+	c.decryptCnt++
+
+	c.recv += n
+
+	return chacha20poly1305.DecryptAndVerify(c.decryptKey, ciphertext[:0], nonce, ciphertext, verify)
+}
+
+func (c *Conn) Read(p []byte) (n int, err error) {
+	b, err := c.read()
+	if err != nil {
+		return 0, err
+	}
+	n = copy(p, b)
+	if len(b) > n {
+		err = errors.New("hds: read buffer too small")
+	}
+	return
+}
+
+func (c *Conn) WriteTo(w io.Writer) (int64, error) {
+	var total int64
+	for {
+		b, err := c.read()
+		if err != nil {
+			return total, err
+		}
+
+		n, err := w.Write(b)
+		total += int64(n)
+		if err != nil {
+			return total, err
+		}
+	}
+}
+
+func (c *Conn) Write(b []byte) (n int, err error) {
+	n = len(b)
+
+	if n > 0xFFFFFF {
+		return 0, errors.New("hds: write buffer too big")
+	}
+
+	verify := make([]byte, 4)
+	binary.BigEndian.PutUint32(verify, 0x01000000|uint32(n))
+	if _, err = c.wr.Write(verify); err != nil {
+		return
+	}
+
+	nonce := make([]byte, hap.NonceSize)
+	binary.LittleEndian.PutUint64(nonce, c.encryptCnt)
+	c.encryptCnt++
+
+	buf := make([]byte, n+hap.Overhead)
+	if _, err = chacha20poly1305.EncryptAndSeal(c.encryptKey, buf[:0], nonce, b, verify); err != nil {
+		return
+	}
+
+	if _, err = c.wr.Write(buf); err != nil {
+		return
+	}
+
+	err = c.wr.Flush()
+
+	c.send += n
+	return
+}
+
+func (c *Conn) Close() error {
+	return c.conn.Close()
+}
+
+func (c *Conn) LocalAddr() net.Addr {
+	return c.conn.LocalAddr()
+}
+
+func (c *Conn) RemoteAddr() net.Addr {
+	return c.conn.RemoteAddr()
+}
+
+func (c *Conn) SetDeadline(t time.Time) error {
+	return c.conn.SetDeadline(t)
+}
+
+func (c *Conn) SetReadDeadline(t time.Time) error {
+	return c.conn.SetReadDeadline(t)
+}
+
+func (c *Conn) SetWriteDeadline(t time.Time) error {
+	return c.conn.SetWriteDeadline(t)
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/hds/hds_test.go b/installs_on_host/go2rtc/pkg/hap/hds/hds_test.go
new file mode 100644
index 0000000..f1c8545
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/hds/hds_test.go
@@ -0,0 +1,35 @@
+package hds
+
+import (
+	"bufio"
+	"bytes"
+	"testing"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/stretchr/testify/require"
+)
+
+func TestEncryption(t *testing.T) {
+	key := []byte(core.RandString(16, 0))
+	salt := core.RandString(32, 0)
+
+	c, err := Client(nil, key, salt, true)
+	require.NoError(t, err)
+
+	buf := bytes.NewBuffer(nil)
+	c.wr = bufio.NewWriter(buf)
+
+	n, err := c.Write([]byte("test"))
+	require.NoError(t, err)
+	require.Equal(t, 4, n)
+
+	c, err = Client(nil, key, salt, false)
+	c.rd = bufio.NewReader(buf)
+	require.NoError(t, err)
+
+	b := make([]byte, 32)
+	n, err = c.Read(b)
+	require.NoError(t, err)
+
+	require.Equal(t, "test", string(b[:n]))
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/helpers.go b/installs_on_host/go2rtc/pkg/hap/helpers.go
new file mode 100644
index 0000000..3c3b287
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/helpers.go
@@ -0,0 +1,130 @@
+package hap
+
+import (
+	"crypto/ed25519"
+	"crypto/rand"
+	"crypto/sha512"
+	"encoding/base64"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"strings"
+)
+
+const (
+	TXTConfigNumber = "c#" // Current configuration number (ex. 1, 2, 3)
+	TXTDeviceID     = "id" // Device ID of the accessory (ex. 77:75:87:A0:7D:F4)
+	TXTModel        = "md" // Model name of the accessory (ex. MJCTD02YL)
+	TXTProtoVersion = "pv" // Protocol version string (ex. 1.1)
+	TXTStateNumber  = "s#" // Current state number (ex. 1)
+	TXTCategory     = "ci" // Accessory Category Identifier (ex. 2, 5, 17)
+	TXTSetupHash    = "sh" // Setup hash (ex. Y9w9hQ==)
+
+	// TXTFeatureFlags
+	//  - 0001b - Supports Apple Authentication Coprocessor
+	//  - 0010b - Supports Software Authentication
+	TXTFeatureFlags = "ff" // Pairing Feature flags (ex. 0, 1, 2)
+
+	// TXTStatusFlags
+	//  - 0001b - Accessory has not been paired with any controllers
+	//  - 0100b - A problem has been detected on the accessory
+	TXTStatusFlags = "sf" // Status flags (ex. 0, 1)
+
+	StatusPaired    = "0"
+	StatusNotPaired = "1"
+
+	CategoryBridge   = "2"
+	CategoryCamera   = "17"
+	CategoryDoorbell = "18"
+
+	StateM1 = 1
+	StateM2 = 2
+	StateM3 = 3
+	StateM4 = 4
+	StateM5 = 5
+	StateM6 = 6
+
+	MethodPair          = 0
+	MethodPairMFi       = 1 // if device has MFI cert
+	MethodVerifyPair    = 2
+	MethodAddPairing    = 3
+	MethodDeletePairing = 4
+	MethodListPairings  = 5
+
+	PermissionUser  = 0
+	PermissionAdmin = 1
+)
+
+const DeviceAID = 1 // TODO: fix someday
+
+type JSONAccessories struct {
+	Value []*Accessory `json:"accessories"`
+}
+
+type JSONCharacters struct {
+	Value []JSONCharacter `json:"characteristics"`
+}
+
+type JSONCharacter struct {
+	AID    uint8  `json:"aid"`
+	IID    uint64 `json:"iid"`
+	Status any    `json:"status,omitempty"`
+	Value  any    `json:"value,omitempty"`
+	Event  any    `json:"ev,omitempty"`
+}
+
+// 4.2.1.2 Invalid Setup Codes
+const insecurePINs = "00000000 11111111 22222222 33333333 44444444 55555555 66666666 77777777 88888888 99999999 12345678 87654321"
+
+func SanitizePin(pin string) (string, error) {
+	s := strings.ReplaceAll(pin, "-", "")
+	if len(s) != 8 {
+		return "", errors.New("hap: wrong PIN format: " + pin)
+	}
+	if strings.Contains(insecurePINs, s) {
+		return "", errors.New("hap: insecure PIN: " + pin)
+	}
+	// 123-45-678
+	return s[:3] + "-" + s[3:5] + "-" + s[5:], nil
+}
+
+func GenerateKey() []byte {
+	_, key, _ := ed25519.GenerateKey(nil)
+	return key
+}
+
+func GenerateUUID() string {
+	//12345678-9012-3456-7890-123456789012
+	data := make([]byte, 16)
+	_, _ = rand.Read(data)
+	s := hex.EncodeToString(data)
+	return s[:8] + "-" + s[8:12] + "-" + s[12:16] + "-" + s[16:20] + "-" + s[20:]
+}
+
+func SetupHash(setupID, deviceID string) string {
+	// should be setup_id (random 4 alphanum) + device_id (mac address)
+	b := sha512.Sum512([]byte(setupID + deviceID))
+	return base64.StdEncoding.EncodeToString(b[:4])
+}
+
+func Append(items ...any) (b []byte) {
+	for _, item := range items {
+		switch v := item.(type) {
+		case string:
+			b = append(b, v...)
+		case []byte:
+			b = append(b, v[:]...)
+		default:
+			panic(v)
+		}
+	}
+	return
+}
+
+func newRequestError(req any) error {
+	return fmt.Errorf("hap: wrong request: %#v", req)
+}
+
+func newResponseError(req, res any) error {
+	return fmt.Errorf("hap: wrong response: %#v, on request: %#v", res, req)
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/hkdf/hkdf.go b/installs_on_host/go2rtc/pkg/hap/hkdf/hkdf.go
new file mode 100644
index 0000000..989dcfb
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/hkdf/hkdf.go
@@ -0,0 +1,17 @@
+package hkdf
+
+import (
+	"crypto/sha512"
+	"io"
+
+	"golang.org/x/crypto/hkdf"
+)
+
+func Sha512(key []byte, salt, info string) ([]byte, error) {
+	r := hkdf.New(sha512.New, key, []byte(salt), []byte(info))
+
+	buf := make([]byte, 32)
+	_, err := io.ReadFull(r, buf)
+
+	return buf, err
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/server.go b/installs_on_host/go2rtc/pkg/hap/server.go
new file mode 100644
index 0000000..a992528
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/server.go
@@ -0,0 +1,396 @@
+package hap
+
+import (
+	"bufio"
+	"crypto/sha512"
+	"errors"
+	"fmt"
+	"net/http"
+
+	"github.com/AlexxIT/go2rtc/pkg/hap/chacha20poly1305"
+	"github.com/AlexxIT/go2rtc/pkg/hap/curve25519"
+	"github.com/AlexxIT/go2rtc/pkg/hap/ed25519"
+	"github.com/AlexxIT/go2rtc/pkg/hap/hkdf"
+	"github.com/AlexxIT/go2rtc/pkg/hap/tlv8"
+	"github.com/tadglines/go-pkgs/crypto/srp"
+)
+
+type Server struct {
+	Pin           string
+	DeviceID      string
+	DevicePrivate []byte
+
+	// GetClientPublic may be nil, so client validation will be disabled
+	GetClientPublic func(id string) []byte
+}
+
+func (s *Server) ServerPublic() []byte {
+	return s.DevicePrivate[32:]
+}
+
+//func (s *Server) Status() string {
+//	if len(s.Pairings) == 0 {
+//		return StatusNotPaired
+//	}
+//	return StatusPaired
+//}
+
+func (s *Server) PairSetup(req *http.Request, rw *bufio.ReadWriter) (id string, publicKey []byte, err error) {
+	// STEP 1. Request from iPhone
+	var plainM1 struct {
+		State  byte   `tlv8:"6"`
+		Method byte   `tlv8:"0"`
+		Flags  uint32 `tlv8:"19"`
+	}
+	if err = tlv8.UnmarshalReader(req.Body, req.ContentLength, &plainM1); err != nil {
+		return
+	}
+	if plainM1.State != StateM1 {
+		err = newRequestError(plainM1)
+		return
+	}
+
+	username := []byte("Pair-Setup")
+
+	// Stanford Secure Remote Password (SRP) / Password Authenticated Key Exchange (PAKE)
+	pake, err := srp.NewSRP("rfc5054.3072", sha512.New, keyDerivativeFuncRFC2945(username))
+	if err != nil {
+		return
+	}
+
+	pake.SaltLength = 16
+
+	salt, verifier, err := pake.ComputeVerifier([]byte(s.Pin))
+	if err != nil {
+		return
+	}
+
+	session := pake.NewServerSession(username, salt, verifier)
+
+	// STEP 2. Response to iPhone
+	plainM2 := struct {
+		State     byte   `tlv8:"6"`
+		PublicKey string `tlv8:"3"`
+		Salt      string `tlv8:"2"`
+	}{
+		State:     StateM2,
+		PublicKey: string(session.GetB()),
+		Salt:      string(salt),
+	}
+	body, err := tlv8.Marshal(plainM2)
+	if err != nil {
+		return
+	}
+	if err = WriteResponse(rw.Writer, http.StatusOK, MimeTLV8, body); err != nil {
+		return
+	}
+
+	// STEP 3. Request from iPhone
+	if req, err = http.ReadRequest(rw.Reader); err != nil {
+		return
+	}
+
+	var plainM3 struct {
+		State     byte   `tlv8:"6"`
+		PublicKey string `tlv8:"3"`
+		Proof     string `tlv8:"4"`
+	}
+	if err = tlv8.UnmarshalReader(req.Body, req.ContentLength, &plainM3); err != nil {
+		return
+	}
+	if plainM3.State != StateM3 {
+		err = newRequestError(plainM3)
+		return
+	}
+
+	// important to compute key before verify client
+	sessionShared, err := session.ComputeKey([]byte(plainM3.PublicKey))
+	if err != nil {
+		return
+	}
+
+	if !session.VerifyClientAuthenticator([]byte(plainM3.Proof)) {
+		err = errors.New("hap: VerifyClientAuthenticator")
+		return
+	}
+
+	proof := session.ComputeAuthenticator([]byte(plainM3.Proof)) // server proof
+
+	// STEP 4. Response to iPhone
+	payloadM4 := struct {
+		State byte   `tlv8:"6"`
+		Proof string `tlv8:"4"`
+	}{
+		State: StateM4,
+		Proof: string(proof),
+	}
+	if body, err = tlv8.Marshal(payloadM4); err != nil {
+		return
+	}
+	if err = WriteResponse(rw.Writer, http.StatusOK, MimeTLV8, body); err != nil {
+		return
+	}
+
+	// STEP 5. Request from iPhone
+	if req, err = http.ReadRequest(rw.Reader); err != nil {
+		return
+	}
+	var cipherM5 struct {
+		State         byte   `tlv8:"6"`
+		EncryptedData string `tlv8:"5"`
+	}
+	if err = tlv8.UnmarshalReader(req.Body, req.ContentLength, &cipherM5); err != nil {
+		return
+	}
+	if cipherM5.State != StateM5 {
+		err = newRequestError(cipherM5)
+		return
+	}
+
+	// decrypt message using session shared
+	encryptKey, err := hkdf.Sha512(sessionShared, "Pair-Setup-Encrypt-Salt", "Pair-Setup-Encrypt-Info")
+	if err != nil {
+		return
+	}
+
+	b, err := chacha20poly1305.Decrypt(encryptKey, "PS-Msg05", []byte(cipherM5.EncryptedData))
+	if err != nil {
+		return
+	}
+
+	// unpack message from TLV8
+	var plainM5 struct {
+		Identifier string `tlv8:"1"`
+		PublicKey  string `tlv8:"3"`
+		Signature  string `tlv8:"10"`
+	}
+	if err = tlv8.Unmarshal(b, &plainM5); err != nil {
+		return
+	}
+
+	// 3. verify client ID and Public
+	remoteSign, err := hkdf.Sha512(
+		sessionShared, "Pair-Setup-Controller-Sign-Salt", "Pair-Setup-Controller-Sign-Info",
+	)
+	if err != nil {
+		return
+	}
+
+	b = Append(remoteSign, plainM5.Identifier, plainM5.PublicKey)
+	if !ed25519.ValidateSignature([]byte(plainM5.PublicKey), b, []byte(plainM5.Signature)) {
+		err = errors.New("hap: ValidateSignature")
+		return
+	}
+
+	// 4. generate signature to our ID and Public
+	localSign, err := hkdf.Sha512(
+		sessionShared, "Pair-Setup-Accessory-Sign-Salt", "Pair-Setup-Accessory-Sign-Info",
+	)
+	if err != nil {
+		return
+	}
+
+	b = Append(localSign, s.DeviceID, s.ServerPublic()) // ServerPublic
+	signature, err := ed25519.Signature(s.DevicePrivate, b)
+	if err != nil {
+		return
+	}
+
+	// 5. pack our ID and Public
+	plainM6 := struct {
+		Identifier string `tlv8:"1"`
+		PublicKey  string `tlv8:"3"`
+		Signature  string `tlv8:"10"`
+	}{
+		Identifier: s.DeviceID,
+		PublicKey:  string(s.ServerPublic()),
+		Signature:  string(signature),
+	}
+	if b, err = tlv8.Marshal(plainM6); err != nil {
+		return
+	}
+
+	// 6. encrypt message
+	b, err = chacha20poly1305.Encrypt(encryptKey, "PS-Msg06", b)
+	if err != nil {
+		return
+	}
+
+	// STEP 6. Response to iPhone
+	cipherM6 := struct {
+		State         byte   `tlv8:"6"`
+		EncryptedData string `tlv8:"5"`
+	}{
+		State:         StateM6,
+		EncryptedData: string(b),
+	}
+	if body, err = tlv8.Marshal(cipherM6); err != nil {
+		return
+	}
+	if err = WriteResponse(rw.Writer, http.StatusOK, MimeTLV8, body); err != nil {
+		return
+	}
+
+	id = plainM5.Identifier
+	publicKey = []byte(plainM5.PublicKey)
+
+	return
+}
+
+func (s *Server) PairVerify(req *http.Request, rw *bufio.ReadWriter) (id string, sessionKey []byte, err error) {
+	// Request from iPhone
+	var plainM1 struct {
+		State     byte   `tlv8:"6"`
+		PublicKey string `tlv8:"3"`
+	}
+	if err = tlv8.UnmarshalReader(req.Body, req.ContentLength, &plainM1); err != nil {
+		return
+	}
+	if plainM1.State != StateM1 {
+		err = newRequestError(plainM1)
+		return
+	}
+
+	// Generate the key pair
+	sessionPublic, sessionPrivate := curve25519.GenerateKeyPair()
+	sessionShared, err := curve25519.SharedSecret(sessionPrivate, []byte(plainM1.PublicKey))
+	if err != nil {
+		return
+	}
+
+	encryptKey, err := hkdf.Sha512(
+		sessionShared, "Pair-Verify-Encrypt-Salt", "Pair-Verify-Encrypt-Info",
+	)
+	if err != nil {
+		return
+	}
+
+	b := Append(sessionPublic, s.DeviceID, plainM1.PublicKey)
+	signature, err := ed25519.Signature(s.DevicePrivate, b)
+	if err != nil {
+		return
+	}
+
+	// STEP M2. Response to iPhone
+	plainM2 := struct {
+		Identifier string `tlv8:"1"`
+		Signature  string `tlv8:"10"`
+	}{
+		Identifier: s.DeviceID,
+		Signature:  string(signature),
+	}
+	if b, err = tlv8.Marshal(plainM2); err != nil {
+		return
+	}
+
+	b, err = chacha20poly1305.Encrypt(encryptKey, "PV-Msg02", b)
+	if err != nil {
+		return
+	}
+
+	cipherM2 := struct {
+		State         byte   `tlv8:"6"`
+		PublicKey     string `tlv8:"3"`
+		EncryptedData string `tlv8:"5"`
+	}{
+		State:         StateM2,
+		PublicKey:     string(sessionPublic),
+		EncryptedData: string(b),
+	}
+	body, err := tlv8.Marshal(cipherM2)
+	if err != nil {
+		return
+	}
+	if err = WriteResponse(rw.Writer, http.StatusOK, MimeTLV8, body); err != nil {
+		return
+	}
+
+	// STEP M3. Request from iPhone
+	if req, err = http.ReadRequest(rw.Reader); err != nil {
+		return
+	}
+
+	var cipherM3 struct {
+		State         byte   `tlv8:"6"`
+		EncryptedData string `tlv8:"5"`
+	}
+	if err = tlv8.UnmarshalReader(req.Body, req.ContentLength, &cipherM3); err != nil {
+		return
+	}
+	if cipherM3.State != StateM3 {
+		err = newRequestError(cipherM3)
+		return
+	}
+
+	b, err = chacha20poly1305.Decrypt(encryptKey, "PV-Msg03", []byte(cipherM3.EncryptedData))
+	if err != nil {
+		return
+	}
+
+	var plainM3 struct {
+		Identifier string `tlv8:"1"`
+		Signature  string `tlv8:"10"`
+	}
+	if err = tlv8.Unmarshal(b, &plainM3); err != nil {
+		return
+	}
+
+	if s.GetClientPublic != nil {
+		clientPublic := s.GetClientPublic(plainM3.Identifier)
+		if clientPublic == nil {
+			err = errors.New("hap: PairVerify with unknown client_id: " + plainM3.Identifier)
+			return
+		}
+
+		b = Append(plainM1.PublicKey, plainM3.Identifier, sessionPublic)
+		if !ed25519.ValidateSignature(clientPublic, b, []byte(plainM3.Signature)) {
+			err = errors.New("hap: ValidateSignature")
+			return
+		}
+	}
+
+	// STEP M4. Response to iPhone
+	payloadM4 := struct {
+		State byte `tlv8:"6"`
+	}{
+		State: StateM4,
+	}
+	if body, err = tlv8.Marshal(payloadM4); err != nil {
+		return
+	}
+	if err = WriteResponse(rw.Writer, http.StatusOK, MimeTLV8, body); err != nil {
+		return
+	}
+
+	id = plainM3.Identifier
+	sessionKey = sessionShared
+
+	return
+}
+
+func WriteResponse(w *bufio.Writer, statusCode int, contentType string, body []byte) error {
+	header := fmt.Sprintf(
+		"HTTP/1.1 %d %s\r\nContent-Type: %s\r\nContent-Length: %d\r\n\r\n",
+		statusCode, http.StatusText(statusCode), contentType, len(body),
+	)
+	body = append([]byte(header), body...)
+	if _, err := w.Write(body); err != nil {
+		return err
+	}
+	return w.Flush()
+}
+
+//func WriteBackoff(rw *bufio.ReadWriter) error {
+//	plainM2 := struct {
+//		State byte `tlv8:"6"`
+//		Error byte `tlv8:"7"`
+//	}{
+//		State: StateM2,
+//		Error: 3, // BackoffError
+//	}
+//	body, err := tlv8.Marshal(plainM2)
+//	if err != nil {
+//		return err
+//	}
+//	return WriteResponse(rw.Writer, http.StatusOK, MimeTLV8, body)
+//}
diff --git a/installs_on_host/go2rtc/pkg/hap/setup/setup.go b/installs_on_host/go2rtc/pkg/hap/setup/setup.go
new file mode 100644
index 0000000..c5eeb51
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/setup/setup.go
@@ -0,0 +1,32 @@
+package setup
+
+import (
+	"strconv"
+	"strings"
+)
+
+const (
+	FlagNFC = 1
+	FlagIP  = 2
+	FlagBLE = 4
+	FlagWAC = 8 // Wireless Accessory Configuration (WAC)/Apples MFi
+)
+
+func GenerateSetupURI(category, pin, setupID string) string {
+	c, _ := strconv.Atoi(category)
+	p, _ := strconv.Atoi(strings.ReplaceAll(pin, "-", ""))
+	payload := int64(c&0xFF)<<31 | int64(FlagIP&0xF)<<27 | int64(p&0x7FFFFFF)
+	return "X-HM://" + FormatInt36(payload, 9) + setupID
+}
+
+// FormatInt36 equal to strings.ToUpper(fmt.Sprintf("%0"+strconv.Itoa(n)+"s", strconv.FormatInt(value, 36)))
+func FormatInt36(value int64, n int) string {
+	b := make([]byte, n)
+	for i := n - 1; 0 <= i; i-- {
+		b[i] = digits[value%36]
+		value /= 36
+	}
+	return string(b)
+}
+
+const digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
diff --git a/installs_on_host/go2rtc/pkg/hap/setup/setup_test.go b/installs_on_host/go2rtc/pkg/hap/setup/setup_test.go
new file mode 100644
index 0000000..0167221
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/setup/setup_test.go
@@ -0,0 +1,18 @@
+package setup
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestFormatAlphaNum(t *testing.T) {
+	value := int64(999)
+	n := 5
+	s1 := strings.ToUpper(fmt.Sprintf("%0"+strconv.Itoa(n)+"s", strconv.FormatInt(value, 36)))
+	s2 := FormatInt36(value, n)
+	require.Equal(t, s1, s2)
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/tlv8/tlv8.go b/installs_on_host/go2rtc/pkg/hap/tlv8/tlv8.go
new file mode 100644
index 0000000..7b397b9
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/tlv8/tlv8.go
@@ -0,0 +1,386 @@
+package tlv8
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"math"
+	"reflect"
+	"strconv"
+)
+
+type errReader struct {
+	err error
+}
+
+func (e *errReader) Read([]byte) (int, error) {
+	return 0, e.err
+}
+
+func MarshalBase64(v any) (string, error) {
+	b, err := Marshal(v)
+	if err != nil {
+		return "", err
+	}
+	return base64.StdEncoding.EncodeToString(b), nil
+}
+
+func MarshalReader(v any) io.Reader {
+	b, err := Marshal(v)
+	if err != nil {
+		return &errReader{err: err}
+	}
+	return bytes.NewReader(b)
+}
+
+func Marshal(v any) ([]byte, error) {
+	value := reflect.ValueOf(v)
+	kind := value.Type().Kind()
+
+	if kind == reflect.Pointer {
+		value = value.Elem()
+		kind = value.Type().Kind()
+	}
+
+	switch kind {
+	case reflect.Slice:
+		return appendSlice(nil, value)
+	case reflect.Struct:
+		return appendStruct(nil, value)
+	}
+
+	return nil, errors.New("tlv8: not implemented: " + kind.String())
+}
+
+// separator the most confusing meaning in the documentation.
+// It can have a value of 0x00 or 0xFF or even 0x05.
+const separator = 0xFF
+
+func appendSlice(b []byte, value reflect.Value) ([]byte, error) {
+	for i := 0; i < value.Len(); i++ {
+		if i > 0 {
+			b = append(b, separator, 0)
+		}
+		var err error
+		if b, err = appendStruct(b, value.Index(i)); err != nil {
+			return nil, err
+		}
+	}
+	return b, nil
+}
+
+func appendStruct(b []byte, value reflect.Value) ([]byte, error) {
+	valueType := value.Type()
+
+	for i := 0; i < value.NumField(); i++ {
+		refField := value.Field(i)
+		s, ok := valueType.Field(i).Tag.Lookup("tlv8")
+		if !ok {
+			continue
+		}
+
+		tag, err := strconv.Atoi(s)
+		if err != nil {
+			return nil, err
+		}
+
+		b, err = appendValue(b, byte(tag), refField)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return b, nil
+}
+
+func appendValue(b []byte, tag byte, value reflect.Value) ([]byte, error) {
+	var err error
+
+	switch value.Kind() {
+	case reflect.Uint8:
+		v := value.Uint()
+		return append(b, tag, 1, byte(v)), nil
+
+	case reflect.Uint16:
+		v := value.Uint()
+		return append(b, tag, 2, byte(v), byte(v>>8)), nil
+
+	case reflect.Uint32:
+		v := value.Uint()
+		return append(b, tag, 4, byte(v), byte(v>>8), byte(v>>16), byte(v>>24)), nil
+
+	case reflect.Uint64:
+		v := value.Uint()
+		return binary.LittleEndian.AppendUint64(append(b, tag, 8), v), nil
+
+	case reflect.Float32:
+		v := math.Float32bits(float32(value.Float()))
+		return append(b, tag, 4, byte(v), byte(v>>8), byte(v>>16), byte(v>>24)), nil
+
+	case reflect.String:
+		v := value.String()
+		l := len(v) // support "big" string
+		for ; l > 255; l -= 255 {
+			b = append(b, tag, 255)
+			b = append(b, v[:255]...)
+			v = v[255:]
+		}
+		b = append(b, tag, byte(l))
+		return append(b, v...), nil
+
+	case reflect.Array:
+		if value.Type().Elem().Kind() == reflect.Uint8 {
+			n := value.Len()
+			b = append(b, tag, byte(n))
+			for i := 0; i < n; i++ {
+				b = append(b, byte(value.Index(i).Uint()))
+			}
+			return b, nil
+		}
+
+	case reflect.Slice:
+		for i := 0; i < value.Len(); i++ {
+			if i > 0 {
+				b = append(b, separator, 0)
+			}
+			if b, err = appendValue(b, tag, value.Index(i)); err != nil {
+				return nil, err
+			}
+		}
+		return b, nil
+
+	case reflect.Struct:
+		b = append(b, tag, 0)
+		i := len(b)
+		if b, err = appendStruct(b, value); err != nil {
+			return nil, err
+		}
+		b[i-1] = byte(len(b) - i) // set struct size
+		return b, nil
+	}
+
+	return nil, errors.New("tlv8: not implemented: " + value.Kind().String())
+}
+
+func UnmarshalBase64(in any, out any) error {
+	s, _ := in.(string) // protect from in == nil
+	data, err := base64.StdEncoding.DecodeString(s)
+	if err != nil {
+		return err
+	}
+	return Unmarshal(data, out)
+}
+
+func UnmarshalReader(r io.Reader, n int64, v any) error {
+	var data []byte
+	var err error
+
+	if n > 0 {
+		data = make([]byte, n)
+		_, err = io.ReadFull(r, data)
+	} else {
+		data, err = io.ReadAll(r)
+	}
+	if err != nil {
+		return err
+	}
+
+	return Unmarshal(data, v)
+}
+
+func Unmarshal(data []byte, v any) error {
+	if len(data) == 0 {
+		return errors.New("tlv8: unmarshal zero data")
+	}
+
+	value := reflect.ValueOf(v)
+	kind := value.Kind()
+
+	if kind != reflect.Pointer {
+		return errors.New("tlv8: value should be pointer: " + kind.String())
+	}
+
+	value = value.Elem()
+	kind = value.Kind()
+
+	if kind == reflect.Interface {
+		value = value.Elem()
+		kind = value.Kind()
+	}
+
+	switch kind {
+	case reflect.Slice:
+		return unmarshalSlice(data, value)
+	case reflect.Struct:
+		return unmarshalStruct(data, value)
+	}
+
+	return errors.New("tlv8: not implemented: " + kind.String())
+}
+
+// unmarshalTLV can return two types of errors:
+// - critical and then the value of []byte will be nil
+// - not critical and then []byte will contain the value
+func unmarshalTLV(b []byte, value reflect.Value) ([]byte, error) {
+	if len(b) < 2 {
+		return nil, errors.New("tlv8: wrong size: " + value.Type().Name())
+	}
+
+	t := b[0]
+	l := int(b[1])
+
+	// array item divider (t == 0x00 || t == 0xFF)
+	if l == 0 {
+		return b[2:], errors.New("tlv8: zero item")
+	}
+
+	var v []byte
+
+	for {
+		if len(b) < 2+l {
+			return nil, errors.New("tlv8: wrong size: " + value.Type().Name())
+		}
+
+		v = append(v, b[2:2+l]...)
+		b = b[2+l:]
+
+		// if size == 255 and same tag - continue read big payload
+		if l < 255 || len(b) < 2 || b[0] != t {
+			break
+		}
+
+		l = int(b[1])
+	}
+
+	tag := strconv.Itoa(int(t))
+
+	valueField, ok := getStructField(value, tag)
+	if !ok {
+		return b, fmt.Errorf("tlv8: can't find T=%d,L=%d,V=%x for: %s", t, l, v, value.Type().Name())
+	}
+
+	if err := unmarshalValue(v, valueField); err != nil {
+		return nil, err
+	}
+
+	return b, nil
+}
+
+func unmarshalSlice(b []byte, value reflect.Value) error {
+	valueIndex := value.Index(growSlice(value))
+	for len(b) > 0 {
+		var err error
+		if b, err = unmarshalTLV(b, valueIndex); err != nil {
+			if b != nil {
+				valueIndex = value.Index(growSlice(value))
+				continue
+			}
+			return err
+		}
+	}
+	return nil
+}
+
+func unmarshalStruct(b []byte, value reflect.Value) error {
+	for len(b) > 0 {
+		var err error
+		if b, err = unmarshalTLV(b, value); b == nil && err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func unmarshalValue(v []byte, value reflect.Value) error {
+	switch value.Kind() {
+	case reflect.Uint8:
+		if len(v) != 1 {
+			return errors.New("tlv8: wrong size: " + value.Type().Name())
+		}
+		value.SetUint(uint64(v[0]))
+
+	case reflect.Uint16:
+		if len(v) != 2 {
+			return errors.New("tlv8: wrong size: " + value.Type().Name())
+		}
+		value.SetUint(uint64(v[0]) | uint64(v[1])<<8)
+
+	case reflect.Uint32:
+		if len(v) != 4 {
+			return errors.New("tlv8: wrong size: " + value.Type().Name())
+		}
+		value.SetUint(uint64(v[0]) | uint64(v[1])<<8 | uint64(v[2])<<16 | uint64(v[3])<<24)
+
+	case reflect.Uint64:
+		if len(v) != 8 {
+			return errors.New("tlv8: wrong size: " + value.Type().Name())
+		}
+		value.SetUint(binary.LittleEndian.Uint64(v))
+
+	case reflect.Float32:
+		f := math.Float32frombits(binary.LittleEndian.Uint32(v))
+		value.SetFloat(float64(f))
+
+	case reflect.String:
+		value.SetString(string(v))
+
+	case reflect.Array:
+		if kind := value.Type().Elem().Kind(); kind != reflect.Uint8 {
+			return errors.New("tlv8: unsupported array: " + kind.String())
+		}
+
+		for i, b := range v {
+			value.Index(i).SetUint(uint64(b))
+		}
+		return nil
+
+	case reflect.Slice:
+		i := growSlice(value)
+		return unmarshalValue(v, value.Index(i))
+
+	case reflect.Struct:
+		return unmarshalStruct(v, value)
+
+	default:
+		return errors.New("tlv8: not implemented: " + value.Kind().String())
+	}
+
+	return nil
+}
+
+func getStructField(value reflect.Value, tag string) (reflect.Value, bool) {
+	valueType := value.Type()
+
+	for i := 0; i < value.NumField(); i++ {
+		valueField := value.Field(i)
+
+		if s, ok := valueType.Field(i).Tag.Lookup("tlv8"); ok && s == tag {
+			return valueField, true
+		}
+	}
+
+	return reflect.Value{}, false
+}
+
+func growSlice(value reflect.Value) int {
+	size := value.Len()
+
+	if size >= value.Cap() {
+		newcap := value.Cap() + value.Cap()/2
+		if newcap < 4 {
+			newcap = 4
+		}
+		newValue := reflect.MakeSlice(value.Type(), value.Len(), newcap)
+		reflect.Copy(newValue, value)
+		value.Set(newValue)
+	}
+
+	if size >= value.Len() {
+		value.SetLen(size + 1)
+	}
+
+	return size
+}
diff --git a/installs_on_host/go2rtc/pkg/hap/tlv8/tlv8_test.go b/installs_on_host/go2rtc/pkg/hap/tlv8/tlv8_test.go
new file mode 100644
index 0000000..bb44c98
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hap/tlv8/tlv8_test.go
@@ -0,0 +1,156 @@
+package tlv8
+
+import (
+	"encoding/hex"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestMarshal(t *testing.T) {
+	type Struct struct {
+		Byte    byte    `tlv8:"1"`
+		Uint16  uint16  `tlv8:"2"`
+		Uint32  uint32  `tlv8:"3"`
+		Float32 float32 `tlv8:"4"`
+		String  string  `tlv8:"5"`
+		Slice   []byte  `tlv8:"6"`
+		Array   [4]byte `tlv8:"7"`
+	}
+
+	src := Struct{
+		Byte:    1,
+		Uint16:  2,
+		Uint32:  3,
+		Float32: 1.23,
+		String:  "123",
+		Slice:   []byte{1, 2, 3},
+		Array:   [4]byte{1, 2, 3, 4},
+	}
+
+	b, err := Marshal(src)
+	require.Nil(t, err)
+
+	var dst Struct
+	err = Unmarshal(b, &dst)
+	require.Nil(t, err)
+
+	require.Equal(t, src, dst)
+}
+
+func TestBytes(t *testing.T) {
+	bytes := make([]byte, 255)
+	for i := 0; i < len(bytes); i++ {
+		bytes[i] = byte(i)
+	}
+
+	type Struct struct {
+		String string `tlv8:"1"`
+	}
+	src := Struct{
+		String: string(bytes),
+	}
+
+	b, err := Marshal(src)
+	require.Nil(t, err)
+
+	var dst Struct
+	err = Unmarshal(b, &dst)
+	require.Nil(t, err)
+
+	require.Equal(t, src, dst)
+	require.Equal(t, bytes, []byte(dst.String))
+}
+
+func TestVideoCodecParams(t *testing.T) {
+	type VideoCodecParams struct {
+		ProfileID         []byte `tlv8:"1"`
+		Level             []byte `tlv8:"2"`
+		PacketizationMode byte   `tlv8:"3"`
+		CVOEnabled        []byte `tlv8:"4"`
+		CVOID             []byte `tlv8:"5"`
+	}
+
+	src, err := hex.DecodeString("0101010201000000020102030100040100")
+	require.Nil(t, err)
+
+	var v VideoCodecParams
+	err = Unmarshal(src, &v)
+	require.Nil(t, err)
+
+	dst, err := Marshal(v)
+	require.Nil(t, err)
+
+	require.Equal(t, src, dst)
+}
+
+func TestInterface(t *testing.T) {
+	type Struct struct {
+		Byte byte `tlv8:"1"`
+	}
+
+	src := Struct{
+		Byte: 1,
+	}
+	var v1 any = &src
+
+	b, err := Marshal(v1)
+	require.Nil(t, err)
+
+	require.Equal(t, []byte{1, 1, 1}, b)
+
+	var dst Struct
+	var v2 any = &dst
+
+	err = Unmarshal(b, v2)
+	require.Nil(t, err)
+
+	require.Equal(t, src, dst)
+}
+
+func TestSlice1(t *testing.T) {
+	var v struct {
+		VideoAttrs []struct {
+			Width     uint16 `tlv8:"1"`
+			Height    uint16 `tlv8:"2"`
+			Framerate uint8  `tlv8:"3"`
+		} `tlv8:"3"`
+	}
+
+	s := `030b010280070202380403011e ff00 030b010200050202d00203011e`
+	b1, err := hex.DecodeString(strings.ReplaceAll(s, " ", ""))
+	require.NoError(t, err)
+
+	err = Unmarshal(b1, &v)
+	require.NoError(t, err)
+
+	require.Len(t, v.VideoAttrs, 2)
+
+	b2, err := Marshal(v)
+	require.NoError(t, err)
+
+	require.Equal(t, b1, b2)
+}
+
+func TestSlice2(t *testing.T) {
+	var v []struct {
+		Width     uint16 `tlv8:"1"`
+		Height    uint16 `tlv8:"2"`
+		Framerate uint8  `tlv8:"3"`
+	}
+
+	s := `010280070202380403011e ff00 010200050202d00203011e`
+	b1, err := hex.DecodeString(strings.ReplaceAll(s, " ", ""))
+	require.NoError(t, err)
+
+	err = Unmarshal(b1, &v)
+	require.NoError(t, err)
+
+	require.Len(t, v, 2)
+
+	b2, err := Marshal(v)
+	require.NoError(t, err)
+
+	require.Equal(t, b1, b2)
+}
diff --git a/installs_on_host/go2rtc/pkg/hass/api.go b/installs_on_host/go2rtc/pkg/hass/api.go
new file mode 100644
index 0000000..1dcedbb
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hass/api.go
@@ -0,0 +1,144 @@
+package hass
+
+import (
+	"errors"
+	"os"
+
+	"github.com/gorilla/websocket"
+)
+
+type API struct {
+	ws *websocket.Conn
+}
+
+func NewAPI(url, token string) (*API, error) {
+	ws, _, err := websocket.DefaultDialer.Dial(url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	api := &API{ws: ws}
+	if err = api.Auth(token); err != nil {
+		_ = ws.Close()
+		return nil, err
+	}
+
+	return api, nil
+}
+
+func (a *API) Auth(token string) error {
+	var res ResponseAuth
+
+	if err := a.ws.ReadJSON(&res); err != nil {
+		return err
+	}
+	if res.Type != "auth_required" {
+		return errors.New("hass: wrong type: " + res.Type)
+	}
+
+	s := `{"type":"auth","access_token":"` + token + `"}`
+	if err := a.ws.WriteMessage(websocket.TextMessage, []byte(s)); err != nil {
+		return err
+	}
+	if err := a.ws.ReadJSON(&res); err != nil {
+		return err
+	}
+	if res.Type != "auth_ok" {
+		return errors.New("hass: wrong type: " + res.Type)
+	}
+
+	return nil
+}
+
+func (a *API) Close() error {
+	return a.ws.Close()
+}
+
+func (a *API) ExchangeSDP(entityID, offer string) (string, error) {
+	var msg = map[string]any{
+		"id":        1,
+		"type":      "camera/web_rtc_offer",
+		"entity_id": entityID,
+		"offer":     offer,
+	}
+	if err := a.ws.WriteJSON(msg); err != nil {
+		return "", err
+	}
+
+	var res ResponseOffer
+	if err := a.ws.ReadJSON(&res); err != nil {
+		return "", err
+	}
+
+	if res.Type != "result" || !res.Success {
+		return "", errors.New("hass: wrong response")
+	}
+
+	return res.Result.Answer, nil
+}
+
+func (a *API) GetWebRTCEntities() (map[string]string, error) {
+	s := `{"id":1,"type":"get_states"}`
+	if err := a.ws.WriteMessage(websocket.TextMessage, []byte(s)); err != nil {
+		return nil, err
+	}
+
+	var res ResponseStates
+	if err := a.ws.ReadJSON(&res); err != nil {
+		return nil, err
+	}
+	if res.Type != "result" || !res.Success {
+		return nil, errors.New("hass: wrong response")
+	}
+
+	entities := map[string]string{}
+
+	for _, entity := range res.Result {
+		if entity.Attributes.FrontendStreamType == "web_rtc" {
+			entities[entity.Attributes.FriendlyName] = entity.EntityId
+		}
+	}
+
+	return entities, nil
+}
+
+type ResponseAuth struct {
+	Type string `json:"type"`
+}
+
+type ResponseStates struct {
+	//Id      int    `json:"id"`
+	Type    string `json:"type"`
+	Success bool   `json:"success"`
+	Result  []struct {
+		EntityId string `json:"entity_id"`
+		//State      string `json:"state"`
+		Attributes struct {
+			//ModelName          string `json:"model_name"`
+			//Brand              string `json:"brand"`
+			FrontendStreamType string `json:"frontend_stream_type"`
+			FriendlyName       string `json:"friendly_name"`
+			//SupportedFeatures  int    `json:"supported_features"`
+		} `json:"attributes"`
+		//LastChanged time.Time `json:"last_changed"`
+		//LastUpdated time.Time `json:"last_updated"`
+		//Context     struct {
+		//	Id       string      `json:"id"`
+		//	ParentId interface{} `json:"parent_id"`
+		//	UserId   interface{} `json:"user_id"`
+		//} `json:"context"`
+	} `json:"result"`
+}
+
+type ResponseOffer struct {
+	//Id      int    `json:"id"`
+	Type    string `json:"type"`
+	Success bool   `json:"success"`
+	Result  struct {
+		Answer string `json:"answer"`
+	} `json:"result"`
+}
+
+func SupervisorToken() string {
+	return os.Getenv("SUPERVISOR_TOKEN")
+}
diff --git a/installs_on_host/go2rtc/pkg/hass/client.go b/installs_on_host/go2rtc/pkg/hass/client.go
new file mode 100644
index 0000000..a9ea026
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hass/client.go
@@ -0,0 +1,118 @@
+package hass
+
+import (
+	"errors"
+	"net/url"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/webrtc"
+	pion "github.com/pion/webrtc/v4"
+)
+
+type Client struct {
+	conn *webrtc.Conn
+}
+
+func NewClient(rawURL string) (*Client, error) {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	query := u.Query()
+
+	entityID := query.Get("entity_id")
+	if entityID == "" {
+		return nil, errors.New("hass: no entity_id")
+	}
+
+	var uri, token string
+
+	if u.Host == "supervisor" {
+		uri = "ws://supervisor/core/websocket"
+		token = SupervisorToken()
+	} else {
+		uri = "ws://" + u.Host + "/api/websocket"
+		token = query.Get("token")
+	}
+
+	if token == "" {
+		return nil, errors.New("hass: no token")
+	}
+
+	// 1. Check connection to Hass
+	hassAPI, err := NewAPI(uri, token)
+	if err != nil {
+		return nil, err
+	}
+
+	defer hassAPI.Close()
+
+	// 2. Create WebRTC client
+	rtcAPI, err := webrtc.NewAPI()
+	if err != nil {
+		return nil, err
+	}
+
+	conf := pion.Configuration{}
+	pc, err := rtcAPI.NewPeerConnection(conf)
+	if err != nil {
+		return nil, err
+	}
+
+	conn := webrtc.NewConn(pc)
+	conn.FormatName = "hass/webrtc"
+	conn.Mode = core.ModeActiveProducer
+	conn.Protocol = "ws"
+	conn.URL = rawURL
+
+	// https://developers.google.com/nest/device-access/traits/device/camera-live-stream#generatewebrtcstream-request-fields
+	medias := []*core.Media{
+		{Kind: core.KindAudio, Direction: core.DirectionRecvonly},
+		{Kind: core.KindVideo, Direction: core.DirectionRecvonly},
+		{Kind: "app"}, // important for Nest
+	}
+
+	// 3. Create offer with candidates
+	offer, err := conn.CreateCompleteOffer(medias)
+	if err != nil {
+		return nil, err
+	}
+
+	// 4. Exchange SDP via Hass
+	answer, err := hassAPI.ExchangeSDP(entityID, offer)
+	if err != nil {
+		return nil, err
+	}
+
+	// 5. Set answer with remote medias
+	if err = conn.SetAnswer(answer); err != nil {
+		return nil, err
+	}
+
+	return &Client{conn: conn}, nil
+}
+
+func (c *Client) GetMedias() []*core.Media {
+	return c.conn.GetMedias()
+}
+
+func (c *Client) GetTrack(media *core.Media, codec *core.Codec) (*core.Receiver, error) {
+	return c.conn.GetTrack(media, codec)
+}
+
+func (c *Client) AddTrack(media *core.Media, codec *core.Codec, track *core.Receiver) error {
+	return c.conn.AddTrack(media, codec, track)
+}
+
+func (c *Client) Start() error {
+	return c.conn.Start()
+}
+
+func (c *Client) Stop() error {
+	return c.conn.Stop()
+}
+
+func (c *Client) MarshalJSON() ([]byte, error) {
+	return c.conn.MarshalJSON()
+}
diff --git a/installs_on_host/go2rtc/pkg/hls/producer.go b/installs_on_host/go2rtc/pkg/hls/producer.go
new file mode 100644
index 0000000..e1c3ed4
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hls/producer.go
@@ -0,0 +1,22 @@
+package hls
+
+import (
+	"io"
+	"net/url"
+
+	"github.com/AlexxIT/go2rtc/pkg/mpegts"
+)
+
+func OpenURL(u *url.URL, body io.ReadCloser) (*mpegts.Producer, error) {
+	rd, err := NewReader(u, body)
+	if err != nil {
+		return nil, err
+	}
+	prod, err := mpegts.Open(rd)
+	if err != nil {
+		return nil, err
+	}
+	prod.FormatName = "hls/mpegts"
+	prod.RemoteAddr = u.Host
+	return prod, nil
+}
diff --git a/installs_on_host/go2rtc/pkg/hls/reader.go b/installs_on_host/go2rtc/pkg/hls/reader.go
new file mode 100644
index 0000000..37554e3
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/hls/reader.go
@@ -0,0 +1,165 @@
+package hls
+
+import (
+	"bytes"
+	"io"
+	"net/http"
+	"net/url"
+	"regexp"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+type reader struct {
+	client  *http.Client
+	request *http.Request
+
+	playlist    []byte
+	lastSegment []byte
+	lastTime    time.Time
+
+	buf []byte
+}
+
+func NewReader(u *url.URL, body io.ReadCloser) (io.Reader, error) {
+	b, err := io.ReadAll(body)
+	if err != nil {
+		return nil, err
+	}
+
+	var rawURL string
+
+	re := regexp.MustCompile(`#EXT-X-STREAM-INF.+?\n(\S+)`)
+	m := re.FindSubmatch(b)
+	if m != nil {
+		ref, err := url.Parse(string(m[1]))
+		if err != nil {
+			return nil, err
+		}
+
+		rawURL = u.ResolveReference(ref).String()
+	} else {
+		rawURL = u.String()
+	}
+
+	req, err := http.NewRequest("GET", rawURL, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	rd := &reader{
+		client:  &http.Client{Timeout: core.ConnDialTimeout},
+		request: req,
+	}
+	return rd, nil
+}
+
+func (r *reader) Read(dst []byte) (n int, err error) {
+	// 1. Check temporary tempbuffer
+	if len(r.buf) == 0 {
+		src, err2 := r.getSegment()
+		if err2 != nil {
+			return 0, err2
+		}
+
+		// 2. Check if the message fits in the buffer
+		if len(src) <= len(dst) {
+			return copy(dst, src), nil
+		}
+
+		// 3. Put the message into a temporary buffer
+		r.buf = src
+	}
+
+	// 4. Send temporary buffer
+	n = copy(dst, r.buf)
+	r.buf = r.buf[n:]
+	return
+}
+
+func (r *reader) Close() error {
+	r.client.Transport = r // after close we fail on next request
+	return nil
+}
+
+func (r *reader) RoundTrip(_ *http.Request) (*http.Response, error) {
+	return nil, io.EOF
+}
+
+func (r *reader) getSegment() ([]byte, error) {
+	for i := 0; i < 10; i++ {
+		if r.playlist == nil {
+			if wait := time.Second - time.Since(r.lastTime); wait > 0 {
+				time.Sleep(wait)
+			}
+
+			// 1. Load playlist
+			res, err := r.client.Do(r.request)
+			if err != nil {
+				return nil, err
+			}
+
+			r.playlist, err = io.ReadAll(res.Body)
+			if err != nil {
+				return nil, err
+			}
+
+			r.lastTime = time.Now()
+
+			//log.Printf("[hls] load playlist\n%s", r.playlist)
+		}
+
+		for r.playlist != nil {
+			// 2. Remove all previous segments from playlist
+			if i := bytes.Index(r.playlist, r.lastSegment); i > 0 {
+				r.playlist = r.playlist[i:]
+			}
+
+			// 3. Get link to new segment
+			segment := getSegment(r.playlist)
+			if segment == nil {
+				r.playlist = nil
+				break
+			}
+
+			//log.Printf("[hls] load segment: %s", segment)
+
+			ref, err := url.Parse(string(segment))
+			if err != nil {
+				return nil, err
+			}
+
+			ref = r.request.URL.ResolveReference(ref)
+			res, err := r.client.Get(ref.String())
+			if err != nil {
+				return nil, err
+			}
+
+			r.lastSegment = segment
+
+			return io.ReadAll(res.Body)
+		}
+	}
+
+	return nil, io.EOF
+}
+
+func getSegment(src []byte) []byte {
+	for ok := false; !ok; {
+		ok = bytes.HasPrefix(src, []byte("#EXTINF"))
+
+		i := bytes.IndexByte(src, '\n') + 1
+		if i == 0 {
+			return nil
+		}
+
+		src = src[i:]
+	}
+
+	if i := bytes.IndexByte(src, '\n'); i > 0 {
+		return src[:i]
+	}
+
+	return src
+}
diff --git a/installs_on_host/go2rtc/pkg/homekit/consumer.go b/installs_on_host/go2rtc/pkg/homekit/consumer.go
new file mode 100644
index 0000000..c1be744
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/homekit/consumer.go
@@ -0,0 +1,204 @@
+package homekit
+
+import (
+	"fmt"
+	"io"
+	"math/rand"
+	"net"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/hap/camera"
+	"github.com/AlexxIT/go2rtc/pkg/opus"
+	"github.com/AlexxIT/go2rtc/pkg/srtp"
+	"github.com/pion/rtp"
+)
+
+type Consumer struct {
+	core.Connection
+	conn net.Conn
+	srtp *srtp.Server
+
+	deadline *time.Timer
+
+	sessionID    string
+	videoSession *srtp.Session
+	audioSession *srtp.Session
+	audioRTPTime byte
+}
+
+func NewConsumer(conn net.Conn, server *srtp.Server) *Consumer {
+	medias := []*core.Media{
+		{
+			Kind:      core.KindVideo,
+			Direction: core.DirectionSendonly,
+			Codecs: []*core.Codec{
+				{Name: core.CodecH264},
+			},
+		},
+		{
+			Kind:      core.KindAudio,
+			Direction: core.DirectionSendonly,
+			Codecs: []*core.Codec{
+				{Name: core.CodecOpus},
+			},
+		},
+	}
+	return &Consumer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "homekit",
+			Protocol:   "rtp",
+			RemoteAddr: conn.RemoteAddr().String(),
+			Medias:     medias,
+			Transport:  conn,
+		},
+		conn: conn,
+		srtp: server,
+	}
+}
+
+func (c *Consumer) SessionID() string {
+	return c.sessionID
+}
+
+func (c *Consumer) SetOffer(offer *camera.SetupEndpointsRequest) {
+	c.sessionID = offer.SessionID
+	c.videoSession = &srtp.Session{
+		Remote: &srtp.Endpoint{
+			Addr:       offer.Address.IPAddr,
+			Port:       offer.Address.VideoRTPPort,
+			MasterKey:  []byte(offer.VideoCrypto.MasterKey),
+			MasterSalt: []byte(offer.VideoCrypto.MasterSalt),
+		},
+	}
+	c.audioSession = &srtp.Session{
+		Remote: &srtp.Endpoint{
+			Addr:       offer.Address.IPAddr,
+			Port:       offer.Address.AudioRTPPort,
+			MasterKey:  []byte(offer.AudioCrypto.MasterKey),
+			MasterSalt: []byte(offer.AudioCrypto.MasterSalt),
+		},
+	}
+}
+
+func (c *Consumer) GetAnswer() *camera.SetupEndpointsResponse {
+	c.videoSession.Local = c.srtpEndpoint()
+	c.audioSession.Local = c.srtpEndpoint()
+
+	return &camera.SetupEndpointsResponse{
+		SessionID: c.sessionID,
+		Status:    camera.StreamingStatusAvailable,
+		Address: camera.Address{
+			IPAddr:       c.videoSession.Local.Addr,
+			VideoRTPPort: c.videoSession.Local.Port,
+			AudioRTPPort: c.audioSession.Local.Port,
+		},
+		VideoCrypto: camera.SRTPCryptoSuite{
+			MasterKey:  string(c.videoSession.Local.MasterKey),
+			MasterSalt: string(c.videoSession.Local.MasterSalt),
+		},
+		AudioCrypto: camera.SRTPCryptoSuite{
+			MasterKey:  string(c.audioSession.Local.MasterKey),
+			MasterSalt: string(c.audioSession.Local.MasterSalt),
+		},
+		VideoSSRC: c.videoSession.Local.SSRC,
+		AudioSSRC: c.audioSession.Local.SSRC,
+	}
+}
+
+func (c *Consumer) SetConfig(conf *camera.SelectedStreamConfiguration) bool {
+	if c.sessionID != conf.Control.SessionID {
+		return false
+	}
+
+	c.SDP = fmt.Sprintf("%+v\n%+v", conf.VideoCodec, conf.AudioCodec)
+
+	c.videoSession.Remote.SSRC = conf.VideoCodec.RTPParams[0].SSRC
+	c.videoSession.PayloadType = conf.VideoCodec.RTPParams[0].PayloadType
+	c.videoSession.RTCPInterval = toDuration(conf.VideoCodec.RTPParams[0].RTCPInterval)
+
+	c.audioSession.Remote.SSRC = conf.AudioCodec.RTPParams[0].SSRC
+	c.audioSession.PayloadType = conf.AudioCodec.RTPParams[0].PayloadType
+	c.audioSession.RTCPInterval = toDuration(conf.AudioCodec.RTPParams[0].RTCPInterval)
+	c.audioRTPTime = conf.AudioCodec.CodecParams[0].RTPTime[0]
+
+	c.srtp.AddSession(c.videoSession)
+	c.srtp.AddSession(c.audioSession)
+
+	return true
+}
+
+func (c *Consumer) AddTrack(media *core.Media, codec *core.Codec, track *core.Receiver) error {
+	var session *srtp.Session
+	if codec.Kind() == core.KindVideo {
+		session = c.videoSession
+	} else {
+		session = c.audioSession
+	}
+
+	sender := core.NewSender(media, track.Codec)
+
+	if c.deadline == nil {
+		c.deadline = time.NewTimer(time.Second * 30)
+
+		sender.Handler = func(packet *rtp.Packet) {
+			c.deadline.Reset(core.ConnDeadline)
+			if n, err := session.WriteRTP(packet); err == nil {
+				c.Send += n
+			}
+		}
+	} else {
+		sender.Handler = func(packet *rtp.Packet) {
+			if n, err := session.WriteRTP(packet); err == nil {
+				c.Send += n
+			}
+		}
+	}
+
+	switch codec.Name {
+	case core.CodecH264:
+		sender.Handler = h264.RTPPay(1378, sender.Handler)
+		if track.Codec.IsRTP() {
+			sender.Handler = h264.RTPDepay(track.Codec, sender.Handler)
+		} else {
+			sender.Handler = h264.RepairAVCC(track.Codec, sender.Handler)
+		}
+	case core.CodecOpus:
+		sender.Handler = opus.RepackToHAP(c.audioRTPTime, sender.Handler)
+	}
+
+	sender.HandleRTP(track)
+	c.Senders = append(c.Senders, sender)
+	return nil
+}
+
+func (c *Consumer) WriteTo(io.Writer) (int64, error) {
+	if c.deadline != nil {
+		<-c.deadline.C
+	}
+	return 0, nil
+}
+
+func (c *Consumer) Stop() error {
+	if c.deadline != nil {
+		c.deadline.Reset(0)
+	}
+	return c.Connection.Stop()
+}
+
+func (c *Consumer) srtpEndpoint() *srtp.Endpoint {
+	addr := c.conn.LocalAddr().(*net.TCPAddr)
+	return &srtp.Endpoint{
+		Addr:       addr.IP.To4().String(),
+		Port:       uint16(c.srtp.Port()),
+		MasterKey:  []byte(core.RandString(16, 0)),
+		MasterSalt: []byte(core.RandString(14, 0)),
+		SSRC:       rand.Uint32(),
+	}
+}
+
+func toDuration(seconds float32) time.Duration {
+	return time.Duration(seconds * float32(time.Second))
+}
diff --git a/installs_on_host/go2rtc/pkg/homekit/helpers.go b/installs_on_host/go2rtc/pkg/homekit/helpers.go
new file mode 100644
index 0000000..625e3ab
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/homekit/helpers.go
@@ -0,0 +1,147 @@
+package homekit
+
+import (
+	"encoding/hex"
+
+	"github.com/AlexxIT/go2rtc/pkg/aac"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/hap/camera"
+)
+
+var videoCodecs = [...]string{core.CodecH264}
+var videoProfiles = [...]string{"4200", "4D00", "6400"}
+var videoLevels = [...]string{"1F", "20", "28"}
+
+func videoToMedia(codecs []camera.VideoCodecConfiguration) *core.Media {
+	media := &core.Media{
+		Kind: core.KindVideo, Direction: core.DirectionRecvonly,
+	}
+
+	for _, codec := range codecs {
+		for _, param := range codec.CodecParams {
+			// get best profile and level
+			profileID := core.Max(param.ProfileID)
+			level := core.Max(param.Level)
+			profile := videoProfiles[profileID] + videoLevels[level]
+			mediaCodec := &core.Codec{
+				Name:      videoCodecs[codec.CodecType],
+				ClockRate: 90000,
+				FmtpLine:  "profile-level-id=" + profile,
+			}
+			media.Codecs = append(media.Codecs, mediaCodec)
+		}
+	}
+
+	return media
+}
+
+var audioCodecs = [...]string{core.CodecPCMU, core.CodecPCMA, core.CodecELD, core.CodecOpus}
+var audioSampleRates = [...]uint32{8000, 16000, 24000}
+
+func audioToMedia(codecs []camera.AudioCodecConfiguration) *core.Media {
+	media := &core.Media{
+		Kind: core.KindAudio, Direction: core.DirectionRecvonly,
+	}
+
+	for _, codec := range codecs {
+		for _, param := range codec.CodecParams {
+			for _, sampleRate := range param.SampleRate {
+				mediaCodec := &core.Codec{
+					Name:      audioCodecs[codec.CodecType],
+					ClockRate: audioSampleRates[sampleRate],
+					Channels:  param.Channels,
+				}
+
+				if mediaCodec.Name == core.CodecELD {
+					// only this version works with FFmpeg
+					conf := aac.EncodeConfig(aac.TypeAACELD, 24000, 1, true)
+					mediaCodec.FmtpLine = aac.FMTP + hex.EncodeToString(conf)
+				}
+
+				media.Codecs = append(media.Codecs, mediaCodec)
+			}
+		}
+	}
+
+	return media
+}
+
+func trackToVideo(track *core.Receiver, video0 *camera.VideoCodecConfiguration, maxWidth, maxHeight int) *camera.VideoCodecConfiguration {
+	profileID := video0.CodecParams[0].ProfileID[0]
+	level := video0.CodecParams[0].Level[0]
+	var attrs camera.VideoCodecAttributes
+
+	if track != nil {
+		profile := h264.GetProfileLevelID(track.Codec.FmtpLine)
+
+		for i, s := range videoProfiles {
+			if s == profile[:4] {
+				profileID = byte(i)
+				break
+			}
+		}
+
+		for i, s := range videoLevels {
+			if s == profile[4:] {
+				level = byte(i)
+				break
+			}
+		}
+
+		for _, s := range video0.VideoAttrs {
+			if (maxWidth > 0 && int(s.Width) > maxWidth) || (maxHeight > 0 && int(s.Height) > maxHeight) {
+				continue
+			}
+			if s.Width > attrs.Width || s.Height > attrs.Height {
+				attrs = s
+			}
+		}
+	}
+
+	return &camera.VideoCodecConfiguration{
+		CodecType: video0.CodecType,
+		CodecParams: []camera.VideoCodecParameters{
+			{
+				ProfileID: []byte{profileID},
+				Level:     []byte{level},
+			},
+		},
+		VideoAttrs: []camera.VideoCodecAttributes{attrs},
+	}
+}
+
+func trackToAudio(track *core.Receiver, audio0 *camera.AudioCodecConfiguration) *camera.AudioCodecConfiguration {
+	codecType := audio0.CodecType
+	channels := audio0.CodecParams[0].Channels
+	sampleRate := audio0.CodecParams[0].SampleRate[0]
+
+	if track != nil {
+		channels = uint8(track.Codec.Channels)
+
+		for i, s := range audioCodecs {
+			if s == track.Codec.Name {
+				codecType = byte(i)
+				break
+			}
+		}
+
+		for i, s := range audioSampleRates {
+			if s == track.Codec.ClockRate {
+				sampleRate = byte(i)
+				break
+			}
+		}
+	}
+
+	return &camera.AudioCodecConfiguration{
+		CodecType: codecType,
+		CodecParams: []camera.AudioCodecParameters{
+			{
+				Channels:   channels,
+				SampleRate: []byte{sampleRate},
+				RTPTime:    []uint8{20},
+			},
+		},
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/homekit/log/debug.go b/installs_on_host/go2rtc/pkg/homekit/log/debug.go
new file mode 100644
index 0000000..1fb60be
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/homekit/log/debug.go
@@ -0,0 +1,45 @@
+package log
+
+import (
+	"bytes"
+	"io"
+	"log"
+	"net/http"
+)
+
+func Debug(v any) {
+	switch v := v.(type) {
+	case *http.Request:
+		if v == nil {
+			return
+		}
+		if v.ContentLength != 0 {
+			b, err := io.ReadAll(v.Body)
+			if err != nil {
+				panic(err)
+			}
+			v.Body = io.NopCloser(bytes.NewReader(b))
+			log.Printf("[homekit] request: %s %s\n%s", v.Method, v.RequestURI, b)
+		} else {
+			log.Printf("[homekit] request: %s %s <nobody>", v.Method, v.RequestURI)
+		}
+	case *http.Response:
+		if v == nil {
+			return
+		}
+		if v.Header.Get("Content-Type") == "image/jpeg" {
+			log.Printf("[homekit] response: %d <jpeg>", v.StatusCode)
+			return
+		}
+		if v.ContentLength != 0 {
+			b, err := io.ReadAll(v.Body)
+			if err != nil {
+				panic(err)
+			}
+			v.Body = io.NopCloser(bytes.NewReader(b))
+			log.Printf("[homekit] response: %s %d\n%s", v.Proto, v.StatusCode, b)
+		} else {
+			log.Printf("[homekit] response: %s %d <nobody>", v.Proto, v.StatusCode)
+		}
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/homekit/producer.go b/installs_on_host/go2rtc/pkg/homekit/producer.go
new file mode 100644
index 0000000..81352a1
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/homekit/producer.go
@@ -0,0 +1,243 @@
+package homekit
+
+import (
+	"errors"
+	"fmt"
+	"math/rand"
+	"net"
+	"time"
+
+	"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/pion/rtp"
+)
+
+// Deprecated: rename to Producer
+type Client struct {
+	core.Connection
+
+	hap  *hap.Client
+	srtp *srtp.Server
+
+	videoConfig camera.SupportedVideoStreamConfiguration
+	audioConfig camera.SupportedAudioStreamConfiguration
+
+	videoSession *srtp.Session
+	audioSession *srtp.Session
+
+	stream *camera.Stream
+
+	MaxWidth  int `json:"-"`
+	MaxHeight int `json:"-"`
+	Bitrate   int `json:"-"` // in bits/s
+}
+
+func Dial(rawURL string, server *srtp.Server) (*Client, error) {
+	conn, err := hap.Dial(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	client := &Client{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "homekit",
+			Protocol:   "udp",
+			RemoteAddr: conn.Conn.RemoteAddr().String(),
+			Source:     rawURL,
+			Transport:  conn,
+		},
+		hap:  conn,
+		srtp: server,
+	}
+
+	return client, nil
+}
+
+func (c *Client) Conn() net.Conn {
+	return c.hap.Conn
+}
+
+func (c *Client) GetMedias() []*core.Media {
+	if c.Medias != nil {
+		return c.Medias
+	}
+
+	acc, err := c.hap.GetFirstAccessory()
+	if err != nil {
+		return nil
+	}
+
+	char := acc.GetCharacter(camera.TypeSupportedVideoStreamConfiguration)
+	if char == nil {
+		return nil
+	}
+	if err = char.ReadTLV8(&c.videoConfig); err != nil {
+		return nil
+	}
+
+	char = acc.GetCharacter(camera.TypeSupportedAudioStreamConfiguration)
+	if char == nil {
+		return nil
+	}
+	if err = char.ReadTLV8(&c.audioConfig); err != nil {
+		return nil
+	}
+
+	c.SDP = fmt.Sprintf("%+v\n%+v", c.videoConfig, c.audioConfig)
+
+	c.Medias = []*core.Media{
+		videoToMedia(c.videoConfig.Codecs),
+		audioToMedia(c.audioConfig.Codecs),
+		{
+			Kind:      core.KindVideo,
+			Direction: core.DirectionRecvonly,
+			Codecs: []*core.Codec{
+				{
+					Name:        core.CodecJPEG,
+					ClockRate:   90000,
+					PayloadType: core.PayloadTypeRAW,
+				},
+			},
+		},
+	}
+
+	return c.Medias
+}
+
+func (c *Client) Start() error {
+	if c.Receivers == nil {
+		return errors.New("producer without tracks")
+	}
+
+	if c.Receivers[0].Codec.Name == core.CodecJPEG {
+		return c.startMJPEG()
+	}
+
+	videoTrack := c.trackByKind(core.KindVideo)
+	videoCodec := trackToVideo(videoTrack, &c.videoConfig.Codecs[0], c.MaxWidth, c.MaxHeight)
+
+	audioTrack := c.trackByKind(core.KindAudio)
+	audioCodec := trackToAudio(audioTrack, &c.audioConfig.Codecs[0])
+
+	c.videoSession = &srtp.Session{Local: c.srtpEndpoint()}
+	c.audioSession = &srtp.Session{Local: c.srtpEndpoint()}
+
+	var err error
+	c.stream, err = camera.NewStream(c.hap, videoCodec, audioCodec, c.videoSession, c.audioSession, c.Bitrate)
+	if err != nil {
+		return err
+	}
+
+	c.srtp.AddSession(c.videoSession)
+	c.srtp.AddSession(c.audioSession)
+
+	deadline := time.NewTimer(core.ConnDeadline)
+
+	if videoTrack != nil {
+		c.videoSession.OnReadRTP = func(packet *rtp.Packet) {
+			deadline.Reset(core.ConnDeadline)
+			videoTrack.WriteRTP(packet)
+			c.Recv += len(packet.Payload)
+		}
+
+		if audioTrack != nil {
+			c.audioSession.OnReadRTP = func(packet *rtp.Packet) {
+				audioTrack.WriteRTP(packet)
+				c.Recv += len(packet.Payload)
+			}
+		}
+	} else {
+		c.audioSession.OnReadRTP = func(packet *rtp.Packet) {
+			deadline.Reset(core.ConnDeadline)
+			audioTrack.WriteRTP(packet)
+			c.Recv += len(packet.Payload)
+		}
+	}
+
+	if c.audioSession.OnReadRTP != nil {
+		c.audioSession.OnReadRTP = timekeeper(c.audioSession.OnReadRTP)
+	}
+
+	<-deadline.C
+
+	return nil
+}
+
+func (c *Client) Stop() error {
+	if c.videoSession != nil && c.videoSession.Remote != nil {
+		c.srtp.DelSession(c.videoSession)
+	}
+	if c.audioSession != nil && c.audioSession.Remote != nil {
+		c.srtp.DelSession(c.audioSession)
+	}
+
+	return c.Connection.Stop()
+}
+
+func (c *Client) trackByKind(kind string) *core.Receiver {
+	for _, receiver := range c.Receivers {
+		if receiver.Codec.Kind() == kind {
+			return receiver
+		}
+	}
+	return nil
+}
+
+func (c *Client) startMJPEG() error {
+	receiver := c.Receivers[0]
+
+	for {
+		b, err := c.hap.GetImage(1920, 1080)
+		if err != nil {
+			return err
+		}
+
+		c.Recv += len(b)
+
+		packet := &rtp.Packet{
+			Header:  rtp.Header{Timestamp: core.Now90000()},
+			Payload: b,
+		}
+		receiver.WriteRTP(packet)
+	}
+}
+
+func (c *Client) srtpEndpoint() *srtp.Endpoint {
+	return &srtp.Endpoint{
+		Addr:       c.hap.LocalIP(),
+		Port:       uint16(c.srtp.Port()),
+		MasterKey:  []byte(core.RandString(16, 0)),
+		MasterSalt: []byte(core.RandString(14, 0)),
+		SSRC:       rand.Uint32(),
+	}
+}
+
+func timekeeper(handler core.HandlerFunc) core.HandlerFunc {
+	const sampleRate = 16000
+	const sampleSize = 480
+
+	var send time.Duration
+	var firstTime time.Time
+
+	return func(packet *rtp.Packet) {
+		now := time.Now()
+
+		if send != 0 {
+			elapsed := now.Sub(firstTime) * sampleRate / time.Second
+			if send+sampleSize > elapsed {
+				return // drop overflow frame
+			}
+		} else {
+			firstTime = now
+		}
+
+		send += sampleSize
+
+		packet.Timestamp = uint32(send)
+
+		handler(packet)
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/homekit/proxy.go b/installs_on_host/go2rtc/pkg/homekit/proxy.go
new file mode 100644
index 0000000..2132266
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/homekit/proxy.go
@@ -0,0 +1,218 @@
+package homekit
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"io"
+	"net"
+	"net/http"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/hap"
+	"github.com/AlexxIT/go2rtc/pkg/hap/camera"
+	"github.com/AlexxIT/go2rtc/pkg/hap/hds"
+	"github.com/AlexxIT/go2rtc/pkg/hap/tlv8"
+)
+
+type ServerProxy interface {
+	ServerPair
+	AddConn(conn any)
+	DelConn(conn any)
+}
+
+func ProxyHandler(srv ServerProxy, acc net.Conn) HandlerFunc {
+	return func(con net.Conn) error {
+		defer con.Close()
+
+		pr := &Proxy{
+			con: con.(*hap.Conn),
+			acc: acc.(*hap.Conn),
+			res: make(chan *http.Response),
+		}
+
+		// accessory (ex. Camera) => controller (ex. iPhone)
+		go pr.handleAcc()
+
+		// controller => accessory
+		return pr.handleCon(srv)
+	}
+}
+
+type Proxy struct {
+	con *hap.Conn
+	acc *hap.Conn
+	res chan *http.Response
+}
+
+func (p *Proxy) handleCon(srv ServerProxy) error {
+	var hdsCharIID uint64
+
+	rd := bufio.NewReader(p.con)
+	for {
+		req, err := http.ReadRequest(rd)
+		if err != nil {
+			return err
+		}
+
+		var hdsConSalt string
+
+		switch {
+		case req.Method == "POST" && req.URL.Path == hap.PathPairings:
+			var res *http.Response
+			if res, err = handlePairings(req, srv); err != nil {
+				return err
+			}
+			if err = res.Write(p.con); err != nil {
+				return err
+			}
+			continue
+		case req.Method == "PUT" && req.URL.Path == hap.PathCharacteristics && hdsCharIID != 0:
+			body, _ := io.ReadAll(req.Body)
+			var v hap.JSONCharacters
+			_ = json.Unmarshal(body, &v)
+			for _, char := range v.Value {
+				if char.IID == hdsCharIID {
+					var hdsReq camera.SetupDataStreamTransportRequest
+					_ = tlv8.UnmarshalBase64(char.Value, &hdsReq)
+					hdsConSalt = hdsReq.ControllerKeySalt
+					break
+				}
+			}
+			req.Body = io.NopCloser(bytes.NewReader(body))
+		}
+
+		if err = req.Write(p.acc); err != nil {
+			return err
+		}
+
+		res := <-p.res
+
+		switch {
+		case req.Method == "GET" && req.URL.Path == hap.PathAccessories:
+			body, _ := io.ReadAll(res.Body)
+			var v hap.JSONAccessories
+			if err = json.Unmarshal(body, &v); err != nil {
+				return err
+			}
+			for _, acc := range v.Value {
+				if char := acc.GetCharacter(camera.TypeSetupDataStreamTransport); char != nil {
+					hdsCharIID = char.IID
+				}
+				break
+			}
+			res.Body = io.NopCloser(bytes.NewReader(body))
+
+		case hdsConSalt != "":
+			body, _ := io.ReadAll(res.Body)
+			var v hap.JSONCharacters
+			_ = json.Unmarshal(body, &v)
+			for i, char := range v.Value {
+				if char.IID == hdsCharIID {
+					var hdsRes camera.SetupDataStreamTransportResponse
+					_ = tlv8.UnmarshalBase64(char.Value, &hdsRes)
+
+					hdsAccSalt := hdsRes.AccessoryKeySalt
+					hdsPort := int(hdsRes.TransportTypeSessionParameters.TCPListeningPort)
+
+					// swtich accPort to conPort
+					hdsPort, err = p.listenHDS(srv, hdsPort, hdsConSalt+hdsAccSalt)
+					if err != nil {
+						return err
+					}
+
+					hdsRes.TransportTypeSessionParameters.TCPListeningPort = uint16(hdsPort)
+					if v.Value[i].Value, err = tlv8.MarshalBase64(hdsRes); err != nil {
+						return err
+					}
+					body, _ = json.Marshal(v)
+					res.ContentLength = int64(len(body))
+					break
+				}
+			}
+			res.Body = io.NopCloser(bytes.NewReader(body))
+		}
+
+		if err = res.Write(p.con); err != nil {
+			return err
+		}
+	}
+}
+
+func (p *Proxy) handleAcc() error {
+	rd := bufio.NewReader(p.acc)
+	for {
+		res, err := hap.ReadResponse(rd, nil)
+		if err != nil {
+			return err
+		}
+
+		if res.Proto == hap.ProtoEvent {
+			if err = hap.WriteEvent(p.con, res); err != nil {
+				return err
+			}
+			continue
+		}
+
+		// important to read body before next read response
+		body, err := io.ReadAll(res.Body)
+		if err != nil {
+			return err
+		}
+		res.Body = io.NopCloser(bytes.NewReader(body))
+
+		p.res <- res
+	}
+}
+
+func (p *Proxy) listenHDS(srv ServerProxy, accPort int, salt string) (int, error) {
+	// The TCP port range for HDS must be >= 32768.
+	ln, err := net.ListenTCP("tcp", nil)
+	if err != nil {
+		return 0, err
+	}
+
+	go func() {
+		defer ln.Close()
+
+		_ = ln.SetDeadline(time.Now().Add(30 * time.Second))
+
+		// raw controller conn
+		conn1, err := ln.Accept()
+		if err != nil {
+			return
+		}
+
+		defer conn1.Close()
+
+		// secured controller conn (controlle=false because we are accessory)
+		con, err := hds.NewConn(conn1, p.con.SharedKey, salt, false)
+		if err != nil {
+			return
+		}
+
+		srv.AddConn(con)
+		defer srv.DelConn(con)
+
+		accIP := p.acc.RemoteAddr().(*net.TCPAddr).IP
+
+		// raw accessory conn
+		conn2, err := net.DialTCP("tcp", nil, &net.TCPAddr{IP: accIP, Port: accPort})
+		if err != nil {
+			return
+		}
+		defer conn2.Close()
+
+		// secured accessory conn (controller=true because we are controller)
+		acc, err := hds.NewConn(conn2, p.acc.SharedKey, salt, true)
+		if err != nil {
+			return
+		}
+
+		go io.Copy(con, acc)
+		_, _ = io.Copy(acc, con)
+	}()
+
+	conPort := ln.Addr().(*net.TCPAddr).Port
+	return conPort, nil
+}
diff --git a/installs_on_host/go2rtc/pkg/homekit/server.go b/installs_on_host/go2rtc/pkg/homekit/server.go
new file mode 100644
index 0000000..75ba2a0
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/homekit/server.go
@@ -0,0 +1,194 @@
+package homekit
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"errors"
+	"io"
+	"net"
+	"net/http"
+	"strconv"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/pkg/hap"
+	"github.com/AlexxIT/go2rtc/pkg/hap/tlv8"
+)
+
+type HandlerFunc func(net.Conn) error
+
+type Server interface {
+	ServerPair
+	ServerAccessory
+}
+
+type ServerPair interface {
+	GetPair(id string) []byte
+	AddPair(id string, public []byte, permissions byte)
+	DelPair(id string)
+}
+
+type ServerAccessory interface {
+	GetAccessories(conn net.Conn) []*hap.Accessory
+	GetCharacteristic(conn net.Conn, aid uint8, iid uint64) any
+	SetCharacteristic(conn net.Conn, aid uint8, iid uint64, value any)
+	GetImage(conn net.Conn, width, height int) []byte
+}
+
+func ServerHandler(server Server) HandlerFunc {
+	return handleRequest(func(conn net.Conn, req *http.Request) (*http.Response, error) {
+		switch req.URL.Path {
+		case hap.PathPairings:
+			return handlePairings(req, server)
+
+		case hap.PathAccessories:
+			body := hap.JSONAccessories{Value: server.GetAccessories(conn)}
+			return makeResponse(hap.MimeJSON, body)
+
+		case hap.PathCharacteristics:
+			switch req.Method {
+			case "GET":
+				var v hap.JSONCharacters
+
+				id := req.URL.Query().Get("id")
+				for _, id = range strings.Split(id, ",") {
+					s1, s2, _ := strings.Cut(id, ".")
+					aid, _ := strconv.Atoi(s1)
+					iid, _ := strconv.ParseUint(s2, 10, 64)
+					val := server.GetCharacteristic(conn, uint8(aid), iid)
+
+					v.Value = append(v.Value, hap.JSONCharacter{AID: uint8(aid), IID: iid, Value: val})
+				}
+
+				return makeResponse(hap.MimeJSON, v)
+
+			case "PUT":
+				var v struct {
+					Value []struct {
+						AID   uint8  `json:"aid"`
+						IID   uint64 `json:"iid"`
+						Value any    `json:"value"`
+					} `json:"characteristics"`
+				}
+				if err := json.NewDecoder(req.Body).Decode(&v); err != nil {
+					return nil, err
+				}
+
+				for _, char := range v.Value {
+					server.SetCharacteristic(conn, char.AID, char.IID, char.Value)
+				}
+
+				res := &http.Response{
+					StatusCode: http.StatusNoContent,
+					Proto:      "HTTP",
+					ProtoMajor: 1,
+					ProtoMinor: 1,
+				}
+				return res, nil
+			}
+
+		case hap.PathResource:
+			var v struct {
+				Width  int    `json:"image-width"`
+				Height int    `json:"image-height"`
+				Type   string `json:"resource-type"`
+			}
+			if err := json.NewDecoder(req.Body).Decode(&v); err != nil {
+				return nil, err
+			}
+
+			body := server.GetImage(conn, v.Width, v.Height)
+			return makeResponse("image/jpeg", body)
+		}
+
+		return nil, errors.New("hap: unsupported path: " + req.RequestURI)
+	})
+}
+
+func handleRequest(handle func(conn net.Conn, req *http.Request) (*http.Response, error)) HandlerFunc {
+	return func(conn net.Conn) error {
+		rw := bufio.NewReaderSize(conn, 16*1024)
+		wr := bufio.NewWriterSize(conn, 16*1024)
+		for {
+			req, err := http.ReadRequest(rw)
+			//debug(req)
+			if err != nil {
+				return err
+			}
+
+			res, err := handle(conn, req)
+			//debug(res)
+			if err != nil {
+				return err
+			}
+
+			if err = res.Write(wr); err != nil {
+				return err
+			}
+			if err = wr.Flush(); err != nil {
+				return err
+			}
+		}
+	}
+}
+
+func handlePairings(req *http.Request, srv ServerPair) (*http.Response, error) {
+	cmd := struct {
+		Method      byte   `tlv8:"0"`
+		Identifier  string `tlv8:"1"`
+		PublicKey   string `tlv8:"3"`
+		State       byte   `tlv8:"6"`
+		Permissions byte   `tlv8:"11"`
+	}{}
+
+	if err := tlv8.UnmarshalReader(req.Body, req.ContentLength, &cmd); err != nil {
+		return nil, err
+	}
+
+	switch cmd.Method {
+	case 3: // add
+		srv.AddPair(cmd.Identifier, []byte(cmd.PublicKey), cmd.Permissions)
+	case 4: // delete
+		srv.DelPair(cmd.Identifier)
+	}
+
+	body := struct {
+		State byte `tlv8:"6"`
+	}{
+		State: hap.StateM2,
+	}
+
+	return makeResponse(hap.MimeTLV8, body)
+}
+
+func makeResponse(mime string, v any) (*http.Response, error) {
+	var body []byte
+	var err error
+
+	switch mime {
+	case hap.MimeJSON:
+		body, err = json.Marshal(v)
+	case hap.MimeTLV8:
+		body, err = tlv8.Marshal(v)
+	case "image/jpeg":
+		body = v.([]byte)
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	res := &http.Response{
+		StatusCode: http.StatusOK,
+		Proto:      "HTTP",
+		ProtoMajor: 1,
+		ProtoMinor: 1,
+		Header: http.Header{
+			"Content-Type":   []string{mime},
+			"Content-Length": []string{strconv.Itoa(len(body))},
+		},
+		ContentLength: int64(len(body)),
+		Body:          io.NopCloser(bytes.NewReader(body)),
+	}
+	return res, nil
+}
diff --git a/installs_on_host/go2rtc/pkg/image/producer.go b/installs_on_host/go2rtc/pkg/image/producer.go
new file mode 100644
index 0000000..2081c04
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/image/producer.go
@@ -0,0 +1,92 @@
+package image
+
+import (
+	"errors"
+	"io"
+	"net/http"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/tcp"
+	"github.com/pion/rtp"
+)
+
+type Producer struct {
+	core.Connection
+
+	closed bool
+	res    *http.Response
+}
+
+func Open(res *http.Response) (*Producer, error) {
+	return &Producer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "image",
+			Protocol:   "http",
+			RemoteAddr: res.Request.URL.Host,
+			Transport:  res.Body,
+			Medias: []*core.Media{
+				{
+					Kind:      core.KindVideo,
+					Direction: core.DirectionRecvonly,
+					Codecs: []*core.Codec{
+						{
+							Name:        core.CodecJPEG,
+							ClockRate:   90000,
+							PayloadType: core.PayloadTypeRAW,
+						},
+					},
+				},
+			},
+		},
+		res: res,
+	}, nil
+}
+
+func (c *Producer) Start() error {
+	body, err := io.ReadAll(c.res.Body)
+	if err != nil {
+		return err
+	}
+
+	pkt := &rtp.Packet{
+		Header:  rtp.Header{Timestamp: core.Now90000()},
+		Payload: body,
+	}
+	c.Receivers[0].WriteRTP(pkt)
+
+	c.Recv += len(body)
+
+	req := c.res.Request
+
+	for !c.closed {
+		res, err := tcp.Do(req)
+		if err != nil {
+			return err
+		}
+
+		if res.StatusCode != http.StatusOK {
+			return errors.New("wrong status: " + res.Status)
+		}
+
+		body, err = io.ReadAll(res.Body)
+		if err != nil {
+			return err
+		}
+
+		c.Recv += len(body)
+
+		pkt = &rtp.Packet{
+			Header:  rtp.Header{Timestamp: core.Now90000()},
+			Payload: body,
+		}
+		c.Receivers[0].WriteRTP(pkt)
+	}
+
+	return nil
+}
+
+func (c *Producer) Stop() error {
+	c.closed = true
+	return c.Connection.Stop()
+}
diff --git a/installs_on_host/go2rtc/pkg/ioctl/README.md b/installs_on_host/go2rtc/pkg/ioctl/README.md
new file mode 100644
index 0000000..41f82df
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/ioctl/README.md
@@ -0,0 +1,3 @@
+# IOCTL
+
+This is just an example how Linux IOCTL constants works.
diff --git a/installs_on_host/go2rtc/pkg/ioctl/ioctl.go b/installs_on_host/go2rtc/pkg/ioctl/ioctl.go
new file mode 100644
index 0000000..0f21e17
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/ioctl/ioctl.go
@@ -0,0 +1,28 @@
+package ioctl
+
+import (
+	"bytes"
+)
+
+func Str(b []byte) string {
+	if i := bytes.IndexByte(b, 0); i >= 0 {
+		return string(b[:i])
+	}
+	return string(b)
+}
+
+func io(mode byte, type_ byte, number byte, size uint16) uintptr {
+	return uintptr(mode)<<30 | uintptr(size)<<16 | uintptr(type_)<<8 | uintptr(number)
+}
+
+func IOR(type_ byte, number byte, size uint16) uintptr {
+	return io(read, type_, number, size)
+}
+
+func IOW(type_ byte, number byte, size uint16) uintptr {
+	return io(write, type_, number, size)
+}
+
+func IORW(type_ byte, number byte, size uint16) uintptr {
+	return io(read|write, type_, number, size)
+}
diff --git a/installs_on_host/go2rtc/pkg/ioctl/ioctl_be.go b/installs_on_host/go2rtc/pkg/ioctl/ioctl_be.go
new file mode 100644
index 0000000..60de9c4
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/ioctl/ioctl_be.go
@@ -0,0 +1,8 @@
+//go:build arm || arm64 || 386 || amd64
+
+package ioctl
+
+const (
+	write = 1
+	read  = 2
+)
diff --git a/installs_on_host/go2rtc/pkg/ioctl/ioctl_le.go b/installs_on_host/go2rtc/pkg/ioctl/ioctl_le.go
new file mode 100644
index 0000000..3bdb1f6
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/ioctl/ioctl_le.go
@@ -0,0 +1,8 @@
+//go:build mipsle
+
+package ioctl
+
+const (
+	read  = 1
+	write = 2
+)
diff --git a/installs_on_host/go2rtc/pkg/ioctl/ioctl_linux.go b/installs_on_host/go2rtc/pkg/ioctl/ioctl_linux.go
new file mode 100644
index 0000000..ed38f6a
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/ioctl/ioctl_linux.go
@@ -0,0 +1,14 @@
+package ioctl
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+func Ioctl(fd int, req uint, arg unsafe.Pointer) error {
+	_, _, err := syscall.Syscall(syscall.SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(arg))
+	if err != 0 {
+		return err
+	}
+	return nil
+}
diff --git a/installs_on_host/go2rtc/pkg/ioctl/ioctl_test.go b/installs_on_host/go2rtc/pkg/ioctl/ioctl_test.go
new file mode 100644
index 0000000..52657e6
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/ioctl/ioctl_test.go
@@ -0,0 +1,16 @@
+package ioctl
+
+import (
+	"runtime"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestIOR(t *testing.T) {
+	// #define SNDRV_PCM_IOCTL_INFO		_IOR('A', 0x01, struct snd_pcm_info)
+	if runtime.GOARCH == "arm64" {
+		c := IOR('A', 0x01, 288)
+		require.Equal(t, uintptr(0x81204101), c)
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/isapi/backchannel.go b/installs_on_host/go2rtc/pkg/isapi/backchannel.go
new file mode 100644
index 0000000..ade1625
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/isapi/backchannel.go
@@ -0,0 +1,69 @@
+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.Connection{
+		ID:         core.ID(c),
+		FormatName: "isapi",
+		Protocol:   "http",
+		Medias:     c.medias,
+		Send:       c.send,
+	}
+	if c.conn != nil {
+		info.RemoteAddr = c.conn.RemoteAddr().String()
+	}
+	if c.sender != nil {
+		info.Senders = []*core.Sender{c.sender}
+	}
+	return json.Marshal(info)
+}
diff --git a/installs_on_host/go2rtc/pkg/isapi/client.go b/installs_on_host/go2rtc/pkg/isapi/client.go
new file mode 100644
index 0000000..ba3e688
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/isapi/client.go
@@ -0,0 +1,164 @@
+package isapi
+
+import (
+	"errors"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/tcp"
+)
+
+// Deprecated: should be rewritten to core.Connection
+type Client struct {
+	core.Listener
+
+	url     string
+	channel string
+	conn    net.Conn
+
+	medias []*core.Media
+	sender *core.Sender
+	send   int
+}
+
+func Dial(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 = ""
+
+	client := &Client{url: u.String()}
+	if err = client.Dial(); err != nil {
+		return nil, err
+	}
+	return client, err
+}
+
+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) {
+	// Hikvision ISAPI may not accept a new open request if the previous one was not closed (e.g.
+	// using the test button on-camera or via curl command) but a close request can be sent even if
+	// the audio is already closed. So, we send a close request first and then open it again. Seems
+	// janky but it works.
+	if err = c.Close(); err != nil {
+		return err
+	}
+
+	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
+	req, err := http.NewRequest("PUT", link+"/close", 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"`
+//}
diff --git a/installs_on_host/go2rtc/pkg/iso/atoms.go b/installs_on_host/go2rtc/pkg/iso/atoms.go
new file mode 100644
index 0000000..945622e
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/iso/atoms.go
@@ -0,0 +1,339 @@
+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"
+)
+
+const (
+	sampleIsNonSync  = 0x10000
+	sampleDependsOn1 = 0x1000000
+	sampleDependsOn2 = 0x2000000
+
+	SampleVideoIFrame    = sampleDependsOn2
+	SampleVideoNonIFrame = sampleDependsOn1 | sampleIsNonSync
+	SampleAudio          = sampleDependsOn2 //sampleIsNonSync
+)
+
+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
+}
+
+const (
+	TfhdDefaultSampleDuration = 0x000008
+	TfhdDefaultSampleSize     = 0x000010
+	TfhdDefaultSampleFlags    = 0x000020
+	TfhdDefaultBaseIsMoof     = 0x020000
+)
+
+const (
+	TrunDataOffset       = 0x000001
+	TrunFirstSampleFlags = 0x000004
+	TrunSampleDuration   = 0x0000100
+	TrunSampleSize       = 0x0000200
+	TrunSampleFlags      = 0x0000400
+	TrunSampleCTS        = 0x0000800
+)
+
+func (m *Movie) WriteMovieFragment(seq, tid, duration, size, flags uint32, dts uint64, cts uint32) {
+	m.StartAtom(Moof)
+
+	m.StartAtom(MoofMfhd)
+	m.Skip(1)          // version
+	m.Skip(3)          // flags
+	m.WriteUint32(seq) // sequence number
+	m.EndAtom()
+
+	m.StartAtom(MoofTraf)
+
+	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(flags)    // default sample flags
+	m.EndAtom()
+
+	m.StartAtom(MoofTrafTfdt)
+	m.WriteBytes(1)    // version
+	m.Skip(3)          // flags
+	m.WriteUint64(dts) // base media decode time
+	m.EndAtom()
+
+	m.StartAtom(MoofTrafTrun)
+	m.Skip(1) // version
+
+	if cts == 0 {
+		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)
+	} else {
+		m.WriteUint24(TrunDataOffset | TrunSampleCTS)
+		m.WriteUint32(1)
+
+		// data offset: current pos + uint32 len + CTS + MDAT header len
+		m.WriteUint32(uint32(len(m.b)) + 4 + 4 + 8)
+		m.WriteUint32(cts)
+	}
+
+	m.EndAtom() // TRUN
+
+	m.EndAtom() // TRAF
+
+	m.EndAtom() // MOOF
+}
+
+func (m *Movie) WriteData(b []byte) {
+	m.StartAtom(Mdat)
+	m.Write(b)
+	m.EndAtom()
+}
diff --git a/installs_on_host/go2rtc/pkg/iso/codecs.go b/installs_on_host/go2rtc/pkg/iso/codecs.go
new file mode 100644
index 0000000..f4a83c7
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/iso/codecs.go
@@ -0,0 +1,181 @@
+package iso
+
+import (
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/pcm"
+)
+
+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.StartAtom("pasp") // Pixel Aspect Ratio
+	m.WriteUint32(1)    // hSpacing
+	m.WriteUint32(1)    // vSpacing
+	m.EndAtom()
+
+	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") // supported in all players and browsers
+	case core.CodecFLAC:
+		m.StartAtom("fLaC") // supported in all players and browsers
+	case core.CodecOpus:
+		m.StartAtom("Opus") // supported in Chrome and Firefox
+	case core.CodecPCMU:
+		m.StartAtom("ulaw")
+	case core.CodecPCMA:
+		m.StartAtom("alaw")
+	default:
+		panic("unsupported iso audio: " + codec)
+	}
+
+	if channels == 0 {
+		channels = 1
+	}
+
+	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.CodecFLAC:
+		m.StartAtom("dfLa")
+		m.Write(pcm.FLACHeader(false, sampleRate))
+		m.EndAtom()
+	case core.CodecOpus:
+		m.WriteOpus(channels, sampleRate)
+	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
+
+	// https://learn.microsoft.com/en-us/windows/win32/medfound/mpeg-4-file-sink#aac-audio
+	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
+
+	// https://learn.microsoft.com/en-us/windows/win32/medfound/mpeg-4-file-sink#mp3-audio
+	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
+}
+
+func (m *Movie) WriteOpus(channels uint16, sampleRate uint32) {
+	// https://www.opus-codec.org/docs/opus_in_isobmff.html
+	m.StartAtom("dOps")
+	m.Skip(1) // version
+	m.WriteBytes(byte(channels))
+	m.WriteUint16(0) // PreSkip ???
+	m.WriteUint32(sampleRate)
+	m.Skip(2) // OutputGain
+	m.Skip(1) // signed int(16) OutputGain;
+	m.EndAtom()
+}
diff --git a/installs_on_host/go2rtc/pkg/iso/iso.go b/installs_on_host/go2rtc/pkg/iso/iso.go
new file mode 100644
index 0000000..8989072
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/iso/iso.go
@@ -0,0 +1,91 @@
+package iso
+
+import (
+	"encoding/binary"
+	"math"
+)
+
+type Movie struct {
+	b     []byte
+	start []int
+}
+
+func NewMovie(size int) *Movie {
+	return &Movie{b: make([]byte, 0, size)}
+}
+
+func (m *Movie) Bytes() []byte {
+	return m.b
+}
+
+func (m *Movie) StartAtom(name string) {
+	m.start = append(m.start, len(m.b))
+	m.b = append(m.b, 0, 0, 0, 0)
+	m.b = append(m.b, name...)
+}
+
+func (m *Movie) EndAtom() {
+	n := len(m.start) - 1
+
+	i := m.start[n]
+	size := uint32(len(m.b) - i)
+	binary.BigEndian.PutUint32(m.b[i:], size)
+
+	m.start = m.start[:n]
+}
+
+func (m *Movie) Write(b []byte) {
+	m.b = append(m.b, b...)
+}
+
+func (m *Movie) WriteBytes(b ...byte) {
+	m.b = append(m.b, b...)
+}
+
+func (m *Movie) WriteString(s string) {
+	m.b = append(m.b, s...)
+}
+
+func (m *Movie) Skip(n int) {
+	m.b = append(m.b, make([]byte, n)...)
+}
+
+func (m *Movie) WriteUint16(v uint16) {
+	m.b = append(m.b, byte(v>>8), byte(v))
+}
+
+func (m *Movie) WriteUint24(v uint32) {
+	m.b = append(m.b, byte(v>>16), byte(v>>8), byte(v))
+}
+
+func (m *Movie) WriteUint32(v uint32) {
+	m.b = append(m.b, byte(v>>24), byte(v>>16), byte(v>>8), byte(v))
+}
+
+func (m *Movie) WriteUint64(v uint64) {
+	m.b = append(m.b, byte(v>>56), byte(v>>48), byte(v>>40), byte(v>>32), byte(v>>24), byte(v>>16), byte(v>>8), byte(v))
+}
+
+func (m *Movie) WriteFloat16(f float64) {
+	i, f := math.Modf(f)
+	f *= 256
+	m.b = append(m.b, byte(i), byte(f))
+}
+
+func (m *Movie) WriteFloat32(f float64) {
+	i, f := math.Modf(f)
+	f *= 65536
+	m.b = append(m.b, byte(uint16(i)>>8), byte(i), byte(uint16(f)>>8), byte(f))
+}
+
+func (m *Movie) WriteMatrix() {
+	m.WriteUint32(0x00010000)
+	m.Skip(4)
+	m.Skip(4)
+	m.Skip(4)
+	m.WriteUint32(0x00010000)
+	m.Skip(4)
+	m.Skip(4)
+	m.Skip(4)
+	m.WriteUint32(0x40000000)
+}
diff --git a/installs_on_host/go2rtc/pkg/iso/reader.go b/installs_on_host/go2rtc/pkg/iso/reader.go
new file mode 100644
index 0000000..175e256
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/iso/reader.go
@@ -0,0 +1,203 @@
+package iso
+
+import (
+	"bytes"
+	"encoding/binary"
+	"io"
+
+	"github.com/AlexxIT/go2rtc/pkg/bits"
+)
+
+type Atom struct {
+	Name string
+	Data []byte
+}
+
+type AtomTkhd struct {
+	TrackID uint32
+}
+
+type AtomMdhd struct {
+	TimeScale uint32
+}
+
+type AtomVideo struct {
+	Name   string
+	Config []byte
+}
+
+type AtomAudio struct {
+	Name       string
+	Channels   uint16
+	SampleRate uint32
+	Config     []byte
+}
+
+type AtomMfhd struct {
+	Sequence uint32
+}
+
+type AtomMdat struct {
+	Data []byte
+}
+
+type AtomTfhd struct {
+	TrackID        uint32
+	SampleDuration uint32
+	SampleSize     uint32
+	SampleFlags    uint32
+}
+type AtomTfdt struct {
+	DecodeTime uint64
+}
+
+type AtomTrun struct {
+	DataOffset       uint32
+	FirstSampleFlags uint32
+	SamplesDuration  []uint32
+	SamplesSize      []uint32
+	SamplesFlags     []uint32
+	SamplesCTS       []uint32
+}
+
+func DecodeAtom(b []byte) (any, error) {
+	size := binary.BigEndian.Uint32(b)
+	if len(b) < int(size) {
+		return nil, io.EOF
+	}
+
+	name := string(b[4:8])
+	data := b[8:size]
+
+	switch name {
+	// useful containers
+	case Moov, MoovTrak, MoovTrakMdia, MoovTrakMdiaMinf, MoovTrakMdiaMinfStbl, Moof, MoofTraf:
+		return DecodeAtoms(data)
+
+	case MoovTrakTkhd:
+		return &AtomTkhd{TrackID: binary.BigEndian.Uint32(data[1+3+4+4:])}, nil
+
+	case MoovTrakMdiaMdhd:
+		return &AtomMdhd{TimeScale: binary.BigEndian.Uint32(data[1+3+4+4:])}, nil
+
+	case MoovTrakMdiaMinfStblStsd:
+		// support only 1 codec entry
+		if n := binary.BigEndian.Uint32(data[1+3:]); n == 1 {
+			return DecodeAtom(data[1+3+4:])
+		}
+
+	case "avc1", "hev1":
+		b = data[6+2+2+2+4+4+4+2+2+4+4+4+2+32+2+2:]
+		atom, err := DecodeAtom(b)
+		if err != nil {
+			return nil, err
+		}
+		if conf, ok := atom.(*Atom); ok {
+			return &AtomVideo{Name: name, Config: conf.Data}, nil
+		}
+
+	case "mp4a":
+		atom := &AtomAudio{Name: name}
+
+		rd := bits.NewReader(data)
+		rd.ReadBytes(6 + 2 + 2 + 2 + 4) // skip
+		atom.Channels = rd.ReadUint16()
+		rd.ReadBytes(2 + 2 + 2) // skip
+		atom.SampleRate = uint32(rd.ReadFloat32())
+
+		atom2, _ := DecodeAtom(rd.Left())
+		if conf, ok := atom2.(*Atom); ok {
+			_, b, _ = bytes.Cut(conf.Data, []byte{5, 0x80, 0x80, 0x80})
+			if n := len(b); n > 0 && n > 1+int(b[0]) {
+				atom.Config = b[1 : 1+b[0]]
+			}
+		}
+
+		return atom, nil
+
+	case MoofMfhd:
+		return &AtomMfhd{Sequence: binary.BigEndian.Uint32(data[4:])}, nil
+
+	case MoofTrafTfhd:
+		rd := bits.NewReader(data)
+		_ = rd.ReadByte() // version
+		flags := rd.ReadUint24()
+
+		atom := &AtomTfhd{
+			TrackID: rd.ReadUint32(),
+		}
+
+		if flags&TfhdDefaultSampleDuration != 0 {
+			atom.SampleDuration = rd.ReadUint32()
+
+		}
+		if flags&TfhdDefaultSampleSize != 0 {
+			atom.SampleSize = rd.ReadUint32()
+		}
+		if flags&TfhdDefaultSampleFlags != 0 {
+			atom.SampleFlags = rd.ReadUint32() // skip
+		}
+
+		return atom, nil
+
+	case MoofTrafTfdt:
+		return &AtomTfdt{DecodeTime: binary.BigEndian.Uint64(data[4:])}, nil
+
+	case MoofTrafTrun:
+		rd := bits.NewReader(data)
+		_ = rd.ReadByte() // version
+		flags := rd.ReadUint24()
+		samples := rd.ReadUint32()
+
+		atom := &AtomTrun{}
+
+		if flags&TrunDataOffset != 0 {
+			atom.DataOffset = rd.ReadUint32()
+		}
+		if flags&TrunFirstSampleFlags != 0 {
+			atom.FirstSampleFlags = rd.ReadUint32()
+		}
+
+		for i := uint32(0); i < samples; i++ {
+			if flags&TrunSampleDuration != 0 {
+				atom.SamplesDuration = append(atom.SamplesDuration, rd.ReadUint32())
+			}
+			if flags&TrunSampleSize != 0 {
+				atom.SamplesSize = append(atom.SamplesSize, rd.ReadUint32())
+			}
+			if flags&TrunSampleFlags != 0 {
+				atom.SamplesFlags = append(atom.SamplesFlags, rd.ReadUint32())
+			}
+			if flags&TrunSampleCTS != 0 {
+				atom.SamplesCTS = append(atom.SamplesCTS, rd.ReadUint32())
+			}
+		}
+
+		return atom, nil
+
+	case Mdat:
+		return &AtomMdat{Data: data}, nil
+	}
+
+	return &Atom{Name: name, Data: data}, nil
+}
+
+func DecodeAtoms(b []byte) (atoms []any, err error) {
+	for len(b) > 0 {
+		atom, err := DecodeAtom(b)
+		if err != nil {
+			return nil, err
+		}
+
+		if childs, ok := atom.([]any); ok {
+			atoms = append(atoms, childs...)
+		} else {
+			atoms = append(atoms, atom)
+		}
+
+		size := binary.BigEndian.Uint32(b)
+		b = b[size:]
+	}
+
+	return atoms, nil
+}
diff --git a/installs_on_host/go2rtc/pkg/ivideon/ivideon.go b/installs_on_host/go2rtc/pkg/ivideon/ivideon.go
new file mode 100644
index 0000000..973b9ba
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/ivideon/ivideon.go
@@ -0,0 +1,187 @@
+package ivideon
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/mp4"
+	"github.com/gorilla/websocket"
+)
+
+type Producer struct {
+	core.Connection
+	conn *websocket.Conn
+
+	buf []byte
+
+	dem *mp4.Demuxer
+}
+
+func Dial(source string) (core.Producer, error) {
+	id := strings.Replace(source[8:], "/", ":", 1)
+
+	url, err := GetLiveStream(id)
+	if err != nil {
+		return nil, err
+	}
+
+	conn, _, err := websocket.DefaultDialer.Dial(url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	prod := &Producer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "ivideon",
+			Protocol:   core.Before(url, ":"), // wss
+			RemoteAddr: conn.RemoteAddr().String(),
+			Source:     source,
+			URL:        url,
+			Transport:  conn,
+		},
+		conn: conn,
+	}
+
+	if err = prod.probe(); err != nil {
+		_ = conn.Close()
+		return nil, err
+	}
+
+	return prod, nil
+}
+
+func GetLiveStream(id string) (string, error) {
+	// &video_codecs=h264,h265&audio_codecs=aac,mp3,pcma,pcmu,none
+	resp, err := http.Get(
+		"https://openapi-alpha.ivideon.com/cameras/" + id +
+			"/live_stream?op=GET&access_token=public&q=2&video_codecs=h264&format=ws-fmp4",
+	)
+	if err != nil {
+		return "", err
+	}
+
+	var v struct {
+		Message string `json:"message"`
+		Result  struct {
+			URL string `json:"url"`
+		} `json:"result"`
+		Success bool `json:"success"`
+	}
+	if err = json.NewDecoder(resp.Body).Decode(&v); err != nil {
+		return "", err
+	}
+
+	if !v.Success {
+		return "", fmt.Errorf("ivideon: can't get live_stream: " + v.Message)
+	}
+
+	return v.Result.URL, nil
+}
+
+func (p *Producer) Start() error {
+	receivers := make(map[uint32]*core.Receiver)
+	for _, receiver := range p.Receivers {
+		trackID := p.dem.GetTrackID(receiver.Codec)
+		receivers[trackID] = receiver
+	}
+
+	ch := make(chan []byte, 10)
+	defer close(ch)
+
+	ch <- p.buf
+
+	go func() {
+		// add delay to the stream for smooth playing (not a best solution)
+		t0 := time.Now()
+
+		for data := range ch {
+			trackID, packets := p.dem.Demux(data)
+			if receiver := receivers[trackID]; receiver != nil {
+				clockRate := time.Duration(receiver.Codec.ClockRate)
+				for _, packet := range packets {
+					// synchronize framerate for WebRTC and MSE
+					ts := time.Second * time.Duration(packet.Timestamp) / clockRate
+					d := ts - time.Since(t0)
+					if d < 0 {
+						d = 10 * time.Millisecond
+					}
+					time.Sleep(d)
+
+					receiver.WriteRTP(packet)
+				}
+			}
+		}
+	}()
+
+	for {
+		var msg message
+		if err := p.conn.ReadJSON(&msg); err != nil {
+			return err
+		}
+
+		switch msg.Type {
+		case "stream-init", "metadata":
+			continue
+
+		case "fragment":
+			_, b, err := p.conn.ReadMessage()
+			if err != nil {
+				return err
+			}
+
+			p.Recv += len(b)
+			ch <- b
+
+		default:
+			return errors.New("ivideon: wrong message type: " + msg.Type)
+		}
+	}
+}
+
+func (p *Producer) probe() (err error) {
+	p.dem = &mp4.Demuxer{}
+
+	for {
+		var msg message
+		if err = p.conn.ReadJSON(&msg); err != nil {
+			return err
+		}
+
+		switch msg.Type {
+		case "metadata":
+			continue
+
+		case "stream-init":
+			// it's difficult to maintain audio
+			if strings.HasPrefix(msg.CodecString, "avc1") {
+				medias := p.dem.Probe(msg.Data)
+				p.Medias = append(p.Medias, medias...)
+			}
+
+		case "fragment":
+			_, p.buf, err = p.conn.ReadMessage()
+			return
+
+		default:
+			return errors.New("ivideon: wrong message type: " + msg.Type)
+		}
+	}
+}
+
+type message struct {
+	Type        string `json:"type"`
+	CodecString string `json:"codec_string"`
+	Data        []byte `json:"data"`
+	//TrackID     byte    `json:"track_id"`
+	//Track       byte    `json:"track"`
+	//StartTime   float32 `json:"start_time"`
+	//Duration    float32 `json:"duration"`
+	//IsKey       bool    `json:"is_key"`
+	//DataOffset  uint32  `json:"data_offset"`
+}
diff --git a/installs_on_host/go2rtc/pkg/kasa/producer.go b/installs_on_host/go2rtc/pkg/kasa/producer.go
new file mode 100644
index 0000000..697c19e
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/kasa/producer.go
@@ -0,0 +1,215 @@
+package kasa
+
+import (
+	"bufio"
+	"errors"
+	"io"
+	"net/http"
+	"net/http/httputil"
+	"strconv"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/h264/annexb"
+	"github.com/AlexxIT/go2rtc/pkg/mpjpeg"
+	"github.com/AlexxIT/go2rtc/pkg/tcp"
+	"github.com/pion/rtp"
+)
+
+type Producer struct {
+	core.Connection
+	rd *core.ReadBuffer
+
+	reader *bufio.Reader
+}
+
+func Dial(url string) (*Producer, error) {
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	req.URL.Scheme = "httpx"
+
+	res, err := tcp.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	// KC200
+	//   HTTP/1.0 200 OK
+	//   Content-Type: multipart/x-mixed-replace;boundary=data-boundary--
+	// KD110, KC401, KC420WS:
+	//   HTTP/1.0 200 OK
+	//   Content-Type: multipart/x-mixed-replace;boundary=data-boundary--
+	//   Transfer-Encoding: chunked
+	// HTTP/1.0 + chunked = out of standard, so golang remove this header
+	// and we need to check first two bytes
+	buf := bufio.NewReader(res.Body)
+
+	b, err := buf.Peek(2)
+	if err != nil {
+		return nil, err
+	}
+
+	rd := struct {
+		io.Reader
+		io.Closer
+	}{
+		buf,
+		res.Body,
+	}
+
+	if string(b) != "--" {
+		rd.Reader = httputil.NewChunkedReader(buf)
+	}
+
+	prod := &Producer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "kasa",
+			Protocol:   "http",
+			Transport:  rd,
+		},
+		rd: core.NewReadBuffer(rd),
+	}
+	if err = prod.probe(); err != nil {
+		return nil, err
+	}
+	return prod, nil
+}
+
+func (c *Producer) Start() error {
+	if len(c.Receivers) == 0 {
+		return errors.New("multipart: no receivers")
+	}
+
+	var video, audio *core.Receiver
+
+	for _, receiver := range c.Receivers {
+		switch receiver.Codec.Name {
+		case core.CodecH264:
+			video = receiver
+		case core.CodecPCMU:
+			audio = receiver
+		}
+	}
+
+	for {
+		header, body, err := mpjpeg.Next(c.reader)
+		if err != nil {
+			return err
+		}
+
+		c.Recv += len(body)
+
+		ct := header.Get("Content-Type")
+		switch ct {
+		case MimeVideo:
+			if video != nil {
+				ts := GetTimestamp(header)
+				pkt := &rtp.Packet{
+					Header: rtp.Header{
+						Timestamp: uint32(ts * 90000),
+					},
+					Payload: annexb.EncodeToAVCC(body),
+				}
+				video.WriteRTP(pkt)
+			}
+
+		case MimeG711U:
+			if audio != nil {
+				ts := GetTimestamp(header)
+				pkt := &rtp.Packet{
+					Header: rtp.Header{
+						Version:   2,
+						Marker:    true,
+						Timestamp: uint32(ts * 8000),
+					},
+					Payload: body,
+				}
+				audio.WriteRTP(pkt)
+			}
+		}
+	}
+}
+
+const (
+	MimeVideo = "video/x-h264"
+	MimeG711U = "audio/g711u"
+)
+
+func (c *Producer) probe() error {
+	c.rd.BufferSize = core.ProbeSize
+	c.reader = bufio.NewReader(c.rd)
+
+	defer func() {
+		c.rd.Reset()
+		c.reader = bufio.NewReader(c.rd)
+	}()
+
+	waitVideo, waitAudio := true, true
+	timeout := time.Now().Add(core.ProbeTimeout)
+
+	for (waitVideo || waitAudio) && time.Now().Before(timeout) {
+		header, body, err := mpjpeg.Next(c.reader)
+		if err != nil {
+			return err
+		}
+
+		var media *core.Media
+
+		ct := header.Get("Content-Type")
+		switch ct {
+		case MimeVideo:
+			if !waitVideo {
+				continue
+			}
+			waitVideo = false
+
+			body = annexb.EncodeToAVCC(body)
+			codec := h264.AVCCToCodec(body)
+			media = &core.Media{
+				Kind:      core.KindVideo,
+				Direction: core.DirectionRecvonly,
+				Codecs:    []*core.Codec{codec},
+			}
+
+		case MimeG711U:
+			if !waitAudio {
+				continue
+			}
+			waitAudio = false
+
+			media = &core.Media{
+				Kind:      core.KindAudio,
+				Direction: core.DirectionRecvonly,
+				Codecs: []*core.Codec{
+					{
+						Name:      core.CodecPCMU,
+						ClockRate: 8000,
+					},
+				},
+			}
+
+		default:
+			return errors.New("kasa: unsupported type: " + ct)
+		}
+
+		c.Medias = append(c.Medias, media)
+	}
+
+	return nil
+}
+
+// GetTimestamp - return timestamp in seconds
+func GetTimestamp(header http.Header) float64 {
+	if s := header.Get("X-Timestamp"); s != "" {
+		if f, _ := strconv.ParseFloat(s, 32); f != 0 {
+			return f
+		}
+	}
+
+	return float64(time.Duration(time.Now().UnixNano()) / time.Second)
+}
diff --git a/installs_on_host/go2rtc/pkg/magic/bitstream/producer.go b/installs_on_host/go2rtc/pkg/magic/bitstream/producer.go
new file mode 100644
index 0000000..5f00f41
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/magic/bitstream/producer.go
@@ -0,0 +1,95 @@
+package bitstream
+
+import (
+	"encoding/hex"
+	"errors"
+	"io"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/h264/annexb"
+	"github.com/AlexxIT/go2rtc/pkg/h265"
+	"github.com/pion/rtp"
+)
+
+type Producer struct {
+	core.Connection
+	rd *core.ReadBuffer
+}
+
+func Open(r io.Reader) (*Producer, error) {
+	rd := core.NewReadBuffer(r)
+
+	buf, err := rd.Peek(256)
+	if err != nil {
+		return nil, err
+	}
+
+	buf = annexb.EncodeToAVCC(buf) // won't break original buffer
+
+	var codec *core.Codec
+	var format string
+
+	switch {
+	case h264.NALUType(buf) == h264.NALUTypeSPS:
+		codec = h264.AVCCToCodec(buf)
+		format = "h264"
+	case h265.NALUType(buf) == h265.NALUTypeVPS:
+		codec = h265.AVCCToCodec(buf)
+		format = "hevc"
+	default:
+		return nil, errors.New("bitstream: unsupported header: " + hex.EncodeToString(buf[:8]))
+	}
+
+	medias := []*core.Media{
+		{
+			Kind:      core.KindVideo,
+			Direction: core.DirectionRecvonly,
+			Codecs:    []*core.Codec{codec},
+		},
+	}
+	return &Producer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: format,
+			Medias:     medias,
+			Transport:  r,
+		},
+		rd: rd,
+	}, nil
+}
+
+func (c *Producer) Start() error {
+	var buf []byte
+
+	b := make([]byte, core.BufferSize)
+	for {
+		n, err := c.rd.Read(b)
+		if err != nil {
+			return err
+		}
+
+		c.Recv += n
+
+		buf = append(buf, b[:n]...)
+
+		for {
+			i := annexb.IndexFrame(buf)
+			if i < 0 {
+				break
+			}
+
+			if len(c.Receivers) > 0 {
+				pkt := &rtp.Packet{
+					Header:  rtp.Header{Timestamp: core.Now90000()},
+					Payload: annexb.EncodeToAVCC(buf[:i]),
+				}
+				c.Receivers[0].WriteRTP(pkt)
+
+				//log.Printf("[AVC] %v, len: %d", h264.Types(pkt.Payload), len(pkt.Payload))
+			}
+
+			buf = buf[i:]
+		}
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/magic/keyframe.go b/installs_on_host/go2rtc/pkg/magic/keyframe.go
new file mode 100644
index 0000000..9b6ef56
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/magic/keyframe.go
@@ -0,0 +1,116 @@
+package magic
+
+import (
+	"io"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/h264/annexb"
+	"github.com/AlexxIT/go2rtc/pkg/h265"
+	"github.com/AlexxIT/go2rtc/pkg/mjpeg"
+	"github.com/pion/rtp"
+)
+
+type Keyframe struct {
+	core.Connection
+	wr *core.WriteBuffer
+}
+
+// Deprecated: should be rewritten
+func NewKeyframe() *Keyframe {
+	medias := []*core.Media{
+		{
+			Kind:      core.KindVideo,
+			Direction: core.DirectionSendonly,
+			Codecs: []*core.Codec{
+				{Name: core.CodecJPEG},
+				{Name: core.CodecRAW},
+				{Name: core.CodecH264},
+				{Name: core.CodecH265},
+			},
+		},
+	}
+	wr := core.NewWriteBuffer(nil)
+	return &Keyframe{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "keyframe",
+			Medias:     medias,
+			Transport:  wr,
+		},
+		wr: wr,
+	}
+}
+
+func (k *Keyframe) AddTrack(media *core.Media, _ *core.Codec, track *core.Receiver) error {
+	sender := core.NewSender(media, track.Codec)
+
+	switch track.Codec.Name {
+	case core.CodecH264:
+		sender.Handler = func(packet *rtp.Packet) {
+			if !h264.IsKeyframe(packet.Payload) {
+				return
+			}
+			b := annexb.DecodeAVCC(packet.Payload, true)
+			if n, err := k.wr.Write(b); err == nil {
+				k.Send += n
+			}
+		}
+
+		if track.Codec.IsRTP() {
+			sender.Handler = h264.RTPDepay(track.Codec, sender.Handler)
+		} else {
+			sender.Handler = h264.RepairAVCC(track.Codec, sender.Handler)
+		}
+
+	case core.CodecH265:
+		sender.Handler = func(packet *rtp.Packet) {
+			if !h265.IsKeyframe(packet.Payload) {
+				return
+			}
+			b := annexb.DecodeAVCC(packet.Payload, true)
+			if n, err := k.wr.Write(b); err == nil {
+				k.Send += n
+			}
+		}
+
+		if track.Codec.IsRTP() {
+			sender.Handler = h265.RTPDepay(track.Codec, sender.Handler)
+		}
+
+	case core.CodecJPEG:
+		sender.Handler = func(packet *rtp.Packet) {
+			if n, err := k.wr.Write(packet.Payload); err == nil {
+				k.Send += n
+			}
+		}
+
+		if track.Codec.IsRTP() {
+			sender.Handler = mjpeg.RTPDepay(sender.Handler)
+		}
+
+	case core.CodecRAW:
+		sender.Handler = func(packet *rtp.Packet) {
+			if n, err := k.wr.Write(packet.Payload); err == nil {
+				k.Send += n
+			}
+		}
+
+		sender.Handler = mjpeg.Encoder(track.Codec, 5, sender.Handler)
+	}
+
+	sender.HandleRTP(track)
+	k.Senders = append(k.Senders, sender)
+	return nil
+}
+
+func (k *Keyframe) CodecName() string {
+	if len(k.Senders) != 1 {
+		return ""
+	}
+	return k.Senders[0].Codec.Name
+}
+
+func (k *Keyframe) WriteTo(wr io.Writer) (int64, error) {
+	return k.wr.WriteTo(wr)
+}
diff --git a/installs_on_host/go2rtc/pkg/magic/mjpeg/producer.go b/installs_on_host/go2rtc/pkg/magic/mjpeg/producer.go
new file mode 100644
index 0000000..e47c168
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/magic/mjpeg/producer.go
@@ -0,0 +1,78 @@
+package mjpeg
+
+import (
+	"bytes"
+	"io"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+)
+
+type Producer struct {
+	core.Connection
+	rd *core.ReadBuffer
+}
+
+func Open(rd io.Reader) (*Producer, error) {
+	medias := []*core.Media{
+		{
+			Kind:      core.KindVideo,
+			Direction: core.DirectionRecvonly,
+			Codecs: []*core.Codec{
+				{
+					Name:        core.CodecJPEG,
+					ClockRate:   90000,
+					PayloadType: core.PayloadTypeRAW,
+				},
+			},
+		},
+	}
+	return &Producer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "mjpeg",
+			Medias:     medias,
+			Transport:  rd,
+		},
+		rd: core.NewReadBuffer(rd),
+	}, nil
+}
+
+func (c *Producer) Start() error {
+	var buf []byte                     // total bufer
+	b := make([]byte, core.BufferSize) // reading buffer
+
+	for {
+		// one JPEG end and next start
+		i := bytes.Index(buf, []byte{0xFF, 0xD9, 0xFF, 0xD8})
+		if i < 0 {
+			n, err := c.rd.Read(b)
+			if err != nil {
+				return err
+			}
+
+			c.Recv += n
+
+			buf = append(buf, b[:n]...)
+
+			// if we receive frame
+			if n >= 2 && b[n-2] == 0xFF && b[n-1] == 0xD9 {
+				i = len(buf)
+			} else {
+				continue
+			}
+		} else {
+			i += 2
+		}
+
+		pkt := &rtp.Packet{
+			Header:  rtp.Header{Timestamp: core.Now90000()},
+			Payload: buf[:i],
+		}
+		c.Receivers[0].WriteRTP(pkt)
+
+		//log.Printf("[mjpeg] ts=%d size=%d", pkt.Header.Timestamp, len(pkt.Payload))
+
+		buf = buf[i:]
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/magic/producer.go b/installs_on_host/go2rtc/pkg/magic/producer.go
new file mode 100644
index 0000000..3742ccf
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/magic/producer.go
@@ -0,0 +1,69 @@
+package magic
+
+import (
+	"bytes"
+	"encoding/hex"
+	"errors"
+	"io"
+
+	"github.com/AlexxIT/go2rtc/pkg/aac"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/flv"
+	"github.com/AlexxIT/go2rtc/pkg/h264/annexb"
+	"github.com/AlexxIT/go2rtc/pkg/magic/bitstream"
+	"github.com/AlexxIT/go2rtc/pkg/magic/mjpeg"
+	"github.com/AlexxIT/go2rtc/pkg/mpegts"
+	"github.com/AlexxIT/go2rtc/pkg/mpjpeg"
+	"github.com/AlexxIT/go2rtc/pkg/wav"
+	"github.com/AlexxIT/go2rtc/pkg/y4m"
+)
+
+func Open(r io.Reader) (core.Producer, error) {
+	rd := core.NewReadBuffer(r)
+
+	b, err := rd.Peek(4)
+	if err != nil {
+		return nil, err
+	}
+
+	switch string(b) {
+	case annexb.StartCode:
+		return bitstream.Open(rd)
+	case wav.FourCC:
+		return wav.Open(rd)
+	case y4m.FourCC:
+		return y4m.Open(rd)
+	}
+
+	switch string(b[:3]) {
+	case flv.Signature:
+		return flv.Open(rd)
+	}
+
+	switch string(b[:2]) {
+	case "\xFF\xD8":
+		return mjpeg.Open(rd)
+	case "\xFF\xF1", "\xFF\xF9":
+		return aac.Open(rd)
+	case "--":
+		return mpjpeg.Open(rd)
+	}
+
+	switch b[0] {
+	case mpegts.SyncByte:
+		return mpegts.Open(rd)
+	}
+
+	// support MJPEG with trash on start
+	// https://github.com/AlexxIT/go2rtc/issues/747
+	if b, err = rd.Peek(4096); err != nil {
+		return nil, err
+	}
+
+	if i := bytes.Index(b, []byte{0xFF, 0xD8, 0xFF, 0xDB}); i > 0 {
+		_, _ = io.ReadFull(rd, make([]byte, i))
+		return mjpeg.Open(rd)
+	}
+
+	return nil, errors.New("magic: unsupported header: " + hex.EncodeToString(b[:4]))
+}
diff --git a/installs_on_host/go2rtc/pkg/mdns/README.md b/installs_on_host/go2rtc/pkg/mdns/README.md
new file mode 100644
index 0000000..e6e21d6
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mdns/README.md
@@ -0,0 +1,3 @@
+# Useful links
+
+- https://grouper.ieee.org/groups/1722/contributions/2009/Bonjour%20Device%20Discovery.pdf
\ No newline at end of file
diff --git a/installs_on_host/go2rtc/pkg/mdns/client.go b/installs_on_host/go2rtc/pkg/mdns/client.go
new file mode 100644
index 0000000..e7abb50
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mdns/client.go
@@ -0,0 +1,374 @@
+package mdns
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/xnet"
+	"github.com/miekg/dns" // awesome library for parsing mDNS records
+)
+
+const (
+	ServiceDNSSD = "_services._dns-sd._udp.local."
+	ServiceHAP   = "_hap._tcp.local." // HomeKit Accessory Protocol
+)
+
+type ServiceEntry struct {
+	Name string            `json:"name,omitempty"`
+	IP   net.IP            `json:"ip,omitempty"`
+	Port uint16            `json:"port,omitempty"`
+	Info map[string]string `json:"info,omitempty"`
+}
+
+func (e *ServiceEntry) String() string {
+	b, err := json.Marshal(e)
+	if err != nil {
+		return err.Error()
+	}
+	return string(b)
+}
+
+func (e *ServiceEntry) TXT() []string {
+	var txt []string
+	for k, v := range e.Info {
+		txt = append(txt, k+"="+v)
+	}
+	return txt
+}
+
+func (e *ServiceEntry) Complete() bool {
+	return e.IP != nil && e.Port > 0 && e.Info != nil
+}
+
+func (e *ServiceEntry) Addr() string {
+	return fmt.Sprintf("%s:%d", e.IP, e.Port)
+}
+
+func (e *ServiceEntry) Host(service string) string {
+	return e.name() + "." + strings.TrimRight(service, ".")
+}
+
+func (e *ServiceEntry) name() string {
+	b := []byte(e.Name)
+	for i, c := range b {
+		if 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || '0' <= c && c <= '9' {
+			continue
+		}
+		b[i] = '-'
+	}
+	return string(b)
+}
+
+var MulticastAddr = &net.UDPAddr{
+	IP:   net.IP{224, 0, 0, 251},
+	Port: 5353,
+}
+
+const sendTimeout = time.Millisecond * 505
+const respTimeout = time.Second * 3
+
+// BasicDiscovery - default golang Multicast UDP listener.
+// Does not work well with multiple interfaces.
+func BasicDiscovery(service string, onentry func(*ServiceEntry) bool) error {
+	conn, err := net.ListenMulticastUDP("udp4", nil, MulticastAddr)
+	if err != nil {
+		return err
+	}
+
+	b := Browser{
+		Service:     service,
+		Addr:        MulticastAddr,
+		Recv:        conn,
+		Sends:       []net.PacketConn{conn},
+		RecvTimeout: respTimeout,
+		SendTimeout: sendTimeout,
+	}
+
+	defer b.Close()
+
+	return b.Browse(onentry)
+}
+
+// Discovery - better discovery version. Works well with multiple interfaces.
+func Discovery(service string, onentry func(*ServiceEntry) bool) error {
+	b := Browser{
+		Service:     service,
+		Addr:        MulticastAddr,
+		RecvTimeout: respTimeout,
+		SendTimeout: sendTimeout,
+	}
+
+	if err := b.ListenMulticastUDP(); err != nil {
+		return err
+	}
+
+	defer b.Close()
+
+	return b.Browse(onentry)
+}
+
+// Query - direct Discovery request on device IP-address. Works even over VPN.
+func Query(host, service string) (entry *ServiceEntry, err error) {
+	conn, err := net.ListenPacket("udp4", ":0") // shouldn't use ":5353"
+	if err != nil {
+		return
+	}
+
+	br := Browser{
+		Service: service,
+		Addr: &net.UDPAddr{
+			IP:   net.ParseIP(host),
+			Port: 5353,
+		},
+		Recv:        conn,
+		Sends:       []net.PacketConn{conn},
+		SendTimeout: time.Millisecond * 255,
+		RecvTimeout: time.Second,
+	}
+
+	defer br.Close()
+
+	err = br.Browse(func(en *ServiceEntry) bool {
+		entry = en
+		return true
+	})
+
+	return
+}
+
+// QueryOrDiscovery - useful if we know previous device host and want
+// to update port or any other information. Will work even over VPN.
+func QueryOrDiscovery(host, service string, onentry func(*ServiceEntry) bool) error {
+	entry, _ := Query(host, service)
+	if entry != nil && onentry(entry) {
+		return nil
+	}
+
+	return Discovery(service, onentry)
+}
+
+type Browser struct {
+	Service string
+
+	Addr  net.Addr
+	Nets  []*net.IPNet
+	Recv  net.PacketConn
+	Sends []net.PacketConn
+
+	RecvTimeout time.Duration
+	SendTimeout time.Duration
+}
+
+// ListenMulticastUDP - creates multiple senders socket (each for IP4 interface).
+// And one receiver with multicast membership for each sender.
+// Receiver will get multicast responses on senders requests.
+func (b *Browser) ListenMulticastUDP() error {
+	// 1. Collect IPv4 interfaces
+	nets, err := xnet.IPNets(func(ip net.IP) bool {
+		return !xnet.Docker.Contains(ip)
+	})
+	if err != nil {
+		return err
+	}
+
+	// 2. Create senders
+	lc1 := net.ListenConfig{
+		Control: func(network, address string, c syscall.RawConn) error {
+			return c.Control(func(fd uintptr) {
+				// 1. Allow multicast UDP to listen concurrently across multiple listeners
+				_ = SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
+			})
+		},
+	}
+
+	ctx := context.Background()
+
+	for _, ipn := range nets {
+		conn, err := lc1.ListenPacket(ctx, "udp4", ipn.IP.String()+":5353") // same port important
+		if err != nil {
+			continue
+		}
+		b.Nets = append(b.Nets, ipn)
+		b.Sends = append(b.Sends, conn)
+	}
+
+	if b.Sends == nil {
+		return errors.New("no interfaces for listen")
+	}
+
+	// 3. Create receiver
+	lc2 := net.ListenConfig{
+		Control: func(network, address string, c syscall.RawConn) error {
+			return c.Control(func(fd uintptr) {
+				// 1. Allow multicast UDP to listen concurrently across multiple listeners
+				_ = SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
+
+				// 2. Disable loop responses
+				_ = SetsockoptInt(fd, syscall.IPPROTO_IP, syscall.IP_MULTICAST_LOOP, 0)
+
+				// 3. Allow receive multicast responses on all this addresses
+				mreq := &syscall.IPMreq{
+					Multiaddr: [4]byte{224, 0, 0, 251},
+				}
+				_ = SetsockoptIPMreq(fd, syscall.IPPROTO_IP, syscall.IP_ADD_MEMBERSHIP, mreq)
+
+				for _, send := range b.Sends {
+					addr := send.LocalAddr().(*net.UDPAddr)
+					mreq.Interface = [4]byte(addr.IP.To4())
+					_ = SetsockoptIPMreq(fd, syscall.IPPROTO_IP, syscall.IP_ADD_MEMBERSHIP, mreq)
+				}
+			})
+		},
+	}
+
+	b.Recv, err = lc2.ListenPacket(ctx, "udp4", ":5353")
+
+	return err
+}
+
+func (b *Browser) Browse(onentry func(*ServiceEntry) bool) error {
+	msg := &dns.Msg{
+		Question: []dns.Question{
+			{Name: b.Service, Qtype: dns.TypePTR, Qclass: dns.ClassINET},
+		},
+	}
+
+	query, err := msg.Pack()
+	if err != nil {
+		return err
+	}
+
+	if err = b.Recv.SetDeadline(time.Now().Add(b.RecvTimeout)); err != nil {
+		return err
+	}
+
+	go func() {
+		for {
+			for _, send := range b.Sends {
+				if _, err := send.WriteTo(query, b.Addr); err != nil {
+					return
+				}
+			}
+			time.Sleep(b.SendTimeout)
+		}
+	}()
+
+	processed := map[string]struct{}{"": {}}
+
+	b2 := make([]byte, 1500)
+	for {
+		// in the Hass docker network can receive same msg from different address
+		n, addr, err := b.Recv.ReadFrom(b2)
+		if err != nil {
+			break
+		}
+
+		if err = msg.Unpack(b2[:n]); err != nil {
+			continue
+		}
+
+		ptr := GetPTR(msg, b.Service)
+
+		if _, ok := processed[ptr]; ok {
+			continue
+		}
+
+		ip := addr.(*net.UDPAddr).IP
+
+		for _, entry := range NewServiceEntries(msg, ip) {
+			if onentry(entry) {
+				return nil
+			}
+		}
+
+		processed[ptr] = struct{}{}
+	}
+
+	return nil
+}
+
+func (b *Browser) Close() error {
+	if b.Recv != nil {
+		_ = b.Recv.Close()
+	}
+	for _, send := range b.Sends {
+		_ = send.Close()
+	}
+	return nil
+}
+
+func GetPTR(msg *dns.Msg, service string) string {
+	for _, record := range msg.Answer {
+		if ptr, ok := record.(*dns.PTR); ok && ptr.Hdr.Name == service {
+			return ptr.Ptr
+		}
+	}
+	return ""
+}
+
+func NewServiceEntries(msg *dns.Msg, ip net.IP) (entries []*ServiceEntry) {
+	records := make([]dns.RR, 0, len(msg.Answer)+len(msg.Ns)+len(msg.Extra))
+	records = append(records, msg.Answer...)
+	records = append(records, msg.Ns...)
+	records = append(records, msg.Extra...)
+
+	// PTR ptr=SomeName._hap._tcp.local. hdr=_hap._tcp.local.
+	// TXT txt=...                       hdr=SomeName._hap._tcp.local.
+	// SRV target=SomeName.local.        hdr=SomeName._hap._tcp.local.
+	// A   a=192.168.1.123               hdr=SomeName.local.
+
+	for _, record := range records {
+		ptr, ok := record.(*dns.PTR)
+		if !ok {
+			continue
+		}
+
+		entry := &ServiceEntry{}
+
+		if i := strings.IndexByte(ptr.Ptr, '.'); i > 0 {
+			entry.Name = strings.ReplaceAll(ptr.Ptr[:i], `\ `, " ")
+		}
+
+		var txt *dns.TXT
+		var srv *dns.SRV
+		var a *dns.A
+
+		for _, record = range records {
+			if txt, ok = record.(*dns.TXT); ok && txt.Hdr.Name == ptr.Ptr {
+				entry.Info = make(map[string]string, len(txt.Txt))
+				for _, s := range txt.Txt {
+					k, v, _ := strings.Cut(s, "=")
+					entry.Info[k] = v
+				}
+				break
+			}
+		}
+
+		for _, record = range records {
+			if srv, ok = record.(*dns.SRV); ok && srv.Hdr.Name == ptr.Ptr {
+				entry.Port = srv.Port
+
+				for _, record = range records {
+					if a, ok = record.(*dns.A); ok && a.Hdr.Name == srv.Target {
+						// device can send multiple IP addresses (ex. Homebridge)
+						// use first IP from the list or same IP from sender
+						if entry.IP == nil || ip.Equal(a.A) {
+							entry.IP = a.A
+						}
+					}
+				}
+				break
+			}
+		}
+
+		entries = append(entries, entry)
+	}
+
+	return
+}
diff --git a/installs_on_host/go2rtc/pkg/mdns/mdns_test.go b/installs_on_host/go2rtc/pkg/mdns/mdns_test.go
new file mode 100644
index 0000000..2d74520
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mdns/mdns_test.go
@@ -0,0 +1,17 @@
+package mdns
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestDiscovery(t *testing.T) {
+	onentry := func(entry *ServiceEntry) bool {
+		return true
+	}
+	err := Discovery(ServiceHAP, onentry)
+	//err := Discovery("_ewelink._tcp.local.", time.Second, onentry)
+	// err := Discovery("_googlecast._tcp.local.", time.Second, onentry)
+	require.Nil(t, err)
+}
diff --git a/installs_on_host/go2rtc/pkg/mdns/server.go b/installs_on_host/go2rtc/pkg/mdns/server.go
new file mode 100644
index 0000000..802c07c
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mdns/server.go
@@ -0,0 +1,162 @@
+package mdns
+
+import (
+	"net"
+
+	"github.com/miekg/dns"
+)
+
+// ClassCacheFlush https://datatracker.ietf.org/doc/html/rfc6762#section-10.2
+const ClassCacheFlush = 0x8001
+
+func Serve(service string, entries []*ServiceEntry) error {
+	b := Browser{Service: service}
+
+	if err := b.ListenMulticastUDP(); err != nil {
+		return err
+	}
+
+	return b.Serve(entries)
+}
+
+func (b *Browser) Serve(entries []*ServiceEntry) error {
+	names := make(map[string]*ServiceEntry, len(entries))
+	for _, entry := range entries {
+		name := entry.name() + "." + b.Service
+		names[name] = entry
+	}
+
+	buf := make([]byte, 1500)
+	for {
+		n, addr, err := b.Recv.ReadFrom(buf)
+		if err != nil {
+			break
+		}
+
+		var req dns.Msg // request
+		if err = req.Unpack(buf[:n]); err != nil {
+			continue
+		}
+
+		// skip messages without Questions
+		if req.Question == nil {
+			continue
+		}
+
+		remoteIP := addr.(*net.UDPAddr).IP
+		localIP := b.MatchLocalIP(remoteIP)
+
+		// skip messages from unknown networks (can be docker network)
+		if localIP == nil {
+			continue
+		}
+
+		var res dns.Msg // response
+		for _, q := range req.Question {
+			if q.Qtype != dns.TypePTR || q.Qclass != dns.ClassINET {
+				continue
+			}
+
+			if q.Name == ServiceDNSSD {
+				AppendDNSSD(&res, b.Service)
+			} else if q.Name == b.Service {
+				for _, entry := range entries {
+					AppendEntry(&res, entry, b.Service, localIP)
+				}
+			} else if entry, ok := names[q.Name]; ok {
+				AppendEntry(&res, entry, b.Service, localIP)
+			}
+		}
+
+		if res.Answer == nil {
+			continue
+		}
+
+		res.MsgHdr.Response = true
+		res.MsgHdr.Authoritative = true
+
+		data, err := res.Pack()
+		if err != nil {
+			continue
+		}
+
+		for _, send := range b.Sends {
+			_, _ = send.WriteTo(data, MulticastAddr)
+		}
+	}
+
+	return nil
+}
+
+func (b *Browser) MatchLocalIP(remote net.IP) net.IP {
+	for _, ipn := range b.Nets {
+		if ipn.Contains(remote) {
+			return ipn.IP
+		}
+	}
+	return nil
+}
+
+func AppendDNSSD(msg *dns.Msg, service string) {
+	msg.Answer = append(
+		msg.Answer,
+		&dns.PTR{
+			Hdr: dns.RR_Header{
+				Name:   ServiceDNSSD,  // _services._dns-sd._udp.local.
+				Rrtype: dns.TypePTR,   // 12
+				Class:  dns.ClassINET, // 1
+				Ttl:    4500,
+			},
+			Ptr: service, // _home-assistant._tcp.local.
+		},
+	)
+}
+
+func AppendEntry(msg *dns.Msg, entry *ServiceEntry, service string, ip net.IP) {
+	ptrName := entry.name() + "." + service
+	srvName := entry.name() + ".local."
+
+	msg.Answer = append(
+		msg.Answer,
+		&dns.PTR{
+			Hdr: dns.RR_Header{
+				Name:   service,       // _home-assistant._tcp.local.
+				Rrtype: dns.TypePTR,   // 12
+				Class:  dns.ClassINET, // 1
+				Ttl:    4500,
+			},
+			Ptr: ptrName, // Home\ Assistant._home-assistant._tcp.local.
+		},
+	)
+	msg.Extra = append(
+		msg.Extra,
+		&dns.TXT{
+			Hdr: dns.RR_Header{
+				Name:   ptrName,         // Home\ Assistant._home-assistant._tcp.local.
+				Rrtype: dns.TypeTXT,     // 16
+				Class:  ClassCacheFlush, // 32769
+				Ttl:    4500,
+			},
+			Txt: entry.TXT(),
+		},
+		&dns.SRV{
+			Hdr: dns.RR_Header{
+				Name:   ptrName,         // Home\ Assistant._home-assistant._tcp.local.
+				Rrtype: dns.TypeSRV,     // 33
+				Class:  ClassCacheFlush, // 32769
+				Ttl:    120,
+			},
+			Port:   entry.Port, // 8123
+			Target: srvName,    // 963f1fa82b7142809711cebe7c826322.local.
+		},
+		&dns.A{
+			Hdr: dns.RR_Header{
+				Name:   srvName,         // 963f1fa82b7142809711cebe7c826322.local.
+				Rrtype: dns.TypeA,       // 1
+				Class:  ClassCacheFlush, // 32769
+				Ttl:    120,
+			},
+			A: ip,
+		},
+	)
+}
diff --git a/installs_on_host/go2rtc/pkg/mdns/syscall.go b/installs_on_host/go2rtc/pkg/mdns/syscall.go
new file mode 100644
index 0000000..0e50535
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mdns/syscall.go
@@ -0,0 +1,15 @@
+//go:build !(darwin || ios || freebsd || openbsd || netbsd || dragonfly || windows)
+
+package mdns
+
+import (
+	"syscall"
+)
+
+func SetsockoptInt(fd uintptr, level, opt int, value int) (err error) {
+	return syscall.SetsockoptInt(int(fd), level, opt, value)
+}
+
+func SetsockoptIPMreq(fd uintptr, level, opt int, mreq *syscall.IPMreq) (err error) {
+	return syscall.SetsockoptIPMreq(int(fd), level, opt, mreq)
+}
diff --git a/installs_on_host/go2rtc/pkg/mdns/syscall_bsd.go b/installs_on_host/go2rtc/pkg/mdns/syscall_bsd.go
new file mode 100644
index 0000000..6ebb0c9
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mdns/syscall_bsd.go
@@ -0,0 +1,26 @@
+//go:build darwin || ios || freebsd || openbsd || netbsd || dragonfly
+
+package mdns
+
+import (
+	"syscall"
+)
+
+func SetsockoptInt(fd uintptr, level, opt int, value int) (err error) {
+	// change SO_REUSEADDR and REUSEPORT flags simultaneously for BSD-like OS
+	// https://github.com/AlexxIT/go2rtc/issues/626
+	// https://stackoverflow.com/questions/14388706/how-do-so-reuseaddr-and-so-reuseport-differ/14388707
+	if opt == syscall.SO_REUSEADDR {
+		if err = syscall.SetsockoptInt(int(fd), level, opt, value); err != nil {
+			return
+		}
+
+		opt = syscall.SO_REUSEPORT
+	}
+
+	return syscall.SetsockoptInt(int(fd), level, opt, value)
+}
+
+func SetsockoptIPMreq(fd uintptr, level, opt int, mreq *syscall.IPMreq) (err error) {
+	return syscall.SetsockoptIPMreq(int(fd), level, opt, mreq)
+}
diff --git a/installs_on_host/go2rtc/pkg/mdns/syscall_windows.go b/installs_on_host/go2rtc/pkg/mdns/syscall_windows.go
new file mode 100644
index 0000000..770510c
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mdns/syscall_windows.go
@@ -0,0 +1,13 @@
+//go:build windows
+
+package mdns
+
+import "syscall"
+
+func SetsockoptInt(fd uintptr, level, opt int, value int) (err error) {
+	return syscall.SetsockoptInt(syscall.Handle(fd), level, opt, value)
+}
+
+func SetsockoptIPMreq(fd uintptr, level, opt int, mreq *syscall.IPMreq) (err error) {
+	return syscall.SetsockoptIPMreq(syscall.Handle(fd), level, opt, mreq)
+}
diff --git a/installs_on_host/go2rtc/pkg/mjpeg/README.md b/installs_on_host/go2rtc/pkg/mjpeg/README.md
new file mode 100644
index 0000000..fa8c4e1
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mjpeg/README.md
@@ -0,0 +1,5 @@
+## Useful links
+
+- https://www.rfc-editor.org/rfc/rfc2435
+- https://github.com/GStreamer/gst-plugins-good/blob/master/gst/rtp/gstrtpjpegdepay.c
+- https://mjpeg.sanford.io/
diff --git a/installs_on_host/go2rtc/pkg/mjpeg/consumer.go b/installs_on_host/go2rtc/pkg/mjpeg/consumer.go
new file mode 100644
index 0000000..819c558
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mjpeg/consumer.go
@@ -0,0 +1,59 @@
+package mjpeg
+
+import (
+	"io"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+)
+
+type Consumer struct {
+	core.Connection
+	wr *core.WriteBuffer
+}
+
+func NewConsumer() *Consumer {
+	medias := []*core.Media{
+		{
+			Kind:      core.KindVideo,
+			Direction: core.DirectionSendonly,
+			Codecs: []*core.Codec{
+				{Name: core.CodecJPEG},
+				{Name: core.CodecRAW},
+			},
+		},
+	}
+	wr := core.NewWriteBuffer(nil)
+	return &Consumer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "mjpeg",
+			Medias:     medias,
+			Transport:  wr,
+		},
+		wr: wr,
+	}
+}
+
+func (c *Consumer) AddTrack(media *core.Media, _ *core.Codec, track *core.Receiver) error {
+	sender := core.NewSender(media, track.Codec)
+	sender.Handler = func(packet *rtp.Packet) {
+		if n, err := c.wr.Write(packet.Payload); err == nil {
+			c.Send += n
+		}
+	}
+
+	if track.Codec.IsRTP() {
+		sender.Handler = RTPDepay(sender.Handler)
+	} else if track.Codec.Name == core.CodecRAW {
+		sender.Handler = Encoder(track.Codec, 0, sender.Handler)
+	}
+
+	sender.HandleRTP(track)
+	c.Senders = append(c.Senders, sender)
+	return nil
+}
+
+func (c *Consumer) WriteTo(wr io.Writer) (int64, error) {
+	return c.wr.WriteTo(wr)
+}
diff --git a/installs_on_host/go2rtc/pkg/mjpeg/helpers.go b/installs_on_host/go2rtc/pkg/mjpeg/helpers.go
new file mode 100644
index 0000000..87f59e0
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mjpeg/helpers.go
@@ -0,0 +1,100 @@
+package mjpeg
+
+import (
+	"bytes"
+	"image/jpeg"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/y4m"
+	"github.com/pion/rtp"
+)
+
+func FixJPEG(b []byte) []byte {
+	// skip non-JPEG
+	if len(b) < 10 || b[0] != 0xFF || b[1] != markerSOI {
+		return b
+	}
+
+	// skip JPEG without app marker
+	if b[2] == 0xFF && b[3] == markerDQT {
+		return b
+	}
+
+	switch string(b[6:10]) {
+	case "JFIF", "Exif":
+		// skip if header OK for imghdr library
+		// - https://docs.python.org/3/library/imghdr.html
+		return b
+	case "AVI1":
+		// adds DHT tables to JPEG file before SOS marker
+		// useful when you want to save a JPEG frame from an MJPEG stream
+		// - https://github.com/image-rs/jpeg-decoder/issues/76
+		// - https://github.com/pion/mediadevices/pull/493
+		// - https://bugzilla.mozilla.org/show_bug.cgi?id=963907#c18
+		return InjectDHT(b)
+	}
+
+	// reencode JPEG if it has wrong header
+	//
+	// for example, this app produce "bad" images:
+	// https://github.com/jacksonliam/mjpg-streamer
+	//
+	// and they can't be uploaded to the Telegram servers:
+	// {"ok":false,"error_code":400,"description":"Bad Request: IMAGE_PROCESS_FAILED"}
+	img, err := jpeg.Decode(bytes.NewReader(b))
+	if err != nil {
+		return b
+	}
+	buf := bytes.NewBuffer(nil)
+	if err = jpeg.Encode(buf, img, nil); err != nil {
+		return b
+	}
+	return buf.Bytes()
+}
+
+// Encoder convert YUV frame to Img.
+// Support skipping empty frames, for example if USB cam needs time to start.
+func Encoder(codec *core.Codec, skipEmpty int, handler core.HandlerFunc) core.HandlerFunc {
+	newImage := y4m.NewImage(codec.FmtpLine)
+
+	return func(packet *rtp.Packet) {
+		img := newImage(packet.Payload)
+
+		if skipEmpty != 0 && y4m.HasSameColor(img) {
+			skipEmpty--
+			return
+		}
+
+		buf := bytes.NewBuffer(nil)
+		if err := jpeg.Encode(buf, img, nil); err != nil {
+			return
+		}
+
+		clone := *packet
+		clone.Payload = buf.Bytes()
+		handler(&clone)
+	}
+}
+
+const dhtSize = 432 // known size for 4 default tables
+
+func InjectDHT(b []byte) []byte {
+	if bytes.Index(b, []byte{0xFF, markerDHT}) > 0 {
+		return b // already exist
+	}
+
+	i := bytes.Index(b, []byte{0xFF, markerSOS})
+	if i < 0 {
+		return b
+	}
+
+	dht := make([]byte, 0, dhtSize)
+	dht = MakeHuffmanHeaders(dht)
+
+	tmp := make([]byte, len(b)+dhtSize)
+	copy(tmp, b[:i])
+	copy(tmp[i:], dht)
+	copy(tmp[i+dhtSize:], b[i:])
+
+	return tmp
+}
diff --git a/installs_on_host/go2rtc/pkg/mjpeg/jpeg.go b/installs_on_host/go2rtc/pkg/mjpeg/jpeg.go
new file mode 100644
index 0000000..8d6d13d
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mjpeg/jpeg.go
@@ -0,0 +1,10 @@
+package mjpeg
+
+const (
+	markerSOF = 0xC0 // Start Of Frame (Baseline Sequential)
+	markerSOI = 0xD8 // Start Of Image
+	markerEOI = 0xD9 // End Of Image
+	markerSOS = 0xDA // Start Of Scan
+	markerDQT = 0xDB // Define Quantization Table
+	markerDHT = 0xC4 // Define Huffman Table
+)
diff --git a/installs_on_host/go2rtc/pkg/mjpeg/mjpeg_test.go b/installs_on_host/go2rtc/pkg/mjpeg/mjpeg_test.go
new file mode 100644
index 0000000..586f8c8
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mjpeg/mjpeg_test.go
@@ -0,0 +1,13 @@
+package mjpeg
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestRFC2435(t *testing.T) {
+	lqt, cqt := MakeTables(71)
+	require.Equal(t, byte(9), lqt[0])
+	require.Equal(t, byte(10), cqt[0])
+}
diff --git a/installs_on_host/go2rtc/pkg/mjpeg/rfc2435.go b/installs_on_host/go2rtc/pkg/mjpeg/rfc2435.go
new file mode 100644
index 0000000..aa34c2f
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mjpeg/rfc2435.go
@@ -0,0 +1,211 @@
+package mjpeg
+
+// RFC 2435. Appendix A
+
+// don't know why two tables are not respect RFC
+// https://github.com/FFmpeg/FFmpeg/blob/master/libavformat/rtpdec_jpeg.c
+
+var jpeg_luma_quantizer = [64]byte{
+	16, 11, 12, 14, 12, 10, 16, 14,
+	13, 14, 18, 17, 16, 19, 24, 40,
+	26, 24, 22, 22, 24, 49, 35, 37,
+	29, 40, 58, 51, 61, 60, 57, 51,
+	56, 55, 64, 72, 92, 78, 64, 68,
+	87, 69, 55, 56, 80, 109, 81, 87,
+	95, 98, 103, 104, 103, 62, 77, 113,
+	121, 112, 100, 120, 92, 101, 103, 99,
+}
+var jpeg_chroma_quantizer = [64]byte{
+	17, 18, 18, 24, 21, 24, 47, 26,
+	26, 47, 99, 66, 56, 66, 99, 99,
+	99, 99, 99, 99, 99, 99, 99, 99,
+	99, 99, 99, 99, 99, 99, 99, 99,
+	99, 99, 99, 99, 99, 99, 99, 99,
+	99, 99, 99, 99, 99, 99, 99, 99,
+	99, 99, 99, 99, 99, 99, 99, 99,
+	99, 99, 99, 99, 99, 99, 99, 99,
+}
+
+func MakeTables(q byte) (lqt, cqt []byte) {
+	var factor int
+
+	switch {
+	case q < 1:
+		factor = 1
+	case q > 99:
+		factor = 99
+	default:
+		factor = int(q)
+	}
+
+	if q < 50 {
+		factor = 5000 / factor
+	} else {
+		factor = 200 - factor*2
+	}
+
+	lqt = make([]byte, 64)
+	cqt = make([]byte, 64)
+
+	for i := 0; i < 64; i++ {
+		lq := (int(jpeg_luma_quantizer[i])*factor + 50) / 100
+		cq := (int(jpeg_chroma_quantizer[i])*factor + 50) / 100
+
+		/* Limit the quantizers to 1 <= q <= 255 */
+		switch {
+		case lq < 1:
+			lqt[i] = 1
+		case lq > 255:
+			lqt[i] = 255
+		default:
+			lqt[i] = byte(lq)
+		}
+
+		switch {
+		case cq < 1:
+			cqt[i] = 1
+		case cq > 255:
+			cqt[i] = 255
+		default:
+			cqt[i] = byte(cq)
+		}
+	}
+
+	return
+}
+
+// RFC 2435. Appendix B
+
+var lum_dc_codelens = []byte{
+	0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
+}
+var lum_dc_symbols = []byte{
+	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
+}
+var lum_ac_codelens = []byte{
+	0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d,
+}
+var lum_ac_symbols = []byte{
+	0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
+	0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
+	0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
+	0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
+	0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
+	0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
+	0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
+	0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
+	0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
+	0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+	0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+	0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
+	0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
+	0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+	0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
+	0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
+	0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
+	0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
+	0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
+	0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+	0xf9, 0xfa,
+}
+var chm_dc_codelens = []byte{
+	0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
+}
+var chm_dc_symbols = []byte{
+	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
+}
+var chm_ac_codelens = []byte{
+	0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77,
+}
+var chm_ac_symbols = []byte{
+	0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
+	0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
+	0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
+	0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
+	0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
+	0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
+	0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
+	0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
+	0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+	0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
+	0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
+	0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+	0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
+	0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
+	0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
+	0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
+	0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
+	0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
+	0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
+	0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+	0xf9, 0xfa,
+}
+
+func MakeHeaders(p []byte, t byte, w, h uint16, lqt, cqt []byte) []byte {
+	// Appendix A from https://www.rfc-editor.org/rfc/rfc2435
+	p = append(p, 0xFF, markerSOI)
+
+	p = MakeQuantHeader(p, lqt, 0)
+	p = MakeQuantHeader(p, cqt, 1)
+
+	if t == 0 {
+		t = 0x21 // hsamp = 2, vsamp = 1
+	} else {
+		t = 0x22 // hsamp = 2, vsamp = 2
+	}
+
+	p = append(p, 0xFF, markerSOF,
+		0, 17, // size
+		8, // bits per component
+		byte(h>>8), byte(h&0xFF),
+		byte(w>>8), byte(w&0xFF),
+		3, // number of components
+		0, // comp 0
+		t,
+		0,    // quant table 0
+		1,    // comp 1
+		0x11, // hsamp = 1, vsamp = 1
+		1,    // quant table 1
+		2,    // comp 2
+		0x11, // hsamp = 1, vsamp = 1
+		1,    // quant table 1
+	)
+
+	p = MakeHuffmanHeaders(p)
+
+	return append(p, 0xFF, markerSOS,
+		0, 12, // size
+		3,    // 3 components
+		0,    // comp 0
+		0,    // huffman table 0
+		1,    // comp 1
+		0x11, // huffman table 1
+		2,    // comp 2
+		0x11, // huffman table 1
+		0,    // first DCT coeff
+		63,   // last DCT coeff
+		0,    // sucessive approx
+	)
+}
+
+func MakeQuantHeader(p []byte, qt []byte, tableNo byte) []byte {
+	p = append(p, 0xFF, markerDQT, 0, 67, tableNo)
+	return append(p, qt...)
+}
+
+func MakeHuffmanHeader(p, codelens, symbols []byte, tableNo, tableClass byte) []byte {
+	p = append(p, 0xFF, markerDHT,
+		0, byte(3+len(codelens)+len(symbols)), // size
+		(tableClass<<4)|tableNo,
+	)
+	p = append(p, codelens...)
+	return append(p, symbols...)
+}
+
+func MakeHuffmanHeaders(p []byte) []byte {
+	p = MakeHuffmanHeader(p, lum_dc_codelens, lum_dc_symbols, 0, 0)
+	p = MakeHuffmanHeader(p, lum_ac_codelens, lum_ac_symbols, 0, 1)
+	p = MakeHuffmanHeader(p, chm_dc_codelens, chm_dc_symbols, 1, 0)
+	p = MakeHuffmanHeader(p, chm_ac_codelens, chm_ac_symbols, 1, 1)
+	return p
+}
diff --git a/installs_on_host/go2rtc/pkg/mjpeg/rtp.go b/installs_on_host/go2rtc/pkg/mjpeg/rtp.go
new file mode 100644
index 0000000..7a9347e
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mjpeg/rtp.go
@@ -0,0 +1,220 @@
+package mjpeg
+
+import (
+	"bytes"
+	"encoding/binary"
+	"image"
+	"image/jpeg"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+)
+
+func RTPDepay(handlerFunc core.HandlerFunc) core.HandlerFunc {
+	buf := make([]byte, 0, 512*1024) // 512K
+
+	return func(packet *rtp.Packet) {
+		//log.Printf("[RTP] codec: %s, size: %6d, ts: %10d, pt: %2d, ssrc: %d, seq: %d, mark: %v", track.Codec.Name, len(packet.Payload), packet.Timestamp, packet.PayloadType, packet.SSRC, packet.SequenceNumber, packet.Marker)
+
+		// https://www.rfc-editor.org/rfc/rfc2435#section-3.1
+		b := packet.Payload
+
+		// 3.1.  JPEG header
+		t := b[4]
+
+		// 3.1.7.  Restart Marker header
+		if 64 <= t && t <= 127 {
+			b = b[12:] // skip it
+		} else {
+			b = b[8:]
+		}
+
+		if len(buf) == 0 {
+			var lqt, cqt []byte
+
+			// 3.1.8.  Quantization Table header
+			q := packet.Payload[5]
+			if q >= 128 {
+				lqt = b[4:68]
+				cqt = b[68:132]
+				b = b[132:]
+			} else {
+				lqt, cqt = MakeTables(q)
+			}
+
+			// https://www.rfc-editor.org/rfc/rfc2435#section-3.1.5
+			// The maximum width is 2040 pixels.
+			w := uint16(packet.Payload[6]) << 3
+			h := uint16(packet.Payload[7]) << 3
+
+			// fix sizes more than 2040
+			switch {
+			// 512x1920 512x1440
+			case w == cutSize(2560) && (h == 1920 || h == 1440):
+				w = 2560
+			// 1792x112
+			case w == cutSize(3840) && h == cutSize(2160):
+				w = 3840
+				h = 2160
+			// 256x1296
+			case w == cutSize(2304) && h == 1296:
+				w = 2304
+			}
+
+			//fmt.Printf("t: %d, q: %d, w: %d, h: %d\n", t, q, w, h)
+			buf = MakeHeaders(buf, t, w, h, lqt, cqt)
+		}
+
+		// 3.1.9.  JPEG Payload
+		buf = append(buf, b...)
+
+		if !packet.Marker {
+			return
+		}
+
+		if end := buf[len(buf)-2:]; end[0] != 0xFF && end[1] != 0xD9 {
+			buf = append(buf, 0xFF, 0xD9)
+		}
+
+		clone := *packet
+		clone.Payload = buf
+
+		buf = buf[:0] // clear buffer
+
+		handlerFunc(&clone)
+	}
+}
+
+func cutSize(size uint16) uint16 {
+	return ((size >> 3) & 0xFF) << 3
+}
+
+func RTPPay(handlerFunc core.HandlerFunc) core.HandlerFunc {
+	const packetSize = 1436
+
+	sequencer := rtp.NewRandomSequencer()
+
+	return func(packet *rtp.Packet) {
+		// reincode image to more common form
+		p, err := Transcode(packet.Payload)
+		if err != nil {
+			return
+		}
+
+		h1 := make([]byte, 8)
+		h1[4] = 1   // Type
+		h1[5] = 255 // Q
+
+		// MBZ=0, Precision=0, Length=128
+		h2 := make([]byte, 4, 132)
+		h2[3] = 128
+
+		var jpgData []byte
+		for jpgData == nil {
+			// 2 bytes h1
+			if p[0] != 0xFF {
+				return
+			}
+
+			size := binary.BigEndian.Uint16(p[2:]) + 2
+
+			// 2 bytes payload size (include 2 bytes)
+			switch p[1] {
+			case 0xD8: // 0. Start Of Image (size=0)
+				p = p[2:]
+				continue
+			case 0xDB: // 1. Define Quantization Table (size=130)
+				for i := uint16(4 + 1); i < size; i += 1 + 64 {
+					h2 = append(h2, p[i:i+64]...)
+				}
+			case 0xC0: // 2. Start Of Frame (size=15)
+				if p[4] != 8 {
+					return
+				}
+				h := binary.BigEndian.Uint16(p[5:])
+				w := binary.BigEndian.Uint16(p[7:])
+				h1[6] = uint8(w >> 3)
+				h1[7] = uint8(h >> 3)
+			case 0xC4: // 3. Define Huffman Table (size=416)
+			case 0xDA: // 4. Start Of Scan (size=10)
+				jpgData = p[size:]
+			}
+
+			p = p[size:]
+		}
+
+		offset := 0
+		p = make([]byte, 0)
+
+		for jpgData != nil {
+			p = p[:0]
+
+			if offset > 0 {
+				h1[1] = byte(offset >> 16)
+				h1[2] = byte(offset >> 8)
+				h1[3] = byte(offset)
+				p = append(p, h1...)
+			} else {
+				p = append(p, h1...)
+				p = append(p, h2...)
+			}
+
+			dataLen := packetSize - len(p)
+			if dataLen < len(jpgData) {
+				p = append(p, jpgData[:dataLen]...)
+				jpgData = jpgData[dataLen:]
+				offset += dataLen
+			} else {
+				p = append(p, jpgData...)
+				jpgData = nil
+			}
+
+			clone := rtp.Packet{
+				Header: rtp.Header{
+					Version:        2,
+					Marker:         jpgData == nil,
+					SequenceNumber: sequencer.NextSequenceNumber(),
+					Timestamp:      packet.Timestamp,
+				},
+				Payload: p,
+			}
+			handlerFunc(&clone)
+		}
+	}
+}
+
+func Transcode(b []byte) ([]byte, error) {
+	img, err := jpeg.Decode(bytes.NewReader(b))
+	if err != nil {
+		return nil, err
+	}
+
+	wh := img.Bounds().Size()
+	w := wh.X
+	h := wh.Y
+
+	if w > 2040 {
+		w = 2040
+	} else if w&3 > 0 {
+		w &= 3
+	}
+	if h > 2040 {
+		h = 2040
+	} else if h&3 > 0 {
+		h &= 3
+	}
+
+	if w != wh.X || h != wh.Y {
+		x0 := (wh.X - w) / 2
+		y0 := (wh.Y - h) / 2
+		rect := image.Rect(x0, y0, x0+w, y0+h)
+		img = img.(*image.YCbCr).SubImage(rect)
+	}
+
+	buf := bytes.NewBuffer(nil)
+	if err = jpeg.Encode(buf, img, nil); err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
diff --git a/installs_on_host/go2rtc/pkg/mjpeg/writer.go b/installs_on_host/go2rtc/pkg/mjpeg/writer.go
new file mode 100644
index 0000000..8845bf2
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mjpeg/writer.go
@@ -0,0 +1,38 @@
+package mjpeg
+
+import (
+	"io"
+	"net/http"
+	"strconv"
+)
+
+func NewWriter(w io.Writer) io.Writer {
+	h := w.(http.ResponseWriter).Header()
+	h.Set("Content-Type", "multipart/x-mixed-replace; boundary=frame")
+	return &writer{wr: w, buf: []byte(header)}
+}
+
+const header = "--frame\r\nContent-Type: image/jpeg\r\nContent-Length: "
+
+type writer struct {
+	wr  io.Writer
+	buf []byte
+}
+
+func (w *writer) Write(p []byte) (n int, err error) {
+	w.buf = w.buf[:len(header)]
+	w.buf = append(w.buf, strconv.Itoa(len(p))...)
+	w.buf = append(w.buf, "\r\n\r\n"...)
+	w.buf = append(w.buf, p...)
+	w.buf = append(w.buf, "\r\n"...)
+
+	// Chrome bug: mjpeg image always shows the second to last image
+	// https://bugs.chromium.org/p/chromium/issues/detail?id=527446
+	if _, err = w.wr.Write(w.buf); err != nil {
+		return 0, err
+	}
+
+	w.wr.(http.Flusher).Flush()
+
+	return len(p), nil
+}
diff --git a/installs_on_host/go2rtc/pkg/mp4/README.md b/installs_on_host/go2rtc/pkg/mp4/README.md
new file mode 100644
index 0000000..e20e5d7
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mp4/README.md
@@ -0,0 +1,36 @@
+## Fragmented MP4
+
+```
+ffmpeg -i "rtsp://..." -movflags +frag_keyframe+separate_moof+default_base_moof+empty_moov -frag_duration 1 -c copy -t 5 sample.mp4
+```
+
+- movflags frag_keyframe 
+  Start a new fragment at each video keyframe.
+- frag_duration duration
+  Create fragments that are duration microseconds long.
+- movflags separate_moof
+  Write a separate moof (movie fragment) atom for each track.
+- movflags default_base_moof
+  Similarly to the omit_tfhd_offset, this flag avoids writing the absolute base_data_offset field in tfhd atoms, but does so by using the new default-base-is-moof flag instead.
+
+https://ffmpeg.org/ffmpeg-formats.html#Options-13
+
+## HEVC
+
+| Browser     | avc1 | hvc1 | hev1 |
+|-------------|------|------|------|
+ | Mac Chrome  | +    | -    | +    |
+ | Mac Safari  | +    | +    | -    |
+ | iOS 15?     | +    | +    | -    |
+ | Mac Firefox | +    | -    | -    |
+ | iOS 12      | +    | -    | -    |
+ | Android 13  | +    | -    | -    |
+
+## Useful links
+
+- https://stackoverflow.com/questions/63468587/what-hevc-codec-tag-to-use-with-fmp4-hvc1-or-hev1
+- https://stackoverflow.com/questions/32152090/encode-h265-to-hvc1-codec
+- https://jellyfin.org/docs/general/clients/codec-support.html
+- https://github.com/StaZhu/enable-chromium-hevc-hardware-decoding
+- https://developer.mozilla.org/ru/docs/Web/Media/Formats/codecs_parameter
+- https://gstreamer-devel.narkive.com/rhkUolp2/rtp-dts-pts-result-in-varying-mp4-frame-durations
diff --git a/installs_on_host/go2rtc/pkg/mp4/consumer.go b/installs_on_host/go2rtc/pkg/mp4/consumer.go
new file mode 100644
index 0000000..3484986
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mp4/consumer.go
@@ -0,0 +1,189 @@
+package mp4
+
+import (
+	"errors"
+	"io"
+	"sync"
+
+	"github.com/AlexxIT/go2rtc/pkg/aac"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/h265"
+	"github.com/AlexxIT/go2rtc/pkg/pcm"
+	"github.com/pion/rtp"
+)
+
+type Consumer struct {
+	core.Connection
+	wr    *core.WriteBuffer
+	muxer *Muxer
+	mu    sync.Mutex
+	start bool
+
+	Rotate int `json:"-"`
+	ScaleX int `json:"-"`
+	ScaleY int `json:"-"`
+}
+
+func NewConsumer(medias []*core.Media) *Consumer {
+	if medias == nil {
+		// default local medias
+		medias = []*core.Media{
+			{
+				Kind:      core.KindVideo,
+				Direction: core.DirectionSendonly,
+				Codecs: []*core.Codec{
+					{Name: core.CodecH264},
+					{Name: core.CodecH265},
+				},
+			},
+			{
+				Kind:      core.KindAudio,
+				Direction: core.DirectionSendonly,
+				Codecs: []*core.Codec{
+					{Name: core.CodecAAC},
+				},
+			},
+		}
+	}
+
+	wr := core.NewWriteBuffer(nil)
+	return &Consumer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "mp4",
+			Medias:     medias,
+			Transport:  wr,
+		},
+		muxer: &Muxer{},
+		wr:    wr,
+	}
+}
+
+func (c *Consumer) AddTrack(media *core.Media, _ *core.Codec, track *core.Receiver) error {
+	trackID := byte(len(c.Senders))
+
+	codec := track.Codec.Clone()
+	handler := core.NewSender(media, codec)
+
+	switch track.Codec.Name {
+	case core.CodecH264:
+		handler.Handler = func(packet *rtp.Packet) {
+			if !c.start {
+				if !h264.IsKeyframe(packet.Payload) {
+					return
+				}
+				c.start = true
+			}
+
+			// important to use Mutex because right fragment order
+			c.mu.Lock()
+			b := c.muxer.GetPayload(trackID, packet)
+			if n, err := c.wr.Write(b); err == nil {
+				c.Send += n
+			}
+			c.mu.Unlock()
+		}
+
+		if track.Codec.IsRTP() {
+			handler.Handler = h264.RTPDepay(track.Codec, handler.Handler)
+		} else {
+			handler.Handler = h264.RepairAVCC(track.Codec, handler.Handler)
+		}
+
+	case core.CodecH265:
+		handler.Handler = func(packet *rtp.Packet) {
+			if !c.start {
+				if !h265.IsKeyframe(packet.Payload) {
+					return
+				}
+				c.start = true
+			}
+
+			// important to use Mutex because right fragment order
+			c.mu.Lock()
+			b := c.muxer.GetPayload(trackID, packet)
+			if n, err := c.wr.Write(b); err == nil {
+				c.Send += n
+			}
+			c.mu.Unlock()
+		}
+
+		if track.Codec.IsRTP() {
+			handler.Handler = h265.RTPDepay(track.Codec, handler.Handler)
+		} else {
+			handler.Handler = h265.RepairAVCC(track.Codec, handler.Handler)
+		}
+
+	default:
+		handler.Handler = func(packet *rtp.Packet) {
+			if !c.start {
+				return
+			}
+
+			// important to use Mutex because right fragment order
+			c.mu.Lock()
+			b := c.muxer.GetPayload(trackID, packet)
+			if n, err := c.wr.Write(b); err == nil {
+				c.Send += n
+			}
+			c.mu.Unlock()
+		}
+
+		switch track.Codec.Name {
+		case core.CodecAAC:
+			if track.Codec.IsRTP() {
+				handler.Handler = aac.RTPDepay(handler.Handler)
+			}
+		case core.CodecOpus, core.CodecMP3: // no changes
+		case core.CodecPCMA, core.CodecPCMU, core.CodecPCM, core.CodecPCML:
+			codec.Name = core.CodecFLAC
+			if codec.Channels == 2 {
+				// hacky way for support two channels audio
+				codec.Channels = 1
+				codec.ClockRate *= 2
+			}
+			handler.Handler = pcm.FLACEncoder(track.Codec.Name, codec.ClockRate, handler.Handler)
+
+		default:
+			handler.Handler = nil
+		}
+	}
+
+	if handler.Handler == nil {
+		s := "mp4: unsupported codec: " + track.Codec.String()
+		println(s)
+		return errors.New(s)
+	}
+
+	c.muxer.AddTrack(codec)
+
+	handler.HandleRTP(track)
+	c.Senders = append(c.Senders, handler)
+
+	return nil
+}
+
+func (c *Consumer) WriteTo(wr io.Writer) (int64, error) {
+	if len(c.Senders) == 1 && c.Senders[0].Codec.IsAudio() {
+		c.start = true
+	}
+
+	init, err := c.muxer.GetInit()
+	if err != nil {
+		return 0, err
+	}
+
+	if c.Rotate != 0 {
+		PatchVideoRotate(init, c.Rotate)
+	}
+	if c.ScaleX != 0 && c.ScaleY != 0 {
+		PatchVideoScale(init, c.ScaleX, c.ScaleY)
+	}
+
+	if _, err = wr.Write(init); err != nil {
+		return 0, err
+	}
+
+	return c.wr.WriteTo(wr)
+}
diff --git a/installs_on_host/go2rtc/pkg/mp4/demuxer.go b/installs_on_host/go2rtc/pkg/mp4/demuxer.go
new file mode 100644
index 0000000..25c8c70
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mp4/demuxer.go
@@ -0,0 +1,116 @@
+package mp4
+
+import (
+	"github.com/AlexxIT/go2rtc/pkg/aac"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/iso"
+	"github.com/pion/rtp"
+)
+
+type Demuxer struct {
+	codecs     map[uint32]*core.Codec
+	timeScales map[uint32]float32
+}
+
+func (d *Demuxer) Probe(init []byte) (medias []*core.Media) {
+	var trackID, timeScale uint32
+
+	if d.codecs == nil {
+		d.codecs = make(map[uint32]*core.Codec)
+		d.timeScales = make(map[uint32]float32)
+	}
+
+	atoms, _ := iso.DecodeAtoms(init)
+	for _, atom := range atoms {
+		var codec *core.Codec
+
+		switch atom := atom.(type) {
+		case *iso.AtomTkhd:
+			trackID = atom.TrackID
+		case *iso.AtomMdhd:
+			timeScale = atom.TimeScale
+		case *iso.AtomVideo:
+			switch atom.Name {
+			case "avc1":
+				codec = h264.ConfigToCodec(atom.Config)
+			}
+		case *iso.AtomAudio:
+			switch atom.Name {
+			case "mp4a":
+				codec = aac.ConfigToCodec(atom.Config)
+			}
+		}
+
+		if codec != nil {
+			d.codecs[trackID] = codec
+			d.timeScales[trackID] = float32(codec.ClockRate) / float32(timeScale)
+
+			medias = append(medias, &core.Media{
+				Kind:      codec.Kind(),
+				Direction: core.DirectionRecvonly,
+				Codecs:    []*core.Codec{codec},
+			})
+		}
+	}
+
+	return
+}
+
+func (d *Demuxer) GetTrackID(codec *core.Codec) uint32 {
+	for trackID, c := range d.codecs {
+		if c == codec {
+			return trackID
+		}
+	}
+	return 0
+}
+
+func (d *Demuxer) Demux(data2 []byte) (trackID uint32, packets []*core.Packet) {
+	atoms, err := iso.DecodeAtoms(data2)
+	if err != nil {
+		return 0, nil
+	}
+
+	var ts uint32
+	var trun *iso.AtomTrun
+	var data []byte
+
+	for _, atom := range atoms {
+		switch atom := atom.(type) {
+		case *iso.AtomTfhd:
+			trackID = atom.TrackID
+		case *iso.AtomTfdt:
+			ts = uint32(atom.DecodeTime)
+		case *iso.AtomTrun:
+			trun = atom
+		case *iso.AtomMdat:
+			data = atom.Data
+		}
+	}
+
+	timeScale := d.timeScales[trackID]
+	if timeScale == 0 {
+		return 0, nil
+	}
+
+	n := len(trun.SamplesDuration)
+	packets = make([]*core.Packet, n)
+
+	for i := 0; i < n; i++ {
+		duration := trun.SamplesDuration[i]
+		size := trun.SamplesSize[i]
+
+		// can be SPS, PPS and IFrame in one packet
+		timestamp := uint32(float32(ts) * timeScale)
+		packets[i] = &rtp.Packet{
+			Header:  rtp.Header{Timestamp: timestamp},
+			Payload: data[:size],
+		}
+
+		data = data[size:]
+		ts += duration
+	}
+
+	return
+}
diff --git a/installs_on_host/go2rtc/pkg/mp4/helpers.go b/installs_on_host/go2rtc/pkg/mp4/helpers.go
new file mode 100644
index 0000000..ce1825c
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mp4/helpers.go
@@ -0,0 +1,166 @@
+package mp4
+
+import (
+	"bytes"
+	"encoding/binary"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+// ParseQuery - like usual parse, but with mp4 param handler
+func ParseQuery(query map[string][]string) []*core.Media {
+	if v := query["mp4"]; len(v) != 0 {
+		medias := []*core.Media{
+			{
+				Kind:      core.KindVideo,
+				Direction: core.DirectionSendonly,
+				Codecs: []*core.Codec{
+					{Name: core.CodecH264},
+					{Name: core.CodecH265},
+				},
+			},
+			{
+				Kind:      core.KindAudio,
+				Direction: core.DirectionSendonly,
+				Codecs: []*core.Codec{
+					{Name: core.CodecAAC},
+				},
+			},
+		}
+
+		if v[0] == "" {
+			return medias // legacy
+		}
+
+		medias[1].Codecs = append(medias[1].Codecs,
+			&core.Codec{Name: core.CodecPCMA},
+			&core.Codec{Name: core.CodecPCMU},
+			&core.Codec{Name: core.CodecPCM},
+			&core.Codec{Name: core.CodecPCML},
+		)
+
+		if v[0] == "flac" {
+			return medias // modern browsers
+		}
+
+		medias[1].Codecs = append(medias[1].Codecs,
+			&core.Codec{Name: core.CodecOpus},
+			&core.Codec{Name: core.CodecMP3},
+		)
+
+		return medias // Chrome, FFmpeg, VLC
+	}
+
+	return core.ParseQuery(query)
+}
+
+func ParseCodecs(codecs string, parseAudio bool) (medias []*core.Media) {
+	var videos []*core.Codec
+	var audios []*core.Codec
+
+	for _, name := range strings.Split(codecs, ",") {
+		switch name {
+		case MimeH264:
+			codec := &core.Codec{Name: core.CodecH264}
+			videos = append(videos, codec)
+		case MimeH265:
+			codec := &core.Codec{Name: core.CodecH265}
+			videos = append(videos, codec)
+		case MimeAAC:
+			codec := &core.Codec{Name: core.CodecAAC}
+			audios = append(audios, codec)
+		case MimeFlac:
+			audios = append(audios,
+				&core.Codec{Name: core.CodecPCMA},
+				&core.Codec{Name: core.CodecPCMU},
+				&core.Codec{Name: core.CodecPCM},
+				&core.Codec{Name: core.CodecPCML},
+			)
+		case MimeOpus:
+			codec := &core.Codec{Name: core.CodecOpus}
+			audios = append(audios, codec)
+		}
+	}
+
+	if videos != nil {
+		media := &core.Media{
+			Kind:      core.KindVideo,
+			Direction: core.DirectionSendonly,
+			Codecs:    videos,
+		}
+		medias = append(medias, media)
+	}
+
+	if audios != nil && parseAudio {
+		media := &core.Media{
+			Kind:      core.KindAudio,
+			Direction: core.DirectionSendonly,
+			Codecs:    audios,
+		}
+		medias = append(medias, media)
+	}
+
+	return
+}
+
+// PatchVideoRotate - update video track transformation matrix.
+// Rotation supported by many players and browsers (except Safari).
+// Scale has low support and better not to use it.
+// Supported only 0, 90, 180, 270 degrees.
+func PatchVideoRotate(init []byte, degrees int) bool {
+	// search video atom
+	i := bytes.Index(init, []byte("vide"))
+	if i < 0 {
+		return false
+	}
+
+	// seek to video matrix position
+	i -= 4 + 3 + 1 + 8 + 32 + 8 + 4 + 4 + 4*9
+
+	// Rotation matrix:
+	// [   cos   sin     0]
+	// [  -sin   cos     0]
+	// [     0     0 16384]
+	var cos, sin uint16
+
+	switch degrees {
+	case 0:
+		cos = 1
+		sin = 0
+	case 90:
+		cos = 0
+		sin = 1
+	case 180:
+		cos = 0xFFFF // -1
+		sin = 0
+	case 270:
+		cos = 0
+		sin = 0xFFFF // -1
+	default:
+		return false
+	}
+
+	binary.BigEndian.PutUint16(init[i:], cos)
+	binary.BigEndian.PutUint16(init[i+4:], sin)
+	binary.BigEndian.PutUint16(init[i+12:], -sin)
+	binary.BigEndian.PutUint16(init[i+16:], cos)
+
+	return true
+}
+
+// PatchVideoScale - update "Pixel Aspect Ratio" atom.
+// Supported by many players and browsers (except Firefox).
+// Supported only positive integers.
+func PatchVideoScale(init []byte, scaleX, scaleY int) bool {
+	// search video atom
+	i := bytes.Index(init, []byte("pasp"))
+	if i < 0 {
+		return false
+	}
+
+	binary.BigEndian.PutUint32(init[i+4:], uint32(scaleX))
+	binary.BigEndian.PutUint32(init[i+8:], uint32(scaleY))
+
+	return true
+}
diff --git a/installs_on_host/go2rtc/pkg/mp4/keyframe.go b/installs_on_host/go2rtc/pkg/mp4/keyframe.go
new file mode 100644
index 0000000..399f95e
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mp4/keyframe.go
@@ -0,0 +1,104 @@
+package mp4
+
+import (
+	"io"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/h265"
+	"github.com/pion/rtp"
+)
+
+type Keyframe struct {
+	core.Connection
+	wr    *core.WriteBuffer
+	muxer *Muxer
+}
+
+// Deprecated: should be rewritten
+func NewKeyframe(medias []*core.Media) *Keyframe {
+	if medias == nil {
+		medias = []*core.Media{
+			{
+				Kind:      core.KindVideo,
+				Direction: core.DirectionSendonly,
+				Codecs: []*core.Codec{
+					{Name: core.CodecH264},
+					{Name: core.CodecH265},
+				},
+			},
+		}
+	}
+
+	wr := core.NewWriteBuffer(nil)
+	cons := &Keyframe{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "mp4",
+			Transport:  wr,
+		},
+		muxer: &Muxer{},
+		wr:    wr,
+	}
+	cons.Medias = medias
+	return cons
+}
+
+func (c *Keyframe) AddTrack(media *core.Media, _ *core.Codec, track *core.Receiver) error {
+	c.muxer.AddTrack(track.Codec)
+	init, err := c.muxer.GetInit()
+	if err != nil {
+		return err
+	}
+
+	handler := core.NewSender(media, track.Codec)
+
+	switch track.Codec.Name {
+	case core.CodecH264:
+		handler.Handler = func(packet *rtp.Packet) {
+			if !h264.IsKeyframe(packet.Payload) {
+				return
+			}
+
+			// important to use Mutex because right fragment order
+			b := c.muxer.GetPayload(0, packet)
+			b = append(init, b...)
+			if n, err := c.wr.Write(b); err == nil {
+				c.Send += n
+			}
+		}
+
+		if track.Codec.IsRTP() {
+			handler.Handler = h264.RTPDepay(track.Codec, handler.Handler)
+		} else {
+			handler.Handler = h264.RepairAVCC(track.Codec, handler.Handler)
+		}
+
+	case core.CodecH265:
+		handler.Handler = func(packet *rtp.Packet) {
+			if !h265.IsKeyframe(packet.Payload) {
+				return
+			}
+
+			// important to use Mutex because right fragment order
+			b := c.muxer.GetPayload(0, packet)
+			b = append(init, b...)
+			if n, err := c.wr.Write(b); err == nil {
+				c.Send += n
+			}
+		}
+
+		if track.Codec.IsRTP() {
+			handler.Handler = h265.RTPDepay(track.Codec, handler.Handler)
+		}
+	}
+
+	handler.HandleRTP(track)
+	c.Senders = append(c.Senders, handler)
+
+	return nil
+}
+
+func (c *Keyframe) WriteTo(wr io.Writer) (int64, error) {
+	return c.wr.WriteTo(wr)
+}
diff --git a/installs_on_host/go2rtc/pkg/mp4/mime.go b/installs_on_host/go2rtc/pkg/mp4/mime.go
new file mode 100644
index 0000000..f1a74e4
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mp4/mime.go
@@ -0,0 +1,45 @@
+package mp4
+
+import (
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+)
+
+const (
+	MimeH264 = "avc1.640029"
+	MimeH265 = "hvc1.1.6.L153.B0"
+	MimeAAC  = "mp4a.40.2"
+	MimeFlac = "flac"
+	MimeOpus = "opus"
+)
+
+func MimeCodecs(codecs []*core.Codec) string {
+	var s string
+
+	for i, codec := range codecs {
+		if i > 0 {
+			s += ","
+		}
+
+		switch codec.Name {
+		case core.CodecH264:
+			s += "avc1." + h264.GetProfileLevelID(codec.FmtpLine)
+		case core.CodecH265:
+			// H.265 profile=main level=5.1
+			// hvc1 - supported in Safari, hev1 - doesn't, both supported in Chrome
+			s += MimeH265
+		case core.CodecAAC:
+			s += MimeAAC
+		case core.CodecOpus:
+			s += MimeOpus
+		case core.CodecFLAC:
+			s += MimeFlac
+		}
+	}
+
+	return s
+}
+
+func ContentType(codecs []*core.Codec) string {
+	return `video/mp4; codecs="` + MimeCodecs(codecs) + `"`
+}
diff --git a/installs_on_host/go2rtc/pkg/mp4/muxer.go b/installs_on_host/go2rtc/pkg/mp4/muxer.go
new file mode 100644
index 0000000..b371f68
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mp4/muxer.go
@@ -0,0 +1,172 @@
+package mp4
+
+import (
+	"encoding/hex"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/h265"
+	"github.com/AlexxIT/go2rtc/pkg/iso"
+	"github.com/pion/rtp"
+)
+
+type Muxer struct {
+	index  uint32
+	dts    []uint64
+	pts    []uint32
+	codecs []*core.Codec
+}
+
+func (m *Muxer) AddTrack(codec *core.Codec) {
+	m.dts = append(m.dts, 0)
+	m.pts = append(m.pts, 0)
+	m.codecs = append(m.codecs, codec)
+}
+
+func (m *Muxer) GetInit() ([]byte, error) {
+	mv := iso.NewMovie(1024)
+	mv.WriteFileType()
+
+	mv.StartAtom(iso.Moov)
+	mv.WriteMovieHeader()
+
+	for i, codec := range m.codecs {
+		switch codec.Name {
+		case core.CodecH264:
+			sps, pps := h264.GetParameterSet(codec.FmtpLine)
+			// some dummy SPS and PPS not a problem for MP4, but problem for HLS :(
+			if len(sps) == 0 {
+				sps = []byte{0x67, 0x42, 0x00, 0x0a, 0xf8, 0x41, 0xa2}
+			}
+			if len(pps) == 0 {
+				pps = []byte{0x68, 0xce, 0x38, 0x80}
+			}
+
+			var width, height uint16
+			if s := h264.DecodeSPS(sps); s != nil {
+				width = s.Width()
+				height = s.Height()
+			} else {
+				width = 1920
+				height = 1080
+			}
+
+			mv.WriteVideoTrack(
+				uint32(i+1), codec.Name, codec.ClockRate, width, height, h264.EncodeConfig(sps, pps),
+			)
+
+		case core.CodecH265:
+			vps, sps, pps := h265.GetParameterSet(codec.FmtpLine)
+			// some dummy SPS and PPS not a problem
+			if len(vps) == 0 {
+				vps = []byte{0x40, 0x01, 0x0c, 0x01, 0xff, 0xff, 0x01, 0x40, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03, 0x00, 0x99, 0xac, 0x09}
+			}
+			if len(sps) == 0 {
+				sps = []byte{0x42, 0x01, 0x01, 0x01, 0x40, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03, 0x00, 0x99, 0xa0, 0x01, 0x40, 0x20, 0x05, 0xa1, 0xfe, 0x5a, 0xee, 0x46, 0xc1, 0xae, 0x55, 0x04}
+			}
+			if len(pps) == 0 {
+				pps = []byte{0x44, 0x01, 0xc0, 0x73, 0xc0, 0x4c, 0x90}
+			}
+
+			var width, height uint16
+			if s := h265.DecodeSPS(sps); s != nil {
+				width = s.Width()
+				height = s.Height()
+			} else {
+				width = 1920
+				height = 1080
+			}
+
+			mv.WriteVideoTrack(
+				uint32(i+1), codec.Name, codec.ClockRate, width, height, h265.EncodeConfig(vps, sps, pps),
+			)
+
+		case core.CodecAAC:
+			s := core.Between(codec.FmtpLine, "config=", ";")
+			b, err := hex.DecodeString(s)
+			if err != nil {
+				return nil, err
+			}
+
+			mv.WriteAudioTrack(
+				uint32(i+1), codec.Name, codec.ClockRate, uint16(codec.Channels), b,
+			)
+
+		case core.CodecOpus, core.CodecMP3, core.CodecPCMA, core.CodecPCMU, core.CodecFLAC:
+			mv.WriteAudioTrack(
+				uint32(i+1), codec.Name, codec.ClockRate, uint16(codec.Channels), nil,
+			)
+		}
+	}
+
+	mv.StartAtom(iso.MoovMvex)
+	for i := range m.codecs {
+		mv.WriteTrackExtend(uint32(i + 1))
+	}
+	mv.EndAtom() // MVEX
+
+	mv.EndAtom() // MOOV
+
+	return mv.Bytes(), nil
+}
+
+func (m *Muxer) Reset() {
+	m.index = 0
+	for i := range m.dts {
+		m.dts[i] = 0
+		m.pts[i] = 0
+	}
+}
+
+func (m *Muxer) GetPayload(trackID byte, packet *rtp.Packet) []byte {
+	codec := m.codecs[trackID]
+
+	m.index++
+
+	duration := packet.Timestamp - m.pts[trackID]
+	m.pts[trackID] = packet.Timestamp
+
+	// flags important for Apple Finder video preview
+	var flags uint32
+
+	switch codec.Name {
+	case core.CodecH264:
+		if h264.IsKeyframe(packet.Payload) {
+			flags = iso.SampleVideoIFrame
+		} else {
+			flags = iso.SampleVideoNonIFrame
+		}
+	case core.CodecH265:
+		if h265.IsKeyframe(packet.Payload) {
+			flags = iso.SampleVideoIFrame
+		} else {
+			flags = iso.SampleVideoNonIFrame
+		}
+	case core.CodecAAC:
+		duration = 1024         // important for Apple Finder and QuickTime
+		flags = iso.SampleAudio // not important?
+	default:
+		flags = iso.SampleAudio // important for FLAC on Android Telegram
+	}
+
+	// minumum duration important for MSE in Apple Safari
+	if duration == 0 || duration > codec.ClockRate {
+		duration = codec.ClockRate/1000 + 1
+		m.pts[trackID] += duration
+	}
+
+	size := len(packet.Payload)
+
+	mv := iso.NewMovie(1024 + size)
+	mv.WriteMovieFragment(
+		// ExtensionProfile - wrong place for CTS (supported by mpegts.Demuxer)
+		m.index, uint32(trackID+1), duration, uint32(size), flags, m.dts[trackID], uint32(packet.ExtensionProfile),
+	)
+	mv.WriteData(packet.Payload)
+
+	//log.Printf("[MP4] idx:%3d trk:%d dts:%6d cts:%4d dur:%5d time:%10d len:%5d", m.index, trackID+1, m.dts[trackID], packet.SSRC, duration, packet.Timestamp, len(packet.Payload))
+
+	m.dts[trackID] += uint64(duration)
+
+	return mv.Bytes()
+}
diff --git a/installs_on_host/go2rtc/pkg/mpegts/README.md b/installs_on_host/go2rtc/pkg/mpegts/README.md
new file mode 100644
index 0000000..5f19fc7
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mpegts/README.md
@@ -0,0 +1,35 @@
+## PTS/DTS/CTS
+
+```
+if DTS == 0 {
+    // for I and P frames
+	packet.Timestamp = PTS (presentation time)
+} else {
+    // for B frames
+    packet.Timestamp = DTS (decode time)
+    CTS = PTS-DTS (composition time)
+}
+```
+
+- MPEG-TS container uses PTS and optional DTS.
+- MP4 container uses DTS and CTS
+- RTP container uses PTS
+
+## MPEG-TS
+
+FFmpeg:
+- PMTID=4096
+- H264: PESID=256, StreamType=27, StreamID=224
+- H265: PESID=256, StreamType=36, StreamID=224
+- AAC: PESID=257, StreamType=15, StreamID=192
+
+Tapo:
+- PMTID=18
+- H264: PESID=68, StreamType=27, StreamID=224
+- AAC: PESID=69, StreamType=144, StreamID=192
+
+## Useful links
+
+- https://github.com/theREDspace/video-onboarding/blob/main/MPEGTS%20Knowledge.md
+- https://en.wikipedia.org/wiki/MPEG_transport_stream
+- https://en.wikipedia.org/wiki/Program-specific_information
diff --git a/installs_on_host/go2rtc/pkg/mpegts/checksum.go b/installs_on_host/go2rtc/pkg/mpegts/checksum.go
new file mode 100644
index 0000000..e059d06
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mpegts/checksum.go
@@ -0,0 +1,57 @@
+package mpegts
+
+// have to create this table manually because it is in another endian
+// https://github.com/arturvt/TSreader/blob/master/src/br/ufpe/cin/tool/mpegts/CRC32.java
+var table = [256]uint32{
+	0x00000000, 0xB71DC104, 0x6E3B8209, 0xD926430D, 0xDC760413, 0x6B6BC517,
+	0xB24D861A, 0x0550471E, 0xB8ED0826, 0x0FF0C922, 0xD6D68A2F, 0x61CB4B2B,
+	0x649B0C35, 0xD386CD31, 0x0AA08E3C, 0xBDBD4F38, 0x70DB114C, 0xC7C6D048,
+	0x1EE09345, 0xA9FD5241, 0xACAD155F, 0x1BB0D45B, 0xC2969756, 0x758B5652,
+	0xC836196A, 0x7F2BD86E, 0xA60D9B63, 0x11105A67, 0x14401D79, 0xA35DDC7D,
+	0x7A7B9F70, 0xCD665E74, 0xE0B62398, 0x57ABE29C, 0x8E8DA191, 0x39906095,
+	0x3CC0278B, 0x8BDDE68F, 0x52FBA582, 0xE5E66486, 0x585B2BBE, 0xEF46EABA,
+	0x3660A9B7, 0x817D68B3, 0x842D2FAD, 0x3330EEA9, 0xEA16ADA4, 0x5D0B6CA0,
+	0x906D32D4, 0x2770F3D0, 0xFE56B0DD, 0x494B71D9, 0x4C1B36C7, 0xFB06F7C3,
+	0x2220B4CE, 0x953D75CA, 0x28803AF2, 0x9F9DFBF6, 0x46BBB8FB, 0xF1A679FF,
+	0xF4F63EE1, 0x43EBFFE5, 0x9ACDBCE8, 0x2DD07DEC, 0x77708634, 0xC06D4730,
+	0x194B043D, 0xAE56C539, 0xAB068227, 0x1C1B4323, 0xC53D002E, 0x7220C12A,
+	0xCF9D8E12, 0x78804F16, 0xA1A60C1B, 0x16BBCD1F, 0x13EB8A01, 0xA4F64B05,
+	0x7DD00808, 0xCACDC90C, 0x07AB9778, 0xB0B6567C, 0x69901571, 0xDE8DD475,
+	0xDBDD936B, 0x6CC0526F, 0xB5E61162, 0x02FBD066, 0xBF469F5E, 0x085B5E5A,
+	0xD17D1D57, 0x6660DC53, 0x63309B4D, 0xD42D5A49, 0x0D0B1944, 0xBA16D840,
+	0x97C6A5AC, 0x20DB64A8, 0xF9FD27A5, 0x4EE0E6A1, 0x4BB0A1BF, 0xFCAD60BB,
+	0x258B23B6, 0x9296E2B2, 0x2F2BAD8A, 0x98366C8E, 0x41102F83, 0xF60DEE87,
+	0xF35DA999, 0x4440689D, 0x9D662B90, 0x2A7BEA94, 0xE71DB4E0, 0x500075E4,
+	0x892636E9, 0x3E3BF7ED, 0x3B6BB0F3, 0x8C7671F7, 0x555032FA, 0xE24DF3FE,
+	0x5FF0BCC6, 0xE8ED7DC2, 0x31CB3ECF, 0x86D6FFCB, 0x8386B8D5, 0x349B79D1,
+	0xEDBD3ADC, 0x5AA0FBD8, 0xEEE00C69, 0x59FDCD6D, 0x80DB8E60, 0x37C64F64,
+	0x3296087A, 0x858BC97E, 0x5CAD8A73, 0xEBB04B77, 0x560D044F, 0xE110C54B,
+	0x38368646, 0x8F2B4742, 0x8A7B005C, 0x3D66C158, 0xE4408255, 0x535D4351,
+	0x9E3B1D25, 0x2926DC21, 0xF0009F2C, 0x471D5E28, 0x424D1936, 0xF550D832,
+	0x2C769B3F, 0x9B6B5A3B, 0x26D61503, 0x91CBD407, 0x48ED970A, 0xFFF0560E,
+	0xFAA01110, 0x4DBDD014, 0x949B9319, 0x2386521D, 0x0E562FF1, 0xB94BEEF5,
+	0x606DADF8, 0xD7706CFC, 0xD2202BE2, 0x653DEAE6, 0xBC1BA9EB, 0x0B0668EF,
+	0xB6BB27D7, 0x01A6E6D3, 0xD880A5DE, 0x6F9D64DA, 0x6ACD23C4, 0xDDD0E2C0,
+	0x04F6A1CD, 0xB3EB60C9, 0x7E8D3EBD, 0xC990FFB9, 0x10B6BCB4, 0xA7AB7DB0,
+	0xA2FB3AAE, 0x15E6FBAA, 0xCCC0B8A7, 0x7BDD79A3, 0xC660369B, 0x717DF79F,
+	0xA85BB492, 0x1F467596, 0x1A163288, 0xAD0BF38C, 0x742DB081, 0xC3307185,
+	0x99908A5D, 0x2E8D4B59, 0xF7AB0854, 0x40B6C950, 0x45E68E4E, 0xF2FB4F4A,
+	0x2BDD0C47, 0x9CC0CD43, 0x217D827B, 0x9660437F, 0x4F460072, 0xF85BC176,
+	0xFD0B8668, 0x4A16476C, 0x93300461, 0x242DC565, 0xE94B9B11, 0x5E565A15,
+	0x87701918, 0x306DD81C, 0x353D9F02, 0x82205E06, 0x5B061D0B, 0xEC1BDC0F,
+	0x51A69337, 0xE6BB5233, 0x3F9D113E, 0x8880D03A, 0x8DD09724, 0x3ACD5620,
+	0xE3EB152D, 0x54F6D429, 0x7926A9C5, 0xCE3B68C1, 0x171D2BCC, 0xA000EAC8,
+	0xA550ADD6, 0x124D6CD2, 0xCB6B2FDF, 0x7C76EEDB, 0xC1CBA1E3, 0x76D660E7,
+	0xAFF023EA, 0x18EDE2EE, 0x1DBDA5F0, 0xAAA064F4, 0x738627F9, 0xC49BE6FD,
+	0x09FDB889, 0xBEE0798D, 0x67C63A80, 0xD0DBFB84, 0xD58BBC9A, 0x62967D9E,
+	0xBBB03E93, 0x0CADFF97, 0xB110B0AF, 0x060D71AB, 0xDF2B32A6, 0x6836F3A2,
+	0x6D66B4BC, 0xDA7B75B8, 0x035D36B5, 0xB440F7B1,
+}
+
+func checksum(data []byte) uint32 {
+	crc := uint32(0xFFFFFFFF)
+	for _, b := range data {
+		crc = table[b^byte(crc)] ^ (crc >> 8)
+	}
+	return crc
+}
diff --git a/installs_on_host/go2rtc/pkg/mpegts/consumer.go b/installs_on_host/go2rtc/pkg/mpegts/consumer.go
new file mode 100644
index 0000000..fcb57c7
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mpegts/consumer.go
@@ -0,0 +1,124 @@
+package mpegts
+
+import (
+	"io"
+
+	"github.com/AlexxIT/go2rtc/pkg/aac"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/h265"
+	"github.com/pion/rtp"
+)
+
+type Consumer struct {
+	core.Connection
+	muxer *Muxer
+	wr    *core.WriteBuffer
+}
+
+func NewConsumer() *Consumer {
+	medias := []*core.Media{
+		{
+			Kind:      core.KindVideo,
+			Direction: core.DirectionSendonly,
+			Codecs: []*core.Codec{
+				{Name: core.CodecH264},
+				{Name: core.CodecH265},
+			},
+		},
+		{
+			Kind:      core.KindAudio,
+			Direction: core.DirectionSendonly,
+			Codecs: []*core.Codec{
+				{Name: core.CodecAAC},
+			},
+		},
+	}
+	wr := core.NewWriteBuffer(nil)
+	return &Consumer{
+		core.Connection{
+			ID:         core.NewID(),
+			FormatName: "mpegts",
+			Medias:     medias,
+			Transport:  wr,
+		},
+		NewMuxer(),
+		wr,
+	}
+}
+
+func (c *Consumer) AddTrack(media *core.Media, codec *core.Codec, track *core.Receiver) error {
+	sender := core.NewSender(media, track.Codec)
+
+	switch track.Codec.Name {
+	case core.CodecH264:
+		pid := c.muxer.AddTrack(StreamTypeH264)
+
+		sender.Handler = func(pkt *rtp.Packet) {
+			b := c.muxer.GetPayload(pid, pkt.Timestamp, pkt.Payload)
+			if n, err := c.wr.Write(b); err == nil {
+				c.Send += n
+			}
+		}
+
+		if track.Codec.IsRTP() {
+			sender.Handler = h264.RTPDepay(track.Codec, sender.Handler)
+		} else {
+			sender.Handler = h264.RepairAVCC(track.Codec, sender.Handler)
+		}
+
+	case core.CodecH265:
+		pid := c.muxer.AddTrack(StreamTypeH265)
+
+		sender.Handler = func(pkt *rtp.Packet) {
+			b := c.muxer.GetPayload(pid, pkt.Timestamp, pkt.Payload)
+			if n, err := c.wr.Write(b); err == nil {
+				c.Send += n
+			}
+		}
+
+		if track.Codec.IsRTP() {
+			sender.Handler = h265.RTPDepay(track.Codec, sender.Handler)
+		}
+
+	case core.CodecAAC:
+		pid := c.muxer.AddTrack(StreamTypeAAC)
+
+		// convert timestamp to 90000Hz clock
+		dt := 90000 / float64(track.Codec.ClockRate)
+
+		sender.Handler = func(pkt *rtp.Packet) {
+			pts := uint32(float64(pkt.Timestamp) * dt)
+			b := c.muxer.GetPayload(pid, pts, pkt.Payload)
+			if n, err := c.wr.Write(b); err == nil {
+				c.Send += n
+			}
+		}
+
+		if track.Codec.IsRTP() {
+			sender.Handler = aac.RTPToADTS(track.Codec, sender.Handler)
+		} else {
+			sender.Handler = aac.EncodeToADTS(track.Codec, sender.Handler)
+		}
+	}
+
+	sender.HandleRTP(track)
+	c.Senders = append(c.Senders, sender)
+	return nil
+}
+
+func (c *Consumer) WriteTo(wr io.Writer) (int64, error) {
+	b := c.muxer.GetHeader()
+	if _, err := wr.Write(b); err != nil {
+		return 0, err
+	}
+
+	return c.wr.WriteTo(wr)
+}
+
+//func TimestampFromRTP(rtp *rtp.Packet, codec *core.Codec) {
+//	if codec.ClockRate == ClockRate {
+//		return
+//	}
+//	rtp.Timestamp = uint32(float64(rtp.Timestamp) / float64(codec.ClockRate) * ClockRate)
+//}
diff --git a/installs_on_host/go2rtc/pkg/mpegts/demuxer.go b/installs_on_host/go2rtc/pkg/mpegts/demuxer.go
new file mode 100644
index 0000000..3e78fce
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mpegts/demuxer.go
@@ -0,0 +1,434 @@
+package mpegts
+
+import (
+	"bytes"
+	"errors"
+	"io"
+
+	"github.com/AlexxIT/go2rtc/pkg/aac"
+	"github.com/AlexxIT/go2rtc/pkg/bits"
+	"github.com/AlexxIT/go2rtc/pkg/h264/annexb"
+	"github.com/pion/rtp"
+)
+
+type Demuxer struct {
+	buf [PacketSize]byte // total buf
+
+	byte byte // current byte
+	bits byte // bits left in byte
+	pos  byte // current pos in buf
+	end  byte // end position
+
+	pmtID uint16 // Program Map Table (PMT) PID
+	pes   map[uint16]*PES
+}
+
+func NewDemuxer() *Demuxer {
+	return &Demuxer{}
+}
+
+const skipRead = 0xFF
+
+func (d *Demuxer) ReadPacket(rd io.Reader) (*rtp.Packet, error) {
+	for {
+		if d.pos != skipRead {
+			if _, err := io.ReadFull(rd, d.buf[:]); err != nil {
+				return nil, err
+			}
+		}
+
+		pid, start, err := d.readPacketHeader()
+		if err != nil {
+			return nil, err
+		}
+
+		if d.pes == nil {
+			switch pid {
+			case 0: // PAT ID
+				d.readPAT() // PAT: Program Association Table
+			case d.pmtID:
+				d.readPMT() // PMT : Program Map Table
+
+				pkt := &rtp.Packet{
+					Payload: make([]byte, 0, len(d.pes)),
+				}
+				for _, pes := range d.pes {
+					pkt.Payload = append(pkt.Payload, pes.StreamType)
+				}
+				return pkt, nil
+			}
+			continue
+		}
+
+		if pkt := d.readPES(pid, start); pkt != nil {
+			return pkt, nil
+		}
+	}
+}
+
+func (d *Demuxer) readPacketHeader() (pid uint16, start bool, err error) {
+	d.reset()
+
+	sb := d.readByte() // Sync byte
+	if sb != SyncByte {
+		return 0, false, errors.New("mpegts: wrong sync byte")
+	}
+
+	_ = d.readBit()        // Transport error indicator (TEI)
+	pusi := d.readBit()    // Payload unit start indicator (PUSI)
+	_ = d.readBit()        // Transport priority
+	pid = d.readBits16(13) // PID
+
+	_ = d.readBits(2) // Transport scrambling control (TSC)
+	af := d.readBit() // Adaptation field
+	_ = d.readBit()   // Payload
+	_ = d.readBits(4) // Continuity counter
+
+	if af != 0 {
+		adSize := d.readByte() // Adaptation field length
+		if adSize > PacketSize-6 {
+			return 0, false, errors.New("mpegts: wrong adaptation size")
+		}
+		d.skip(adSize)
+	}
+
+	return pid, pusi != 0, nil
+}
+
+func (d *Demuxer) skip(i byte) {
+	d.pos += i
+}
+
+func (d *Demuxer) readBytes(i byte) []byte {
+	d.pos += i
+	return d.buf[d.pos-i : d.pos]
+}
+
+func (d *Demuxer) readPSIHeader() {
+	// https://en.wikipedia.org/wiki/Program-specific_information#Table_Sections
+	pointer := d.readByte() // Pointer field
+	d.skip(pointer)         // Pointer filler bytes
+
+	_ = d.readByte()       // Table ID
+	_ = d.readBit()        // Section syntax indicator
+	_ = d.readBit()        // Private bit
+	_ = d.readBits(2)      // Reserved bits
+	_ = d.readBits(2)      // Section length unused bits
+	size := d.readBits(10) // Section length
+	d.setSize(byte(size))
+
+	_ = d.readBits(16) // Table ID extension
+	_ = d.readBits(2)  // Reserved bits
+	_ = d.readBits(5)  // Version number
+	_ = d.readBit()    // Current/next indicator
+	_ = d.readByte()   // Section number
+	_ = d.readByte()   // Last section number
+}
+
+// ReadPAT (Program Association Table)
+func (d *Demuxer) readPAT() {
+	// https://en.wikipedia.org/wiki/Program-specific_information#PAT_(Program_Association_Table)
+	d.readPSIHeader()
+
+	const CRCSize = 4
+	for d.left() > CRCSize {
+		num := d.readBits(16)   // Program num
+		_ = d.readBits(3)       // Reserved bits
+		pid := d.readBits16(13) // Program map PID
+		if num != 0 {
+			d.pmtID = pid
+		}
+	}
+
+	d.skip(4) // CRC32
+}
+
+// ReadPMT (Program map specific data)
+func (d *Demuxer) readPMT() {
+	// https://en.wikipedia.org/wiki/Program-specific_information#PMT_(Program_map_specific_data)
+	d.readPSIHeader()
+
+	_ = d.readBits(3)      // Reserved bits
+	_ = d.readBits(13)     // PCR PID
+	_ = d.readBits(4)      // Reserved bits
+	_ = d.readBits(2)      // Program info length unused bits
+	size := d.readBits(10) // Program info length
+	d.skip(byte(size))
+
+	d.pes = map[uint16]*PES{}
+
+	const CRCSize = 4
+	for d.left() > CRCSize {
+		streamType := d.readByte() // Stream type
+		_ = d.readBits(3)          // Reserved bits
+		pid := d.readBits16(13)    // Elementary PID
+		_ = d.readBits(4)          // Reserved bits
+		_ = d.readBits(2)          // ES Info length unused bits
+		size = d.readBits(10)      // ES Info length
+		info := d.readBytes(byte(size))
+
+		if streamType == StreamTypePrivate && bytes.HasPrefix(info, opusInfo) {
+			streamType = StreamTypePrivateOPUS
+		}
+
+		d.pes[pid] = &PES{StreamType: streamType}
+	}
+
+	d.skip(4) // CRC32
+}
+
+func (d *Demuxer) readPES(pid uint16, start bool) *rtp.Packet {
+	pes := d.pes[pid]
+	if pes == nil {
+		return nil
+	}
+
+	// if new payload beging
+	if start {
+		if len(pes.Payload) != 0 {
+			d.pos = skipRead
+			return pes.GetPacket() // finish previous packet
+		}
+
+		// https://en.wikipedia.org/wiki/Packetized_elementary_stream
+		// Packet start code prefix
+		if d.readByte() != 0 || d.readByte() != 0 || d.readByte() != 1 {
+			return nil
+		}
+
+		pes.StreamID = d.readByte()    // Stream id
+		packetSize := d.readBits16(16) // PES Packet length
+
+		_ = d.readBits(2) // Marker bits
+		_ = d.readBits(2) // Scrambling control
+		_ = d.readBit()   // Priority
+		_ = d.readBit()   // Data alignment indicator
+		_ = d.readBit()   // Copyright
+		_ = d.readBit()   // Original or Copy
+
+		ptsi := d.readBit() // PTS indicator
+		dtsi := d.readBit() // DTS indicator
+		_ = d.readBit()     // ESCR flag
+		_ = d.readBit()     // ES rate flag
+		_ = d.readBit()     // DSM trick mode flag
+		_ = d.readBit()     // Additional copy info flag
+		_ = d.readBit()     // CRC flag
+		_ = d.readBit()     // extension flag
+
+		headerSize := d.readByte() // PES header length
+
+		if packetSize != 0 {
+			packetSize -= uint16(3 + headerSize)
+		}
+
+		if ptsi != 0 {
+			pes.PTS = d.readTime()
+			headerSize -= 5
+		} else {
+			pes.PTS = 0
+		}
+
+		if dtsi != 0 {
+			pes.DTS = d.readTime()
+			headerSize -= 5
+		} else {
+			pes.DTS = 0
+		}
+
+		d.skip(headerSize)
+
+		pes.SetBuffer(packetSize, d.bytes())
+	} else {
+		pes.AppendBuffer(d.bytes())
+	}
+
+	if pes.Size != 0 && len(pes.Payload) >= pes.Size {
+		return pes.GetPacket() // finish current packet
+	}
+
+	return nil
+}
+
+func (d *Demuxer) reset() {
+	d.pos = 0
+	d.end = PacketSize
+	d.bits = 0
+}
+
+//goland:noinspection GoStandardMethods
+func (d *Demuxer) readByte() byte {
+	if d.bits != 0 {
+		return byte(d.readBits(8))
+	}
+
+	b := d.buf[d.pos]
+	d.pos++
+	return b
+}
+
+func (d *Demuxer) readBit() byte {
+	if d.bits == 0 {
+		d.byte = d.readByte()
+		d.bits = 7
+	} else {
+		d.bits--
+	}
+
+	return (d.byte >> d.bits) & 0b1
+}
+
+func (d *Demuxer) readBits(n byte) (res uint32) {
+	for i := n - 1; i != 255; i-- {
+		res |= uint32(d.readBit()) << i
+	}
+	return
+}
+
+func (d *Demuxer) readBits16(n byte) (res uint16) {
+	for i := n - 1; i != 255; i-- {
+		res |= uint16(d.readBit()) << i
+	}
+	return
+}
+
+func (d *Demuxer) readTime() uint32 {
+	// https://en.wikipedia.org/wiki/Packetized_elementary_stream
+	// xxxxAAAx BBBBBBBB BBBBBBBx CCCCCCCC CCCCCCCx
+	_ = d.readBits(4) // 0010b or 0011b or 0001b
+	ts := d.readBits(3) << 30
+	_ = d.readBits(1) // 1b
+	ts |= d.readBits(15) << 15
+	_ = d.readBits(1) // 1b
+	ts |= d.readBits(15)
+	_ = d.readBits(1) // 1b
+	return ts
+}
+
+func (d *Demuxer) bytes() []byte {
+	return d.buf[d.pos:PacketSize]
+}
+
+func (d *Demuxer) left() byte {
+	return d.end - d.pos
+}
+
+func (d *Demuxer) setSize(size byte) {
+	d.end = d.pos + size
+}
+
+const (
+	PacketSize = 188
+	SyncByte   = 0x47  // Uppercase G
+	ClockRate  = 90000 // fixed clock rate for PTS/DTS of any type
+)
+
+// https://en.wikipedia.org/wiki/Program-specific_information#Elementary_stream_types
+const (
+	StreamTypeMetadata    = 0    // Reserved
+	StreamTypePrivate     = 0x06 // PCMU or PCMA or FLAC from FFmpeg
+	StreamTypeAAC         = 0x0F
+	StreamTypeH264        = 0x1B
+	StreamTypeH265        = 0x24
+	StreamTypePCMATapo    = 0x90
+	StreamTypePCMUTapo    = 0x91
+	StreamTypePrivateOPUS = 0xEB
+)
+
+// PES - Packetized Elementary Stream
+type PES struct {
+	StreamID   byte   // from each PES header
+	StreamType byte   // from PMT table
+	Sequence   uint16 // manual
+	Timestamp  uint32 // manual
+	PTS        uint32 // from extra header, always 90000Hz
+	DTS        uint32
+	Payload    []byte // from PES body
+	Size       int    // from PES header, can be 0
+
+	wr *bits.Writer
+}
+
+func (p *PES) SetBuffer(size uint16, b []byte) {
+	p.Payload = make([]byte, 0, size)
+	p.Payload = append(p.Payload, b...)
+	p.Size = int(size)
+}
+
+func (p *PES) AppendBuffer(b []byte) {
+	p.Payload = append(p.Payload, b...)
+}
+
+func (p *PES) GetPacket() (pkt *rtp.Packet) {
+	switch p.StreamType {
+	case StreamTypeH264, StreamTypeH265:
+		pkt = &rtp.Packet{
+			Header: rtp.Header{
+				PayloadType: p.StreamType,
+			},
+			Payload: annexb.EncodeToAVCC(p.Payload),
+		}
+
+		if p.DTS != 0 {
+			pkt.Timestamp = p.DTS
+			// wrong place for CTS, but we don't have another one
+			pkt.ExtensionProfile = uint16(p.PTS - p.DTS)
+		} else {
+			pkt.Timestamp = p.PTS
+		}
+
+	case StreamTypeAAC:
+		p.Sequence++
+
+		pkt = &rtp.Packet{
+			Header: rtp.Header{
+				Version:        2,
+				Marker:         true,
+				PayloadType:    p.StreamType,
+				SequenceNumber: p.Sequence,
+				Timestamp:      p.PTS,
+				//Timestamp:      p.Timestamp,
+			},
+			Payload: aac.ADTStoRTP(p.Payload),
+		}
+
+		//p.Timestamp += aac.RTPTimeSize(pkt.Payload) // update next timestamp!
+
+	case StreamTypePCMATapo, StreamTypePCMUTapo:
+		p.Sequence++
+
+		pkt = &rtp.Packet{
+			Header: rtp.Header{
+				Version:        2,
+				Marker:         true,
+				PayloadType:    p.StreamType,
+				SequenceNumber: p.Sequence,
+				Timestamp:      p.PTS,
+				//Timestamp:      p.Timestamp,
+			},
+			Payload: p.Payload,
+		}
+
+		//p.Timestamp += uint32(len(p.Payload)) // update next timestamp!
+
+	case StreamTypePrivateOPUS:
+		p.Sequence++
+
+		pkt = &rtp.Packet{
+			Header: rtp.Header{
+				Version:        2,
+				Marker:         true,
+				PayloadType:    p.StreamType,
+				SequenceNumber: p.Sequence,
+				Timestamp:      p.PTS,
+			},
+		}
+
+		pkt.Payload, p.Payload = CutOPUSPacket(p.Payload)
+		p.PTS += opusDT
+		return
+	}
+
+	p.Payload = nil
+
+	return
+}
diff --git a/installs_on_host/go2rtc/pkg/mpegts/muxer.go b/installs_on_host/go2rtc/pkg/mpegts/muxer.go
new file mode 100644
index 0000000..5d4129d
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mpegts/muxer.go
@@ -0,0 +1,226 @@
+package mpegts
+
+import (
+	"encoding/binary"
+
+	"github.com/AlexxIT/go2rtc/pkg/bits"
+	"github.com/AlexxIT/go2rtc/pkg/h264/annexb"
+)
+
+type Muxer struct {
+	pes map[uint16]*PES
+}
+
+func NewMuxer() *Muxer {
+	return &Muxer{
+		pes: map[uint16]*PES{},
+	}
+}
+
+func (m *Muxer) AddTrack(streamType byte) (pid uint16) {
+	pes := &PES{StreamType: streamType}
+
+	// Audio streams (0xC0-0xDF), Video streams (0xE0-0xEF)
+	switch streamType {
+	case StreamTypeH264, StreamTypeH265:
+		pes.StreamID = 0xE0
+	case StreamTypeAAC, StreamTypePCMATapo:
+		pes.StreamID = 0xC0
+	}
+
+	pid = pes0PID + uint16(len(m.pes))
+	m.pes[pid] = pes
+
+	return
+}
+
+func (m *Muxer) GetHeader() []byte {
+	bw := bits.NewWriter(nil)
+	m.writePAT(bw)
+	m.writePMT(bw)
+	return bw.Bytes()
+}
+
+// GetPayload - safe to run concurently with different pid
+func (m *Muxer) GetPayload(pid uint16, timestamp uint32, payload []byte) []byte {
+	pes := m.pes[pid]
+
+	switch pes.StreamType {
+	case StreamTypeH264, StreamTypeH265:
+		payload = annexb.DecodeAVCCWithAUD(payload)
+	}
+
+	if pes.Timestamp != 0 {
+		pes.PTS += timestamp - pes.Timestamp
+	}
+	pes.Timestamp = timestamp
+
+	// min header size (3 byte) + adv header size (PES)
+	size := 3 + 5 + len(payload)
+
+	b := make([]byte, 6+3+5)
+
+	b[0], b[1], b[2] = 0, 0, 1 // Packet start code prefix
+	b[3] = pes.StreamID        // Stream ID
+
+	// PES Packet length (zero value OK for video)
+	if size <= 0xFFFF {
+		binary.BigEndian.PutUint16(b[4:], uint16(size))
+	}
+
+	// Optional PES header:
+	b[6] = 0x80 // Marker bits (binary)
+	b[7] = 0x80 // PTS indicator
+	b[8] = 5    // PES header length
+
+	WriteTime(b[9:], pes.PTS)
+
+	pes.Payload = append(b, payload...)
+	pes.Size = 1 // set PUSI in first PES
+
+	if pes.wr == nil {
+		pes.wr = bits.NewWriter(nil)
+	} else {
+		pes.wr.Reset()
+	}
+
+	for len(pes.Payload) > 0 {
+		m.writePES(pes.wr, pid, pes)
+		pes.Sequence++
+		pes.Size = 0
+	}
+
+	return pes.wr.Bytes()
+}
+
+const patPID = 0
+const pmtPID = 0x1000
+const pes0PID = 0x100
+
+func (m *Muxer) writePAT(wr *bits.Writer) {
+	m.writeHeader(wr, patPID)
+	i := wr.Len() + 1 // start for CRC32
+	m.writePSIHeader(wr, 0, 4)
+
+	wr.WriteUint16(1)          // Program num
+	wr.WriteBits8(0b111, 3)    // Reserved bits (all to 1)
+	wr.WriteBits16(pmtPID, 13) // Program map PID
+
+	crc := checksum(wr.Bytes()[i:])
+	wr.WriteBytes(byte(crc), byte(crc>>8), byte(crc>>16), byte(crc>>24)) // CRC32 (little endian)
+
+	m.WriteTail(wr)
+}
+
+func (m *Muxer) writePMT(wr *bits.Writer) {
+	m.writeHeader(wr, pmtPID)
+	i := wr.Len() + 1                               // start for CRC32
+	m.writePSIHeader(wr, 2, 4+uint16(len(m.pes))*5) // 4 bytes below + 5 bytes each PES
+
+	wr.WriteBits8(0b111, 3)    // Reserved bits (all to 1)
+	wr.WriteBits16(0x1FFF, 13) // Program map PID (not used)
+
+	wr.WriteBits8(0b1111, 4) // Reserved bits (all to 1)
+	wr.WriteBits8(0, 2)      // Program info length unused bits (all to 0)
+	wr.WriteBits16(0, 10)    // Program info length
+
+	for pid := uint16(pes0PID); ; pid++ {
+		pes, ok := m.pes[pid]
+		if !ok {
+			break
+		}
+		wr.WriteByte(pes.StreamType) // Stream type
+		wr.WriteBits8(0b111, 3)      // Reserved bits (all to 1)
+		wr.WriteBits16(pid, 13)      // Elementary PID
+		wr.WriteBits8(0b1111, 4)     // Reserved bits (all to 1)
+		wr.WriteBits(0, 2)           // ES Info length unused bits
+		wr.WriteBits16(0, 10)        // ES Info length
+	}
+
+	crc := checksum(wr.Bytes()[i:])
+	wr.WriteBytes(byte(crc), byte(crc>>8), byte(crc>>16), byte(crc>>24)) // CRC32 (little endian)
+
+	m.WriteTail(wr)
+}
+
+func (m *Muxer) writePES(wr *bits.Writer, pid uint16, pes *PES) {
+	const flagPUSI = 0b01000000_00000000
+	const flagAdaptation = 0b00100000
+	const flagPayload = 0b00010000
+
+	wr.WriteByte(SyncByte)
+
+	if pes.Size != 0 {
+		pid |= flagPUSI // Payload unit start indicator (PUSI)
+	}
+
+	wr.WriteUint16(pid)
+
+	counter := byte(pes.Sequence) & 0xF
+
+	if size := len(pes.Payload); size < PacketSize-4 {
+		wr.WriteByte(flagAdaptation | flagPayload | counter) // adaptation + payload
+
+		// for 183 payload will be zero
+		adSize := PacketSize - 4 - 1 - byte(size)
+		wr.WriteByte(adSize)
+		wr.WriteBytes(make([]byte, adSize)...)
+
+		wr.WriteBytes(pes.Payload...)
+		pes.Payload = nil
+	} else {
+		wr.WriteByte(flagPayload | counter) // only payload
+
+		wr.WriteBytes(pes.Payload[:PacketSize-4]...)
+		pes.Payload = pes.Payload[PacketSize-4:]
+	}
+}
+
+func (m *Muxer) writeHeader(wr *bits.Writer, pid uint16) {
+	wr.WriteByte(SyncByte)
+
+	wr.WriteBit(0)          // Transport error indicator (TEI)
+	wr.WriteBit(1)          // Payload unit start indicator (PUSI)
+	wr.WriteBit(0)          // Transport priority
+	wr.WriteBits16(pid, 13) // PID
+
+	wr.WriteBits8(0, 2) // Transport scrambling control (TSC)
+	wr.WriteBit(0)      // Adaptation field
+	wr.WriteBit(1)      // Payload
+	wr.WriteBits8(0, 4) // Continuity counter
+}
+
+func (m *Muxer) writePSIHeader(wr *bits.Writer, tableID byte, size uint16) {
+	wr.WriteByte(0) // Pointer field
+
+	wr.WriteByte(tableID) // Table ID
+
+	wr.WriteBit(1)               // Section syntax indicator
+	wr.WriteBit(0)               // Private bit
+	wr.WriteBits8(0b11, 2)       // Reserved bits (all to 1)
+	wr.WriteBits8(0, 2)          // Section length unused bits (all to 0)
+	wr.WriteBits16(5+size+4, 10) // Section length (5 bytes below + content + 4 bytes CRC32)
+
+	wr.WriteUint16(1)      // Table ID extension
+	wr.WriteBits8(0b11, 2) // Reserved bits (all to 1)
+	wr.WriteBits8(0, 5)    // Version number
+	wr.WriteBit(1)         // Current/next indicator
+
+	wr.WriteByte(0) // Section number
+	wr.WriteByte(0) // Last section number
+}
+
+func (m *Muxer) WriteTail(wr *bits.Writer) {
+	size := PacketSize - wr.Len()%PacketSize
+	wr.WriteBytes(make([]byte, size)...)
+}
+
+func WriteTime(b []byte, t uint32) {
+	_ = b[4] // bounds
+	const onlyPTS = 0x20
+	b[0] = onlyPTS | byte(t>>(32-3)) | 1
+	b[1] = byte(t >> (24 - 2))
+	b[2] = byte(t>>(16-2)) | 1
+	b[3] = byte(t >> (8 - 1))
+	b[4] = byte(t<<1) | 1 // t>>(0-1)
+}
diff --git a/installs_on_host/go2rtc/pkg/mpegts/opus.go b/installs_on_host/go2rtc/pkg/mpegts/opus.go
new file mode 100644
index 0000000..d6077ea
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mpegts/opus.go
@@ -0,0 +1,66 @@
+package mpegts
+
+import (
+	"github.com/AlexxIT/go2rtc/pkg/bits"
+)
+
+// opusDT - each AU from FFmpeg has 5 OPUS packets. Each packet len = 960 in the 48000 clock.
+const opusDT = 960 * ClockRate / 48000
+
+// https://opus-codec.org/docs/
+var opusInfo = []byte{ // registration_descriptor
+	0x05,               // descriptor_tag
+	0x04,               // descriptor_length
+	'O', 'p', 'u', 's', // format_identifier
+}
+
+//goland:noinspection GoSnakeCaseUsage
+func CutOPUSPacket(b []byte) (packet []byte, left []byte) {
+	r := bits.NewReader(b)
+
+	size := opus_control_header(r)
+	if size == 0 {
+		return nil, nil
+	}
+
+	packet = r.ReadBytes(size)
+	left = r.Left()
+	return
+}
+
+//goland:noinspection GoSnakeCaseUsage
+func opus_control_header(r *bits.Reader) int {
+	control_header_prefix := r.ReadBits(11)
+	if control_header_prefix != 0x3FF {
+		return 0
+	}
+
+	start_trim_flag := r.ReadBit()
+	end_trim_flag := r.ReadBit()
+	control_extension_flag := r.ReadBit()
+	_ = r.ReadBits(2) // reserved
+
+	var payload_size int
+	for {
+		i := r.ReadByte()
+		payload_size += int(i)
+		if i < 255 {
+			break
+		}
+	}
+
+	if start_trim_flag != 0 {
+		_ = r.ReadBits(3)
+		_ = r.ReadBits(13)
+	}
+	if end_trim_flag != 0 {
+		_ = r.ReadBits(3)
+		_ = r.ReadBits(13)
+	}
+	if control_extension_flag != 0 {
+		control_extension_length := r.ReadByte()
+		_ = r.ReadBytes(int(control_extension_length)) // reserved
+	}
+
+	return payload_size
+}
diff --git a/installs_on_host/go2rtc/pkg/mpegts/producer.go b/installs_on_host/go2rtc/pkg/mpegts/producer.go
new file mode 100644
index 0000000..14417bf
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mpegts/producer.go
@@ -0,0 +1,177 @@
+package mpegts
+
+import (
+	"bytes"
+	"io"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/aac"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/h265"
+	"github.com/pion/rtp"
+)
+
+type Producer struct {
+	core.Connection
+	rd *core.ReadBuffer
+}
+
+func Open(rd io.Reader) (*Producer, error) {
+	prod := &Producer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "mpegts",
+			Transport:  rd,
+		},
+		rd: core.NewReadBuffer(rd),
+	}
+	if err := prod.probe(); err != nil {
+		return nil, err
+	}
+	return prod, nil
+}
+
+func (c *Producer) GetTrack(media *core.Media, codec *core.Codec) (*core.Receiver, error) {
+	receiver, _ := c.Connection.GetTrack(media, codec)
+	receiver.ID = StreamType(codec)
+	return receiver, nil
+}
+
+func (c *Producer) Start() error {
+	rd := NewDemuxer()
+
+	for {
+		pkt, err := rd.ReadPacket(c.rd)
+		if err != nil {
+			return err
+		}
+
+		c.Recv += len(pkt.Payload)
+
+		//log.Printf("[mpegts] size: %6d, muxer: %10d, pt: %2d", len(pkt.Payload), pkt.Timestamp, pkt.PayloadType)
+
+		for _, receiver := range c.Receivers {
+			if receiver.ID == pkt.PayloadType {
+				TimestampToRTP(pkt, receiver.Codec)
+				receiver.WriteRTP(pkt)
+				break
+			}
+		}
+	}
+}
+
+func (c *Producer) probe() error {
+	c.rd.BufferSize = core.ProbeSize
+	defer c.rd.Reset()
+
+	rd := NewDemuxer()
+
+	// Strategy:
+	// 1. Wait packet with metadata, init other packets for wait
+	// 2. Wait other packets
+	// 3. Stop after timeout
+	waitType := []byte{StreamTypeMetadata}
+	timeout := time.Now().Add(core.ProbeTimeout)
+
+	for len(waitType) != 0 && time.Now().Before(timeout) {
+		pkt, err := rd.ReadPacket(c.rd)
+		if err != nil {
+			return err
+		}
+
+		// check if we wait this type
+		if i := bytes.IndexByte(waitType, pkt.PayloadType); i < 0 {
+			continue
+		} else {
+			waitType = append(waitType[:i], waitType[i+1:]...)
+		}
+
+		switch pkt.PayloadType {
+		case StreamTypeMetadata:
+			for _, streamType := range pkt.Payload {
+				switch streamType {
+				case StreamTypeH264, StreamTypeH265, StreamTypeAAC, StreamTypePrivateOPUS, StreamTypePCMATapo:
+					waitType = append(waitType, streamType)
+				}
+			}
+
+		case StreamTypeH264:
+			codec := h264.AVCCToCodec(pkt.Payload)
+			media := &core.Media{
+				Kind:      core.KindVideo,
+				Direction: core.DirectionRecvonly,
+				Codecs:    []*core.Codec{codec},
+			}
+			c.Medias = append(c.Medias, media)
+
+		case StreamTypeH265:
+			codec := h265.AVCCToCodec(pkt.Payload)
+			media := &core.Media{
+				Kind:      core.KindVideo,
+				Direction: core.DirectionRecvonly,
+				Codecs:    []*core.Codec{codec},
+			}
+			c.Medias = append(c.Medias, media)
+
+		case StreamTypeAAC:
+			codec := aac.RTPToCodec(pkt.Payload)
+			media := &core.Media{
+				Kind:      core.KindAudio,
+				Direction: core.DirectionRecvonly,
+				Codecs:    []*core.Codec{codec},
+			}
+			c.Medias = append(c.Medias, media)
+
+		case StreamTypePrivateOPUS:
+			codec := &core.Codec{
+				Name:      core.CodecOpus,
+				ClockRate: 48000,
+				Channels:  2,
+			}
+			media := &core.Media{
+				Kind:      core.KindAudio,
+				Direction: core.DirectionRecvonly,
+				Codecs:    []*core.Codec{codec},
+			}
+			c.Medias = append(c.Medias, media)
+
+		case StreamTypePCMATapo:
+			codec := &core.Codec{
+				Name:      core.CodecPCMA,
+				ClockRate: 8000,
+			}
+			media := &core.Media{
+				Kind:      core.KindAudio,
+				Direction: core.DirectionRecvonly,
+				Codecs:    []*core.Codec{codec},
+			}
+			c.Medias = append(c.Medias, media)
+		}
+	}
+
+	return nil
+}
+
+func StreamType(codec *core.Codec) uint8 {
+	switch codec.Name {
+	case core.CodecH264:
+		return StreamTypeH264
+	case core.CodecH265:
+		return StreamTypeH265
+	case core.CodecAAC:
+		return StreamTypeAAC
+	case core.CodecPCMA:
+		return StreamTypePCMATapo
+	case core.CodecOpus:
+		return StreamTypePrivateOPUS
+	}
+	return 0
+}
+
+func TimestampToRTP(rtp *rtp.Packet, codec *core.Codec) {
+	if codec.ClockRate == ClockRate {
+		return
+	}
+	rtp.Timestamp = uint32(float64(rtp.Timestamp) * float64(codec.ClockRate) / ClockRate)
+}
diff --git a/installs_on_host/go2rtc/pkg/mpjpeg/multipart.go b/installs_on_host/go2rtc/pkg/mpjpeg/multipart.go
new file mode 100644
index 0000000..ca8924e
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mpjpeg/multipart.go
@@ -0,0 +1,60 @@
+package mpjpeg
+
+import (
+	"bufio"
+	"errors"
+	"io"
+	"net/http"
+	"net/textproto"
+	"strconv"
+	"strings"
+)
+
+func Next(rd *bufio.Reader) (http.Header, []byte, error) {
+	for {
+		// search next boundary and skip empty lines
+		s, err := rd.ReadString('\n')
+		if err != nil {
+			return nil, nil, err
+		}
+
+		if s == "\r\n" {
+			continue
+		}
+
+		if !strings.HasPrefix(s, "--") {
+			return nil, nil, errors.New("multipart: wrong boundary: " + s)
+		}
+
+		// Foscam G2 has a awful implementation of MJPEG
+		// https://github.com/AlexxIT/go2rtc/issues/1258
+		if b, _ := rd.Peek(2); string(b) == "--" {
+			continue
+		}
+
+		break
+	}
+
+	tp := textproto.NewReader(rd)
+	header, err := tp.ReadMIMEHeader()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	s := header.Get("Content-Length")
+	if s == "" {
+		return nil, nil, errors.New("multipart: no content length")
+	}
+
+	size, err := strconv.Atoi(s)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	buf := make([]byte, size)
+	if _, err = io.ReadFull(rd, buf); err != nil {
+		return nil, nil, err
+	}
+
+	return http.Header(header), buf, nil
+}
diff --git a/installs_on_host/go2rtc/pkg/mpjpeg/producer.go b/installs_on_host/go2rtc/pkg/mpjpeg/producer.go
new file mode 100644
index 0000000..a8d5e16
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mpjpeg/producer.go
@@ -0,0 +1,65 @@
+package mpjpeg
+
+import (
+	"bufio"
+	"errors"
+	"io"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+)
+
+type Producer struct {
+	core.Connection
+	rd *bufio.Reader
+}
+
+func Open(rd io.Reader) (*Producer, error) {
+	return &Producer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "mpjpeg", // Multipart JPEG
+			Transport:  rd,
+			Medias: []*core.Media{
+				{
+					Kind:      core.KindVideo,
+					Direction: core.DirectionRecvonly,
+					Codecs: []*core.Codec{
+						{
+							Name:        core.CodecJPEG,
+							ClockRate:   90000,
+							PayloadType: core.PayloadTypeRAW,
+						},
+					},
+				},
+			},
+		},
+	}, nil
+}
+
+func (c *Producer) Start() error {
+	if len(c.Receivers) != 1 {
+		return errors.New("mjpeg: no receivers")
+	}
+
+	rd := bufio.NewReader(c.Transport.(io.Reader))
+
+	mjpeg := c.Receivers[0]
+
+	for {
+		_, body, err := Next(rd)
+		if err != nil {
+			return err
+		}
+
+		c.Recv += len(body)
+
+		if mjpeg != nil {
+			packet := &rtp.Packet{
+				Header:  rtp.Header{Timestamp: core.Now90000()},
+				Payload: body,
+			}
+			mjpeg.WriteRTP(packet)
+		}
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/mqtt/client.go b/installs_on_host/go2rtc/pkg/mqtt/client.go
new file mode 100644
index 0000000..8874d08
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mqtt/client.go
@@ -0,0 +1,112 @@
+package mqtt
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"io"
+	"net"
+	"time"
+)
+
+const Timeout = time.Second * 5
+
+type Client struct {
+	conn net.Conn
+	mid  uint16
+}
+
+func NewClient(conn net.Conn) *Client {
+	return &Client{conn: conn, mid: 2}
+}
+
+func (c *Client) Connect(clientID, username, password string) (err error) {
+	if err = c.conn.SetDeadline(time.Now().Add(Timeout)); err != nil {
+		return
+	}
+
+	msg := NewConnect(clientID, username, password)
+	if _, err = c.conn.Write(msg.b); err != nil {
+		return
+	}
+
+	b := make([]byte, 4)
+	if _, err = io.ReadFull(c.conn, b); err != nil {
+		return
+	}
+
+	if !bytes.Equal(b, []byte{CONNACK, 2, 0, 0}) {
+		return errors.New("wrong login")
+	}
+
+	return
+}
+
+func (c *Client) Subscribe(topic string) (err error) {
+	if err = c.conn.SetDeadline(time.Now().Add(Timeout)); err != nil {
+		return
+	}
+
+	c.mid++
+	msg := NewSubscribe(c.mid, topic, 1)
+	_, err = c.conn.Write(msg.b)
+	return
+}
+
+func (c *Client) Publish(topic string, payload []byte) (err error) {
+	if err = c.conn.SetDeadline(time.Now().Add(Timeout)); err != nil {
+		return
+	}
+
+	c.mid++
+	msg := NewPublishQOS1(c.mid, topic, payload)
+	_, err = c.conn.Write(msg.b)
+	return
+}
+
+func (c *Client) Read() (string, []byte, error) {
+	if err := c.conn.SetDeadline(time.Now().Add(Timeout)); err != nil {
+		return "", nil, err
+	}
+
+	b := make([]byte, 1)
+	if _, err := io.ReadFull(c.conn, b); err != nil {
+		return "", nil, err
+	}
+
+	size, err := ReadLen(c.conn)
+	if err != nil {
+		return "", nil, err
+	}
+
+	b0 := b[0]
+	b = make([]byte, size)
+	if _, err = io.ReadFull(c.conn, b); err != nil {
+		return "", nil, err
+	}
+
+	if b0&0xF0 != PUBLISH {
+		return "", nil, nil
+	}
+
+	i := binary.BigEndian.Uint16(b)
+	if uint32(i) > size {
+		return "", nil, errors.New("wrong topic size")
+	}
+
+	b = b[2:]
+
+	if qos := (b0 >> 1) & 0b11; qos == 0 {
+		return string(b[:i]), b[i:], nil
+	}
+
+	// response with packet ID
+	_, _ = c.conn.Write([]byte{PUBACK, 2, b[i], b[i+1]})
+
+	return string(b[2:i]), b[i+2:], nil
+}
+
+func (c *Client) Close() error {
+	// TODO: Teardown
+	return c.conn.Close()
+}
diff --git a/installs_on_host/go2rtc/pkg/mqtt/message.go b/installs_on_host/go2rtc/pkg/mqtt/message.go
new file mode 100644
index 0000000..e3d3421
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/mqtt/message.go
@@ -0,0 +1,122 @@
+package mqtt
+
+import (
+	"io"
+)
+
+type Message struct {
+	b []byte
+}
+
+// https://docs.oasis-open.org/mqtt/mqtt/v5.0/mqtt-v5.0.html
+const (
+	CONNECT   = 0x10
+	CONNACK   = 0x20
+	PUBLISH   = 0x30
+	PUBACK    = 0x40
+	SUBSCRIBE = 0x82
+	SUBACK    = 0x90
+	QOS1      = 0x02
+)
+
+func (m *Message) WriteByte(b byte) {
+	m.b = append(m.b, b)
+}
+
+func (m *Message) WriteBytes(b []byte) {
+	m.b = append(m.b, b...)
+}
+
+func (m *Message) WriteUint16(i uint16) {
+	m.b = append(m.b, byte(i>>8), byte(i))
+}
+
+func (m *Message) WriteLen(i int) {
+	for i > 0 {
+		b := byte(i % 128)
+		if i /= 128; i > 0 {
+			b |= 0x80
+		}
+		m.WriteByte(b)
+	}
+}
+
+func (m *Message) WriteString(s string) {
+	m.WriteUint16(uint16(len(s)))
+	m.b = append(m.b, s...)
+}
+
+func (m *Message) Bytes() []byte {
+	return m.b
+}
+
+const (
+	flagCleanStart = 0x02
+	flagUsername   = 0x80
+	flagPassword   = 0x40
+)
+
+func NewConnect(clientID, username, password string) *Message {
+	m := &Message{}
+	m.WriteByte(CONNECT)
+	m.WriteLen(16 + len(clientID) + len(username) + len(password))
+
+	m.WriteString("MQTT")
+	m.WriteByte(4) // MQTT version
+	m.WriteByte(flagCleanStart | flagUsername | flagPassword)
+	m.WriteUint16(30) // keepalive
+
+	m.WriteString(clientID)
+	m.WriteString(username)
+	m.WriteString(password)
+	return m
+}
+
+func NewSubscribe(mid uint16, topic string, qos byte) *Message {
+	m := &Message{}
+	m.WriteByte(SUBSCRIBE)
+	m.WriteLen(5 + len(topic))
+
+	m.WriteUint16(mid)
+	m.WriteString(topic)
+	m.WriteByte(qos)
+	return m
+}
+
+func NewPublish(topic string, payload []byte) *Message {
+	m := &Message{}
+	m.WriteByte(PUBLISH)
+	m.WriteLen(2 + len(topic) + len(payload))
+
+	m.WriteString(topic)
+	m.WriteBytes(payload)
+	return m
+}
+
+func NewPublishQOS1(mid uint16, topic string, payload []byte) *Message {
+	m := &Message{}
+	m.WriteByte(PUBLISH | QOS1)
+	m.WriteLen(4 + len(topic) + len(payload))
+
+	m.WriteString(topic)
+	m.WriteUint16(mid)
+	m.WriteBytes(payload)
+	return m
+}
+
+func ReadLen(r io.Reader) (uint32, error) {
+	var i uint32
+	var shift byte
+
+	b := []byte{0x80}
+	for b[0]&0x80 != 0 {
+		if _, err := r.Read(b); err != nil {
+			return 0, err
+		}
+
+		i += uint32(b[0]&0x7F) << shift
+		shift += 7
+	}
+
+	return i, nil
+}
diff --git a/installs_on_host/go2rtc/pkg/multitrans/client.go b/installs_on_host/go2rtc/pkg/multitrans/client.go
new file mode 100644
index 0000000..d71269c
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/multitrans/client.go
@@ -0,0 +1,203 @@
+package multitrans
+
+import (
+	"bufio"
+	"bytes"
+	"errors"
+	"fmt"
+	"net"
+	"net/http"
+	"net/url"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/tcp"
+	"github.com/google/uuid"
+	"github.com/pion/rtp"
+)
+
+type Client struct {
+	core.Connection
+	conn   net.Conn
+	rd     *bufio.Reader
+	closed core.Waiter
+}
+
+func Dial(rawURL string) (core.Producer, error) {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	if u.Port() == "" {
+		u.Host += ":554"
+	}
+
+	conn, err := net.DialTimeout("tcp", u.Host, core.ConnDialTimeout)
+	if err != nil {
+		return nil, err
+	}
+
+	c := &Client{
+		conn: conn,
+		rd:   bufio.NewReader(conn),
+	}
+
+	if err = c.handshake(u); err != nil {
+		_ = conn.Close()
+		return nil, err
+	}
+
+	c.Connection = core.Connection{
+		ID:         core.NewID(),
+		FormatName: "multitrans",
+		Protocol:   "rtsp",
+		RemoteAddr: conn.RemoteAddr().String(),
+		Source:     rawURL,
+		Medias: []*core.Media{
+			{
+				Kind:      core.KindAudio,
+				Direction: core.DirectionSendonly,
+				Codecs:    []*core.Codec{{Name: core.CodecPCMA, ClockRate: 8000, PayloadType: 8}},
+			},
+		},
+		Transport: conn,
+	}
+
+	return c, nil
+}
+
+func (c *Client) AddTrack(media *core.Media, _ *core.Codec, track *core.Receiver) error {
+	sender := core.NewSender(media, track.Codec)
+	sender.Handler = func(packet *rtp.Packet) {
+		clone := rtp.Packet{
+			Header: rtp.Header{
+				Version:        2,
+				Marker:         packet.Marker,
+				PayloadType:    8,
+				SequenceNumber: packet.SequenceNumber,
+				Timestamp:      packet.Timestamp,
+				SSRC:           packet.SSRC,
+			},
+			Payload: packet.Payload,
+		}
+
+		// Encapsulate in RTSP Interleaved Frame (Channel 1)
+		// $ + Channel(1 byte) + Length(2 bytes) + Packet
+		size := 12 + len(clone.Payload)
+		b := make([]byte, 4+size)
+		b[0] = '$'
+		b[1] = 1 // Channel 1 for audio
+		b[2] = byte(size >> 8)
+		b[3] = byte(size)
+		if _, err := clone.MarshalTo(b[4:]); err != nil {
+			return
+		}
+		if _, err := c.conn.Write(b); err != nil {
+			return
+		}
+	}
+	sender.HandleRTP(track)
+	c.Senders = append(c.Senders, sender)
+	return nil
+}
+
+func (c *Client) handshake(u *url.URL) error {
+	// Step 1: Get Challenge
+	uid := uuid.New().String()
+
+	uri := fmt.Sprintf("rtsp://%s/multitrans", u.Host)
+	data := fmt.Sprintf("MULTITRANS %s RTSP/1.0\r\nCSeq: 0\r\nX-Client-UUID: %s\r\n\r\n", uri, uid)
+
+	if _, err := c.conn.Write([]byte(data)); err != nil {
+		return err
+	}
+
+	res, err := tcp.ReadResponse(c.rd)
+	if err != nil {
+		return err
+	}
+
+	if res.StatusCode != http.StatusUnauthorized {
+		return errors.New("multitrans: expected 401, got " + res.Status)
+	}
+
+	auth := res.Header.Get("WWW-Authenticate")
+	realm := tcp.Between(auth, `realm="`, `"`)
+	nonce := tcp.Between(auth, `nonce="`, `"`)
+
+	// Step 2: Send Auth
+	user := u.User.Username()
+	pass, _ := u.User.Password()
+
+	ha1 := tcp.HexMD5(user, realm, pass)
+	ha2 := tcp.HexMD5("MULTITRANS", uri)
+	response := tcp.HexMD5(ha1, nonce, ha2)
+
+	authHeader := fmt.Sprintf(`Digest username="%s", realm="%s", nonce="%s", uri="%s", response="%s"`,
+		user, realm, nonce, uri, response)
+
+	data = fmt.Sprintf("MULTITRANS %s RTSP/1.0\r\nCSeq: 1\r\nAuthorization: %s\r\nX-Client-UUID: %s\r\n\r\n",
+		uri, authHeader, uid)
+
+	if _, err = c.conn.Write([]byte(data)); err != nil {
+		return err
+	}
+
+	res, err = tcp.ReadResponse(c.rd)
+	if err != nil {
+		return err
+	}
+
+	if res.StatusCode != http.StatusOK {
+		return errors.New("multitrans: auth failed: " + res.Status)
+	}
+
+	// Session: 7116520596809429228
+	session := res.Header.Get("Session")
+	if session == "" {
+		return errors.New("multitrans: no session")
+	}
+
+	return c.openTalkChannel(uri, session)
+}
+
+func (c *Client) openTalkChannel(uri, session string) error {
+	payload := `{"type":"request","seq":0,"params":{"method":"get","talk":{"mode":"full_duplex"}}}`
+
+	data := fmt.Sprintf("MULTITRANS %s RTSP/1.0\r\nCSeq: 2\r\nSession: %s\r\nContent-Type: application/json\r\nContent-Length: %d\r\n\r\n%s",
+		uri, session, len(payload), payload)
+
+	if _, err := c.conn.Write([]byte(data)); err != nil {
+		return err
+	}
+
+	res, err := tcp.ReadResponse(c.rd)
+	if err != nil {
+		return err
+	}
+
+	if res.StatusCode != http.StatusOK {
+		return errors.New("multitrans: talkback failed: " + res.Status)
+	}
+
+	// Python checks for "error_code":0 in body.
+	if !bytes.Contains(res.Body, []byte(`"error_code":0`)) {
+		return fmt.Errorf("multitrans: talkback error: %s", string(res.Body))
+	}
+
+	return nil
+}
+
+func (c *Client) GetTrack(media *core.Media, codec *core.Codec) (*core.Receiver, error) {
+	return nil, core.ErrCantGetTrack
+}
+
+func (c *Client) Start() error {
+	_ = c.closed.Wait()
+	return nil
+}
+
+func (c *Client) Stop() error {
+	c.closed.Done(nil)
+	return c.Connection.Stop()
+}
diff --git a/installs_on_host/go2rtc/pkg/nest/api.go b/installs_on_host/go2rtc/pkg/nest/api.go
new file mode 100644
index 0000000..4e9e4db
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/nest/api.go
@@ -0,0 +1,486 @@
+package nest
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+	"time"
+)
+
+type API struct {
+	Token     string
+	ExpiresAt time.Time
+
+	StreamProjectID string
+	StreamDeviceID  string
+	StreamExpiresAt time.Time
+
+	// WebRTC
+	StreamSessionID string
+
+	// RTSP
+	StreamToken          string
+	StreamExtensionToken string
+
+	extendTimer *time.Timer
+}
+
+type Auth struct {
+	AccessToken string
+}
+
+type DeviceInfo struct {
+	Name      string
+	DeviceID  string
+	Protocols []string
+}
+
+var cache = map[string]*API{}
+var cacheMu sync.Mutex
+
+func NewAPI(clientID, clientSecret, refreshToken string) (*API, error) {
+	cacheMu.Lock()
+	defer cacheMu.Unlock()
+
+	key := clientID + ":" + clientSecret + ":" + refreshToken
+	now := time.Now()
+
+	if api := cache[key]; api != nil && now.Before(api.ExpiresAt) {
+		return api, nil
+	}
+
+	data := url.Values{
+		"grant_type":    []string{"refresh_token"},
+		"client_id":     []string{clientID},
+		"client_secret": []string{clientSecret},
+		"refresh_token": []string{refreshToken},
+	}
+
+	client := &http.Client{Timeout: time.Second * 5000}
+	res, err := client.PostForm("https://www.googleapis.com/oauth2/v4/token", data)
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != 200 {
+		return nil, errors.New("nest: wrong status: " + res.Status)
+	}
+
+	var resv struct {
+		AccessToken string        `json:"access_token"`
+		ExpiresIn   time.Duration `json:"expires_in"`
+		Scope       string        `json:"scope"`
+		TokenType   string        `json:"token_type"`
+	}
+
+	if err = json.NewDecoder(res.Body).Decode(&resv); err != nil {
+		return nil, err
+	}
+
+	api := &API{
+		Token:     resv.AccessToken,
+		ExpiresAt: now.Add(resv.ExpiresIn * time.Second),
+	}
+
+	cache[key] = api
+
+	return api, nil
+}
+
+func (a *API) GetDevices(projectID string) ([]DeviceInfo, error) {
+	uri := "https://smartdevicemanagement.googleapis.com/v1/enterprises/" + projectID + "/devices"
+	req, err := http.NewRequest("GET", uri, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Set("Authorization", "Bearer "+a.Token)
+
+	client := &http.Client{Timeout: time.Second * 5000}
+	res, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != 200 {
+		return nil, errors.New("nest: wrong status: " + res.Status)
+	}
+
+	var resv struct {
+		Devices []Device
+	}
+
+	if err = json.NewDecoder(res.Body).Decode(&resv); err != nil {
+		return nil, err
+	}
+
+	devices := make([]DeviceInfo, 0, len(resv.Devices))
+
+	for _, device := range resv.Devices {
+		// only RTSP and WEB_RTC available (both supported)
+		if len(device.Traits.SdmDevicesTraitsCameraLiveStream.SupportedProtocols) == 0 {
+			continue
+		}
+
+		i := strings.LastIndexByte(device.Name, '/')
+		if i <= 0 {
+			continue
+		}
+
+		name := device.Traits.SdmDevicesTraitsInfo.CustomName
+		// Devices configured through the Nest app use the container/room name as opposed to the customName trait
+		if name == "" && len(device.ParentRelations) > 0 {
+			name = device.ParentRelations[0].DisplayName
+		}
+
+		devices = append(devices, DeviceInfo{
+			Name:      name,
+			DeviceID:  device.Name[i+1:],
+			Protocols: device.Traits.SdmDevicesTraitsCameraLiveStream.SupportedProtocols,
+		})
+	}
+
+	return devices, nil
+}
+
+func (a *API) ExchangeSDP(projectID, deviceID, offer string) (string, error) {
+	var reqv struct {
+		Command string `json:"command"`
+		Params  struct {
+			Offer string `json:"offerSdp"`
+		} `json:"params"`
+	}
+	reqv.Command = "sdm.devices.commands.CameraLiveStream.GenerateWebRtcStream"
+	reqv.Params.Offer = offer
+
+	b, err := json.Marshal(reqv)
+	if err != nil {
+		return "", err
+	}
+
+	uri := "https://smartdevicemanagement.googleapis.com/v1/enterprises/" +
+		projectID + "/devices/" + deviceID + ":executeCommand"
+
+	maxRetries := 3
+	retryDelay := time.Second * 30
+
+	for attempt := 0; attempt < maxRetries; attempt++ {
+		req, err := http.NewRequest("POST", uri, bytes.NewReader(b))
+		if err != nil {
+			return "", err
+		}
+
+		req.Header.Set("Authorization", "Bearer "+a.Token)
+
+		client := &http.Client{Timeout: time.Second * 5000}
+		res, err := client.Do(req)
+		if err != nil {
+			return "", err
+		}
+
+		// Handle 409 (Conflict), 429 (Too Many Requests), and 401 (Unauthorized)
+		if res.StatusCode == 409 || res.StatusCode == 429 || res.StatusCode == 401 {
+			res.Body.Close()
+			if attempt < maxRetries-1 {
+				// Get new token from Google
+				if err := a.refreshToken(); err != nil {
+					return "", err
+				}
+				time.Sleep(retryDelay)
+				retryDelay *= 2 // exponential backoff
+				continue
+			}
+		}
+
+		defer res.Body.Close()
+
+		if res.StatusCode != 200 {
+			return "", errors.New("nest: wrong status: " + res.Status)
+		}
+
+		var resv struct {
+			Results struct {
+				Answer         string    `json:"answerSdp"`
+				ExpiresAt      time.Time `json:"expiresAt"`
+				MediaSessionID string    `json:"mediaSessionId"`
+			} `json:"results"`
+		}
+
+		if err = json.NewDecoder(res.Body).Decode(&resv); err != nil {
+			return "", err
+		}
+
+		a.StreamProjectID = projectID
+		a.StreamDeviceID = deviceID
+		a.StreamSessionID = resv.Results.MediaSessionID
+		a.StreamExpiresAt = resv.Results.ExpiresAt
+
+		return resv.Results.Answer, nil
+	}
+
+	return "", errors.New("nest: max retries exceeded")
+}
+
+func (a *API) refreshToken() error {
+	// Get the cached API with matching token to get credentials
+	var refreshKey string
+	cacheMu.Lock()
+	for key, api := range cache {
+		if api.Token == a.Token {
+			refreshKey = key
+			break
+		}
+	}
+	cacheMu.Unlock()
+
+	if refreshKey == "" {
+		return errors.New("nest: unable to find cached credentials")
+	}
+
+	// Parse credentials from cache key
+	parts := strings.Split(refreshKey, ":")
+	if len(parts) != 3 {
+		return errors.New("nest: invalid cache key format")
+	}
+	clientID, clientSecret, refreshToken := parts[0], parts[1], parts[2]
+
+	// Get new API instance which will refresh the token
+	newAPI, err := NewAPI(clientID, clientSecret, refreshToken)
+	if err != nil {
+		return err
+	}
+
+	// Update current API with new token
+	a.Token = newAPI.Token
+	a.ExpiresAt = newAPI.ExpiresAt
+	return nil
+}
+
+func (a *API) ExtendStream() error {
+	var reqv struct {
+		Command string `json:"command"`
+		Params  struct {
+			MediaSessionID       string `json:"mediaSessionId,omitempty"`
+			StreamExtensionToken string `json:"streamExtensionToken,omitempty"`
+		} `json:"params"`
+	}
+
+	if a.StreamToken != "" {
+		// RTSP
+		reqv.Command = "sdm.devices.commands.CameraLiveStream.ExtendRtspStream"
+		reqv.Params.StreamExtensionToken = a.StreamExtensionToken
+	} else {
+		// WebRTC
+		reqv.Command = "sdm.devices.commands.CameraLiveStream.ExtendWebRtcStream"
+		reqv.Params.MediaSessionID = a.StreamSessionID
+	}
+
+	b, err := json.Marshal(reqv)
+	if err != nil {
+		return err
+	}
+
+	uri := "https://smartdevicemanagement.googleapis.com/v1/enterprises/" +
+		a.StreamProjectID + "/devices/" + a.StreamDeviceID + ":executeCommand"
+	req, err := http.NewRequest("POST", uri, bytes.NewReader(b))
+	if err != nil {
+		return err
+	}
+
+	req.Header.Set("Authorization", "Bearer "+a.Token)
+
+	client := &http.Client{Timeout: time.Second * 5000}
+	res, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != 200 {
+		return errors.New("nest: wrong status: " + res.Status)
+	}
+
+	var resv struct {
+		Results struct {
+			ExpiresAt            time.Time `json:"expiresAt"`
+			MediaSessionID       string    `json:"mediaSessionId"`
+			StreamExtensionToken string    `json:"streamExtensionToken"`
+			StreamToken          string    `json:"streamToken"`
+		} `json:"results"`
+	}
+
+	if err = json.NewDecoder(res.Body).Decode(&resv); err != nil {
+		return err
+	}
+
+	a.StreamSessionID = resv.Results.MediaSessionID
+	a.StreamExpiresAt = resv.Results.ExpiresAt
+	a.StreamExtensionToken = resv.Results.StreamExtensionToken
+	a.StreamToken = resv.Results.StreamToken
+
+	return nil
+}
+
+func (a *API) GenerateRtspStream(projectID, deviceID string) (string, error) {
+	var reqv struct {
+		Command string   `json:"command"`
+		Params  struct{} `json:"params"`
+	}
+	reqv.Command = "sdm.devices.commands.CameraLiveStream.GenerateRtspStream"
+
+	b, err := json.Marshal(reqv)
+	if err != nil {
+		return "", err
+	}
+
+	uri := "https://smartdevicemanagement.googleapis.com/v1/enterprises/" +
+		projectID + "/devices/" + deviceID + ":executeCommand"
+	req, err := http.NewRequest("POST", uri, bytes.NewReader(b))
+	if err != nil {
+		return "", err
+	}
+
+	req.Header.Set("Authorization", "Bearer "+a.Token)
+
+	client := &http.Client{Timeout: time.Second * 5000}
+	res, err := client.Do(req)
+	if err != nil {
+		return "", err
+	}
+
+	if res.StatusCode != 200 {
+		return "", errors.New("nest: wrong status: " + res.Status)
+	}
+
+	var resv struct {
+		Results struct {
+			StreamURLs           map[string]string `json:"streamUrls"`
+			StreamExtensionToken string            `json:"streamExtensionToken"`
+			StreamToken          string            `json:"streamToken"`
+			ExpiresAt            time.Time         `json:"expiresAt"`
+		} `json:"results"`
+	}
+
+	if err = json.NewDecoder(res.Body).Decode(&resv); err != nil {
+		return "", err
+	}
+
+	if _, ok := resv.Results.StreamURLs["rtspUrl"]; !ok {
+		return "", errors.New("nest: failed to generate rtsp url")
+	}
+
+	a.StreamProjectID = projectID
+	a.StreamDeviceID = deviceID
+	a.StreamToken = resv.Results.StreamToken
+	a.StreamExtensionToken = resv.Results.StreamExtensionToken
+	a.StreamExpiresAt = resv.Results.ExpiresAt
+
+	return resv.Results.StreamURLs["rtspUrl"], nil
+}
+
+func (a *API) StopRTSPStream() error {
+	if a.StreamProjectID == "" || a.StreamDeviceID == "" {
+		return errors.New("nest: tried to stop rtsp stream without a project or device ID")
+	}
+
+	var reqv struct {
+		Command string `json:"command"`
+		Params  struct {
+			StreamExtensionToken string `json:"streamExtensionToken"`
+		} `json:"params"`
+	}
+	reqv.Command = "sdm.devices.commands.CameraLiveStream.StopRtspStream"
+	reqv.Params.StreamExtensionToken = a.StreamExtensionToken
+
+	b, err := json.Marshal(reqv)
+	if err != nil {
+		return err
+	}
+
+	uri := "https://smartdevicemanagement.googleapis.com/v1/enterprises/" +
+		a.StreamProjectID + "/devices/" + a.StreamDeviceID + ":executeCommand"
+	req, err := http.NewRequest("POST", uri, bytes.NewReader(b))
+	if err != nil {
+		return err
+	}
+
+	req.Header.Set("Authorization", "Bearer "+a.Token)
+
+	client := &http.Client{Timeout: time.Second * 5000}
+	res, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+
+	if res.StatusCode != 200 {
+		return errors.New("nest: wrong status: " + res.Status)
+	}
+
+	a.StreamProjectID = ""
+	a.StreamDeviceID = ""
+	a.StreamExtensionToken = ""
+	a.StreamToken = ""
+
+	return nil
+}
+
+type Device struct {
+	Name string `json:"name"`
+	Type string `json:"type"`
+	//Assignee string `json:"assignee"`
+	Traits struct {
+		SdmDevicesTraitsInfo struct {
+			CustomName string `json:"customName"`
+		} `json:"sdm.devices.traits.Info"`
+		SdmDevicesTraitsCameraLiveStream struct {
+			VideoCodecs        []string `json:"videoCodecs"`
+			AudioCodecs        []string `json:"audioCodecs"`
+			SupportedProtocols []string `json:"supportedProtocols"`
+		} `json:"sdm.devices.traits.CameraLiveStream"`
+		//SdmDevicesTraitsCameraImage struct {
+		//	MaxImageResolution struct {
+		//		Width  int `json:"width"`
+		//		Height int `json:"height"`
+		//	} `json:"maxImageResolution"`
+		//} `json:"sdm.devices.traits.CameraImage"`
+		//SdmDevicesTraitsCameraPerson struct {
+		//} `json:"sdm.devices.traits.CameraPerson"`
+		//SdmDevicesTraitsCameraMotion struct {
+		//} `json:"sdm.devices.traits.CameraMotion"`
+		//SdmDevicesTraitsDoorbellChime struct {
+		//} `json:"sdm.devices.traits.DoorbellChime"`
+		//SdmDevicesTraitsCameraClipPreview struct {
+		//} `json:"sdm.devices.traits.CameraClipPreview"`
+	} `json:"traits"`
+	ParentRelations []struct {
+		Parent      string `json:"parent"`
+		DisplayName string `json:"displayName"`
+	} `json:"parentRelations"`
+}
+
+func (a *API) StartExtendStreamTimer() {
+	if a.extendTimer != nil {
+		return
+	}
+
+	a.extendTimer = time.NewTimer(time.Until(a.StreamExpiresAt) - time.Minute)
+	go func() {
+		<-a.extendTimer.C
+		if err := a.ExtendStream(); err != nil {
+			return
+		}
+	}()
+}
+
+func (a *API) StopExtendStreamTimer() {
+	if a.extendTimer != nil {
+		a.extendTimer.Stop()
+		a.extendTimer = nil
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/nest/client.go b/installs_on_host/go2rtc/pkg/nest/client.go
new file mode 100644
index 0000000..6a57091
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/nest/client.go
@@ -0,0 +1,197 @@
+package nest
+
+import (
+	"errors"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/rtsp"
+	"github.com/AlexxIT/go2rtc/pkg/webrtc"
+	pion "github.com/pion/webrtc/v4"
+)
+
+type WebRTCClient struct {
+	conn *webrtc.Conn
+	api  *API
+}
+
+type RTSPClient struct {
+	conn *rtsp.Conn
+	api  *API
+}
+
+func Dial(rawURL string) (core.Producer, error) {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	query := u.Query()
+	cliendID := query.Get("client_id")
+	cliendSecret := query.Get("client_secret")
+	refreshToken := query.Get("refresh_token")
+	projectID := query.Get("project_id")
+	deviceID := query.Get("device_id")
+
+	if cliendID == "" || cliendSecret == "" || refreshToken == "" || projectID == "" || deviceID == "" {
+		return nil, errors.New("nest: wrong query")
+	}
+
+	maxRetries := 3
+	retryDelay := time.Second * 30
+
+	var nestAPI *API
+	var lastErr error
+
+	for attempt := 0; attempt < maxRetries; attempt++ {
+		nestAPI, err = NewAPI(cliendID, cliendSecret, refreshToken)
+		if err == nil {
+			break
+		}
+		lastErr = err
+		if attempt < maxRetries-1 {
+			time.Sleep(retryDelay)
+			retryDelay *= 2 // exponential backoff
+		}
+	}
+
+	if nestAPI == nil {
+		return nil, lastErr
+	}
+
+	protocols := strings.Split(query.Get("protocols"), ",")
+	if len(protocols) > 0 && protocols[0] == "RTSP" {
+		return rtspConn(nestAPI, rawURL, projectID, deviceID)
+	}
+
+	// Default to WEB_RTC for backwards compataiility
+	return rtcConn(nestAPI, rawURL, projectID, deviceID)
+}
+
+func (c *WebRTCClient) GetMedias() []*core.Media {
+	return c.conn.GetMedias()
+}
+
+func (c *WebRTCClient) GetTrack(media *core.Media, codec *core.Codec) (*core.Receiver, error) {
+	return c.conn.GetTrack(media, codec)
+}
+
+func (c *WebRTCClient) AddTrack(media *core.Media, codec *core.Codec, track *core.Receiver) error {
+	return c.conn.AddTrack(media, codec, track)
+}
+
+func (c *WebRTCClient) Start() error {
+	c.api.StartExtendStreamTimer()
+	return c.conn.Start()
+}
+
+func (c *WebRTCClient) Stop() error {
+	c.api.StopExtendStreamTimer()
+	return c.conn.Stop()
+}
+
+func (c *WebRTCClient) MarshalJSON() ([]byte, error) {
+	return c.conn.MarshalJSON()
+}
+
+func rtcConn(nestAPI *API, rawURL, projectID, deviceID string) (*WebRTCClient, error) {
+	maxRetries := 3
+	retryDelay := time.Second * 30
+	var lastErr error
+
+	for attempt := 0; attempt < maxRetries; attempt++ {
+		rtcAPI, err := webrtc.NewAPI()
+		if err != nil {
+			return nil, err
+		}
+
+		conf := pion.Configuration{}
+		pc, err := rtcAPI.NewPeerConnection(conf)
+		if err != nil {
+			return nil, err
+		}
+
+		conn := webrtc.NewConn(pc)
+		conn.FormatName = "nest/webrtc"
+		conn.Mode = core.ModeActiveProducer
+		conn.Protocol = "http"
+		conn.URL = rawURL
+
+		// https://developers.google.com/nest/device-access/traits/device/camera-live-stream#generatewebrtcstream-request-fields
+		medias := []*core.Media{
+			{Kind: core.KindAudio, Direction: core.DirectionRecvonly},
+			{Kind: core.KindVideo, Direction: core.DirectionRecvonly},
+			{Kind: "app"}, // important for Nest
+		}
+
+		// 3. Create offer with candidates
+		offer, err := conn.CreateCompleteOffer(medias)
+		if err != nil {
+			return nil, err
+		}
+
+		// 4. Exchange SDP via Hass
+		answer, err := nestAPI.ExchangeSDP(projectID, deviceID, offer)
+		if err != nil {
+			lastErr = err
+			if attempt < maxRetries-1 {
+				time.Sleep(retryDelay)
+				retryDelay *= 2
+				continue
+			}
+			return nil, err
+		}
+
+		// 5. Set answer with remote medias
+		if err = conn.SetAnswer(answer); err != nil {
+			return nil, err
+		}
+
+		return &WebRTCClient{conn: conn, api: nestAPI}, nil
+	}
+
+	return nil, lastErr
+}
+
+func rtspConn(nestAPI *API, rawURL, projectID, deviceID string) (*RTSPClient, error) {
+	rtspURL, err := nestAPI.GenerateRtspStream(projectID, deviceID)
+	if err != nil {
+		return nil, err
+	}
+
+	rtspClient := rtsp.NewClient(rtspURL)
+	if err := rtspClient.Dial(); err != nil {
+		return nil, err
+	}
+	if err := rtspClient.Describe(); err != nil {
+		return nil, err
+	}
+
+	return &RTSPClient{conn: rtspClient, api: nestAPI}, nil
+}
+
+func (c *RTSPClient) GetMedias() []*core.Media {
+	result := c.conn.GetMedias()
+	return result
+}
+
+func (c *RTSPClient) GetTrack(media *core.Media, codec *core.Codec) (*core.Receiver, error) {
+	return c.conn.GetTrack(media, codec)
+}
+
+func (c *RTSPClient) Start() error {
+	c.api.StartExtendStreamTimer()
+	return c.conn.Start()
+}
+
+func (c *RTSPClient) Stop() error {
+	c.api.StopRTSPStream()
+	c.api.StopExtendStreamTimer()
+	return c.conn.Stop()
+}
+
+func (c *RTSPClient) MarshalJSON() ([]byte, error) {
+	return c.conn.MarshalJSON()
+}
diff --git a/installs_on_host/go2rtc/pkg/ngrok/ngrok.go b/installs_on_host/go2rtc/pkg/ngrok/ngrok.go
new file mode 100644
index 0000000..33fa0f8
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/ngrok/ngrok.go
@@ -0,0 +1,80 @@
+package ngrok
+
+import (
+	"bufio"
+	"encoding/json"
+	"io"
+	"os/exec"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+type Ngrok struct {
+	core.Listener
+
+	Tunnels map[string]string
+
+	reader *bufio.Reader
+}
+
+type Message struct {
+	Msg  string `json:"msg"`
+	Addr string `json:"addr"`
+	URL  string `json:"url"`
+	Line string
+}
+
+func NewNgrok(command any) (*Ngrok, error) {
+	var arg []string
+	switch command.(type) {
+	case string:
+		arg = strings.Split(command.(string), " ")
+	case []string:
+		arg = command.([]string)
+	}
+
+	arg = append(arg, "--log", "stdout", "--log-format", "json")
+
+	cmd := exec.Command(arg[0], arg[1:]...)
+
+	r, err := cmd.StdoutPipe()
+	if err != nil {
+		return nil, err
+	}
+	cmd.Stderr = cmd.Stdout
+
+	n := &Ngrok{
+		Tunnels: map[string]string{},
+		reader:  bufio.NewReader(r),
+	}
+
+	if err = cmd.Start(); err != nil {
+		return nil, err
+	}
+
+	return n, nil
+}
+
+func (n *Ngrok) Serve() error {
+	for {
+		line, _, err := n.reader.ReadLine()
+		if err != nil {
+			if err != io.EOF {
+				return err
+			}
+			return nil
+		}
+
+		msg := new(Message)
+		_ = json.Unmarshal(line, msg)
+
+		if msg.Msg == "started tunnel" {
+			n.Tunnels[msg.Addr] = msg.URL
+		}
+
+		msg.Line = string(line)
+
+		n.Fire(msg)
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/onvif/README.md b/installs_on_host/go2rtc/pkg/onvif/README.md
new file mode 100644
index 0000000..7326737
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/onvif/README.md
@@ -0,0 +1,38 @@
+## Profiles
+
+- Profile A - For access control configuration
+- Profile C - For door control and event management
+- Profile S - For basic video streaming
+  - Video streaming and configuration
+- Profile T - For advanced video streaming
+  - H.264 / H.265 video compression
+  - Imaging settings
+  - Motion alarm and tampering events
+  - Metadata streaming
+  - Bi-directional audio
+
+## Services
+
+https://www.onvif.org/profiles/specifications/
+
+- https://www.onvif.org/ver10/device/wsdl/devicemgmt.wsdl
+- https://www.onvif.org/ver20/imaging/wsdl/imaging.wsdl
+- https://www.onvif.org/ver10/media/wsdl/media.wsdl
+
+## TMP
+
+|                        | Dahua   | Reolink | TP-Link |
+|------------------------|---------|---------|---------|
+| GetCapabilities        | no auth | no auth | no auth |
+| GetServices            | no auth | no auth | no auth |
+| GetServiceCapabilities | no auth | no auth | auth    |
+| GetSystemDateAndTime   | no auth | no auth | no auth |
+| GetNetworkInterfaces   | auth    | auth    | auth    |
+| GetDeviceInformation   | auth    | auth    | auth    |
+| GetProfiles            | auth    | auth    | auth    |
+| GetScopes              | auth    | auth    | auth    |
+
+- Dahua - onvif://192.168.10.90:80
+- Reolink - onvif://192.168.10.92:8000
+- TP-Link - onvif://192.168.10.91:2020/onvif/device_service
+- 
\ No newline at end of file
diff --git a/installs_on_host/go2rtc/pkg/onvif/client.go b/installs_on_host/go2rtc/pkg/onvif/client.go
new file mode 100644
index 0000000..bad103c
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/onvif/client.go
@@ -0,0 +1,197 @@
+package onvif
+
+import (
+	"bytes"
+	"errors"
+	"html"
+	"io"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strings"
+	"time"
+)
+
+const PathDevice = "/onvif/device_service"
+
+type Client struct {
+	url *url.URL
+
+	deviceURL string
+	mediaURL  string
+	imaginURL string
+}
+
+func NewClient(rawURL string) (*Client, error) {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	baseURL := "http://" + u.Host
+
+	client := &Client{url: u}
+	client.deviceURL = baseURL + GetPath(u.Path, PathDevice)
+
+	b, err := client.DeviceRequest(DeviceGetCapabilities)
+	if err != nil {
+		return nil, err
+	}
+
+	s := FindTagValue(b, "Media.+?XAddr")
+	client.mediaURL = baseURL + GetPath(s, "/onvif/media_service")
+
+	s = FindTagValue(b, "Imaging.+?XAddr")
+	client.imaginURL = baseURL + GetPath(s, "/onvif/imaging_service")
+
+	return client, nil
+}
+
+func (c *Client) GetURI() (string, error) {
+	query := c.url.Query()
+
+	token := query.Get("subtype")
+
+	// support empty
+	if i := atoi(token); i >= 0 {
+		tokens, err := c.GetProfilesTokens()
+		if err != nil {
+			return "", err
+		}
+		if i >= len(tokens) {
+			return "", errors.New("onvif: wrong subtype")
+		}
+		token = tokens[i]
+	}
+
+	getUri := c.GetStreamUri
+	if query.Has("snapshot") {
+		getUri = c.GetSnapshotUri
+	}
+
+	b, err := getUri(token)
+	if err != nil {
+		return "", err
+	}
+
+	rawURL := FindTagValue(b, "Uri")
+	rawURL = strings.TrimSpace(html.UnescapeString(rawURL))
+
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return "", err
+	}
+
+	if u.User == nil && c.url.User != nil {
+		u.User = c.url.User
+	}
+
+	return u.String(), nil
+}
+
+func (c *Client) GetName() (string, error) {
+	b, err := c.DeviceRequest(DeviceGetDeviceInformation)
+	if err != nil {
+		return "", err
+	}
+
+	return FindTagValue(b, "Manufacturer") + " " + FindTagValue(b, "Model"), nil
+}
+
+func (c *Client) GetProfilesTokens() ([]string, error) {
+	b, err := c.MediaRequest(MediaGetProfiles)
+	if err != nil {
+		return nil, err
+	}
+
+	var tokens []string
+
+	re := regexp.MustCompile(`Profiles.+?token="([^"]+)`)
+	for _, s := range re.FindAllStringSubmatch(string(b), 10) {
+		tokens = append(tokens, s[1])
+	}
+
+	return tokens, nil
+}
+
+func (c *Client) HasSnapshots() bool {
+	b, err := c.GetServiceCapabilities()
+	if err != nil {
+		return false
+	}
+	return strings.Contains(string(b), `SnapshotUri="true"`)
+}
+
+func (c *Client) GetProfile(token string) ([]byte, error) {
+	return c.Request(
+		c.mediaURL, `<trt:GetProfile><trt:ProfileToken>`+token+`</trt:ProfileToken></trt:GetProfile>`,
+	)
+}
+
+func (c *Client) GetVideoSourceConfiguration(token string) ([]byte, error) {
+	return c.Request(c.mediaURL, `<trt:GetVideoSourceConfiguration>
+	<trt:ConfigurationToken>`+token+`</trt:ConfigurationToken>
+</trt:GetVideoSourceConfiguration>`)
+}
+
+func (c *Client) GetStreamUri(token string) ([]byte, error) {
+	return c.Request(c.mediaURL, `<trt:GetStreamUri>
+	<trt:StreamSetup>
+		<tt:Stream>RTP-Unicast</tt:Stream>
+		<tt:Transport><tt:Protocol>RTSP</tt:Protocol></tt:Transport>
+	</trt:StreamSetup>
+	<trt:ProfileToken>`+token+`</trt:ProfileToken>
+</trt:GetStreamUri>`)
+}
+
+func (c *Client) GetSnapshotUri(token string) ([]byte, error) {
+	return c.Request(
+		c.imaginURL, `<trt:GetSnapshotUri><trt:ProfileToken>`+token+`</trt:ProfileToken></trt:GetSnapshotUri>`,
+	)
+}
+
+func (c *Client) GetServiceCapabilities() ([]byte, error) {
+	// some cameras answer GetServiceCapabilities for media only for path = "/onvif/media"
+	return c.Request(
+		c.mediaURL, `<trt:GetServiceCapabilities />`,
+	)
+}
+
+func (c *Client) DeviceRequest(operation string) ([]byte, error) {
+	switch operation {
+	case DeviceGetServices:
+		operation = `<tds:GetServices><tds:IncludeCapability>true</tds:IncludeCapability></tds:GetServices>`
+	case DeviceGetCapabilities:
+		operation = `<tds:GetCapabilities><tds:Category>All</tds:Category></tds:GetCapabilities>`
+	default:
+		operation = `<tds:` + operation + `/>`
+	}
+	return c.Request(c.deviceURL, operation)
+}
+
+func (c *Client) MediaRequest(operation string) ([]byte, error) {
+	operation = `<trt:` + operation + `/>`
+	return c.Request(c.mediaURL, operation)
+}
+
+func (c *Client) Request(url, body string) ([]byte, error) {
+	if url == "" {
+		return nil, errors.New("onvif: unsupported service")
+	}
+
+	e := NewEnvelopeWithUser(c.url.User)
+	e.Append(body)
+
+	client := &http.Client{Timeout: time.Second * 5000}
+	res, err := client.Post(url, `application/soap+xml;charset=utf-8`, bytes.NewReader(e.Bytes()))
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != http.StatusOK {
+		return nil, errors.New("onvif: wrong response " + res.Status)
+	}
+
+	return io.ReadAll(res.Body)
+}
diff --git a/installs_on_host/go2rtc/pkg/onvif/envelope.go b/installs_on_host/go2rtc/pkg/onvif/envelope.go
new file mode 100644
index 0000000..76a4126
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/onvif/envelope.go
@@ -0,0 +1,73 @@
+package onvif
+
+import (
+	"crypto/sha1"
+	"encoding/base64"
+	"fmt"
+	"net/url"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+type Envelope struct {
+	buf []byte
+}
+
+const (
+	prefix1 = `<?xml version="1.0" encoding="utf-8"?><s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope" xmlns:tt="http://www.onvif.org/ver10/schema" xmlns:tds="http://www.onvif.org/ver10/device/wsdl" xmlns:trt="http://www.onvif.org/ver10/media/wsdl">`
+	prefix2 = `<s:Body>`
+	suffix  = `</s:Body></s:Envelope>`
+)
+
+func NewEnvelope() *Envelope {
+	e := &Envelope{buf: make([]byte, 0, 1024)}
+	e.Append(prefix1, prefix2)
+	return e
+}
+
+func NewEnvelopeWithUser(user *url.Userinfo) *Envelope {
+	if user == nil {
+		return NewEnvelope()
+	}
+
+	nonce := core.RandString(16, 36)
+	created := time.Now().UTC().Format(time.RFC3339Nano)
+	pass, _ := user.Password()
+
+	h := sha1.New()
+	h.Write([]byte(nonce + created + pass))
+
+	e := &Envelope{buf: make([]byte, 0, 1024)}
+	e.Append(prefix1)
+	e.Appendf(`<s:Header>
+	<wsse:Security xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd">
+		<wsse:UsernameToken>
+			<wsse:Username>%s</wsse:Username>
+			<wsse:Password Type="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordDigest">%s</wsse:Password>
+			<wsse:Nonce EncodingType="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-security-1.0#Base64Binary">%s</wsse:Nonce>
+			<wsu:Created xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd">%s</wsu:Created>
+		</wsse:UsernameToken>
+	</wsse:Security>
+</s:Header>`,
+		user.Username(),
+		base64.StdEncoding.EncodeToString(h.Sum(nil)),
+		base64.StdEncoding.EncodeToString([]byte(nonce)),
+		created)
+	e.Append(prefix2)
+	return e
+}
+
+func (e *Envelope) Append(args ...string) {
+	for _, s := range args {
+		e.buf = append(e.buf, s...)
+	}
+}
+
+func (e *Envelope) Appendf(format string, args ...any) {
+	e.buf = fmt.Appendf(e.buf, format, args...)
+}
+
+func (e *Envelope) Bytes() []byte {
+	return append(e.buf, suffix...)
+}
diff --git a/installs_on_host/go2rtc/pkg/onvif/helpers.go b/installs_on_host/go2rtc/pkg/onvif/helpers.go
new file mode 100644
index 0000000..8fac9ac
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/onvif/helpers.go
@@ -0,0 +1,162 @@
+package onvif
+
+import (
+	"fmt"
+	"net"
+	"net/url"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+type DiscoveryDevice struct {
+	URL      string
+	Name     string
+	Hardware string
+}
+
+func FindTagValue(b []byte, tag string) string {
+	re := regexp.MustCompile(`(?s)<(?:\w+:)?` + tag + `\b[^>]*>([^<]+)`)
+	m := re.FindSubmatch(b)
+	if len(m) != 2 {
+		return ""
+	}
+	return string(m[1])
+}
+
+// UUID - generate something like 44302cbf-0d18-4feb-79b3-33b575263da3
+func UUID() string {
+	s := core.RandString(32, 16)
+	return s[:8] + "-" + s[8:12] + "-" + s[12:16] + "-" + s[16:20] + "-" + s[20:]
+}
+
+// DiscoveryStreamingDevices return list of tuple (onvif_url, name, hardware)
+func DiscoveryStreamingDevices() ([]DiscoveryDevice, error) {
+	conn, err := net.ListenUDP("udp4", nil)
+	if err != nil {
+		return nil, err
+	}
+
+	defer conn.Close()
+
+	// https://www.onvif.org/wp-content/uploads/2016/12/ONVIF_Feature_Discovery_Specification_16.07.pdf
+	// 5.3 Discovery Procedure:
+	msg := `<?xml version="1.0" ?>
+<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">
+	<s:Header xmlns:a="http://schemas.xmlsoap.org/ws/2004/08/addressing">
+		<a:Action>http://schemas.xmlsoap.org/ws/2005/04/discovery/Probe</a:Action>
+		<a:MessageID>urn:uuid:` + UUID() + `</a:MessageID>
+		<a:To>urn:schemas-xmlsoap-org:ws:2005:04:discovery</a:To>
+	</s:Header>
+	<s:Body>
+		<d:Probe xmlns:d="http://schemas.xmlsoap.org/ws/2005/04/discovery">
+			<d:Types />
+			<d:Scopes />
+		</d:Probe>
+	</s:Body>
+</s:Envelope>`
+
+	addr := &net.UDPAddr{
+		IP:   net.IP{239, 255, 255, 250},
+		Port: 3702,
+	}
+
+	if _, err = conn.WriteTo([]byte(msg), addr); err != nil {
+		return nil, err
+	}
+
+	_ = conn.SetReadDeadline(time.Now().Add(5 * time.Second))
+
+	var devices []DiscoveryDevice
+
+	b := make([]byte, 8192)
+	for {
+		n, addr, err := conn.ReadFromUDP(b)
+		if err != nil {
+			break
+		}
+
+		//log.Printf("[onvif] discovery response addr=%s:\n%s", addr, b[:n])
+
+		// ignore printers, etc
+		if !strings.Contains(string(b[:n]), "onvif") {
+			continue
+		}
+
+		device := DiscoveryDevice{
+			URL: FindTagValue(b[:n], "XAddrs"),
+		}
+
+		if device.URL == "" {
+			continue
+		}
+
+		// fix some buggy cameras
+		// <wsdd:XAddrs>http://0.0.0.0:8080/onvif/device_service</wsdd:XAddrs>
+		if s, ok := strings.CutPrefix(device.URL, "http://0.0.0.0"); ok {
+			device.URL = "http://" + addr.IP.String() + s
+		}
+
+		// try to find the camera name and model (hardware)
+		scopes := FindTagValue(b[:n], "Scopes")
+		device.Name = findScope(scopes, "onvif://www.onvif.org/name/")
+		device.Hardware = findScope(scopes, "onvif://www.onvif.org/hardware/")
+
+		devices = append(devices, device)
+	}
+
+	return devices, nil
+}
+
+func findScope(s, prefix string) string {
+	s = core.Between(s, prefix, " ")
+	s, _ = url.QueryUnescape(s)
+	return s
+}
+
+func atoi(s string) int {
+	if s == "" {
+		return 0
+	}
+	i, err := strconv.Atoi(s)
+	if err != nil {
+		return -1
+	}
+	return i
+}
+
+func GetPosixTZ(current time.Time) string {
+	// Thanks to https://github.com/Path-Variable/go-posix-time
+	_, offset := current.Zone()
+
+	if current.IsDST() {
+		_, end := current.ZoneBounds()
+		endPlus1 := end.Add(time.Hour * 25)
+		_, offset = endPlus1.Zone()
+	}
+
+	var prefix string
+	if offset < 0 {
+		prefix = "GMT+"
+		offset = -offset / 60
+	} else {
+		prefix = "GMT-"
+		offset = offset / 60
+	}
+
+	return prefix + fmt.Sprintf("%02d:%02d", offset/60, offset%60)
+}
+
+func GetPath(urlOrPath, defPath string) string {
+	if urlOrPath == "" || urlOrPath[0] == '/' {
+		return defPath
+	}
+	u, err := url.Parse(urlOrPath)
+	if err != nil {
+		return defPath
+	}
+	return GetPath(u.Path, defPath)
+}
diff --git a/installs_on_host/go2rtc/pkg/onvif/onvif_test.go b/installs_on_host/go2rtc/pkg/onvif/onvif_test.go
new file mode 100644
index 0000000..e9ffab0
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/onvif/onvif_test.go
@@ -0,0 +1,227 @@
+package onvif
+
+import (
+	"html"
+	"net/url"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestGetStreamUri(t *testing.T) {
+	tests := []struct {
+		name string
+		xml  string
+		url  string
+	}{
+		{
+			name: "Dahua stream default",
+			xml:  `<?xml version="1.0" encoding="utf-8" standalone="yes" ?><s:Envelope xmlns:sc="http://www.w3.org/2003/05/soap-encoding" xmlns:s="http://www.w3.org/2003/05/soap-envelope" xmlns:tt="http://www.onvif.org/ver10/schema" xmlns:trt="http://www.onvif.org/ver10/media/wsdl"><s:Header/><s:Body><trt:GetStreamUriResponse><trt:MediaUri><tt:Uri>rtsp://192.168.1.123:554/cam/realmonitor?channel=1&amp;subtype=1&amp;unicast=true&amp;proto=Onvif</tt:Uri><tt:InvalidAfterConnect>true</tt:InvalidAfterConnect><tt:InvalidAfterReboot>true</tt:InvalidAfterReboot><tt:Timeout>PT0S</tt:Timeout></trt:MediaUri></trt:GetStreamUriResponse></s:Body></s:Envelope>`,
+			url:  "rtsp://192.168.1.123:554/cam/realmonitor?channel=1&subtype=1&unicast=true&proto=Onvif",
+		},
+		{
+			name: "Dahua snapshot default",
+			xml:  `<?xml version="1.0" encoding="utf-8" standalone="yes" ?><s:Envelope xmlns:sc="http://www.w3.org/2003/05/soap-encoding" xmlns:s="http://www.w3.org/2003/05/soap-envelope" xmlns:tt="http://www.onvif.org/ver10/schema" xmlns:trt="http://www.onvif.org/ver10/media/wsdl"><s:Header/><s:Body><trt:GetSnapshotUriResponse><trt:MediaUri><tt:Uri>http://192.168.1.123/onvifsnapshot/media_service/snapshot?channel=1&amp;subtype=1</tt:Uri><tt:InvalidAfterConnect>false</tt:InvalidAfterConnect><tt:InvalidAfterReboot>false</tt:InvalidAfterReboot><tt:Timeout>PT0S</tt:Timeout></trt:MediaUri></trt:GetSnapshotUriResponse></s:Body></s:Envelope>`,
+			url:  "http://192.168.1.123/onvifsnapshot/media_service/snapshot?channel=1&subtype=1",
+		},
+		{
+			name: "Dahua stream formatted",
+			xml: `<?xml version="1.0" encoding="utf-8" standalone="yes"?>
+<s:Envelope xmlns:sc="http://www.w3.org/2003/05/soap-encoding"
+    xmlns:s="http://www.w3.org/2003/05/soap-envelope" xmlns:tt="http://www.onvif.org/ver10/schema"
+    xmlns:trt="http://www.onvif.org/ver10/media/wsdl">
+    <s:Header />
+    <s:Body>
+        <trt:GetStreamUriResponse>
+            <trt:MediaUri>
+                <tt:Uri>
+                    rtsp://192.168.1.123:554/cam/realmonitor?channel=1&amp;subtype=1&amp;unicast=true&amp;proto=Onvif</tt:Uri>
+                <tt:InvalidAfterConnect>true</tt:InvalidAfterConnect>
+                <tt:InvalidAfterReboot>true</tt:InvalidAfterReboot>
+                <tt:Timeout>PT0S</tt:Timeout>
+            </trt:MediaUri>
+        </trt:GetStreamUriResponse>
+    </s:Body>
+</s:Envelope>`,
+			url: "rtsp://192.168.1.123:554/cam/realmonitor?channel=1&subtype=1&unicast=true&proto=Onvif",
+		},
+		{
+			name: "Dahua snapshot formatted",
+			xml: `<?xml version="1.0" encoding="utf-8" standalone="yes"?>
+<s:Envelope xmlns:sc="http://www.w3.org/2003/05/soap-encoding"
+    xmlns:s="http://www.w3.org/2003/05/soap-envelope" xmlns:tt="http://www.onvif.org/ver10/schema"
+    xmlns:trt="http://www.onvif.org/ver10/media/wsdl">
+    <s:Header />
+    <s:Body>
+        <trt:GetSnapshotUriResponse>
+            <trt:MediaUri>
+                <tt:Uri>
+                    http://192.168.1.123/onvifsnapshot/media_service/snapshot?channel=1&amp;subtype=1</tt:Uri>
+                <tt:InvalidAfterConnect>false</tt:InvalidAfterConnect>
+                <tt:InvalidAfterReboot>false</tt:InvalidAfterReboot>
+                <tt:Timeout>PT0S</tt:Timeout>
+            </trt:MediaUri>
+        </trt:GetSnapshotUriResponse>
+    </s:Body>
+</s:Envelope>`,
+			url: "http://192.168.1.123/onvifsnapshot/media_service/snapshot?channel=1&subtype=1",
+		},
+		{
+			name: "Unknown",
+			xml: `<?xml version="1.0" encoding="UTF-8"?>
+<SOAP-ENV:Envelope ...>
+   <SOAP-ENV:Header></SOAP-ENV:Header>
+   <SOAP-ENV:Body>
+	   <MC1:GetStreamUriResponse>
+		   <MC1:MediaUri>
+			   <MC2:Uri>
+					rtsp://192.168.5.53:8090/profile1=r
+				</MC2:Uri>
+		   </MC1:MediaUri>
+	   </MC1:GetStreamUriResponse>
+   </SOAP-ENV:Body>
+</SOAP-ENV:Envelope>`,
+			url: "rtsp://192.168.5.53:8090/profile1=r",
+		},
+		{
+			name: "go2rtc 1.9.4",
+			xml: `<?xml version="1.0" encoding="utf-8"?><s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">
+    <s:Body>
+        <trt:GetStreamUriResponse xmlns:trt="http://www.onvif.org/ver10/media/wsdl">
+            <trt:MediaUri>
+                <tt:Uri xmlns:tt="http://www.onvif.org/ver10/schema">rtsp://192.168.1.123:8554/rtsp-dahua1</tt:Uri>
+            </trt:MediaUri>
+        </trt:GetStreamUriResponse>
+    </s:Body>
+</s:Envelope>`,
+			url: "rtsp://192.168.1.123:8554/rtsp-dahua1",
+		},
+		{
+			name: "go2rtc 1.9.8",
+			xml: `<?xml version="1.0" encoding="utf-8" standalone="no"?>
+<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope" xmlns:tds="http://www.onvif.org/ver10/device/wsdl" xmlns:trt="http://www.onvif.org/ver10/media/wsdl" xmlns:tt="http://www.onvif.org/ver10/schema">
+    <s:Body>
+        <trt:GetStreamUriResponse>
+            <trt:MediaUri>
+                <tt:Uri>rtsp://192.168.1.123:8554/rtsp-dahua2</tt:Uri>
+            </trt:MediaUri>
+        </trt:GetStreamUriResponse>
+    </s:Body>
+</s:Envelope>
+`,
+			url: "rtsp://192.168.1.123:8554/rtsp-dahua2",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			uri := FindTagValue([]byte(test.xml), "Uri")
+			uri = strings.TrimSpace(html.UnescapeString(uri))
+			u, err := url.Parse(uri)
+			require.Nil(t, err)
+			require.Equal(t, test.url, u.String())
+		})
+	}
+}
+
+func TestGetCapabilities(t *testing.T) {
+	tests := []struct {
+		name string
+		xml  string
+	}{
+		{
+			name: "Dahua default",
+			xml:  `<?xml version="1.0" encoding="utf-8" standalone="yes" ?><s:Envelope xmlns:sc="http://www.w3.org/2003/05/soap-encoding" xmlns:s="http://www.w3.org/2003/05/soap-envelope" xmlns:tt="http://www.onvif.org/ver10/schema" xmlns:tds="http://www.onvif.org/ver10/device/wsdl"><s:Header/><s:Body><tds:GetCapabilitiesResponse><tds:Capabilities><tt:Analytics><tt:XAddr>http://192.168.1.123/onvif/analytics_service</tt:XAddr><tt:RuleSupport>true</tt:RuleSupport><tt:AnalyticsModuleSupport>true</tt:AnalyticsModuleSupport></tt:Analytics><tt:Device><tt:XAddr>http://192.168.1.123/onvif/device_service</tt:XAddr><tt:Network><tt:IPFilter>false</tt:IPFilter><tt:ZeroConfiguration>false</tt:ZeroConfiguration><tt:IPVersion6>false</tt:IPVersion6><tt:DynDNS>false</tt:DynDNS><tt:Extension><tt:Dot11Configuration>false</tt:Dot11Configuration></tt:Extension></tt:Network><tt:System><tt:DiscoveryResolve>false</tt:DiscoveryResolve><tt:DiscoveryBye>true</tt:DiscoveryBye><tt:RemoteDiscovery>false</tt:RemoteDiscovery><tt:SystemBackup>false</tt:SystemBackup><tt:SystemLogging>true</tt:SystemLogging><tt:FirmwareUpgrade>true</tt:FirmwareUpgrade><tt:SupportedVersions><tt:Major>2</tt:Major><tt:Minor>00</tt:Minor></tt:SupportedVersions><tt:SupportedVersions><tt:Major>2</tt:Major><tt:Minor>10</tt:Minor></tt:SupportedVersions><tt:SupportedVersions><tt:Major>2</tt:Major><tt:Minor>20</tt:Minor></tt:SupportedVersions><tt:SupportedVersions><tt:Major>2</tt:Major><tt:Minor>30</tt:Minor></tt:SupportedVersions><tt:SupportedVersions><tt:Major>2</tt:Major><tt:Minor>40</tt:Minor></tt:SupportedVersions><tt:SupportedVersions><tt:Major>2</tt:Major><tt:Minor>42</tt:Minor></tt:SupportedVersions><tt:SupportedVersions><tt:Major>16</tt:Major><tt:Minor>12</tt:Minor></tt:SupportedVersions><tt:SupportedVersions><tt:Major>18</tt:Major><tt:Minor>06</tt:Minor></tt:SupportedVersions><tt:SupportedVersions><tt:Major>18</tt:Major><tt:Minor>12</tt:Minor></tt:SupportedVersions><tt:SupportedVersions><tt:Major>19</tt:Major><tt:Minor>06</tt:Minor></tt:SupportedVersions><tt:SupportedVersions><tt:Major>19</tt:Major><tt:Minor>12</tt:Minor></tt:SupportedVersions><tt:SupportedVersions><tt:Major>20</tt:Major><tt:Minor>06</tt:Minor></tt:SupportedVersions><tt:Extension><tt:HttpFirmwareUpgrade>true</tt:HttpFirmwareUpgrade><tt:HttpSystemBackup>false</tt:HttpSystemBackup><tt:HttpSystemLogging>false</tt:HttpSystemLogging><tt:HttpSupportInformation>false</tt:HttpSupportInformation></tt:Extension></tt:System><tt:IO><tt:InputConnectors>2</tt:InputConnectors><tt:RelayOutputs>1</tt:RelayOutputs><tt:Extension><tt:Auxiliary>false</tt:Auxiliary><tt:AuxiliaryCommands></tt:AuxiliaryCommands><tt:Extension></tt:Extension></tt:Extension></tt:IO><tt:Security><tt:TLS1.1>false</tt:TLS1.1><tt:TLS1.2>false</tt:TLS1.2><tt:OnboardKeyGeneration>false</tt:OnboardKeyGeneration><tt:AccessPolicyConfig>false</tt:AccessPolicyConfig><tt:X.509Token>false</tt:X.509Token><tt:SAMLToken>false</tt:SAMLToken><tt:KerberosToken>false</tt:KerberosToken><tt:RELToken>false</tt:RELToken><tt:Extension><tt:TLS1.0>false</tt:TLS1.0><tt:Extension><tt:Dot1X>false</tt:Dot1X><tt:SupportedEAPMethod>0</tt:SupportedEAPMethod><tt:RemoteUserHandling>false</tt:RemoteUserHandling></tt:Extension></tt:Extension></tt:Security></tt:Device><tt:Events><tt:XAddr>http://192.168.1.123/onvif/event_service</tt:XAddr><tt:WSSubscriptionPolicySupport>true</tt:WSSubscriptionPolicySupport><tt:WSPullPointSupport>true</tt:WSPullPointSupport><tt:WSPausableSubscriptionManagerInterfaceSupport>false</tt:WSPausableSubscriptionManagerInterfaceSupport></tt:Events><tt:Imaging><tt:XAddr>http://192.168.1.123/onvif/imaging_service</tt:XAddr></tt:Imaging><tt:Media><tt:XAddr>http://192.168.1.123/onvif/media_service</tt:XAddr><tt:StreamingCapabilities><tt:RTPMulticast>true</tt:RTPMulticast><tt:RTP_TCP>true</tt:RTP_TCP><tt:RTP_RTSP_TCP>true</tt:RTP_RTSP_TCP></tt:StreamingCapabilities><tt:Extension><tt:ProfileCapabilities><tt:MaximumNumberOfProfiles>6</tt:MaximumNumberOfProfiles></tt:ProfileCapabilities></tt:Extension></tt:Media><tt:Extension><tt:DeviceIO><tt:XAddr>http://192.168.1.123/onvif/deviceIO_service</tt:XAddr><tt:VideoSources>1</tt:VideoSources><tt:VideoOutputs>0</tt:VideoOutputs><tt:AudioSources>1</tt:AudioSources><tt:AudioOutputs>1</tt:AudioOutputs><tt:RelayOutputs>1</tt:RelayOutputs></tt:DeviceIO></tt:Extension></tds:Capabilities></tds:GetCapabilitiesResponse></s:Body></s:Envelope>`,
+		},
+		{
+			name: "Dahua formatted",
+			xml: `<?xml version="1.0" encoding="utf-8" standalone="yes"?>
+<s:Envelope xmlns:sc="http://www.w3.org/2003/05/soap-encoding"
+    xmlns:s="http://www.w3.org/2003/05/soap-envelope" xmlns:tt="http://www.onvif.org/ver10/schema"
+    xmlns:tds="http://www.onvif.org/ver10/device/wsdl">
+    <s:Header />
+    <s:Body>
+        <tds:GetCapabilitiesResponse>
+            <tds:Capabilities>
+                <tt:Analytics>
+                    <tt:XAddr>http://192.168.1.123/onvif/analytics_service</tt:XAddr>
+                    <tt:RuleSupport>true</tt:RuleSupport>
+                    <tt:AnalyticsModuleSupport>true</tt:AnalyticsModuleSupport>
+                </tt:Analytics>
+                <tt:Device>
+                    <tt:XAddr>http://192.168.1.123/onvif/device_service</tt:XAddr>
+                    <tt:Network>
+                        <tt:IPFilter>false</tt:IPFilter>
+                        <tt:ZeroConfiguration>false</tt:ZeroConfiguration>
+                        <tt:IPVersion6>false</tt:IPVersion6>
+                        <tt:DynDNS>false</tt:DynDNS>
+                        <tt:Extension>
+                            <tt:Dot11Configuration>false</tt:Dot11Configuration>
+                        </tt:Extension>
+                    </tt:Network>
+                    <tt:System>
+                        ...
+                    </tt:System>
+                    <tt:IO>
+                        <tt:InputConnectors>2</tt:InputConnectors>
+                        <tt:RelayOutputs>1</tt:RelayOutputs>
+                        <tt:Extension>
+                            <tt:Auxiliary>false</tt:Auxiliary>
+                            <tt:AuxiliaryCommands></tt:AuxiliaryCommands>
+                            <tt:Extension></tt:Extension>
+                        </tt:Extension>
+                    </tt:IO>
+                    <tt:Security>
+                        ...
+                    </tt:Security>
+                </tt:Device>
+                <tt:Events>
+                    <tt:XAddr>http://192.168.1.123/onvif/event_service</tt:XAddr>
+                    <tt:WSSubscriptionPolicySupport>true</tt:WSSubscriptionPolicySupport>
+                    <tt:WSPullPointSupport>true</tt:WSPullPointSupport>
+                    <tt:WSPausableSubscriptionManagerInterfaceSupport>false</tt:WSPausableSubscriptionManagerInterfaceSupport>
+                </tt:Events>
+                <tt:Imaging>
+                    <tt:XAddr>http://192.168.1.123/onvif/imaging_service</tt:XAddr>
+                </tt:Imaging>
+                <tt:Media>
+                    <tt:XAddr>http://192.168.1.123/onvif/media_service</tt:XAddr>
+                    <tt:StreamingCapabilities>
+                        <tt:RTPMulticast>true</tt:RTPMulticast>
+                        <tt:RTP_TCP>true</tt:RTP_TCP>
+                        <tt:RTP_RTSP_TCP>true</tt:RTP_RTSP_TCP>
+                    </tt:StreamingCapabilities>
+                    <tt:Extension>
+                        <tt:ProfileCapabilities>
+                            <tt:MaximumNumberOfProfiles>6</tt:MaximumNumberOfProfiles>
+                        </tt:ProfileCapabilities>
+                    </tt:Extension>
+                </tt:Media>
+                <tt:Extension>
+                    <tt:DeviceIO>
+                        <tt:XAddr>http://192.168.1.123/onvif/deviceIO_service</tt:XAddr>
+                        <tt:VideoSources>1</tt:VideoSources>
+                        <tt:VideoOutputs>0</tt:VideoOutputs>
+                        <tt:AudioSources>1</tt:AudioSources>
+                        <tt:AudioOutputs>1</tt:AudioOutputs>
+                        <tt:RelayOutputs>1</tt:RelayOutputs>
+                    </tt:DeviceIO>
+                </tt:Extension>
+            </tds:Capabilities>
+        </tds:GetCapabilitiesResponse>
+    </s:Body>
+</s:Envelope>`,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			rawURL := FindTagValue([]byte(test.xml), "Media.+?XAddr")
+			require.Equal(t, "http://192.168.1.123/onvif/media_service", rawURL)
+
+			rawURL = FindTagValue([]byte(test.xml), "Imaging.+?XAddr")
+			require.Equal(t, "http://192.168.1.123/onvif/imaging_service", rawURL)
+		})
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/onvif/server.go b/installs_on_host/go2rtc/pkg/onvif/server.go
new file mode 100644
index 0000000..fe3ba8b
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/onvif/server.go
@@ -0,0 +1,301 @@
+package onvif
+
+import (
+	"bytes"
+	"regexp"
+	"time"
+)
+
+const ServiceGetServiceCapabilities = "GetServiceCapabilities"
+
+const (
+	DeviceGetCapabilities          = "GetCapabilities"
+	DeviceGetDeviceInformation     = "GetDeviceInformation"
+	DeviceGetDiscoveryMode         = "GetDiscoveryMode"
+	DeviceGetDNS                   = "GetDNS"
+	DeviceGetHostname              = "GetHostname"
+	DeviceGetNetworkDefaultGateway = "GetNetworkDefaultGateway"
+	DeviceGetNetworkInterfaces     = "GetNetworkInterfaces"
+	DeviceGetNetworkProtocols      = "GetNetworkProtocols"
+	DeviceGetNTP                   = "GetNTP"
+	DeviceGetScopes                = "GetScopes"
+	DeviceGetServices              = "GetServices"
+	DeviceGetSystemDateAndTime     = "GetSystemDateAndTime"
+	DeviceSetSystemDateAndTime     = "SetSystemDateAndTime"
+	DeviceSystemReboot             = "SystemReboot"
+)
+
+const (
+	MediaGetAudioEncoderConfigurations       = "GetAudioEncoderConfigurations"
+	MediaGetAudioSources                     = "GetAudioSources"
+	MediaGetAudioSourceConfigurations        = "GetAudioSourceConfigurations"
+	MediaGetProfile                          = "GetProfile"
+	MediaGetProfiles                         = "GetProfiles"
+	MediaGetSnapshotUri                      = "GetSnapshotUri"
+	MediaGetStreamUri                        = "GetStreamUri"
+	MediaGetVideoEncoderConfiguration        = "GetVideoEncoderConfiguration"
+	MediaGetVideoEncoderConfigurations       = "GetVideoEncoderConfigurations"
+	MediaGetVideoEncoderConfigurationOptions = "GetVideoEncoderConfigurationOptions"
+	MediaGetVideoSources                     = "GetVideoSources"
+	MediaGetVideoSourceConfiguration         = "GetVideoSourceConfiguration"
+	MediaGetVideoSourceConfigurations        = "GetVideoSourceConfigurations"
+)
+
+func GetRequestAction(b []byte) string {
+	// <soap-env:Body><ns0:GetCapabilities xmlns:ns0="http://www.onvif.org/ver10/device/wsdl">
+	// <v:Body><GetSystemDateAndTime xmlns="http://www.onvif.org/ver10/device/wsdl" /></v:Body>
+	re := regexp.MustCompile(`Body[^<]+<([^ />]+)`)
+	m := re.FindSubmatch(b)
+	if len(m) != 2 {
+		return ""
+	}
+	if i := bytes.IndexByte(m[1], ':'); i > 0 {
+		return string(m[1][i+1:])
+	}
+	return string(m[1])
+}
+
+func GetCapabilitiesResponse(host string) []byte {
+	e := NewEnvelope()
+	e.Appendf(`<tds:GetCapabilitiesResponse>
+	<tds:Capabilities>
+		<tt:Device>
+			<tt:XAddr>http://%s/onvif/device_service</tt:XAddr>
+		</tt:Device>
+		<tt:Media>
+			<tt:XAddr>http://%s/onvif/media_service</tt:XAddr>
+			<tt:StreamingCapabilities>
+				<tt:RTPMulticast>false</tt:RTPMulticast>
+				<tt:RTP_TCP>false</tt:RTP_TCP>
+				<tt:RTP_RTSP_TCP>true</tt:RTP_RTSP_TCP>
+			</tt:StreamingCapabilities>
+		</tt:Media>
+	</tds:Capabilities>
+</tds:GetCapabilitiesResponse>`, host, host)
+	return e.Bytes()
+}
+
+func GetServicesResponse(host string) []byte {
+	e := NewEnvelope()
+	e.Appendf(`<tds:GetServicesResponse>
+	<tds:Service>
+		<tds:Namespace>http://www.onvif.org/ver10/device/wsdl</tds:Namespace>
+		<tds:XAddr>http://%s/onvif/device_service</tds:XAddr>
+		<tds:Version><tt:Major>2</tt:Major><tt:Minor>5</tt:Minor></tds:Version>
+	</tds:Service>
+	<tds:Service>
+		<tds:Namespace>http://www.onvif.org/ver10/media/wsdl</tds:Namespace>
+		<tds:XAddr>http://%s/onvif/media_service</tds:XAddr>
+		<tds:Version><tt:Major>2</tt:Major><tt:Minor>5</tt:Minor></tds:Version>
+	</tds:Service>
+</tds:GetServicesResponse>`, host, host)
+	return e.Bytes()
+}
+
+func GetSystemDateAndTimeResponse() []byte {
+	loc := time.Now()
+	utc := loc.UTC()
+
+	e := NewEnvelope()
+	e.Appendf(`<tds:GetSystemDateAndTimeResponse>
+	<tds:SystemDateAndTime>
+		<tt:DateTimeType>NTP</tt:DateTimeType>
+		<tt:DaylightSavings>true</tt:DaylightSavings>
+		<tt:TimeZone>
+			<tt:TZ>%s</tt:TZ>
+		</tt:TimeZone>
+		<tt:UTCDateTime>
+			<tt:Time><tt:Hour>%d</tt:Hour><tt:Minute>%d</tt:Minute><tt:Second>%d</tt:Second></tt:Time>
+			<tt:Date><tt:Year>%d</tt:Year><tt:Month>%d</tt:Month><tt:Day>%d</tt:Day></tt:Date>
+		</tt:UTCDateTime>
+		<tt:LocalDateTime>
+			<tt:Time><tt:Hour>%d</tt:Hour><tt:Minute>%d</tt:Minute><tt:Second>%d</tt:Second></tt:Time>
+			<tt:Date><tt:Year>%d</tt:Year><tt:Month>%d</tt:Month><tt:Day>%d</tt:Day></tt:Date>
+		</tt:LocalDateTime>
+	</tds:SystemDateAndTime>
+</tds:GetSystemDateAndTimeResponse>`,
+		GetPosixTZ(loc),
+		utc.Hour(), utc.Minute(), utc.Second(), utc.Year(), utc.Month(), utc.Day(),
+		loc.Hour(), loc.Minute(), loc.Second(), loc.Year(), loc.Month(), loc.Day(),
+	)
+	return e.Bytes()
+}
+
+func GetDeviceInformationResponse(manuf, model, firmware, serial string) []byte {
+	e := NewEnvelope()
+	e.Appendf(`<tds:GetDeviceInformationResponse>
+	<tds:Manufacturer>%s</tds:Manufacturer>
+	<tds:Model>%s</tds:Model>
+	<tds:FirmwareVersion>%s</tds:FirmwareVersion>
+	<tds:SerialNumber>%s</tds:SerialNumber>
+	<tds:HardwareId>1.00</tds:HardwareId>
+</tds:GetDeviceInformationResponse>`, manuf, model, firmware, serial)
+	return e.Bytes()
+}
+
+func GetProfilesResponse(names []string) []byte {
+	e := NewEnvelope()
+	e.Append(`<trt:GetProfilesResponse>`)
+	for _, name := range names {
+		appendProfile(e, "Profiles", name)
+	}
+	e.Append(`</trt:GetProfilesResponse>`)
+	return e.Bytes()
+}
+
+func GetProfileResponse(name string) []byte {
+	e := NewEnvelope()
+	e.Append(`<trt:GetProfileResponse>`)
+	appendProfile(e, "Profile", name)
+	e.Append(`</trt:GetProfileResponse>`)
+	return e.Bytes()
+}
+
+func appendProfile(e *Envelope, tag, name string) {
+	// go2rtc name = ONVIF Profile Name = ONVIF Profile token
+	e.Appendf(`<trt:%s token="%s" fixed="true">`, tag, name)
+	e.Appendf(`<tt:Name>%s</tt:Name>`, name)
+	appendVideoSourceConfiguration(e, "VideoSourceConfiguration", name)
+	appendVideoEncoderConfiguration(e, "VideoEncoderConfiguration")
+	e.Appendf(`</trt:%s>`, tag)
+}
+
+func GetVideoSourcesResponse(names []string) []byte {
+	// go2rtc name = ONVIF VideoSource token
+	e := NewEnvelope()
+	e.Append(`<trt:GetVideoSourcesResponse>`)
+	for _, name := range names {
+		e.Appendf(`<trt:VideoSources token="%s">
+	<tt:Framerate>30.000000</tt:Framerate>
+	<tt:Resolution><tt:Width>1920</tt:Width><tt:Height>1080</tt:Height></tt:Resolution>
+</trt:VideoSources>`, name)
+	}
+	e.Append(`</trt:GetVideoSourcesResponse>`)
+	return e.Bytes()
+}
+
+func GetVideoSourceConfigurationsResponse(names []string) []byte {
+	e := NewEnvelope()
+	e.Append(`<trt:GetVideoSourceConfigurationsResponse>`)
+	for _, name := range names {
+		appendVideoSourceConfiguration(e, "Configurations", name)
+	}
+	e.Append(`</trt:GetVideoSourceConfigurationsResponse>`)
+	return e.Bytes()
+}
+
+func GetVideoSourceConfigurationResponse(name string) []byte {
+	e := NewEnvelope()
+	e.Append(`<trt:GetVideoSourceConfigurationResponse>`)
+	appendVideoSourceConfiguration(e, "Configuration", name)
+	e.Append(`</trt:GetVideoSourceConfigurationResponse>`)
+	return e.Bytes()
+}
+
+func appendVideoSourceConfiguration(e *Envelope, tag, name string) {
+	// go2rtc name = ONVIF VideoSourceConfiguration token
+	e.Appendf(`<tt:%s token="%s" fixed="true">
+	<tt:Name>VSC</tt:Name>
+	<tt:SourceToken>%s</tt:SourceToken>
+	<tt:Bounds x="0" y="0" width="1920" height="1080"></tt:Bounds>
+</tt:%s>`, tag, name, name, tag)
+}
+
+func GetVideoEncoderConfigurationsResponse() []byte {
+	e := NewEnvelope()
+	e.Append(`<trt:GetVideoEncoderConfigurationsResponse>`)
+	appendVideoEncoderConfiguration(e, "VideoEncoderConfigurations")
+	e.Append(`</trt:GetVideoEncoderConfigurationsResponse>`)
+	return e.Bytes()
+}
+
+func GetVideoEncoderConfigurationResponse() []byte {
+	e := NewEnvelope()
+	e.Append(`<trt:GetVideoEncoderConfigurationResponse>`)
+	appendVideoEncoderConfiguration(e, "VideoEncoderConfiguration")
+	e.Append(`</trt:GetVideoEncoderConfigurationResponse>`)
+	return e.Bytes()
+}
+
+func appendVideoEncoderConfiguration(e *Envelope, tag string) {
+	// empty `RateControl` important for UniFi Protect
+	e.Appendf(`<tt:%s token="vec">
+		<tt:Name>VEC</tt:Name>
+        <tt:UseCount>1</tt:UseCount>
+		<tt:Encoding>H264</tt:Encoding>
+		<tt:Resolution><tt:Width>1920</tt:Width><tt:Height>1080</tt:Height></tt:Resolution>
+        <tt:Quality>0</tt:Quality>
+		<tt:RateControl><tt:FrameRateLimit>30</tt:FrameRateLimit><tt:EncodingInterval>1</tt:EncodingInterval><tt:BitrateLimit>8192</tt:BitrateLimit></tt:RateControl>
+        <tt:H264><tt:GovLength>10</tt:GovLength><tt:H264Profile>Main</tt:H264Profile></tt:H264>
+        <tt:SessionTimeout>PT10S</tt:SessionTimeout>
+	</tt:%s>`, tag, tag)
+}
+
+func GetStreamUriResponse(uri string) []byte {
+	e := NewEnvelope()
+	e.Appendf(`<trt:GetStreamUriResponse><trt:MediaUri><tt:Uri>%s</tt:Uri></trt:MediaUri></trt:GetStreamUriResponse>`, uri)
+	return e.Bytes()
+}
+
+func GetSnapshotUriResponse(uri string) []byte {
+	e := NewEnvelope()
+	e.Appendf(`<trt:GetSnapshotUriResponse><trt:MediaUri><tt:Uri>%s</tt:Uri></trt:MediaUri></trt:GetSnapshotUriResponse>`, uri)
+	return e.Bytes()
+}
+
+func StaticResponse(operation string) []byte {
+	switch operation {
+	case DeviceGetSystemDateAndTime:
+		return GetSystemDateAndTimeResponse()
+	case MediaGetVideoEncoderConfiguration:
+		return GetVideoEncoderConfigurationResponse()
+	case MediaGetVideoEncoderConfigurations:
+		return GetVideoEncoderConfigurationsResponse()
+	}
+
+	e := NewEnvelope()
+	e.Append(responses[operation])
+	return e.Bytes()
+}
+
+var responses = map[string]string{
+	ServiceGetServiceCapabilities: `<trt:GetServiceCapabilitiesResponse>
+	<trt:Capabilities SnapshotUri="true" Rotation="false" VideoSourceMode="false" OSD="false" TemporaryOSDText="false" EXICompression="false">
+		<trt:StreamingCapabilities RTPMulticast="false" RTP_TCP="false" RTP_RTSP_TCP="true" NonAggregateControl="false" NoRTSPStreaming="false" />
+	</trt:Capabilities>
+</trt:GetServiceCapabilitiesResponse>`,
+
+	DeviceGetDiscoveryMode:         `<tds:GetDiscoveryModeResponse><tds:DiscoveryMode>Discoverable</tds:DiscoveryMode></tds:GetDiscoveryModeResponse>`,
+	DeviceGetDNS:                   `<tds:GetDNSResponse><tds:DNSInformation /></tds:GetDNSResponse>`,
+	DeviceGetHostname:              `<tds:GetHostnameResponse><tds:HostnameInformation /></tds:GetHostnameResponse>`,
+	DeviceGetNetworkDefaultGateway: `<tds:GetNetworkDefaultGatewayResponse><tds:NetworkGateway /></tds:GetNetworkDefaultGatewayResponse>`,
+	DeviceGetNTP:                   `<tds:GetNTPResponse><tds:NTPInformation /></tds:GetNTPResponse>`,
+	DeviceSetSystemDateAndTime:     `<tds:SetSystemDateAndTimeResponse />`,
+	DeviceSystemReboot:             `<tds:SystemRebootResponse><tds:Message>OK</tds:Message></tds:SystemRebootResponse>`,
+
+	DeviceGetNetworkInterfaces: `<tds:GetNetworkInterfacesResponse />`,
+	DeviceGetNetworkProtocols:  `<tds:GetNetworkProtocolsResponse />`,
+	DeviceGetScopes: `<tds:GetScopesResponse>
+	<tds:Scopes><tt:ScopeDef>Fixed</tt:ScopeDef><tt:ScopeItem>onvif://www.onvif.org/name/go2rtc</tt:ScopeItem></tds:Scopes>
+	<tds:Scopes><tt:ScopeDef>Fixed</tt:ScopeDef><tt:ScopeItem>onvif://www.onvif.org/location/github</tt:ScopeItem></tds:Scopes>
+	<tds:Scopes><tt:ScopeDef>Fixed</tt:ScopeDef><tt:ScopeItem>onvif://www.onvif.org/Profile/Streaming</tt:ScopeItem></tds:Scopes>
+	<tds:Scopes><tt:ScopeDef>Fixed</tt:ScopeDef><tt:ScopeItem>onvif://www.onvif.org/type/Network_Video_Transmitter</tt:ScopeItem></tds:Scopes>
+</tds:GetScopesResponse>`,
+
+	MediaGetAudioEncoderConfigurations: `<trt:GetAudioEncoderConfigurationsResponse />`,
+	MediaGetAudioSources:               `<trt:GetAudioSourcesResponse />`,
+	MediaGetAudioSourceConfigurations:  `<trt:GetAudioSourceConfigurationsResponse />`,
+
+	MediaGetVideoEncoderConfigurationOptions: `<trt:GetVideoEncoderConfigurationOptionsResponse>
+   <trt:Options>
+       <tt:QualityRange><tt:Min>1</tt:Min><tt:Max>6</tt:Max></tt:QualityRange>
+	   <tt:H264>
+		   <tt:ResolutionsAvailable><tt:Width>1920</tt:Width><tt:Height>1080</tt:Height></tt:ResolutionsAvailable>
+		   <tt:GovLengthRange><tt:Min>0</tt:Min><tt:Max>100</tt:Max></tt:GovLengthRange>
+		   <tt:FrameRateRange><tt:Min>1</tt:Min><tt:Max>30</tt:Max></tt:FrameRateRange>
+		   <tt:EncodingIntervalRange><tt:Min>1</tt:Min><tt:Max>100</tt:Max></tt:EncodingIntervalRange>
+           <tt:H264ProfilesSupported>Main</tt:H264ProfilesSupported>
+	   </tt:H264>
+   </trt:Options>
+</trt:GetVideoEncoderConfigurationOptionsResponse>`,
+}
diff --git a/installs_on_host/go2rtc/pkg/opus/README.md b/installs_on_host/go2rtc/pkg/opus/README.md
new file mode 100644
index 0000000..15e3cc8
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/opus/README.md
@@ -0,0 +1,5 @@
+## Useful links
+
+- [RFC 3550: RTP: A Transport Protocol for Real-Time Applications](https://datatracker.ietf.org/doc/html/rfc3550)
+- [RFC 6716: Definition of the Opus Audio Codec](https://datatracker.ietf.org/doc/html/rfc6716)
+- [RFC 7587: RTP Payload Format for the Opus Speech and Audio Codec](https://datatracker.ietf.org/doc/html/rfc7587)
diff --git a/installs_on_host/go2rtc/pkg/opus/homekit.go b/installs_on_host/go2rtc/pkg/opus/homekit.go
new file mode 100644
index 0000000..e0eaee9
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/opus/homekit.go
@@ -0,0 +1,96 @@
+package opus
+
+import (
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+)
+
+// Some info about this magic:
+// - Apple has no respect for RFC 7587 standard and using RFC 3550 for RTP timestamps
+// - Apple can request packets with 20ms duration over LAN connection and 60ms over LTE
+// - FFmpeg produce packets with 20ms duration by default and only one frame per packet
+// - FFmpeg should use "-min_comp 0" option, so every packet will be same duration
+// - Apple doesn't care about real sample rate of track
+// - Apple only cares about proper timestamp based on REQUESTED sample rate
+
+// RepackToHAP - convert standart RTP packet with OPUS to HAP packet
+// We expect that:
+// - incoming packet will be 20ms duration and only one frame per packet
+// - outgouing packet will be 20ms or 60ms duration
+// - incoming sample rate will be any (but not very big if we needs 60ms packets for output)
+// - outgouing sample rate will be 16000
+// https://github.com/AlexxIT/go2rtc/issues/667
+func RepackToHAP(rtpTime byte, handler core.HandlerFunc) core.HandlerFunc {
+	switch rtpTime {
+	case 20:
+		return repackToHAP20(handler)
+	case 60:
+		return repackToHAP60(handler)
+	}
+	return handler
+}
+
+// we using only one sample rate in the pkg/hap/camera/accessory.go
+const (
+	timestamp20 = 16000 * 0.020
+	timestamp60 = 16000 * 0.060
+)
+
+// repackToHAP20 - just fix RTP timestamp from RFC 7587 to RFC 3550
+func repackToHAP20(handler core.HandlerFunc) core.HandlerFunc {
+	var timestamp uint32
+
+	return func(pkt *rtp.Packet) {
+		timestamp += timestamp20
+
+		clone := *pkt
+		clone.Timestamp = timestamp
+		handler(&clone)
+	}
+}
+
+// repackToHAP60 - collect 20ms frames to single 60ms packet
+// thanks to @civita idea https://github.com/AlexxIT/go2rtc/pull/843
+func repackToHAP60(handler core.HandlerFunc) core.HandlerFunc {
+	var sequence uint16
+	var timestamp uint32
+
+	var framesCount byte
+	var framesSize []byte
+	var framesData []byte
+
+	return func(pkt *rtp.Packet) {
+		framesData = append(framesData, pkt.Payload[1:]...)
+
+		if framesCount++; framesCount < 3 {
+			if frameSize := len(pkt.Payload) - 1; frameSize >= 252 {
+				b0 := 252 + byte(frameSize)&0b11
+				framesSize = append(framesSize, b0, byte(frameSize/4)-b0)
+			} else {
+				framesSize = append(framesSize, byte(frameSize))
+			}
+			return
+		}
+
+		toc := pkt.Payload[0]
+
+		payload := make([]byte, 2, 2+len(framesSize)+len(framesData))
+		payload[0] = toc | 0b11  // code 3 (multiple frames per packet)
+		payload[1] = 0b1000_0011 // VBR, no padding, 3 frames
+		payload = append(payload, framesSize...)
+		payload = append(payload, framesData...)
+
+		sequence++
+		timestamp += timestamp60
+
+		clone := *pkt
+		clone.Payload = payload
+		clone.SequenceNumber = sequence
+		clone.Timestamp = timestamp
+		handler(&clone)
+
+		framesCount = 0
+		framesSize = framesSize[:0]
+		framesData = framesData[:0]
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/opus/opus.go b/installs_on_host/go2rtc/pkg/opus/opus.go
new file mode 100644
index 0000000..fb67c66
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/opus/opus.go
@@ -0,0 +1,118 @@
+package opus
+
+import (
+	"time"
+)
+
+type Header struct {
+	Mode       string
+	SampleRate uint16
+	FrameSize  time.Duration
+	Channels   byte
+	Frames     byte
+}
+
+func UnmarshalHeader(b []byte) *Header {
+	// https://datatracker.ietf.org/doc/html/rfc6716#section-3.1
+	b0 := b[0]
+	config := b0 >> 3
+	return &Header{
+		Mode:       parseMode(config),
+		SampleRate: parseSampleRate(config),
+		FrameSize:  parseFrameSize(config),
+		Channels:   parseChannels(b0 >> 2 & 0b1),
+		Frames:     parseFrames(b0 & 0b11),
+	}
+}
+
+func parseMode(config byte) string {
+	if config <= 11 {
+		return "silk"
+	}
+	if config <= 15 {
+		return "hybrid"
+	}
+	return "celt"
+}
+
+func parseSampleRate(config byte) uint16 {
+	switch config {
+	case 0, 1, 2, 3, 16, 17, 18, 19:
+		return 8000 // NB (narrowband)
+	case 4, 5, 6, 7:
+		return 12000 // MB (medium-band)
+	case 8, 9, 10, 11, 20, 21, 22, 23:
+		return 16000 // WB (wideband)
+	case 12, 13, 24, 25, 26, 27:
+		return 24000 // SWB (super-wideband)
+	case 14, 15, 28, 29, 30, 31:
+		return 48000 // FB (fullband)
+	}
+	return 0
+}
+
+func parseFrameSize(config byte) time.Duration {
+	switch config {
+	case 0, 4, 8, 12, 14, 18, 22, 26, 30:
+		return 10_000_000
+	case 1, 5, 9, 13, 15, 19, 23, 27, 31:
+		return 20_000_000
+	case 2, 6, 10:
+		return 40_000_000
+	case 3, 7, 11:
+		return 60_000_000
+	case 16, 20, 24, 28:
+		return 2_500_000
+	case 17, 21, 25, 29:
+		return 5_000_000
+	}
+	return 0
+}
+
+func parseChannels(s byte) byte {
+	if s == 1 {
+		return 2
+	}
+	return 1
+}
+
+func parseFrames(c byte) byte {
+	switch c {
+	case 0:
+		return 1
+	case 1, 2:
+		return 2
+	}
+	return 0xFF
+}
+
+func JoinFrames(b1, b2 []byte) []byte {
+	// can't join
+	if b1[0]&0b11 != 0 || b2[0]&0b11 != 0 {
+		return append(b1, b2...)
+	}
+
+	size1, size2 := len(b1)-1, len(b2)-1
+
+	// join same sizes
+	if size1 == size2 {
+		b := make([]byte, 1+size1+size2)
+		copy(b, b1)
+		copy(b[1+size1:], b2[1:])
+		b[0] |= 0b01
+		return b
+	}
+
+	b := make([]byte, 1, 3+size1+size2)
+	b[0] = b1[0] | 0b10
+	if size1 >= 252 {
+		b0 := 252 + byte(size1)&0b11
+		b = append(b, b0, byte(size1/4)-b0)
+	} else {
+		b = append(b, byte(size1))
+	}
+
+	b = append(b, b1[1:]...)
+	b = append(b, b2[1:]...)
+	return b
+}
diff --git a/installs_on_host/go2rtc/pkg/pcm/backchannel.go b/installs_on_host/go2rtc/pkg/pcm/backchannel.go
new file mode 100644
index 0000000..99b6e3a
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/pcm/backchannel.go
@@ -0,0 +1,69 @@
+package pcm
+
+import (
+	"errors"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/shell"
+	"github.com/pion/rtp"
+)
+
+type Backchannel struct {
+	core.Connection
+	cmd *shell.Command
+}
+
+func NewBackchannel(cmd *shell.Command, audio string) (core.Producer, error) {
+	var codec *core.Codec
+
+	if audio == "" {
+		// default codec
+		codec = &core.Codec{Name: core.CodecPCML, ClockRate: 16000}
+	} else if codec = core.ParseCodecString(audio); codec == nil {
+		return nil, errors.New("pcm: unsupported audio format: " + audio)
+	}
+
+	medias := []*core.Media{
+		{
+			Kind:      core.KindAudio,
+			Direction: core.DirectionSendonly,
+			Codecs:    []*core.Codec{codec},
+		},
+	}
+
+	return &Backchannel{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "pcm",
+			Protocol:   "pipe",
+			Medias:     medias,
+			Transport:  cmd,
+		},
+		cmd: cmd,
+	}, nil
+}
+
+func (c *Backchannel) GetTrack(media *core.Media, codec *core.Codec) (*core.Receiver, error) {
+	return nil, core.ErrCantGetTrack
+}
+
+func (c *Backchannel) AddTrack(media *core.Media, codec *core.Codec, track *core.Receiver) error {
+	wr, err := c.cmd.StdinPipe()
+	if err != nil {
+		return err
+	}
+
+	sender := core.NewSender(media, track.Codec)
+	sender.Handler = func(packet *rtp.Packet) {
+		if n, err := wr.Write(packet.Payload); err != nil {
+			c.Send += n
+		}
+	}
+	sender.HandleRTP(track)
+	c.Senders = append(c.Senders, sender)
+	return nil
+}
+
+func (c *Backchannel) Start() error {
+	return c.cmd.Run()
+}
diff --git a/installs_on_host/go2rtc/pkg/pcm/flac.go b/installs_on_host/go2rtc/pkg/pcm/flac.go
new file mode 100644
index 0000000..808d4a7
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/pcm/flac.go
@@ -0,0 +1,151 @@
+// Package pcm - support raw (verbatim) PCM 16 bit in the FLAC container:
+// - only 1 channel
+// - only 16 bit per sample
+// - only 8000, 16000, 24000, 48000 sample rate
+package pcm
+
+import (
+	"encoding/binary"
+	"unicode/utf8"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+	"github.com/sigurn/crc16"
+	"github.com/sigurn/crc8"
+)
+
+func FLACHeader(magic bool, sampleRate uint32) []byte {
+	b := make([]byte, 42)
+
+	if magic {
+		copy(b, "fLaC") // [0..3]
+	}
+
+	// https://xiph.org/flac/format.html#metadata_block_header
+	b[4] = 0x80 // [4] lastMetadata=1 (1 bit), blockType=0 - STREAMINFO (7 bit)
+	b[7] = 0x22 // [5..7] blockLength=34 (24 bit)
+
+	// Important for Apple QuickTime player:
+	// 1. Both values should be same
+	// 2. Maximum value = 32768
+	binary.BigEndian.PutUint16(b[8:], 32768)  // [8..9] info.BlockSizeMin=16 (16 bit)
+	binary.BigEndian.PutUint16(b[10:], 32768) // [10..11] info.BlockSizeMin=65535 (16 bit)
+
+	// [12..14] info.FrameSizeMin=0 (24 bit)
+	// [15..17] info.FrameSizeMax=0 (24 bit)
+
+	b[18] = byte(sampleRate >> 12)
+	b[19] = byte(sampleRate >> 4)
+	b[20] = byte(sampleRate << 4) // [18..20] info.SampleRate=8000 (20 bit), info.NChannels=1-1 (3 bit)
+
+	b[21] = 0xF0 // [21..25] info.BitsPerSample=16-1 (5 bit), info.NSamples (36 bit)
+
+	// [26..41] MD5sum (16 bytes)
+
+	return b
+}
+
+var table8 *crc8.Table
+var table16 *crc16.Table
+
+func FLACEncoder(codecName string, clockRate uint32, handler core.HandlerFunc) core.HandlerFunc {
+	var sr byte
+	switch clockRate {
+	case 8000:
+		sr = 0b0100
+	case 16000:
+		sr = 0b0101
+	case 22050:
+		sr = 0b0110
+	case 24000:
+		sr = 0b0111
+	case 32000:
+		sr = 0b1000
+	case 44100:
+		sr = 0b1001
+	case 48000:
+		sr = 0b1010
+	case 96000:
+		sr = 0b1011
+	default:
+		return nil
+	}
+
+	if table8 == nil {
+		table8 = crc8.MakeTable(crc8.CRC8)
+	}
+	if table16 == nil {
+		table16 = crc16.MakeTable(crc16.CRC16_BUYPASS)
+	}
+
+	var sampleNumber int32
+
+	return func(packet *rtp.Packet) {
+		samples := uint16(len(packet.Payload))
+
+		if codecName == core.CodecPCM || codecName == core.CodecPCML {
+			samples /= 2
+		}
+
+		// https://xiph.org/flac/format.html#frame_header
+		buf := make([]byte, samples*2+30)
+
+		// 1. Frame header
+		buf[0] = 0xFF
+		buf[1] = 0xF9      // [0..1] syncCode=0xFFF8 - reserved (15 bit), blockStrategy=1 - variable-blocksize (1 bit)
+		buf[2] = 0x70 | sr // blockSizeType=7 (4 bit), sampleRate=4 - 8000 (4 bit)
+		buf[3] = 0x08      // channels=1-1 (4 bit), sampleSize=4 - 16 (3 bit), reserved=0 (1 bit)
+
+		n := 4 + utf8.EncodeRune(buf[4:], sampleNumber) // 4 bytes max
+		sampleNumber += int32(samples)
+
+		// this is wrong but very simple frame block size value
+		binary.BigEndian.PutUint16(buf[n:], samples-1)
+		n += 2
+
+		buf[n] = crc8.Checksum(buf[:n], table8)
+		n += 1
+
+		// 2. Subframe header
+		buf[n] = 0x02 // padding=0 (1 bit), subframeType=1 - verbatim (6 bit), wastedFlag=0 (1 bit)
+		n += 1
+
+		// 3. Subframe
+		switch codecName {
+		case core.CodecPCMA:
+			for _, b := range packet.Payload {
+				s16 := PCMAtoPCM(b)
+				buf[n] = byte(s16 >> 8)
+				buf[n+1] = byte(s16)
+				n += 2
+			}
+		case core.CodecPCMU:
+			for _, b := range packet.Payload {
+				s16 := PCMUtoPCM(b)
+				buf[n] = byte(s16 >> 8)
+				buf[n+1] = byte(s16)
+				n += 2
+			}
+		case core.CodecPCM:
+			n += copy(buf[n:], packet.Payload)
+		case core.CodecPCML:
+			// reverse endian from little to big
+			size := len(packet.Payload)
+			for i := 0; i < size; i += 2 {
+				buf[n] = packet.Payload[i+1]
+				buf[n+1] = packet.Payload[i]
+				n += 2
+			}
+		}
+
+		// 4. Frame footer
+		crc := crc16.Checksum(buf[:n], table16)
+		binary.BigEndian.PutUint16(buf[n:], crc)
+		n += 2
+
+		clone := *packet
+		clone.Payload = buf[:n]
+
+		handler(&clone)
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/pcm/handlers.go b/installs_on_host/go2rtc/pkg/pcm/handlers.go
new file mode 100644
index 0000000..18a9646
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/pcm/handlers.go
@@ -0,0 +1,109 @@
+package pcm
+
+import (
+	"sync"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+)
+
+// RepackG711 - Repack G.711 PCMA/PCMU into frames of size 1024
+//  1. Fixes WebRTC audio quality issue (monotonic timestamp)
+//  2. Fixes Reolink Doorbell backchannel issue (zero timestamp)
+//     https://github.com/AlexxIT/go2rtc/issues/331
+func RepackG711(zeroTS bool, handler core.HandlerFunc) core.HandlerFunc {
+	const PacketSize = 1024
+
+	var buf []byte
+	var seq uint16
+	var ts uint32
+
+	// fix https://github.com/AlexxIT/go2rtc/issues/432
+	var mu sync.Mutex
+
+	return func(packet *rtp.Packet) {
+		mu.Lock()
+
+		buf = append(buf, packet.Payload...)
+		if len(buf) < PacketSize {
+			mu.Unlock()
+			return
+		}
+
+		pkt := &rtp.Packet{
+			Header: rtp.Header{
+				Version:        2,
+				Marker:         true,               // should be true
+				PayloadType:    packet.PayloadType, // will be owerwriten
+				SequenceNumber: seq,
+				SSRC:           packet.SSRC,
+			},
+			Payload: buf[:PacketSize],
+		}
+
+		seq++
+
+		// don't know if zero TS important for Reolink Doorbell
+		// don't have this strange devices for tests
+		if !zeroTS {
+			pkt.Timestamp = ts
+			ts += PacketSize
+		}
+
+		buf = buf[PacketSize:]
+
+		mu.Unlock()
+
+		handler(pkt)
+	}
+}
+
+// LittleToBig - convert PCM little endian to PCM big endian
+func LittleToBig(handler core.HandlerFunc) core.HandlerFunc {
+	return func(packet *rtp.Packet) {
+		clone := *packet
+		clone.Payload = FlipEndian(packet.Payload)
+		handler(&clone)
+	}
+}
+
+func TranscodeHandler(dst, src *core.Codec, handler core.HandlerFunc) core.HandlerFunc {
+	var ts uint32
+	k := float32(BytesPerFrame(dst)) / float32(BytesPerFrame(src))
+	f := Transcode(dst, src)
+
+	return func(packet *rtp.Packet) {
+		ts += uint32(k * float32(len(packet.Payload)))
+
+		clone := *packet
+		clone.Payload = f(packet.Payload)
+		clone.Timestamp = ts
+		handler(&clone)
+	}
+}
+
+func BytesPerSample(codec *core.Codec) int {
+	switch codec.Name {
+	case core.CodecPCML, core.CodecPCM:
+		return 2
+	case core.CodecPCMU, core.CodecPCMA:
+		return 1
+	}
+	return 0
+}
+
+func BytesPerFrame(codec *core.Codec) int {
+	if codec.Channels <= 1 {
+		return BytesPerSample(codec)
+	}
+	return int(codec.Channels) * BytesPerSample(codec)
+}
+
+func FramesPerDuration(codec *core.Codec, duration time.Duration) int {
+	return int(time.Duration(codec.ClockRate) * duration / time.Second)
+}
+
+func BytesPerDuration(codec *core.Codec, duration time.Duration) int {
+	return BytesPerFrame(codec) * FramesPerDuration(codec, duration)
+}
diff --git a/installs_on_host/go2rtc/pkg/pcm/pcm.go b/installs_on_host/go2rtc/pkg/pcm/pcm.go
new file mode 100644
index 0000000..5395621
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/pcm/pcm.go
@@ -0,0 +1,220 @@
+package pcm
+
+import (
+	"math"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func ceil(x float32) int {
+	d, fract := math.Modf(float64(x))
+	if fract == 0.0 {
+		return int(d)
+	}
+	return int(d) + 1
+}
+
+func Downsample(k float32) func([]int16) []int16 {
+	var sampleN, sampleSum float32
+
+	return func(src []int16) (dst []int16) {
+		var i int
+		dst = make([]int16, ceil((float32(len(src))+sampleN)/k))
+		for _, sample := range src {
+			sampleSum += float32(sample)
+			sampleN++
+			if sampleN >= k {
+				dst[i] = int16(sampleSum / k)
+				i++
+
+				sampleSum = 0
+				sampleN -= k
+			}
+		}
+		return
+	}
+}
+
+func Upsample(k float32) func([]int16) []int16 {
+	var sampleN float32
+
+	return func(src []int16) (dst []int16) {
+		var i int
+		dst = make([]int16, ceil(k*float32(len(src))))
+		for _, sample := range src {
+			sampleN += k
+			for sampleN > 0 {
+				dst[i] = sample
+				i++
+
+				sampleN -= 1
+			}
+		}
+		return
+	}
+}
+
+func FlipEndian(src []byte) (dst []byte) {
+	var i, j int
+	n := len(src)
+	dst = make([]byte, n)
+	for i < n {
+		x := src[i]
+		i++
+		dst[j] = src[i]
+		j++
+		i++
+		dst[j] = x
+		j++
+	}
+	return
+}
+
+func Transcode(dst, src *core.Codec) func([]byte) []byte {
+	var reader func([]byte) []int16
+	var writer func([]int16) []byte
+	var filters []func([]int16) []int16
+
+	switch src.Name {
+	case core.CodecPCML:
+		reader = func(src []byte) (dst []int16) {
+			var i, j int
+			n := len(src)
+			dst = make([]int16, n/2)
+			for i < n {
+				lo := src[i]
+				i++
+				hi := src[i]
+				i++
+				dst[j] = int16(hi)<<8 | int16(lo)
+				j++
+			}
+			return
+		}
+	case core.CodecPCM:
+		reader = func(src []byte) (dst []int16) {
+			var i, j int
+			n := len(src)
+			dst = make([]int16, n/2)
+			for i < n {
+				hi := src[i]
+				i++
+				lo := src[i]
+				i++
+				dst[j] = int16(hi)<<8 | int16(lo)
+				j++
+			}
+			return
+		}
+	case core.CodecPCMU:
+		reader = func(src []byte) (dst []int16) {
+			var i int
+			dst = make([]int16, len(src))
+			for _, sample := range src {
+				dst[i] = PCMUtoPCM(sample)
+				i++
+			}
+			return
+		}
+	case core.CodecPCMA:
+		reader = func(src []byte) (dst []int16) {
+			var i int
+			dst = make([]int16, len(src))
+			for _, sample := range src {
+				dst[i] = PCMAtoPCM(sample)
+				i++
+			}
+			return
+		}
+	}
+
+	if src.Channels > 1 {
+		filters = append(filters, Downsample(float32(src.Channels)))
+	}
+
+	if src.ClockRate > dst.ClockRate {
+		filters = append(filters, Downsample(float32(src.ClockRate)/float32(dst.ClockRate)))
+	} else if src.ClockRate < dst.ClockRate {
+		filters = append(filters, Upsample(float32(dst.ClockRate)/float32(src.ClockRate)))
+	}
+
+	if dst.Channels > 1 {
+		filters = append(filters, Upsample(float32(dst.Channels)))
+	}
+
+	switch dst.Name {
+	case core.CodecPCML:
+		writer = func(src []int16) (dst []byte) {
+			var i int
+			dst = make([]byte, len(src)*2)
+			for _, sample := range src {
+				dst[i] = byte(sample)
+				i++
+				dst[i] = byte(sample >> 8)
+				i++
+			}
+			return
+		}
+	case core.CodecPCM:
+		writer = func(src []int16) (dst []byte) {
+			var i int
+			dst = make([]byte, len(src)*2)
+			for _, sample := range src {
+				dst[i] = byte(sample >> 8)
+				i++
+				dst[i] = byte(sample)
+				i++
+			}
+			return
+		}
+	case core.CodecPCMU:
+		writer = func(src []int16) (dst []byte) {
+			var i int
+			dst = make([]byte, len(src))
+			for _, sample := range src {
+				dst[i] = PCMtoPCMU(sample)
+				i++
+			}
+			return
+		}
+	case core.CodecPCMA:
+		writer = func(src []int16) (dst []byte) {
+			var i int
+			dst = make([]byte, len(src))
+			for _, sample := range src {
+				dst[i] = PCMtoPCMA(sample)
+				i++
+			}
+			return
+		}
+	}
+
+	return func(b []byte) []byte {
+		samples := reader(b)
+		for _, filter := range filters {
+			samples = filter(samples)
+		}
+		return writer(samples)
+	}
+}
+
+func ConsumerCodecs() []*core.Codec {
+	return []*core.Codec{
+		{Name: core.CodecPCML},
+		{Name: core.CodecPCM},
+		{Name: core.CodecPCMA},
+		{Name: core.CodecPCMU},
+	}
+}
+
+func ProducerCodecs() []*core.Codec {
+	return []*core.Codec{
+		{Name: core.CodecPCML, ClockRate: 16000},
+		{Name: core.CodecPCM, ClockRate: 16000},
+		{Name: core.CodecPCML, ClockRate: 8000},
+		{Name: core.CodecPCM, ClockRate: 8000},
+		{Name: core.CodecPCMA, ClockRate: 8000},
+		{Name: core.CodecPCMU, ClockRate: 8000},
+		{Name: core.CodecPCML, ClockRate: 22050}, // wyoming-snd-external
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/pcm/pcm_test.go b/installs_on_host/go2rtc/pkg/pcm/pcm_test.go
new file mode 100644
index 0000000..2832be6
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/pcm/pcm_test.go
@@ -0,0 +1,79 @@
+package pcm
+
+import (
+	"encoding/hex"
+	"fmt"
+	"testing"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/stretchr/testify/require"
+)
+
+func TestTranscode(t *testing.T) {
+	tests := []struct {
+		name   string
+		src    core.Codec
+		dst    core.Codec
+		source string
+		expect string
+	}{
+		{
+			name:   "s16be->s16be",
+			src:    core.Codec{Name: core.CodecPCM, ClockRate: 8000, Channels: 1},
+			dst:    core.Codec{Name: core.CodecPCM, ClockRate: 8000, Channels: 1},
+			source: "FCCA00130343062808130B510D9E0F7610DA111113EA15BD16F2168215D41561",
+			expect: "FCCA00130343062808130B510D9E0F7610DA111113EA15BD16F2168215D41561",
+		},
+		{
+			name:   "s16be->s16le",
+			src:    core.Codec{Name: core.CodecPCM, ClockRate: 8000, Channels: 1},
+			dst:    core.Codec{Name: core.CodecPCML, ClockRate: 8000, Channels: 1},
+			source: "FCCA00130343062808130B510D9E0F7610DA111113EA15BD16F2168215D41561",
+			expect: "CAFC1300430328061308510B9E0D760FDA101111EA13BD15F2168216D4156115",
+		},
+		{
+			name:   "s16be->mulaw",
+			src:    core.Codec{Name: core.CodecPCM, ClockRate: 8000, Channels: 1},
+			dst:    core.Codec{Name: core.CodecPCMU, ClockRate: 8000, Channels: 1},
+			source: "FCCA00130343062808130B510D9E0F7610DA111113EA15BD16F2168215D41561",
+			expect: "52FDD1C5BEB8B3B0AEAEABA9A8A8A9AA",
+		},
+		{
+			name:   "s16be->alaw",
+			src:    core.Codec{Name: core.CodecPCM, ClockRate: 8000, Channels: 1},
+			dst:    core.Codec{Name: core.CodecPCMA, ClockRate: 8000, Channels: 1},
+			source: "FCCA00130343062808130B510D9E0F7610DA111113EA15BD16F2168215D41561",
+			expect: "7CD4FFED95939E9B8584868083838080",
+		},
+		{
+			name:   "2ch->1ch",
+			src:    core.Codec{Name: core.CodecPCM, ClockRate: 8000, Channels: 2},
+			dst:    core.Codec{Name: core.CodecPCM, ClockRate: 8000, Channels: 1},
+			source: "FCCAFCCA001300130343034306280628081308130B510B510D9E0D9E0F760F76",
+			expect: "FCCA00130343062808130B510D9E0F76",
+		},
+		{
+			name:   "1ch->2ch",
+			src:    core.Codec{Name: core.CodecPCM, ClockRate: 8000, Channels: 1},
+			dst:    core.Codec{Name: core.CodecPCM, ClockRate: 8000, Channels: 2},
+			source: "FCCA00130343062808130B510D9E0F76",
+			expect: "FCCAFCCA001300130343034306280628081308130B510B510D9E0D9E0F760F76",
+		},
+		{
+			name:   "16khz->8khz",
+			src:    core.Codec{Name: core.CodecPCM, ClockRate: 16000, Channels: 1},
+			dst:    core.Codec{Name: core.CodecPCM, ClockRate: 8000, Channels: 1},
+			source: "FCCAFCCA001300130343034306280628081308130B510B510D9E0D9E0F760F76",
+			expect: "FCCA00130343062808130B510D9E0F76",
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			f := Transcode(&test.dst, &test.src)
+			b, _ := hex.DecodeString(test.source)
+			b = f(b)
+			s := fmt.Sprintf("%X", b)
+			require.Equal(t, test.expect, s)
+		})
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/pcm/pcma.go b/installs_on_host/go2rtc/pkg/pcm/pcma.go
new file mode 100644
index 0000000..3e1ef11
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/pcm/pcma.go
@@ -0,0 +1,53 @@
+// Package pcm
+// https://www.codeproject.com/Articles/14237/Using-the-G711-standard
+package pcm
+
+const alawMax = 0x7FFF
+
+func PCMAtoPCM(alaw byte) int16 {
+	alaw ^= 0xD5
+
+	data := int16(((alaw & 0x0F) << 4) + 8)
+	exponent := (alaw & 0x70) >> 4
+
+	if exponent != 0 {
+		data |= 0x100
+	}
+
+	if exponent > 1 {
+		data <<= exponent - 1
+	}
+
+	// sign
+	if alaw&0x80 == 0 {
+		return data
+	} else {
+		return -data
+	}
+}
+
+func PCMtoPCMA(pcm int16) byte {
+	var alaw byte
+
+	if pcm < 0 {
+		pcm = -pcm
+		alaw = 0x80
+	}
+
+	if pcm > alawMax {
+		pcm = alawMax
+	}
+
+	exponent := byte(7)
+	for expMask := int16(0x4000); (pcm&expMask) == 0 && exponent > 0; expMask >>= 1 {
+		exponent--
+	}
+
+	if exponent == 0 {
+		alaw |= byte(pcm>>4) & 0x0F
+	} else {
+		alaw |= (exponent << 4) | (byte(pcm>>(exponent+3)) & 0x0F)
+	}
+
+	return alaw ^ 0xD5
+}
diff --git a/installs_on_host/go2rtc/pkg/pcm/pcmu.go b/installs_on_host/go2rtc/pkg/pcm/pcmu.go
new file mode 100644
index 0000000..954d8a9
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/pcm/pcmu.go
@@ -0,0 +1,51 @@
+// Package pcm
+// https://www.codeproject.com/Articles/14237/Using-the-G711-standard
+package pcm
+
+const bias = 0x84 // 132 or 1000 0100
+const ulawMax = alawMax - bias
+
+func PCMUtoPCM(ulaw byte) int16 {
+	ulaw = ^ulaw
+
+	exponent := (ulaw & 0x70) >> 4
+	data := (int16((((ulaw&0x0F)|0x10)<<1)+1) << (exponent + 2)) - bias
+
+	// sign
+	if ulaw&0x80 == 0 {
+		return data
+	} else if data == 0 {
+		return -1
+	} else {
+		return -data
+	}
+}
+
+func PCMtoPCMU(pcm int16) byte {
+	var ulaw byte
+
+	if pcm < 0 {
+		pcm = -pcm
+		ulaw = 0x80
+	}
+
+	if pcm > ulawMax {
+		pcm = ulawMax
+	}
+
+	pcm += bias
+
+	exponent := byte(7)
+	for expMask := int16(0x4000); (pcm & expMask) == 0; expMask >>= 1 {
+		exponent--
+	}
+
+	// mantisa
+	ulaw |= byte(pcm>>(exponent+3)) & 0x0F
+
+	if exponent > 0 {
+		ulaw |= exponent << 4
+	}
+
+	return ^ulaw
+}
diff --git a/installs_on_host/go2rtc/pkg/pcm/producer.go b/installs_on_host/go2rtc/pkg/pcm/producer.go
new file mode 100644
index 0000000..8a957f6
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/pcm/producer.go
@@ -0,0 +1,55 @@
+package pcm
+
+import (
+	"io"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+)
+
+type Producer struct {
+	core.Connection
+	rd io.Reader
+}
+
+func Open(rd io.Reader) (*Producer, error) {
+	medias := []*core.Media{
+		{
+			Kind:      core.KindAudio,
+			Direction: core.DirectionRecvonly,
+			Codecs: []*core.Codec{
+				{Name: core.CodecPCMU, ClockRate: 8000},
+			},
+		},
+	}
+	return &Producer{
+		core.Connection{
+			ID:         core.NewID(),
+			FormatName: "pcm",
+			Medias:     medias,
+			Transport:  rd,
+		},
+		rd,
+	}, nil
+}
+
+func (c *Producer) Start() error {
+	for {
+		payload := make([]byte, 1024)
+		if _, err := io.ReadFull(c.rd, payload); err != nil {
+			return err
+		}
+
+		c.Recv += 1024
+
+		if len(c.Receivers) == 0 {
+			continue
+		}
+
+		pkt := &rtp.Packet{
+			Header:  rtp.Header{Timestamp: core.Now90000()},
+			Payload: payload,
+		}
+		c.Receivers[0].WriteRTP(pkt)
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/pcm/producer_sync.go b/installs_on_host/go2rtc/pkg/pcm/producer_sync.go
new file mode 100644
index 0000000..fedef26
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/pcm/producer_sync.go
@@ -0,0 +1,96 @@
+package pcm
+
+import (
+	"io"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+)
+
+type ProducerSync struct {
+	core.Connection
+	src     *core.Codec
+	rd      io.Reader
+	onClose func()
+}
+
+func OpenSync(codec *core.Codec, rd io.Reader) *ProducerSync {
+	medias := []*core.Media{
+		{
+			Kind:      core.KindAudio,
+			Direction: core.DirectionRecvonly,
+			Codecs:    ProducerCodecs(),
+		},
+	}
+
+	return &ProducerSync{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "pcm",
+			Medias:     medias,
+			Transport:  rd,
+		},
+		src: codec,
+		rd:  rd,
+	}
+}
+
+func (p *ProducerSync) OnClose(f func()) {
+	p.onClose = f
+}
+
+func (p *ProducerSync) Start() error {
+	if len(p.Receivers) == 0 {
+		return nil
+	}
+
+	var pktSeq uint16
+	var pktTS uint32          // time in frames
+	var pktTime time.Duration // time in seconds
+
+	t0 := time.Now()
+
+	dst := p.Receivers[0].Codec
+	transcode := Transcode(dst, p.src)
+
+	const chunkDuration = 20 * time.Millisecond
+	chunkBytes := BytesPerDuration(p.src, chunkDuration)
+	chunkFrames := uint32(FramesPerDuration(dst, chunkDuration))
+
+	for {
+		buf := make([]byte, chunkBytes)
+		n, _ := io.ReadFull(p.rd, buf)
+
+		if n == 0 {
+			break
+		}
+
+		pkt := &core.Packet{
+			Header: rtp.Header{
+				Version:        2,
+				Marker:         true,
+				SequenceNumber: pktSeq,
+				Timestamp:      pktTS,
+			},
+			Payload: transcode(buf[:n]),
+		}
+
+		if d := pktTime - time.Since(t0); d > 0 {
+			time.Sleep(d)
+		}
+
+		p.Receivers[0].WriteRTP(pkt)
+		p.Recv += n
+
+		pktSeq++
+		pktTS += chunkFrames
+		pktTime += chunkDuration
+	}
+
+	if p.onClose != nil {
+		p.onClose()
+	}
+
+	return nil
+}
diff --git a/installs_on_host/go2rtc/pkg/pcm/s16le/s16le.go b/installs_on_host/go2rtc/pkg/pcm/s16le/s16le.go
new file mode 100644
index 0000000..acd2d4f
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/pcm/s16le/s16le.go
@@ -0,0 +1,42 @@
+package s16le
+
+func PeaksRMS(b []byte) int16 {
+	// RMS of sine wave = peak / sqrt2
+	// https://en.wikipedia.org/wiki/Root_mean_square
+	// https://www.youtube.com/watch?v=MUDkL4KZi0I
+	var peaks int32
+	var peaksSum int32
+	var prevSample int16
+	var prevUp bool
+
+	var i int
+	for n := len(b); i < n; {
+		lo := b[i]
+		i++
+		hi := b[i]
+		i++
+
+		sample := int16(hi)<<8 | int16(lo)
+		up := sample >= prevSample
+
+		if i >= 4 {
+			if up != prevUp {
+				if prevSample >= 0 {
+					peaksSum += int32(prevSample)
+				} else {
+					peaksSum -= int32(prevSample)
+				}
+				peaks++
+			}
+		}
+
+		prevSample = sample
+		prevUp = up
+	}
+
+	if peaks == 0 {
+		return 0
+	}
+
+	return int16(peaksSum / peaks)
+}
diff --git a/installs_on_host/go2rtc/pkg/pcm/v1/pcm.go b/installs_on_host/go2rtc/pkg/pcm/v1/pcm.go
new file mode 100644
index 0000000..e165235
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/pcm/v1/pcm.go
@@ -0,0 +1,155 @@
+// Package v1
+// http://web.archive.org/web/20110719132013/http://hazelware.luggle.com/tutorials/mulawcompression.html
+package v1
+
+const cBias = 0x84
+const cClip = 32635
+
+var MuLawCompressTable = [256]byte{
+	0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
+	4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+	5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+	5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+}
+
+func LinearToMuLawSample(sample int16) byte {
+	sign := byte(sample>>8) & 0x80
+	if sign != 0 {
+		sample = -sample
+	}
+
+	if sample > cClip {
+		sample = cClip
+	}
+	sample = sample + cBias
+
+	exponent := MuLawCompressTable[(sample>>7)&0xFF]
+	mantissa := byte(sample>>(exponent+3)) & 0x0F
+
+	compressedByte := ^(sign | (exponent << 4) | mantissa)
+
+	return compressedByte
+}
+
+var ALawCompressTable = [128]byte{
+	1, 1, 2, 2, 3, 3, 3, 3,
+	4, 4, 4, 4, 4, 4, 4, 4,
+	5, 5, 5, 5, 5, 5, 5, 5,
+	5, 5, 5, 5, 5, 5, 5, 5,
+	6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6,
+	7, 7, 7, 7, 7, 7, 7, 7,
+	7, 7, 7, 7, 7, 7, 7, 7,
+	7, 7, 7, 7, 7, 7, 7, 7,
+	7, 7, 7, 7, 7, 7, 7, 7,
+	7, 7, 7, 7, 7, 7, 7, 7,
+	7, 7, 7, 7, 7, 7, 7, 7,
+	7, 7, 7, 7, 7, 7, 7, 7,
+	7, 7, 7, 7, 7, 7, 7, 7,
+}
+
+func LinearToALawSample(sample int16) byte {
+	sign := byte((^sample)>>8) & 0x80
+	if sign == 0 {
+		sample = -sample
+	}
+
+	if sample > cClip {
+		sample = cClip
+	}
+
+	var compressedByte byte
+	if sample >= 256 {
+		exponent := ALawCompressTable[(sample>>8)&0x7F]
+		mantissa := byte(sample>>(exponent+3)) & 0x0F
+		compressedByte = (exponent << 4) | mantissa
+	} else {
+		compressedByte = byte(sample >> 4)
+	}
+	compressedByte ^= sign ^ 0x55
+	return compressedByte
+}
+
+var MuLawDecompressTable = [256]int16{
+	-32124, -31100, -30076, -29052, -28028, -27004, -25980, -24956,
+	-23932, -22908, -21884, -20860, -19836, -18812, -17788, -16764,
+	-15996, -15484, -14972, -14460, -13948, -13436, -12924, -12412,
+	-11900, -11388, -10876, -10364, -9852, -9340, -8828, -8316,
+	-7932, -7676, -7420, -7164, -6908, -6652, -6396, -6140,
+	-5884, -5628, -5372, -5116, -4860, -4604, -4348, -4092,
+	-3900, -3772, -3644, -3516, -3388, -3260, -3132, -3004,
+	-2876, -2748, -2620, -2492, -2364, -2236, -2108, -1980,
+	-1884, -1820, -1756, -1692, -1628, -1564, -1500, -1436,
+	-1372, -1308, -1244, -1180, -1116, -1052, -988, -924,
+	-876, -844, -812, -780, -748, -716, -684, -652,
+	-620, -588, -556, -524, -492, -460, -428, -396,
+	-372, -356, -340, -324, -308, -292, -276, -260,
+	-244, -228, -212, -196, -180, -164, -148, -132,
+	-120, -112, -104, -96, -88, -80, -72, -64,
+	-56, -48, -40, -32, -24, -16, -8, -1,
+	32124, 31100, 30076, 29052, 28028, 27004, 25980, 24956,
+	23932, 22908, 21884, 20860, 19836, 18812, 17788, 16764,
+	15996, 15484, 14972, 14460, 13948, 13436, 12924, 12412,
+	11900, 11388, 10876, 10364, 9852, 9340, 8828, 8316,
+	7932, 7676, 7420, 7164, 6908, 6652, 6396, 6140,
+	5884, 5628, 5372, 5116, 4860, 4604, 4348, 4092,
+	3900, 3772, 3644, 3516, 3388, 3260, 3132, 3004,
+	2876, 2748, 2620, 2492, 2364, 2236, 2108, 1980,
+	1884, 1820, 1756, 1692, 1628, 1564, 1500, 1436,
+	1372, 1308, 1244, 1180, 1116, 1052, 988, 924,
+	876, 844, 812, 780, 748, 716, 684, 652,
+	620, 588, 556, 524, 492, 460, 428, 396,
+	372, 356, 340, 324, 308, 292, 276, 260,
+	244, 228, 212, 196, 180, 164, 148, 132,
+	120, 112, 104, 96, 88, 80, 72, 64,
+	56, 48, 40, 32, 24, 16, 8, 0,
+}
+
+var ALawDecompressTable = [256]int16{
+	-5504, -5248, -6016, -5760, -4480, -4224, -4992, -4736,
+	-7552, -7296, -8064, -7808, -6528, -6272, -7040, -6784,
+	-2752, -2624, -3008, -2880, -2240, -2112, -2496, -2368,
+	-3776, -3648, -4032, -3904, -3264, -3136, -3520, -3392,
+	-22016, -20992, -24064, -23040, -17920, -16896, -19968, -18944,
+	-30208, -29184, -32256, -31232, -26112, -25088, -28160, -27136,
+	-11008, -10496, -12032, -11520, -8960, -8448, -9984, -9472,
+	-15104, -14592, -16128, -15616, -13056, -12544, -14080, -13568,
+	-344, -328, -376, -360, -280, -264, -312, -296,
+	-472, -456, -504, -488, -408, -392, -440, -424,
+	-88, -72, -120, -104, -24, -8, -56, -40,
+	-216, -200, -248, -232, -152, -136, -184, -168,
+	-1376, -1312, -1504, -1440, -1120, -1056, -1248, -1184,
+	-1888, -1824, -2016, -1952, -1632, -1568, -1760, -1696,
+	-688, -656, -752, -720, -560, -528, -624, -592,
+	-944, -912, -1008, -976, -816, -784, -880, -848,
+	5504, 5248, 6016, 5760, 4480, 4224, 4992, 4736,
+	7552, 7296, 8064, 7808, 6528, 6272, 7040, 6784,
+	2752, 2624, 3008, 2880, 2240, 2112, 2496, 2368,
+	3776, 3648, 4032, 3904, 3264, 3136, 3520, 3392,
+	22016, 20992, 24064, 23040, 17920, 16896, 19968, 18944,
+	30208, 29184, 32256, 31232, 26112, 25088, 28160, 27136,
+	11008, 10496, 12032, 11520, 8960, 8448, 9984, 9472,
+	15104, 14592, 16128, 15616, 13056, 12544, 14080, 13568,
+	344, 328, 376, 360, 280, 264, 312, 296,
+	472, 456, 504, 488, 408, 392, 440, 424,
+	88, 72, 120, 104, 24, 8, 56, 40,
+	216, 200, 248, 232, 152, 136, 184, 168,
+	1376, 1312, 1504, 1440, 1120, 1056, 1248, 1184,
+	1888, 1824, 2016, 1952, 1632, 1568, 1760, 1696,
+	688, 656, 752, 720, 560, 528, 624, 592,
+	944, 912, 1008, 976, 816, 784, 880, 848,
+}
diff --git a/installs_on_host/go2rtc/pkg/pcm/v1/pcm_test.go b/installs_on_host/go2rtc/pkg/pcm/v1/pcm_test.go
new file mode 100644
index 0000000..07b70b9
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/pcm/v1/pcm_test.go
@@ -0,0 +1,40 @@
+package v1
+
+import (
+	"testing"
+
+	v2 "github.com/AlexxIT/go2rtc/pkg/pcm"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPCMUtoPCM(t *testing.T) {
+	for pcmu := byte(0); pcmu < 255; pcmu++ {
+		pcm1 := MuLawDecompressTable[pcmu]
+		pcm2 := v2.PCMUtoPCM(pcmu)
+		require.Equal(t, pcm1, pcm2)
+	}
+}
+
+func TestPCMAtoPCM(t *testing.T) {
+	for pcma := byte(0); pcma < 255; pcma++ {
+		pcm1 := ALawDecompressTable[pcma]
+		pcm2 := v2.PCMAtoPCM(pcma)
+		require.Equal(t, pcm1, pcm2)
+	}
+}
+
+func TestPCMtoPCMU(t *testing.T) {
+	for pcm := int16(-32768); pcm < 32767; pcm++ {
+		pcmu1 := LinearToMuLawSample(pcm)
+		pcmu2 := v2.PCMtoPCMU(pcm)
+		require.Equal(t, pcmu1, pcmu2)
+	}
+}
+
+func TestPCMtoPCMA(t *testing.T) {
+	for pcm := int16(-32768); pcm < 32767; pcm++ {
+		pcma1 := LinearToALawSample(pcm)
+		pcma2 := v2.PCMtoPCMA(pcm)
+		require.Equal(t, pcma1, pcma2)
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/pinggy/pinggy.go b/installs_on_host/go2rtc/pkg/pinggy/pinggy.go
new file mode 100644
index 0000000..22ebfc9
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/pinggy/pinggy.go
@@ -0,0 +1,137 @@
+package pinggy
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"io"
+	"net"
+	"net/http"
+	"time"
+
+	"golang.org/x/crypto/ssh"
+)
+
+type Client struct {
+	SSH *ssh.Client
+	TCP net.Listener
+	API *http.Client
+}
+
+func NewClient(proto string) (*Client, error) {
+	switch proto {
+	case "http", "tcp", "tls", "tlstcp":
+	case "":
+		proto = "http"
+	default:
+		return nil, errors.New("pinggy: unsupported proto: " + proto)
+	}
+
+	config := &ssh.ClientConfig{
+		User:            "auth+" + proto,
+		Auth:            []ssh.AuthMethod{ssh.Password("nopass")},
+		HostKeyCallback: ssh.InsecureIgnoreHostKey(),
+		Timeout:         5 * time.Second,
+	}
+
+	client, err := ssh.Dial("tcp", "a.pinggy.io:443", config)
+	if err != nil {
+		return nil, err
+	}
+
+	ln, err := client.Listen("tcp", "0.0.0.0:0")
+	if err != nil {
+		_ = client.Close()
+		return nil, err
+	}
+
+	c := &Client{
+		SSH: client,
+		TCP: ln,
+		API: &http.Client{
+			Transport: &http.Transport{
+				DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
+					return client.Dial(network, addr)
+				},
+			},
+		},
+	}
+
+	if proto == "http" {
+		if err = c.NewSession(); err != nil {
+			_ = client.Close()
+			return nil, err
+		}
+	}
+
+	return c, nil
+}
+
+func (c *Client) Close() error {
+	return errors.Join(c.SSH.Close(), c.TCP.Close())
+}
+
+func (c *Client) NewSession() error {
+	session, err := c.SSH.NewSession()
+	if err != nil {
+		return err
+	}
+	return session.Shell()
+}
+
+func (c *Client) GetURLs() ([]string, error) {
+	res, err := c.API.Get("http://localhost:4300/urls")
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+
+	var v struct {
+		URLs []string `json:"urls"`
+	}
+
+	if err = json.NewDecoder(res.Body).Decode(&v); err != nil {
+		return nil, err
+	}
+
+	return v.URLs, nil
+}
+
+func (c *Client) Proxy(address string) error {
+	defer c.TCP.Close()
+
+	for {
+		conn, err := c.TCP.Accept()
+		if err != nil {
+			return err
+		}
+		go proxy(conn, address)
+	}
+}
+
+func proxy(conn1 net.Conn, address string) {
+	defer conn1.Close()
+
+	conn2, err := net.Dial("tcp", address)
+	if err != nil {
+		return
+	}
+	defer conn2.Close()
+
+	go io.Copy(conn2, conn1)
+	io.Copy(conn1, conn2)
+}
+
+// DialTLS like ssh.Dial but with TLS
+//func DialTLS(network, addr, sni string, config *ssh.ClientConfig) (*ssh.Client, error) {
+//	conn, err := net.DialTimeout(network, addr, config.Timeout)
+//	if err != nil {
+//		return nil, err
+//	}
+//	conn = tls.Client(conn, &tls.Config{ServerName: sni, InsecureSkipVerify: sni == ""})
+//	c, chans, reqs, err := ssh.NewClientConn(conn, addr, config)
+//	if err != nil {
+//		return nil, err
+//	}
+//	return ssh.NewClient(c, chans, reqs), nil
+//}
diff --git a/installs_on_host/go2rtc/pkg/probe/consumer.go b/installs_on_host/go2rtc/pkg/probe/consumer.go
new file mode 100644
index 0000000..a1ca7ca
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/probe/consumer.go
@@ -0,0 +1,53 @@
+package probe
+
+import (
+	"net/url"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+type Probe struct {
+	core.Connection
+}
+
+func Create(name string, query url.Values) *Probe {
+	medias := core.ParseQuery(query)
+
+	for _, value := range query["microphone"] {
+		media := &core.Media{Kind: core.KindAudio, Direction: core.DirectionRecvonly}
+
+		for _, name := range strings.Split(value, ",") {
+			name = strings.ToUpper(name)
+			switch name {
+			case "", "COPY":
+				name = core.CodecAny
+			}
+			media.Codecs = append(media.Codecs, &core.Codec{Name: name})
+		}
+
+		medias = append(medias, media)
+	}
+
+	return &Probe{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: name,
+			Medias:     medias,
+		},
+	}
+}
+
+func (p *Probe) AddTrack(media *core.Media, codec *core.Codec, track *core.Receiver) error {
+	sender := core.NewSender(media, track.Codec)
+	sender.Handler = func(pkt *core.Packet) {
+		p.Send += len(pkt.Payload)
+	}
+	sender.HandleRTP(track)
+	p.Senders = append(p.Senders, sender)
+	return nil
+}
+
+func (p *Probe) Start() error {
+	return nil
+}
diff --git a/installs_on_host/go2rtc/pkg/ring/api.go b/installs_on_host/go2rtc/pkg/ring/api.go
new file mode 100644
index 0000000..ea7c95a
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/ring/api.go
@@ -0,0 +1,702 @@
+package ring
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"reflect"
+	"strings"
+	"sync"
+	"time"
+)
+
+var clientCache = map[string]*RingApi{}
+var cacheMutex sync.Mutex
+
+type RefreshTokenAuth struct {
+	RefreshToken string
+}
+
+type EmailAuth struct {
+	Email    string
+	Password string
+}
+
+type AuthConfig struct {
+	RT  string `json:"rt"`  // Refresh Token
+	HID string `json:"hid"` // Hardware ID
+}
+
+type AuthTokenResponse struct {
+	AccessToken  string `json:"access_token"`
+	ExpiresIn    int    `json:"expires_in"`
+	RefreshToken string `json:"refresh_token"`
+	Scope        string `json:"scope"`      // Always "client"
+	TokenType    string `json:"token_type"` // Always "Bearer"
+}
+
+type Auth2faResponse struct {
+	Error            string `json:"error"`
+	ErrorDescription string `json:"error_description"`
+	TSVState         string `json:"tsv_state"`
+	Phone            string `json:"phone"`
+	NextTimeInSecs   int    `json:"next_time_in_secs"`
+}
+
+type SocketTicketResponse struct {
+	Ticket            string `json:"ticket"`
+	ResponseTimestamp int64  `json:"response_timestamp"`
+}
+
+type SessionResponse struct {
+	Profile struct {
+		ID        int64  `json:"id"`
+		Email     string `json:"email"`
+		FirstName string `json:"first_name"`
+		LastName  string `json:"last_name"`
+	} `json:"profile"`
+}
+
+type RingApi struct {
+	httpClient     *http.Client
+	authConfig     *AuthConfig
+	hardwareID     string
+	authToken      *AuthTokenResponse
+	tokenExpiry    time.Time
+	Using2FA       bool
+	PromptFor2FA   string
+	RefreshToken   string
+	auth           interface{} // EmailAuth or RefreshTokenAuth
+	onTokenRefresh func(string)
+	authMutex      sync.Mutex
+	session        *SessionResponse
+	sessionExpiry  time.Time
+	sessionMutex   sync.Mutex
+	cacheKey       string
+}
+
+type CameraKind string
+
+type CameraData struct {
+	ID          int    `json:"id"`
+	Description string `json:"description"`
+	DeviceID    string `json:"device_id"`
+	Kind        string `json:"kind"`
+	LocationID  string `json:"location_id"`
+}
+
+type RingDeviceType string
+
+type RingDevicesResponse struct {
+	Doorbots           []CameraData             `json:"doorbots"`
+	AuthorizedDoorbots []CameraData             `json:"authorized_doorbots"`
+	StickupCams        []CameraData             `json:"stickup_cams"`
+	AllCameras         []CameraData             `json:"all_cameras"`
+	Chimes             []CameraData             `json:"chimes"`
+	Other              []map[string]interface{} `json:"other"`
+}
+
+const (
+	Doorbot             CameraKind = "doorbot"
+	Doorbell            CameraKind = "doorbell"
+	DoorbellV3          CameraKind = "doorbell_v3"
+	DoorbellV4          CameraKind = "doorbell_v4"
+	DoorbellV5          CameraKind = "doorbell_v5"
+	DoorbellOyster      CameraKind = "doorbell_oyster"
+	DoorbellPortal      CameraKind = "doorbell_portal"
+	DoorbellScallop     CameraKind = "doorbell_scallop"
+	DoorbellScallopLite CameraKind = "doorbell_scallop_lite"
+	DoorbellGraham      CameraKind = "doorbell_graham_cracker"
+	LpdV1               CameraKind = "lpd_v1"
+	LpdV2               CameraKind = "lpd_v2"
+	LpdV4               CameraKind = "lpd_v4"
+	JboxV1              CameraKind = "jbox_v1"
+	StickupCam          CameraKind = "stickup_cam"
+	StickupCamV3        CameraKind = "stickup_cam_v3"
+	StickupCamElite     CameraKind = "stickup_cam_elite"
+	StickupCamLongfin   CameraKind = "stickup_cam_longfin"
+	StickupCamLunar     CameraKind = "stickup_cam_lunar"
+	SpotlightV2         CameraKind = "spotlightw_v2"
+	HpCamV1             CameraKind = "hp_cam_v1"
+	HpCamV2             CameraKind = "hp_cam_v2"
+	StickupCamV4        CameraKind = "stickup_cam_v4"
+	FloodlightV1        CameraKind = "floodlight_v1"
+	FloodlightV2        CameraKind = "floodlight_v2"
+	FloodlightPro       CameraKind = "floodlight_pro"
+	CocoaCamera         CameraKind = "cocoa_camera"
+	CocoaDoorbell       CameraKind = "cocoa_doorbell"
+	CocoaFloodlight     CameraKind = "cocoa_floodlight"
+	CocoaSpotlight      CameraKind = "cocoa_spotlight"
+	StickupCamMini      CameraKind = "stickup_cam_mini"
+	OnvifCamera         CameraKind = "onvif_camera"
+)
+
+const (
+	IntercomHandsetAudio RingDeviceType = "intercom_handset_audio"
+	OnvifCameraType      RingDeviceType = "onvif_camera"
+)
+
+const (
+	clientAPIBaseURL   = "https://api.ring.com/clients_api/"
+	deviceAPIBaseURL   = "https://api.ring.com/devices/v1/"
+	commandsAPIBaseURL = "https://api.ring.com/commands/v1/"
+	appAPIBaseURL      = "https://prd-api-us.prd.rings.solutions/api/v1/"
+	oauthURL           = "https://oauth.ring.com/oauth/token"
+	apiVersion         = 11
+	defaultTimeout     = 20 * time.Second
+	maxRetries         = 3
+	sessionValidTime   = 12 * time.Hour
+)
+
+func NewRestClient(auth interface{}, onTokenRefresh func(string)) (*RingApi, error) {
+	var cacheKey string
+
+	// Create cache key based on auth data
+	switch a := auth.(type) {
+	case RefreshTokenAuth:
+		if a.RefreshToken == "" {
+			return nil, fmt.Errorf("refresh token is required")
+		}
+		cacheKey = "refresh:" + a.RefreshToken
+	case EmailAuth:
+		if a.Email == "" || a.Password == "" {
+			return nil, fmt.Errorf("email and password are required")
+		}
+		cacheKey = "email:" + a.Email + ":" + a.Password
+	default:
+		return nil, fmt.Errorf("invalid auth type")
+	}
+
+	cacheMutex.Lock()
+	defer cacheMutex.Unlock()
+
+	if cachedClient, ok := clientCache[cacheKey]; ok {
+		// Check if token is not nil and not expired
+		if cachedClient.authToken != nil && time.Now().Before(cachedClient.tokenExpiry) {
+			cachedClient.onTokenRefresh = onTokenRefresh
+			return cachedClient, nil
+		}
+	}
+
+	client := &RingApi{
+		httpClient:     &http.Client{Timeout: defaultTimeout},
+		onTokenRefresh: onTokenRefresh,
+		hardwareID:     generateHardwareID(),
+		auth:           auth,
+		cacheKey:       cacheKey,
+	}
+
+	switch a := auth.(type) {
+	case RefreshTokenAuth:
+		config, err := parseAuthConfig(a.RefreshToken)
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse refresh token: %w", err)
+		}
+
+		client.authConfig = config
+		client.hardwareID = config.HID
+		client.RefreshToken = a.RefreshToken
+	}
+
+	clientCache[cacheKey] = client
+
+	return client, nil
+}
+
+func ClientAPI(path string) string {
+	return clientAPIBaseURL + path
+}
+
+func DeviceAPI(path string) string {
+	return deviceAPIBaseURL + path
+}
+
+func CommandsAPI(path string) string {
+	return commandsAPIBaseURL + path
+}
+
+func AppAPI(path string) string {
+	return appAPIBaseURL + path
+}
+
+func (c *RingApi) GetAuth(twoFactorAuthCode string) (*AuthTokenResponse, error) {
+	var grantData map[string]string
+
+	if c.authConfig != nil && twoFactorAuthCode == "" {
+		grantData = map[string]string{
+			"grant_type":    "refresh_token",
+			"refresh_token": c.authConfig.RT,
+		}
+	} else {
+		authEmail, ok := c.auth.(EmailAuth)
+		if !ok {
+			return nil, fmt.Errorf("invalid auth type for email authentication")
+		}
+		grantData = map[string]string{
+			"grant_type": "password",
+			"username":   authEmail.Email,
+			"password":   authEmail.Password,
+		}
+	}
+
+	grantData["client_id"] = "ring_official_android"
+	grantData["scope"] = "client"
+
+	body, err := json.Marshal(grantData)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal auth request: %w", err)
+	}
+
+	req, err := http.NewRequest("POST", oauthURL, bytes.NewReader(body))
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("hardware_id", c.hardwareID)
+	req.Header.Set("User-Agent", "android:com.ringapp")
+	req.Header.Set("2fa-support", "true")
+	if twoFactorAuthCode != "" {
+		req.Header.Set("2fa-code", twoFactorAuthCode)
+	}
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	// Handle 2FA Responses
+	if resp.StatusCode == http.StatusPreconditionFailed ||
+		(resp.StatusCode == http.StatusBadRequest && strings.Contains(resp.Header.Get("WWW-Authenticate"), "Verification Code")) {
+
+		var tfaResp Auth2faResponse
+		if err := json.NewDecoder(resp.Body).Decode(&tfaResp); err != nil {
+			return nil, err
+		}
+
+		c.Using2FA = true
+		if resp.StatusCode == http.StatusBadRequest {
+			c.PromptFor2FA = "Invalid 2fa code entered. Please try again."
+			return nil, fmt.Errorf("invalid 2FA code")
+		}
+
+		if tfaResp.TSVState != "" {
+			prompt := "from your authenticator app"
+			if tfaResp.TSVState != "totp" {
+				prompt = fmt.Sprintf("sent to %s via %s", tfaResp.Phone, tfaResp.TSVState)
+			}
+			c.PromptFor2FA = fmt.Sprintf("Please enter the code %s", prompt)
+		} else {
+			c.PromptFor2FA = "Please enter the code sent to your text/email"
+		}
+
+		return nil, fmt.Errorf("2FA required")
+	}
+
+	// Handle errors
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("auth request failed with status %d: %s", resp.StatusCode, string(body))
+	}
+
+	var authResp AuthTokenResponse
+	if err := json.NewDecoder(resp.Body).Decode(&authResp); err != nil {
+		return nil, fmt.Errorf("failed to decode auth response: %w", err)
+	}
+
+	// Refresh token and expiry
+	c.authToken = &authResp
+	c.authConfig = &AuthConfig{
+		RT:  authResp.RefreshToken,
+		HID: c.hardwareID,
+	}
+	// Set token expiry (1 minute before actual expiry)
+	expiresIn := time.Duration(authResp.ExpiresIn-60) * time.Second
+	c.tokenExpiry = time.Now().Add(expiresIn)
+
+	c.RefreshToken = encodeAuthConfig(c.authConfig)
+	if c.onTokenRefresh != nil {
+		c.onTokenRefresh(c.RefreshToken)
+	}
+
+	// Refresh the cached client
+	cacheMutex.Lock()
+	clientCache[c.cacheKey] = c
+	cacheMutex.Unlock()
+
+	return c.authToken, nil
+}
+
+func (c *RingApi) FetchRingDevices() (*RingDevicesResponse, error) {
+	response, err := c.Request("GET", ClientAPI("ring_devices"), nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch ring devices: %w", err)
+	}
+
+	var devices RingDevicesResponse
+	if err := json.Unmarshal(response, &devices); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal devices response: %w", err)
+	}
+
+	// Process "other" devices
+	var onvifCameras []CameraData
+	var intercoms []CameraData
+
+	for _, device := range devices.Other {
+		kind, ok := device["kind"].(string)
+		if !ok {
+			continue
+		}
+
+		switch RingDeviceType(kind) {
+		case OnvifCameraType:
+			var camera CameraData
+			if deviceJson, err := json.Marshal(device); err == nil {
+				if err := json.Unmarshal(deviceJson, &camera); err == nil {
+					onvifCameras = append(onvifCameras, camera)
+				}
+			}
+		case IntercomHandsetAudio:
+			var intercom CameraData
+			if deviceJson, err := json.Marshal(device); err == nil {
+				if err := json.Unmarshal(deviceJson, &intercom); err == nil {
+					intercoms = append(intercoms, intercom)
+				}
+			}
+		}
+	}
+
+	// Combine all cameras into AllCameras slice
+	allCameras := make([]CameraData, 0)
+	allCameras = append(allCameras, interfaceSlice(devices.Doorbots)...)
+	allCameras = append(allCameras, interfaceSlice(devices.StickupCams)...)
+	allCameras = append(allCameras, interfaceSlice(devices.AuthorizedDoorbots)...)
+	allCameras = append(allCameras, interfaceSlice(onvifCameras)...)
+	allCameras = append(allCameras, interfaceSlice(intercoms)...)
+
+	devices.AllCameras = allCameras
+
+	return &devices, nil
+}
+
+func (c *RingApi) GetSocketTicket() (*SocketTicketResponse, error) {
+	response, err := c.Request("POST", AppAPI("clap/ticket/request/signalsocket"), nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch socket ticket: %w", err)
+	}
+
+	var ticket SocketTicketResponse
+	if err := json.Unmarshal(response, &ticket); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal socket ticket response: %w", err)
+	}
+
+	return &ticket, nil
+}
+
+func (c *RingApi) Request(method, url string, body interface{}) ([]byte, error) {
+	// Ensure we have a valid session
+	if err := c.ensureSession(); err != nil {
+		return nil, fmt.Errorf("session validation failed: %w", err)
+	}
+
+	var bodyReader io.Reader
+	if body != nil {
+		jsonBody, err := json.Marshal(body)
+		if err != nil {
+			return nil, fmt.Errorf("failed to marshal request body: %w", err)
+		}
+		bodyReader = bytes.NewReader(jsonBody)
+	}
+
+	// Create request
+	req, err := http.NewRequest(method, url, bodyReader)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	// Set headers
+	req.Header.Set("Authorization", "Bearer "+c.authToken.AccessToken)
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("hardware_id", c.hardwareID)
+	req.Header.Set("User-Agent", "android:com.ringapp")
+
+	// Make request with retries
+	var resp *http.Response
+	var responseBody []byte
+
+	for attempt := 0; attempt <= maxRetries; attempt++ {
+		resp, err = c.httpClient.Do(req)
+		if err != nil {
+			if attempt == maxRetries {
+				return nil, fmt.Errorf("request failed after %d retries: %w", maxRetries, err)
+			}
+			time.Sleep(5 * time.Second)
+			continue
+		}
+		defer resp.Body.Close()
+
+		responseBody, err = io.ReadAll(resp.Body)
+		if err != nil {
+			return nil, fmt.Errorf("failed to read response body: %w", err)
+		}
+
+		// Handle 401 by refreshing auth and retrying
+		if resp.StatusCode == http.StatusUnauthorized {
+			// Reset token to force refresh
+			c.authMutex.Lock()
+			c.authToken = nil
+			c.tokenExpiry = time.Time{} // Reset token expiry
+			c.authMutex.Unlock()
+
+			if attempt == maxRetries {
+				return nil, fmt.Errorf("authentication failed after %d retries", maxRetries)
+			}
+
+			// By 401 with Auth AND Session start over
+			c.sessionMutex.Lock()
+			c.session = nil
+			c.sessionExpiry = time.Time{} // Reset session expiry
+			c.sessionMutex.Unlock()
+
+			if err := c.ensureSession(); err != nil {
+				return nil, fmt.Errorf("failed to refresh session: %w", err)
+			}
+
+			req.Header.Set("Authorization", "Bearer "+c.authToken.AccessToken)
+			continue
+		}
+
+		// Handle 404 error with hardware_id reference - session issue
+		if resp.StatusCode == 404 && strings.Contains(url, clientAPIBaseURL) {
+			var errorBody map[string]interface{}
+			if err := json.Unmarshal(responseBody, &errorBody); err == nil {
+				if errorStr, ok := errorBody["error"].(string); ok && strings.Contains(errorStr, c.hardwareID) {
+					// Session with hardware_id not found, refresh session
+					c.sessionMutex.Lock()
+					c.session = nil
+					c.sessionExpiry = time.Time{} // Reset session expiry
+					c.sessionMutex.Unlock()
+
+					if attempt == maxRetries {
+						return nil, fmt.Errorf("session refresh failed after %d retries", maxRetries)
+					}
+
+					if err := c.ensureSession(); err != nil {
+						return nil, fmt.Errorf("failed to refresh session: %w", err)
+					}
+
+					continue
+				}
+			}
+		}
+
+		// Handle other error status codes
+		if resp.StatusCode >= 400 {
+			return nil, fmt.Errorf("request failed with status %d: %s", resp.StatusCode, string(responseBody))
+		}
+
+		break
+	}
+
+	return responseBody, nil
+}
+
+func (c *RingApi) ensureSession() error {
+	c.sessionMutex.Lock()
+	defer c.sessionMutex.Unlock()
+
+	// If session is still valid, use it
+	if c.session != nil && time.Now().Before(c.sessionExpiry) {
+		return nil
+	}
+
+	// Make sure we have a valid auth token
+	if err := c.ensureAuth(); err != nil {
+		return fmt.Errorf("authentication failed while creating session: %w", err)
+	}
+
+	sessionPayload := map[string]interface{}{
+		"device": map[string]interface{}{
+			"hardware_id": c.hardwareID,
+			"metadata": map[string]interface{}{
+				"api_version":  apiVersion,
+				"device_model": "ring-client-go",
+			},
+			"os": "android",
+		},
+	}
+
+	body, err := json.Marshal(sessionPayload)
+	if err != nil {
+		return fmt.Errorf("failed to marshal session request: %w", err)
+	}
+
+	req, err := http.NewRequest("POST", ClientAPI("session"), bytes.NewReader(body))
+	if err != nil {
+		return err
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("Authorization", "Bearer "+c.authToken.AccessToken)
+	req.Header.Set("hardware_id", c.hardwareID)
+	req.Header.Set("User-Agent", "android:com.ringapp")
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		respBody, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("session request failed with status %d: %s", resp.StatusCode, string(respBody))
+	}
+
+	var sessionResp SessionResponse
+	if err := json.NewDecoder(resp.Body).Decode(&sessionResp); err != nil {
+		return fmt.Errorf("failed to decode session response: %w", err)
+	}
+
+	c.session = &sessionResp
+	c.sessionExpiry = time.Now().Add(sessionValidTime)
+
+	// Aktualisiere den gecachten Client
+	cacheMutex.Lock()
+	clientCache[c.cacheKey] = c
+	cacheMutex.Unlock()
+
+	return nil
+}
+
+func (c *RingApi) ensureAuth() error {
+	c.authMutex.Lock()
+	defer c.authMutex.Unlock()
+
+	// If token exists and is not expired, use it
+	if c.authToken != nil && time.Now().Before(c.tokenExpiry) {
+		return nil
+	}
+
+	var grantData = map[string]string{
+		"grant_type":    "refresh_token",
+		"refresh_token": c.authConfig.RT,
+	}
+
+	// Add common fields
+	grantData["client_id"] = "ring_official_android"
+	grantData["scope"] = "client"
+
+	// Make auth request
+	body, err := json.Marshal(grantData)
+	if err != nil {
+		return fmt.Errorf("failed to marshal auth request: %w", err)
+	}
+
+	req, err := http.NewRequest("POST", oauthURL, bytes.NewReader(body))
+	if err != nil {
+		return fmt.Errorf("failed to create auth request: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("hardware_id", c.hardwareID)
+	req.Header.Set("User-Agent", "android:com.ringapp")
+	req.Header.Set("2fa-support", "true")
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("auth request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode == http.StatusPreconditionFailed {
+		return fmt.Errorf("2FA required. Please see documentation for handling 2FA")
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("auth request failed with status %d: %s", resp.StatusCode, string(body))
+	}
+
+	var authResp AuthTokenResponse
+	if err := json.NewDecoder(resp.Body).Decode(&authResp); err != nil {
+		return fmt.Errorf("failed to decode auth response: %w", err)
+	}
+
+	// Update auth config and refresh token
+	c.authToken = &authResp
+	c.authConfig = &AuthConfig{
+		RT:  authResp.RefreshToken,
+		HID: c.hardwareID,
+	}
+
+	// Set token expiry (1 minute before actual expiry)
+	expiresIn := time.Duration(authResp.ExpiresIn-60) * time.Second
+	c.tokenExpiry = time.Now().Add(expiresIn)
+
+	// Encode and notify about new refresh token
+	if c.onTokenRefresh != nil {
+		newRefreshToken := encodeAuthConfig(c.authConfig)
+		c.onTokenRefresh(newRefreshToken)
+	}
+
+	// Refreshn the token in the client
+	c.RefreshToken = encodeAuthConfig(c.authConfig)
+
+	// Refresh the cached client
+	cacheMutex.Lock()
+	clientCache[c.cacheKey] = c
+	cacheMutex.Unlock()
+
+	return nil
+}
+
+func parseAuthConfig(refreshToken string) (*AuthConfig, error) {
+	decoded, err := base64.StdEncoding.DecodeString(refreshToken)
+	if err != nil {
+		return nil, err
+	}
+
+	var config AuthConfig
+	if err := json.Unmarshal(decoded, &config); err != nil {
+		// Handle legacy format where refresh token is the raw token
+		return &AuthConfig{RT: refreshToken}, nil
+	}
+
+	return &config, nil
+}
+
+func encodeAuthConfig(config *AuthConfig) string {
+	jsonBytes, _ := json.Marshal(config)
+	return base64.StdEncoding.EncodeToString(jsonBytes)
+}
+
+func generateHardwareID() string {
+	h := sha256.New()
+	h.Write([]byte("ring-client-go2rtc"))
+	return hex.EncodeToString(h.Sum(nil)[:16])
+}
+
+func interfaceSlice(slice interface{}) []CameraData {
+	s := reflect.ValueOf(slice)
+	if s.Kind() != reflect.Slice {
+		return nil
+	}
+
+	ret := make([]CameraData, s.Len())
+	for i := 0; i < s.Len(); i++ {
+		if camera, ok := s.Index(i).Interface().(CameraData); ok {
+			ret[i] = camera
+		}
+	}
+	return ret
+}
diff --git a/installs_on_host/go2rtc/pkg/ring/client.go b/installs_on_host/go2rtc/pkg/ring/client.go
new file mode 100644
index 0000000..fb77e19
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/ring/client.go
@@ -0,0 +1,355 @@
+package ring
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/url"
+	"strconv"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/webrtc"
+	"github.com/google/uuid"
+	pion "github.com/pion/webrtc/v4"
+)
+
+type Client struct {
+	api       *RingApi
+	wsClient  *WSClient
+	prod      core.Producer
+	cameraID  int
+	dialogID  string
+	connected core.Waiter
+	closed    bool
+}
+
+func Dial(rawURL string) (*Client, error) {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	query := u.Query()
+	encodedToken := query.Get("refresh_token")
+	cameraID := query.Get("camera_id")
+	deviceID := query.Get("device_id")
+	_, isSnapshot := query["snapshot"]
+
+	if encodedToken == "" || deviceID == "" || cameraID == "" {
+		return nil, errors.New("ring: wrong query")
+	}
+
+	client := &Client{
+		dialogID: uuid.NewString(),
+	}
+
+	client.cameraID, err = strconv.Atoi(cameraID)
+	if err != nil {
+		return nil, fmt.Errorf("ring: invalid camera_id: %w", err)
+	}
+
+	refreshToken, err := url.QueryUnescape(encodedToken)
+	if err != nil {
+		return nil, fmt.Errorf("ring: invalid refresh token encoding: %w", err)
+	}
+
+	client.api, err = NewRestClient(RefreshTokenAuth{RefreshToken: refreshToken}, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// Snapshot Flow
+	if isSnapshot {
+		client.prod = NewSnapshotProducer(client.api, client.cameraID)
+		return client, nil
+	}
+
+	client.wsClient, err = StartWebsocket(client.cameraID, client.api)
+	if err != nil {
+		client.Stop()
+		return nil, err
+	}
+
+	// Create Peer Connection
+	conf := pion.Configuration{
+		ICEServers: []pion.ICEServer{
+			{URLs: []string{
+				"stun:stun.kinesisvideo.us-east-1.amazonaws.com:443",
+				"stun:stun.kinesisvideo.us-east-2.amazonaws.com:443",
+				"stun:stun.kinesisvideo.us-west-2.amazonaws.com:443",
+				"stun:stun.l.google.com:19302",
+				"stun:stun1.l.google.com:19302",
+				"stun:stun2.l.google.com:19302",
+				"stun:stun3.l.google.com:19302",
+				"stun:stun4.l.google.com:19302",
+			}},
+		},
+		ICETransportPolicy: pion.ICETransportPolicyAll,
+		BundlePolicy:       pion.BundlePolicyBalanced,
+	}
+
+	api, err := webrtc.NewAPI()
+	if err != nil {
+		client.Stop()
+		return nil, err
+	}
+
+	pc, err := api.NewPeerConnection(conf)
+	if err != nil {
+		client.Stop()
+		return nil, err
+	}
+
+	// protect from sending ICE candidate before Offer
+	var sendOffer core.Waiter
+
+	// protect from blocking on errors
+	defer sendOffer.Done(nil)
+
+	prod := webrtc.NewConn(pc)
+	prod.FormatName = "ring/webrtc"
+	prod.Mode = core.ModeActiveProducer
+	prod.Protocol = "ws"
+	prod.URL = rawURL
+
+	client.wsClient.onMessage = func(msg WSMessage) {
+		client.onWSMessage(msg)
+	}
+
+	client.wsClient.onError = func(err error) {
+		// fmt.Printf("ring: error: %s\n", err.Error())
+		client.Stop()
+		client.connected.Done(err)
+	}
+
+	client.wsClient.onClose = func() {
+		// fmt.Println("ring: disconnect")
+		client.Stop()
+		client.connected.Done(errors.New("ring: disconnect"))
+	}
+
+	prod.Listen(func(msg any) {
+		switch msg := msg.(type) {
+		case *pion.ICECandidate:
+			_ = sendOffer.Wait()
+
+			iceCandidate := msg.ToJSON()
+
+			// skip empty ICE candidates
+			if iceCandidate.Candidate == "" {
+				return
+			}
+
+			icePayload := map[string]interface{}{
+				"ice":        iceCandidate.Candidate,
+				"mlineindex": iceCandidate.SDPMLineIndex,
+			}
+
+			if err = client.wsClient.sendSessionMessage("ice", icePayload); err != nil {
+				client.connected.Done(err)
+				return
+			}
+
+		case pion.PeerConnectionState:
+			switch msg {
+			case pion.PeerConnectionStateNew:
+				break
+			case pion.PeerConnectionStateConnecting:
+				break
+			case pion.PeerConnectionStateConnected:
+				client.connected.Done(nil)
+			default:
+				client.Stop()
+				client.connected.Done(errors.New("ring: " + msg.String()))
+			}
+		}
+	})
+
+	client.prod = prod
+
+	// Setup media configuration
+	medias := []*core.Media{
+		{
+			Kind:      core.KindAudio,
+			Direction: core.DirectionSendRecv,
+			Codecs: []*core.Codec{
+				{
+					Name:      "opus",
+					ClockRate: 48000,
+					Channels:  2,
+				},
+			},
+		},
+		{
+			Kind:      core.KindVideo,
+			Direction: core.DirectionRecvonly,
+			Codecs: []*core.Codec{
+				{
+					Name:      "H264",
+					ClockRate: 90000,
+				},
+			},
+		},
+	}
+
+	// Create offer
+	offer, err := prod.CreateOffer(medias)
+	if err != nil {
+		client.Stop()
+		return nil, err
+	}
+
+	// Send offer
+	offerPayload := map[string]interface{}{
+		"stream_options": map[string]bool{
+			"audio_enabled": true,
+			"video_enabled": true,
+		},
+		"sdp": offer,
+	}
+
+	if err = client.wsClient.sendSessionMessage("live_view", offerPayload); err != nil {
+		client.Stop()
+		return nil, err
+	}
+
+	sendOffer.Done(nil)
+
+	if err = client.connected.Wait(); err != nil {
+		return nil, err
+	}
+
+	return client, nil
+}
+
+func (c *Client) onWSMessage(msg WSMessage) {
+	rawMsg, _ := json.Marshal(msg)
+
+	// fmt.Printf("ring: onWSMessage: %s\n", string(rawMsg))
+
+	// check if "doorbot_id" is present
+	if _, ok := msg.Body["doorbot_id"]; !ok {
+		return
+	}
+
+	// check if the message is from the correct doorbot
+	doorbotID := msg.Body["doorbot_id"].(float64)
+	if int(doorbotID) != c.cameraID {
+		return
+	}
+
+	if msg.Method == "session_created" || msg.Method == "session_started" {
+		if _, ok := msg.Body["session_id"]; ok && c.wsClient.sessionID == "" {
+			c.wsClient.sessionID = msg.Body["session_id"].(string)
+		}
+	}
+
+	// check if the message is from the correct session
+	if _, ok := msg.Body["session_id"]; ok {
+		if msg.Body["session_id"].(string) != c.wsClient.sessionID {
+			return
+		}
+	}
+
+	switch msg.Method {
+	case "sdp":
+		if prod, ok := c.prod.(*webrtc.Conn); ok {
+			// Get answer
+			var msg AnswerMessage
+			if err := json.Unmarshal(rawMsg, &msg); err != nil {
+				c.Stop()
+				c.connected.Done(err)
+				return
+			}
+
+			if err := prod.SetAnswer(msg.Body.SDP); err != nil {
+				c.Stop()
+				c.connected.Done(err)
+				return
+			}
+
+			if err := c.wsClient.activateSession(); err != nil {
+				c.Stop()
+				c.connected.Done(err)
+				return
+			}
+
+			prod.SDP = msg.Body.SDP
+		}
+
+	case "ice":
+		if prod, ok := c.prod.(*webrtc.Conn); ok {
+			var msg IceCandidateMessage
+			if err := json.Unmarshal(rawMsg, &msg); err != nil {
+				break
+			}
+
+			// Skip empty candidates
+			if msg.Body.Ice == "" {
+				break
+			}
+
+			if err := prod.AddCandidate(msg.Body.Ice); err != nil {
+				c.Stop()
+				c.connected.Done(err)
+				return
+			}
+		}
+
+	case "close":
+		c.Stop()
+		c.connected.Done(errors.New("ring: close"))
+
+	case "pong":
+		// Ignore
+	}
+}
+
+func (c *Client) GetMedias() []*core.Media {
+	return c.prod.GetMedias()
+}
+
+func (c *Client) GetTrack(media *core.Media, codec *core.Codec) (*core.Receiver, error) {
+	return c.prod.GetTrack(media, codec)
+}
+
+func (c *Client) AddTrack(media *core.Media, codec *core.Codec, track *core.Receiver) error {
+	if webrtcProd, ok := c.prod.(*webrtc.Conn); ok {
+		if media.Kind == core.KindAudio {
+			// Enable speaker
+			speakerPayload := map[string]interface{}{
+				"stealth_mode": false,
+			}
+			_ = c.wsClient.sendSessionMessage("camera_options", speakerPayload)
+		}
+		return webrtcProd.AddTrack(media, codec, track)
+	}
+
+	return fmt.Errorf("add track not supported for snapshot")
+}
+
+func (c *Client) Start() error {
+	return c.prod.Start()
+}
+
+func (c *Client) Stop() error {
+	if c.closed {
+		return nil
+	}
+
+	c.closed = true
+
+	if c.prod != nil {
+		_ = c.prod.Stop()
+	}
+
+	if c.wsClient != nil {
+		_ = c.wsClient.Close()
+	}
+
+	return nil
+}
+
+func (c *Client) MarshalJSON() ([]byte, error) {
+	return json.Marshal(c.prod)
+}
diff --git a/installs_on_host/go2rtc/pkg/ring/snapshot.go b/installs_on_host/go2rtc/pkg/ring/snapshot.go
new file mode 100644
index 0000000..b52eada
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/ring/snapshot.go
@@ -0,0 +1,61 @@
+package ring
+
+import (
+	"fmt"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+)
+
+type SnapshotProducer struct {
+	core.Connection
+
+	client   *RingApi
+	cameraID int
+}
+
+func NewSnapshotProducer(client *RingApi, cameraID int) *SnapshotProducer {
+	return &SnapshotProducer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "ring/snapshot",
+			Protocol:   "https",
+			RemoteAddr: "app-snaps.ring.com",
+			Medias: []*core.Media{
+				{
+					Kind:      core.KindVideo,
+					Direction: core.DirectionRecvonly,
+					Codecs: []*core.Codec{
+						{
+							Name:        core.CodecJPEG,
+							ClockRate:   90000,
+							PayloadType: core.PayloadTypeRAW,
+						},
+					},
+				},
+			},
+		},
+		client:   client,
+		cameraID: cameraID,
+	}
+}
+
+func (p *SnapshotProducer) Start() error {
+	response, err := p.client.Request("GET", fmt.Sprintf("https://app-snaps.ring.com/snapshots/next/%d", p.cameraID), nil)
+	if err != nil {
+		return err
+	}
+
+	pkt := &rtp.Packet{
+		Header:  rtp.Header{Timestamp: core.Now90000()},
+		Payload: response,
+	}
+
+	p.Receivers[0].WriteRTP(pkt)
+
+	return nil
+}
+
+func (p *SnapshotProducer) Stop() error {
+	return p.Connection.Stop()
+}
diff --git a/installs_on_host/go2rtc/pkg/ring/ws.go b/installs_on_host/go2rtc/pkg/ring/ws.go
new file mode 100644
index 0000000..51e72fe
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/ring/ws.go
@@ -0,0 +1,265 @@
+package ring
+
+import (
+	"fmt"
+	"net/http"
+	"net/url"
+	"sync"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/gorilla/websocket"
+)
+
+type SessionBody struct {
+	DoorbotID int    `json:"doorbot_id"`
+	SessionID string `json:"session_id"`
+}
+
+type AnswerMessage struct {
+	Method string `json:"method"` // "sdp"
+	Body   struct {
+		SessionBody
+		SDP  string `json:"sdp"`
+		Type string `json:"type"` // "answer"
+	} `json:"body"`
+}
+
+type IceCandidateMessage struct {
+	Method string `json:"method"` // "ice"
+	Body   struct {
+		SessionBody
+		Ice        string `json:"ice"`
+		MLineIndex int    `json:"mlineindex"`
+	} `json:"body"`
+}
+
+type SessionMessage struct {
+	Method string      `json:"method"` // "session_created" or "session_started"
+	Body   SessionBody `json:"body"`
+}
+
+type PongMessage struct {
+	Method string      `json:"method"` // "pong"
+	Body   SessionBody `json:"body"`
+}
+
+type NotificationMessage struct {
+	Method string `json:"method"` // "notification"
+	Body   struct {
+		SessionBody
+		IsOK bool   `json:"is_ok"`
+		Text string `json:"text"`
+	} `json:"body"`
+}
+
+type StreamInfoMessage struct {
+	Method string `json:"method"` // "stream_info"
+	Body   struct {
+		SessionBody
+		Transcoding       bool   `json:"transcoding"`
+		TranscodingReason string `json:"transcoding_reason"`
+	} `json:"body"`
+}
+
+type CloseRequest struct {
+	Method string `json:"method"` // "close"
+	Body   struct {
+		SessionBody
+		Reason struct {
+			Code int    `json:"code"`
+			Text string `json:"text"`
+		} `json:"reason"`
+	} `json:"body"`
+}
+
+type WSMessage struct {
+	Method string         `json:"method"`
+	Body   map[string]any `json:"body"`
+}
+
+type WSClient struct {
+	ws        *websocket.Conn
+	api       *RingApi
+	wsMutex   sync.Mutex
+	cameraID  int
+	dialogID  string
+	sessionID string
+
+	onMessage func(msg WSMessage)
+	onError   func(err error)
+	onClose   func()
+
+	closed chan struct{}
+}
+
+const (
+	CloseReasonNormalClose          = 0
+	CloseReasonAuthenticationFailed = 5
+	CloseReasonTimeout              = 6
+)
+
+func StartWebsocket(cameraID int, api *RingApi) (*WSClient, error) {
+	client := &WSClient{
+		api:      api,
+		cameraID: cameraID,
+		dialogID: uuid.NewString(),
+		closed:   make(chan struct{}),
+	}
+
+	ticket, err := client.api.GetSocketTicket()
+	if err != nil {
+		return nil, err
+	}
+
+	url := fmt.Sprintf("wss://api.prod.signalling.ring.devices.a2z.com/ws?api_version=4.0&auth_type=ring_solutions&client_id=ring_site-%s&token=%s",
+		uuid.NewString(), url.QueryEscape(ticket.Ticket))
+
+	httpHeader := http.Header{}
+	httpHeader.Set("User-Agent", "android:com.ringapp")
+
+	client.ws, _, err = websocket.DefaultDialer.Dial(url, httpHeader)
+	if err != nil {
+		return nil, err
+	}
+
+	client.ws.SetCloseHandler(func(code int, text string) error {
+		client.onWsClose()
+		return nil
+	})
+
+	go client.startPingLoop()
+	go client.startMessageLoop()
+
+	return client, nil
+}
+
+func (c *WSClient) Close() error {
+	select {
+	case <-c.closed:
+		return nil
+	default:
+		close(c.closed)
+	}
+
+	closePayload := map[string]interface{}{
+		"reason": map[string]interface{}{
+			"code": CloseReasonNormalClose,
+			"text": "",
+		},
+	}
+
+	_ = c.sendSessionMessage("close", closePayload)
+
+	return c.ws.Close()
+}
+
+func (c *WSClient) startPingLoop() {
+	ticker := time.NewTicker(5 * time.Second)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-c.closed:
+			return
+		case <-ticker.C:
+			if err := c.sendSessionMessage("ping", nil); err != nil {
+				return
+			}
+		}
+	}
+}
+
+func (c *WSClient) startMessageLoop() {
+	for {
+		select {
+		case <-c.closed:
+			return
+		default:
+			var res WSMessage
+			if err := c.ws.ReadJSON(&res); err != nil {
+				select {
+				case <-c.closed:
+					// Ignore error if closed
+				default:
+					c.onWsError(err)
+				}
+
+				return
+			}
+
+			c.onWsMessage(res)
+		}
+	}
+}
+
+func (c *WSClient) activateSession() error {
+	if err := c.sendSessionMessage("activate_session", nil); err != nil {
+		return err
+	}
+
+	streamPayload := map[string]interface{}{
+		"audio_enabled": true,
+		"video_enabled": true,
+	}
+
+	if err := c.sendSessionMessage("stream_options", streamPayload); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c *WSClient) sendSessionMessage(method string, payload map[string]interface{}) error {
+	select {
+	case <-c.closed:
+		return nil
+	default:
+		// continue
+	}
+
+	c.wsMutex.Lock()
+	defer c.wsMutex.Unlock()
+
+	if payload == nil {
+		payload = make(map[string]interface{})
+	}
+
+	payload["doorbot_id"] = c.cameraID
+	if c.sessionID != "" {
+		payload["session_id"] = c.sessionID
+	}
+
+	msg := map[string]interface{}{
+		"method":    method,
+		"dialog_id": c.dialogID,
+		"body":      payload,
+	}
+
+	// rawMsg, _ := json.Marshal(msg)
+	// fmt.Printf("ring: sendSessionMessage: %s: %s\n", method, string(rawMsg))
+
+	if err := c.ws.WriteJSON(msg); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c *WSClient) onWsMessage(msg WSMessage) {
+	if c.onMessage != nil {
+		c.onMessage(msg)
+	}
+}
+
+func (c *WSClient) onWsError(err error) {
+	if c.onError != nil {
+		c.onError(err)
+	}
+}
+
+func (c *WSClient) onWsClose() {
+	if c.onClose != nil {
+		c.onClose()
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/roborock/api.go b/installs_on_host/go2rtc/pkg/roborock/api.go
new file mode 100644
index 0000000..8876a85
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/roborock/api.go
@@ -0,0 +1,167 @@
+package roborock
+
+import (
+	"crypto/hmac"
+	"crypto/md5"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strconv"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+type UserInfo struct {
+	Token string `json:"token"`
+	IoT   struct {
+		User   string `json:"u"`
+		Pass   string `json:"s"`
+		Hash   string `json:"h"`
+		Domain string `json:"k"`
+		URL    struct {
+			API  string `json:"a"`
+			MQTT string `json:"m"`
+		} `json:"r"`
+	} `json:"rriot"`
+}
+
+func GetBaseURL(username string) (string, error) {
+	u := "https://euiot.roborock.com/api/v1/getUrlByEmail?email=" + url.QueryEscape(username)
+	req, err := http.NewRequest("POST", u, nil)
+	if err != nil {
+		return "", err
+	}
+
+	client := http.Client{Timeout: time.Second * 5000}
+	res, err := client.Do(req)
+
+	var v struct {
+		Msg  string `json:"msg"`
+		Code int    `json:"code"`
+		Data struct {
+			URL string `json:"url"`
+		} `json:"data"`
+	}
+	if err = json.NewDecoder(res.Body).Decode(&v); err != nil {
+		return "", err
+	}
+
+	if v.Code != 200 {
+		return "", fmt.Errorf("%d: %s", v.Code, v.Msg)
+	}
+
+	return v.Data.URL, nil
+}
+
+func Login(baseURL, username, password string) (*UserInfo, error) {
+	u := baseURL + "/api/v1/login?username=" + url.QueryEscape(username) +
+		"&password=" + url.QueryEscape(password) + "&needtwostepauth=false"
+	req, err := http.NewRequest("POST", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	clientID := core.RandString(16, 64)
+	clientID = base64.StdEncoding.EncodeToString([]byte(clientID))
+	req.Header.Set("header_clientid", clientID)
+
+	client := http.Client{Timeout: time.Second * 5000}
+	res, err := client.Do(req)
+
+	var v struct {
+		Msg  string   `json:"msg"`
+		Code int      `json:"code"`
+		Data UserInfo `json:"data"`
+	}
+	if err = json.NewDecoder(res.Body).Decode(&v); err != nil {
+		return nil, err
+	}
+
+	if v.Code != 200 {
+		return nil, fmt.Errorf("%d: %s", v.Code, v.Msg)
+	}
+
+	return &v.Data, nil
+}
+
+func GetHomeID(baseURL, token string) (int, error) {
+	req, err := http.NewRequest("GET", baseURL+"/api/v1/getHomeDetail", nil)
+	if err != nil {
+		return 0, err
+	}
+	req.Header.Set("Authorization", token)
+
+	client := http.Client{Timeout: time.Second * 5000}
+	res, err := client.Do(req)
+	if err != nil {
+		return 0, err
+	}
+
+	var v struct {
+		Msg  string `json:"msg"`
+		Code int    `json:"code"`
+		Data struct {
+			HomeID int `json:"rrHomeId"`
+		} `json:"data"`
+	}
+	if err = json.NewDecoder(res.Body).Decode(&v); err != nil {
+		return 0, err
+	}
+
+	if v.Code != 200 {
+		return 0, fmt.Errorf("%d: %s", v.Code, v.Msg)
+	}
+
+	return v.Data.HomeID, nil
+}
+
+type DeviceInfo struct {
+	DID  string `json:"duid"`
+	Name string `json:"name"`
+	Key  string `json:"localKey"`
+}
+
+func GetDevices(ui *UserInfo, homeID int) ([]DeviceInfo, error) {
+	nonce := core.RandString(6, 64)
+	ts := time.Now().Unix()
+	path := "/user/homes/" + strconv.Itoa(homeID)
+
+	mac := fmt.Sprintf(
+		"%s:%s:%s:%d:%x::", ui.IoT.User, ui.IoT.Pass, nonce, ts, md5.Sum([]byte(path)),
+	)
+	hash := hmac.New(sha256.New, []byte(ui.IoT.Hash))
+	hash.Write([]byte(mac))
+	mac = base64.StdEncoding.EncodeToString(hash.Sum(nil))
+
+	auth := fmt.Sprintf(
+		`Hawk id="%s", s="%s", ts="%d", nonce="%s", mac="%s"`,
+		ui.IoT.User, ui.IoT.Pass, ts, nonce, mac,
+	)
+
+	req, err := http.NewRequest("GET", ui.IoT.URL.API+path, nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Authorization", auth)
+
+	client := http.Client{Timeout: time.Second * 5000}
+	res, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	var v struct {
+		Result struct {
+			Devices []DeviceInfo `json:"devices"`
+		} `json:"result"`
+	}
+	if err = json.NewDecoder(res.Body).Decode(&v); err != nil {
+		return nil, err
+	}
+
+	return v.Result.Devices, nil
+}
diff --git a/installs_on_host/go2rtc/pkg/roborock/client.go b/installs_on_host/go2rtc/pkg/roborock/client.go
new file mode 100644
index 0000000..4940b74
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/roborock/client.go
@@ -0,0 +1,381 @@
+package roborock
+
+import (
+	"crypto/md5"
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/rpc"
+	"net/url"
+	"strconv"
+	"sync"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/roborock/iot"
+	"github.com/AlexxIT/go2rtc/pkg/webrtc"
+	pion "github.com/pion/webrtc/v4"
+)
+
+// Deprecated: should be rewritten to core.Connection
+type Client struct {
+	core.Listener
+
+	url string
+
+	conn *webrtc.Conn
+	iot  *rpc.Client
+
+	devKey   string
+	pin      string
+	devTopic string
+
+	audio       bool
+	backchannel bool
+}
+
+func Dial(rawURL string) (*Client, error) {
+	client := &Client{url: rawURL}
+	if err := client.Dial(); err != nil {
+		return nil, err
+	}
+	if err := client.Connect(); err != nil {
+		return nil, err
+	}
+	return client, nil
+}
+
+func (c *Client) Dial() error {
+	u, err := url.Parse(c.url)
+	if err != nil {
+		return err
+	}
+
+	if c.iot, err = iot.Dial(c.url); err != nil {
+		return err
+	}
+
+	c.pin = u.Query().Get("pin")
+	if c.pin != "" {
+		c.pin = fmt.Sprintf("%x", md5.Sum([]byte(c.pin)))
+		return c.CheckHomesecPassword()
+	}
+
+	return nil
+}
+
+func (c *Client) Connect() error {
+	// 1. Check if camera ready for connection
+	for i := 0; ; i++ {
+		clientID, err := c.GetHomesecConnectStatus()
+		if err != nil {
+			return err
+		}
+		if clientID == "none" {
+			break
+		}
+		if err = c.StopCameraPreview(clientID); err != nil {
+			return err
+		}
+		if i == 5 {
+			return errors.New("camera not ready")
+		}
+		time.Sleep(time.Second)
+	}
+
+	// 2. Start camera
+	if err := c.StartCameraPreview(); err != nil {
+		return err
+	}
+
+	// 3. Get TURN config
+	conf := pion.Configuration{}
+
+	if turn, _ := c.GetTurnServer(); turn != nil {
+		conf.ICEServers = append(conf.ICEServers, *turn)
+	}
+
+	// 4. Create Peer Connection
+	api, err := webrtc.NewAPI()
+	if err != nil {
+		return err
+	}
+
+	pc, err := api.NewPeerConnection(conf)
+	if err != nil {
+		return err
+	}
+
+	var connected = make(chan bool)
+	var sendOffer sync.WaitGroup
+
+	c.conn = webrtc.NewConn(pc)
+	c.conn.FormatName = "roborock"
+	c.conn.Mode = core.ModeActiveProducer
+	c.conn.Protocol = "mqtt"
+	c.conn.URL = c.url
+	c.conn.Listen(func(msg any) {
+		switch msg := msg.(type) {
+		case *pion.ICECandidate:
+			if msg != nil && msg.Component == 1 {
+				sendOffer.Wait()
+				_ = c.SendICEtoRobot(msg.ToJSON().Candidate, "0")
+			}
+		case pion.PeerConnectionState:
+			if msg == pion.PeerConnectionStateConnecting {
+				return
+			}
+			// unblocking write to channel
+			select {
+			case connected <- msg == pion.PeerConnectionStateConnected:
+			default:
+			}
+		}
+	})
+
+	// 5. Send Offer
+	sendOffer.Add(1)
+
+	medias := []*core.Media{
+		{Kind: core.KindVideo, Direction: core.DirectionRecvonly},
+		{Kind: core.KindAudio, Direction: core.DirectionSendRecv},
+	}
+
+	if _, err = c.conn.CreateOffer(medias); err != nil {
+		return err
+	}
+
+	offer := pc.LocalDescription()
+	//log.Printf("[roborock] offer\n%s", offer.SDP)
+	if err = c.SendSDPtoRobot(offer); err != nil {
+		return err
+	}
+
+	sendOffer.Done()
+
+	// 6. Receive answer
+	ts := time.Now().Add(time.Second * 5)
+	for {
+		time.Sleep(time.Second)
+
+		if desc, _ := c.GetDeviceSDP(); desc != nil {
+			//log.Printf("[roborock] answer\n%s", desc.SDP)
+			if err = c.conn.SetAnswer(desc.SDP); err != nil {
+				return err
+			}
+			break
+		}
+
+		if time.Now().After(ts) {
+			return errors.New("can't get device SDP")
+		}
+	}
+
+	ticker := time.NewTicker(time.Second * 2)
+	for {
+		select {
+		case <-ticker.C:
+			// 7. Receive remote candidates
+			if pc.ICEConnectionState() == pion.ICEConnectionStateCompleted {
+				ticker.Stop()
+				continue
+			}
+
+			if ice, _ := c.GetDeviceICE(); ice != nil {
+				for _, candidate := range ice {
+					_ = c.conn.AddCandidate(candidate)
+				}
+			}
+
+		case ok := <-connected:
+			// 8. Wait connected result (true or false)
+			if !ok {
+				return errors.New("can't connect")
+			}
+
+			return nil
+		}
+	}
+}
+
+func (c *Client) CheckHomesecPassword() (err error) {
+	var ok bool
+
+	params := `{"password":"` + c.pin + `"}`
+	if err = c.iot.Call("check_homesec_password", params, &ok); err != nil {
+		return
+	}
+
+	if !ok {
+		return errors.New("wrong pin code")
+	}
+
+	return nil
+}
+
+func (c *Client) GetHomesecConnectStatus() (clientID string, err error) {
+	var res []byte
+
+	if err = c.iot.Call("get_homesec_connect_status", nil, &res); err != nil {
+		return
+	}
+
+	var v struct {
+		Status   int    `json:"status"`
+		ClientID string `json:"client_id"`
+	}
+	if err = json.Unmarshal(res, &v); err != nil {
+		return
+	}
+
+	return v.ClientID, nil
+}
+
+func (c *Client) StartCameraPreview() error {
+	params := `{"client_id":"676f32727463","quality":"HD","password":"` + c.pin + `"}`
+	return c.Request("start_camera_preview", params)
+}
+
+func (c *Client) StopCameraPreview(clientID string) error {
+	params := `{"client_id":"` + clientID + `"}`
+	return c.Request("stop_camera_preview", params)
+}
+
+func (c *Client) GetTurnServer() (turn *pion.ICEServer, err error) {
+	var res []byte
+
+	if err = c.iot.Call("get_turn_server", nil, &res); err != nil {
+		return
+	}
+
+	var v struct {
+		URL  string `json:"url"`
+		User string `json:"user"`
+		Pwd  string `json:"pwd"`
+	}
+	if err = json.Unmarshal(res, &v); err != nil {
+		return nil, err
+	}
+
+	turn = &pion.ICEServer{
+		URLs:       []string{v.URL},
+		Username:   v.User,
+		Credential: v.Pwd,
+	}
+
+	return
+}
+
+func (c *Client) SendSDPtoRobot(offer *pion.SessionDescription) (err error) {
+	b, err := json.Marshal(offer)
+	if err != nil {
+		return
+	}
+
+	params := `{"app_sdp":"` + base64.StdEncoding.EncodeToString(b) + `"}`
+	return c.iot.Call("send_sdp_to_robot", params, nil)
+}
+
+func (c *Client) SendICEtoRobot(candidate string, mid string) (err error) {
+	b := []byte(`{"candidate":"` + candidate + `","sdpMLineIndex":` + mid + `,"sdpMid":"` + mid + `"}`)
+
+	params := `{"app_ice":"` + base64.StdEncoding.EncodeToString(b) + `"}`
+	return c.iot.Call("send_ice_to_robot", params, nil)
+}
+
+func (c *Client) GetDeviceSDP() (sd *pion.SessionDescription, err error) {
+	var res []byte
+
+	if err = c.iot.Call("get_device_sdp", nil, &res); err != nil {
+		return
+	}
+
+	if string(res) == `{"dev_sdp":"retry"}` {
+		return nil, nil
+	}
+
+	var v struct {
+		SDP []byte `json:"dev_sdp"`
+	}
+	if err = json.Unmarshal(res, &v); err != nil {
+		return nil, err
+	}
+
+	sd = &pion.SessionDescription{}
+	if err = json.Unmarshal(v.SDP, sd); err != nil {
+		return nil, err
+	}
+
+	return
+}
+
+func (c *Client) GetDeviceICE() (ice []string, err error) {
+	var res []byte
+
+	if err = c.iot.Call("get_device_ice", nil, &res); err != nil {
+		return
+	}
+
+	if string(res) == `{"dev_ice":"retry"}` {
+		return nil, nil
+	}
+
+	var v struct {
+		ICE [][]byte `json:"dev_ice"`
+	}
+	if err = json.Unmarshal(res, &v); err != nil {
+		return
+	}
+
+	for _, b := range v.ICE {
+		init := pion.ICECandidateInit{}
+		if err = json.Unmarshal(b, &init); err != nil {
+			return
+		}
+		ice = append(ice, init.Candidate)
+	}
+
+	return
+}
+
+func (c *Client) StartVoiceChat() error {
+	// record - audio from robot, play - audio to robot?
+	params := fmt.Sprintf(`{"record":%t,"play":%t}`, c.audio, c.backchannel)
+	return c.Request("start_voice_chat", params)
+}
+
+func (c *Client) SwitchVideoQuality(hd bool) error {
+	if hd {
+		return c.Request("switch_video_quality", `{"quality":"HD"}`)
+	} else {
+		return c.Request("switch_video_quality", `{"quality":"SD"}`)
+	}
+}
+
+func (c *Client) SetVoiceChatVolume(volume int) error {
+	params := `{"volume":` + strconv.Itoa(volume) + `}`
+	return c.Request("set_voice_chat_volume", params)
+}
+
+func (c *Client) EnableHomesecVoice(enable bool) error {
+	if enable {
+		return c.Request("enable_homesec_voice", `{"enable":true}`)
+	} else {
+		return c.Request("enable_homesec_voice", `{"enable":false}`)
+	}
+}
+
+func (c *Client) Request(method string, args any) (err error) {
+	var reply string
+
+	if err = c.iot.Call(method, args, &reply); err != nil {
+		return
+	}
+
+	if reply != `["ok"]` {
+		return errors.New(reply)
+	}
+
+	return
+}
diff --git a/installs_on_host/go2rtc/pkg/roborock/iot/client.go b/installs_on_host/go2rtc/pkg/roborock/iot/client.go
new file mode 100644
index 0000000..c3b2d97
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/roborock/iot/client.go
@@ -0,0 +1,173 @@
+package iot
+
+import (
+	"crypto/md5"
+	"crypto/tls"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"net"
+	"net/rpc"
+	"net/url"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/mqtt"
+)
+
+type Codec struct {
+	mqtt *mqtt.Client
+
+	devTopic string
+	devKey   string
+
+	body json.RawMessage
+}
+
+type dps struct {
+	Dps struct {
+		Req string `json:"101,omitempty"`
+		Res string `json:"102,omitempty"`
+	} `json:"dps"`
+	T uint32 `json:"t"`
+}
+
+type response struct {
+	ID     uint64          `json:"id"`
+	Result json.RawMessage `json:"result"`
+	Error  struct {
+		Code    int    `json:"code"`
+		Message string `json:"message"`
+	} `json:"error"`
+}
+
+func (c *Codec) WriteRequest(r *rpc.Request, v any) error {
+	if v == nil {
+		v = "[]"
+	}
+
+	ts := uint32(time.Now().Unix())
+	msg := dps{T: ts}
+	msg.Dps.Req = fmt.Sprintf(
+		`{"id":%d,"method":"%s","params":%s}`, r.Seq, r.ServiceMethod, v,
+	)
+
+	payload, err := json.Marshal(msg)
+	if err != nil {
+		return err
+	}
+
+	//log.Printf("[roborock] send: %s", payload)
+
+	payload = c.Encrypt(payload, ts, ts, ts)
+
+	return c.mqtt.Publish("rr/m/i/"+c.devTopic, payload)
+}
+
+func (c *Codec) ReadResponseHeader(r *rpc.Response) error {
+	for {
+		// receive any message from MQTT
+		_, payload, err := c.mqtt.Read()
+		if err != nil {
+			return err
+		}
+
+		// skip if it is not PUBLISH message
+		if payload == nil {
+			continue
+		}
+
+		// decrypt MQTT PUBLISH payload
+		if payload, err = c.Decrypt(payload); err != nil {
+			continue
+		}
+
+		// skip if we can't decrypt this payload (ex. binary payload)
+		if payload == nil {
+			continue
+		}
+
+		//log.Printf("[roborock] recv %s", payload)
+
+		// get content from response payload:
+		// {"t":1676871268,"dps":{"102":"{\"id\":315003,\"result\":[\"ok\"]}"}}
+		var msg dps
+		if err = json.Unmarshal(payload, &msg); err != nil {
+			continue
+		}
+
+		var res response
+		if err = json.Unmarshal([]byte(msg.Dps.Res), &res); err != nil {
+			continue
+		}
+
+		r.Seq = res.ID
+		if res.Error.Code != 0 {
+			r.Error = res.Error.Message
+		} else {
+			c.body = res.Result
+		}
+
+		return nil
+	}
+}
+
+func (c *Codec) ReadResponseBody(v any) error {
+	switch vv := v.(type) {
+	case *[]byte:
+		*vv = c.body
+	case *string:
+		*vv = string(c.body)
+	case *bool:
+		*vv = string(c.body) == `["ok"]`
+	}
+	return nil
+}
+
+func (c *Codec) Close() error {
+	return c.mqtt.Close()
+}
+
+func Dial(rawURL string) (*rpc.Client, error) {
+	link, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	// dial to MQTT
+	conn, err := net.DialTimeout("tcp", link.Host, time.Second*5)
+	if err != nil {
+		return nil, err
+	}
+
+	// process MQTT SSL
+	conf := &tls.Config{ServerName: link.Hostname()}
+	sconn := tls.Client(conn, conf)
+	if err = sconn.Handshake(); err != nil {
+		return nil, err
+	}
+
+	query := link.Query()
+
+	// send MQTT login
+	uk := md5.Sum([]byte(query.Get("u") + ":" + query.Get("k")))
+	sk := md5.Sum([]byte(query.Get("s") + ":" + query.Get("k")))
+	user := hex.EncodeToString(uk[1:5])
+	pass := hex.EncodeToString(sk[8:])
+
+	c := &Codec{
+		mqtt:     mqtt.NewClient(sconn),
+		devKey:   query.Get("key"),
+		devTopic: query.Get("u") + "/" + user + "/" + query.Get("did"),
+	}
+
+	if err = c.mqtt.Connect("com.roborock.smart:mbrriot", user, pass); err != nil {
+		return nil, err
+	}
+
+	// subscribe on device topic
+	if err = c.mqtt.Subscribe("rr/m/o/" + c.devTopic); err != nil {
+		return nil, err
+	}
+
+	return rpc.NewClientWithCodec(c), nil
+}
diff --git a/installs_on_host/go2rtc/pkg/roborock/iot/crypto.go b/installs_on_host/go2rtc/pkg/roborock/iot/crypto.go
new file mode 100644
index 0000000..7a4c641
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/roborock/iot/crypto.go
@@ -0,0 +1,115 @@
+package iot
+
+import (
+	"crypto/aes"
+	"crypto/md5"
+	"encoding/binary"
+	"errors"
+	"hash/crc32"
+)
+
+// key - convert timestamp to key
+func (c *Codec) key(timestamp uint32) []byte {
+	const salt = "TXdfu$jyZ#TZHsg4"
+	key := md5.Sum([]byte(encodeTimestamp(timestamp) + c.devKey + salt))
+	return key[:]
+}
+
+func (c *Codec) Decrypt(cipherText []byte) ([]byte, error) {
+	if len(cipherText) < 32 || string(cipherText[:3]) != "1.0" {
+		return nil, errors.New("wrong message prefix")
+	}
+
+	i := len(cipherText) - 4
+	if binary.BigEndian.Uint32(cipherText[i:]) != crc32.ChecksumIEEE(cipherText[:i]) {
+		return nil, errors.New("wrong message checksum")
+	}
+
+	if proto := binary.BigEndian.Uint16(cipherText[15:]); proto != 102 {
+		return nil, nil
+	}
+
+	timestamp := binary.BigEndian.Uint32(cipherText[11:])
+	return decryptECB(cipherText[19:i], c.key(timestamp)), nil
+}
+
+func (c *Codec) Encrypt(plainText []byte, seq, random, timestamp uint32) []byte {
+	const proto = 101
+
+	cipherText := encryptECB(plainText, c.key(timestamp))
+
+	size := uint16(len(cipherText))
+
+	msg := make([]byte, 23+size)
+	copy(msg, "1.0")
+	binary.BigEndian.PutUint32(msg[3:], seq)
+	binary.BigEndian.PutUint32(msg[7:], random)
+	binary.BigEndian.PutUint32(msg[11:], timestamp)
+	binary.BigEndian.PutUint16(msg[15:], proto)
+	binary.BigEndian.PutUint16(msg[17:], size)
+	copy(msg[19:], cipherText)
+
+	crc := crc32.ChecksumIEEE(msg[:19+size])
+
+	binary.BigEndian.PutUint32(msg[19+size:], crc)
+	return msg
+}
+
+func encodeTimestamp(i uint32) string {
+	const hextable = "0123456789abcdef"
+	b := []byte{
+		hextable[i>>8&0xF], hextable[i>>4&0xF],
+		hextable[i>>16&0xF], hextable[i&0xF],
+		hextable[i>>24&0xF], hextable[i>>20&0xF],
+		hextable[i>>28&0xF], hextable[i>>12&0xF],
+	}
+	return string(b)
+}
+
+func pad(plainText []byte, blockSize int) []byte {
+	b0 := byte(blockSize - len(plainText)%blockSize)
+	for i := byte(0); i < b0; i++ {
+		plainText = append(plainText, b0)
+	}
+	return plainText
+}
+
+func unpad(paddedText []byte) []byte {
+	padSize := int(paddedText[len(paddedText)-1])
+	return paddedText[:len(paddedText)-padSize]
+}
+
+func encryptECB(plainText, key []byte) []byte {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+
+	blockSize := block.BlockSize()
+	plainText = pad(plainText, blockSize)
+	cipherText := plainText
+
+	for len(plainText) > 0 {
+		block.Encrypt(plainText, plainText)
+		plainText = plainText[blockSize:]
+	}
+
+	return cipherText
+}
+
+func decryptECB(cipherText, key []byte) []byte {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+
+	blockSize := block.BlockSize()
+	paddedText := cipherText
+
+	for len(cipherText) > 0 {
+		block.Decrypt(cipherText, cipherText)
+		cipherText = cipherText[blockSize:]
+	}
+
+	return unpad(paddedText)
+}
diff --git a/installs_on_host/go2rtc/pkg/roborock/producer.go b/installs_on_host/go2rtc/pkg/roborock/producer.go
new file mode 100644
index 0000000..c0dbe87
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/roborock/producer.go
@@ -0,0 +1,46 @@
+package roborock
+
+import (
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func (c *Client) GetMedias() []*core.Media {
+	return c.conn.GetMedias()
+}
+
+func (c *Client) GetTrack(media *core.Media, codec *core.Codec) (*core.Receiver, error) {
+	if media.Kind == core.KindAudio {
+		c.audio = true
+	}
+
+	return c.conn.GetTrack(media, codec)
+}
+
+func (c *Client) AddTrack(media *core.Media, codec *core.Codec, track *core.Receiver) error {
+	c.backchannel = true
+	return c.conn.AddTrack(media, codec, track)
+}
+
+func (c *Client) Start() error {
+	if c.audio || c.backchannel {
+		if err := c.StartVoiceChat(); err != nil {
+			return err
+		}
+
+		if c.backchannel {
+			if err := c.SetVoiceChatVolume(80); err != nil {
+				return err
+			}
+		}
+	}
+	return c.conn.Start()
+}
+
+func (c *Client) Stop() error {
+	_ = c.iot.Close()
+	return c.conn.Stop()
+}
+
+func (c *Client) MarshalJSON() ([]byte, error) {
+	return c.conn.MarshalJSON()
+}
diff --git a/installs_on_host/go2rtc/pkg/rtmp/README.md b/installs_on_host/go2rtc/pkg/rtmp/README.md
new file mode 100644
index 0000000..f6e6632
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/rtmp/README.md
@@ -0,0 +1,27 @@
+## Tests
+
+- go2rtc rtmp client => Reolink
+- go2rtc rtmp server <= Dahua
+- go2rtc rtmp publish => YouTube
+- go2rtc rtmp publish => Telegram
+
+## Logs
+
+```
+request  []interface {}{"connect", 1, map[string]interface {}{"app":"s", "flashVer":"FMLE/3.0 (compatible; FMSc/1.0)", "tcUrl":"rtmps://xxx.rtmp.t.me/s/xxxxx"}}
+response []interface {}{"_result", 1, map[string]interface {}{"capabilities":31, "fmsVer":"FMS/3,0,1,123"}, map[string]interface {}{"code":"NetConnection.Connect.Success", "description":"Connection succeeded.", "level":"status", "objectEncoding":0}}
+request  []interface {}{"releaseStream", 2, interface {}(nil), "xxxxx"}
+request  []interface {}{"FCPublish", 3, interface {}(nil), "xxxxx"}
+request  []interface {}{"createStream", 4, interface {}(nil)}
+response []interface {}{"_result", 2, interface {}(nil)}
+response []interface {}{"_result", 4, interface {}(nil), 1}
+request  []interface {}{"publish", 5, interface {}(nil), "xxxxx", "live"}
+response []interface {}{"onStatus", 0, interface {}(nil), map[string]interface {}{"code":"NetStream.Publish.Start", "description":"xxxxx is now published", "detail":"xxxxx", "level":"status"}}
+```
+
+## Useful links
+
+- https://en.wikipedia.org/wiki/Flash_Video
+- https://en.wikipedia.org/wiki/Real-Time_Messaging_Protocol
+- https://rtmp.veriskope.com/pdf/rtmp_specification_1.0.pdf
+- https://rtmp.veriskope.com/docs/spec/
diff --git a/installs_on_host/go2rtc/pkg/rtmp/client.go b/installs_on_host/go2rtc/pkg/rtmp/client.go
new file mode 100644
index 0000000..c9e9ad1
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/rtmp/client.go
@@ -0,0 +1,161 @@
+package rtmp
+
+import (
+	"bufio"
+	"io"
+	"net"
+	"net/url"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/flv"
+	"github.com/AlexxIT/go2rtc/pkg/tcp"
+)
+
+func DialPlay(rawURL string) (*flv.Producer, error) {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	conn, err := tcp.Dial(u, core.ConnDialTimeout)
+	if err != nil {
+		return nil, err
+	}
+
+	client, err := NewClient(conn, u)
+	if err != nil {
+		return nil, err
+	}
+
+	if err = client.play(); err != nil {
+		return nil, err
+	}
+
+	return client.Producer()
+}
+
+func DialPublish(rawURL string, cons *flv.Consumer) (io.Writer, error) {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	conn, err := tcp.Dial(u, core.ConnDialTimeout)
+	if err != nil {
+		return nil, err
+	}
+
+	client, err := NewClient(conn, u)
+	if err != nil {
+		return nil, err
+	}
+
+	if err = client.publish(); err != nil {
+		return nil, err
+	}
+
+	cons.FormatName = "rtmp"
+	cons.Protocol = "rtmp"
+	cons.RemoteAddr = conn.RemoteAddr().String()
+	cons.URL = rawURL
+
+	return client, nil
+}
+
+func NewClient(conn net.Conn, u *url.URL) (*Conn, error) {
+	c := &Conn{
+		url: u.String(),
+
+		conn: conn,
+		rd:   bufio.NewReaderSize(conn, core.BufferSize),
+		wr:   conn,
+
+		chunks: map[uint8]*chunk{},
+
+		rdPacketSize: 128,
+		wrPacketSize: 4096, // OBS - 4096, Reolink - 4096
+	}
+
+	if args := strings.Split(u.Path, "/"); len(args) >= 2 {
+		c.App = args[1]
+		if len(args) >= 3 {
+			c.Stream = args[2]
+			if u.RawQuery != "" {
+				c.Stream += "?" + u.RawQuery
+			}
+		}
+	}
+
+	if err := c.clienHandshake(); err != nil {
+		return nil, err
+	}
+	if err := c.writePacketSize(); err != nil {
+		return nil, err
+	}
+
+	return c, nil
+}
+
+func (c *Conn) clienHandshake() error {
+	// simple handshake without real random and check response
+	b := make([]byte, 1+1536)
+	b[0] = 0x03
+	// write C0+C1
+	if _, err := c.conn.Write(b); err != nil {
+		return err
+	}
+	// read S0+S1
+	if _, err := io.ReadFull(c.rd, b); err != nil {
+		return err
+	}
+	// write S1
+	if _, err := c.conn.Write(b[1:]); err != nil {
+		return err
+	}
+	// read C1, skip check
+	if _, err := io.ReadFull(c.rd, b[1:]); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (c *Conn) play() error {
+	if err := c.writeConnect(); err != nil {
+		return err
+	}
+	if err := c.writeCreateStream(); err != nil {
+		return err
+	}
+	if err := c.writePlay(); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (c *Conn) publish() error {
+	if err := c.writeConnect(); err != nil {
+		return err
+	}
+	if err := c.writeReleaseStream(); err != nil {
+		return err
+	}
+	if err := c.writeCreateStream(); err != nil {
+		return err
+	}
+	if err := c.writePublish(); err != nil {
+		return err
+	}
+
+	go func() {
+		for {
+			_, _, _, err := c.readMessage()
+			//log.Printf("!!! %d %d %.30x", msgType, timeMS, b)
+			if err != nil {
+				return
+			}
+		}
+	}()
+
+	return nil
+}
diff --git a/installs_on_host/go2rtc/pkg/rtmp/conn.go b/installs_on_host/go2rtc/pkg/rtmp/conn.go
new file mode 100644
index 0000000..70e2aec
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/rtmp/conn.go
@@ -0,0 +1,376 @@
+package rtmp
+
+import (
+	"encoding/binary"
+	"fmt"
+	"io"
+	"net"
+	"strings"
+	"sync"
+
+	"github.com/AlexxIT/go2rtc/pkg/flv/amf"
+)
+
+const (
+	TypeSetPacketSize   = 1
+	TypeServerBandwidth = 5
+	TypeClientBandwidth = 6
+	TypeAudio           = 8
+	TypeVideo           = 9
+	TypeData            = 18
+	TypeCommand         = 20
+)
+
+type Conn struct {
+	App    string
+	Stream string
+	Intent string
+
+	rdPacketSize uint32
+	wrPacketSize uint32
+
+	chunks   map[byte]*chunk
+	streamID byte
+	url      string
+
+	conn net.Conn
+	rd   io.Reader
+	wr   io.Writer
+
+	rdBuf []byte
+	wrBuf []byte
+	mu    sync.Mutex
+}
+
+func (c *Conn) Close() error {
+	return c.conn.Close()
+}
+
+func (c *Conn) readResponse(wait func(items []any) bool) ([]any, error) {
+	for {
+		msgType, _, b, err := c.readMessage()
+		if err != nil {
+			return nil, err
+		}
+		//log.Printf("[rtmp] type=%d data=%s", msgType, b)
+
+		switch msgType {
+		case TypeSetPacketSize:
+			c.rdPacketSize = binary.BigEndian.Uint32(b)
+		case TypeCommand:
+			items, _ := amf.NewReader(b).ReadItems()
+			if wait(items) {
+				return items, nil
+			}
+		}
+	}
+}
+
+type chunk struct {
+	conn     *Conn
+	rawTime  uint32
+	dataSize uint32
+	tagType  byte
+	streamID uint32
+	timeMS   uint32
+}
+
+func (c *chunk) readHeader(typ byte) error {
+	switch typ {
+	case 0: // 12 byte header (full header)
+		b, err := c.conn.readSize(11)
+		if err != nil {
+			return err
+		}
+		c.rawTime = Uint24(b)
+		c.dataSize = Uint24(b[3:])
+		c.tagType = b[6]
+		c.streamID = binary.LittleEndian.Uint32(b[7:])
+		c.timeMS = c.readExtendedTime()
+
+	case 1: // 8 bytes - like type b00, not including message ID (4 last bytes)
+		b, err := c.conn.readSize(7)
+		if err != nil {
+			return err
+		}
+		c.rawTime = Uint24(b)
+		c.dataSize = Uint24(b[3:]) // msgdatalen
+		c.tagType = b[6]           // msgtypeid
+		c.timeMS += c.readExtendedTime()
+
+	case 2: // 4 bytes - Basic Header and timestamp (3 bytes) are included
+		b, err := c.conn.readSize(3)
+		if err != nil {
+			return err
+		}
+		c.rawTime = Uint24(b) // timestamp
+		c.timeMS += c.readExtendedTime()
+
+	case 3: // 1 byte - only the Basic Header is included
+		// use here hdr from previous msg with same session ID (sid)
+	}
+	return nil
+}
+
+func (c *chunk) readExtendedTime() uint32 {
+	if c.rawTime == 0xFFFFFF {
+		if b, err := c.conn.readSize(4); err == nil {
+			return binary.BigEndian.Uint32(b)
+		}
+	}
+	return c.rawTime
+}
+
+//var ErrNotImplemented = errors.New("rtmp: not implemented")
+
+func (c *Conn) readMessage() (byte, uint32, []byte, error) {
+	b, err := c.readSize(1) // doesn't support big chunkID!!!
+	if err != nil {
+		return 0, 0, nil, err
+	}
+
+	hdrType := b[0] >> 6
+	chunkID := b[0] & 0b111111
+
+	// storing header information for support header type 3
+	ch, ok := c.chunks[chunkID]
+	if !ok {
+		ch = &chunk{conn: c}
+		c.chunks[chunkID] = ch
+	}
+
+	if err = ch.readHeader(hdrType); err != nil {
+		return 0, 0, nil, err
+	}
+
+	//log.Printf("[rtmp] hdr=%d chunkID=%d timeMS=%d size=%d tagType=%d streamID=%d", hdrType, chunkID, ch.timeMS, ch.dataSize, ch.tagType, ch.streamID)
+
+	// 1. Response zero size
+	if ch.dataSize == 0 {
+		return ch.tagType, ch.timeMS, nil, nil
+	}
+
+	data := make([]byte, ch.dataSize)
+
+	// 2. Response small packet
+	if ch.dataSize <= c.rdPacketSize {
+		if _, err = io.ReadFull(c.rd, data); err != nil {
+			return 0, 0, nil, err
+		}
+		return ch.tagType, ch.timeMS, data, nil
+	}
+
+	// 3. Response big packet
+	var i0 uint32
+	for i1 := c.rdPacketSize; i1 < ch.dataSize; i1 += c.rdPacketSize {
+		if _, err = io.ReadFull(c.rd, data[i0:i1]); err != nil {
+			return 0, 0, nil, err
+		}
+
+		// hopefully this will be hdrType=3 with same chunkID
+		if _, err = c.readSize(1); err != nil {
+			return 0, 0, nil, err
+		}
+
+		_ = ch.readExtendedTime()
+
+		i0 = i1
+	}
+
+	if _, err = io.ReadFull(c.rd, data[i0:]); err != nil {
+		return 0, 0, nil, err
+	}
+
+	return ch.tagType, ch.timeMS, data, nil
+}
+
+func (c *Conn) writeMessage(chunkID, tagType byte, timeMS uint32, payload []byte) error {
+	c.mu.Lock()
+	c.resetBuffer()
+
+	b := payload
+	size := uint32(len(b))
+
+	if size > c.wrPacketSize {
+		c.appendType0(chunkID, tagType, timeMS, size, b[:c.wrPacketSize])
+
+		for {
+			b = b[c.wrPacketSize:]
+			if uint32(len(b)) > c.wrPacketSize {
+				c.appendType3(chunkID, b[:c.wrPacketSize])
+			} else {
+				c.appendType3(chunkID, b)
+				break
+			}
+		}
+	} else {
+		c.appendType0(chunkID, tagType, timeMS, size, b)
+	}
+
+	//log.Printf("%d %2d %5d %6d %.32x", chunkID, tagType, timeMS, size, payload)
+
+	_, err := c.wr.Write(c.wrBuf)
+	c.mu.Unlock()
+	return err
+}
+
+func (c *Conn) resetBuffer() {
+	c.wrBuf = c.wrBuf[:0]
+}
+
+func (c *Conn) appendType0(chunkID, tagType byte, timeMS, size uint32, payload []byte) {
+	// TODO: timeMS more than 24 bit
+	c.wrBuf = append(c.wrBuf,
+		chunkID,
+		byte(timeMS>>16), byte(timeMS>>8), byte(timeMS),
+		byte(size>>16), byte(size>>8), byte(size),
+		tagType,
+		c.streamID, 0, 0, 0, // little endian streamID
+	)
+	c.wrBuf = append(c.wrBuf, payload...)
+}
+
+func (c *Conn) appendType3(chunkID byte, payload []byte) {
+	c.wrBuf = append(c.wrBuf, 3<<6|chunkID)
+	c.wrBuf = append(c.wrBuf, payload...)
+}
+
+func (c *Conn) writePacketSize() error {
+	b := binary.BigEndian.AppendUint32(nil, c.wrPacketSize)
+	return c.writeMessage(2, TypeSetPacketSize, 0, b)
+}
+
+func (c *Conn) writeConnect() error {
+	b := amf.EncodeItems("connect", 1, map[string]any{
+		"app":      c.App,
+		"flashVer": "FMLE/3.0 (compatible; FMSc/1.0)",
+		"tcUrl":    c.url,
+	})
+	if err := c.writeMessage(3, TypeCommand, 0, b); err != nil {
+		return err
+	}
+
+	v, err := c.readResponse(func(items []any) bool {
+		return len(items) >= 3 && items[0] == "_result" && items[1] == float64(1)
+	})
+	if err != nil {
+		return err
+	}
+
+	code := getString(v, 3, "code")
+	if code != "NetConnection.Connect.Success" {
+		return fmt.Errorf("rtmp: wrong response %#v", v)
+	}
+
+	return nil
+}
+
+func (c *Conn) writeReleaseStream() error {
+	b := amf.EncodeItems("releaseStream", 2, nil, c.Stream)
+	if err := c.writeMessage(3, TypeCommand, 0, b); err != nil {
+		return err
+	}
+	b = amf.EncodeItems("FCPublish", 3, nil, c.Stream)
+	if err := c.writeMessage(3, TypeCommand, 0, b); err != nil {
+		return err
+	}
+	return nil
+}
+func (c *Conn) writeCreateStream() error {
+	b := amf.EncodeItems("createStream", 4, nil)
+	if err := c.writeMessage(3, TypeCommand, 0, b); err != nil {
+		return err
+	}
+
+	v, err := c.readResponse(func(items []any) bool {
+		return len(items) >= 3 && items[0] == "_result" && items[1] == float64(4)
+	})
+	if err != nil {
+		return err
+	}
+
+	if len(v) == 4 {
+		if f, ok := v[3].(float64); ok {
+			c.streamID = byte(f)
+			return nil
+		}
+	}
+
+	return fmt.Errorf("rtmp: wrong response %#v", v)
+}
+
+func (c *Conn) writePublish() error {
+	b := amf.EncodeItems("publish", 5, nil, c.Stream, "live")
+	if err := c.writeMessage(3, TypeCommand, 0, b); err != nil {
+		return err
+	}
+
+	// YouTube can response with "onBWDone 0"
+	v, err := c.readResponse(func(items []any) bool {
+		return len(items) >= 3 && items[0] == "onStatus"
+	})
+	if err != nil {
+		return nil
+	}
+
+	code := getString(v, 3, "code")
+	if code != "NetStream.Publish.Start" {
+		return fmt.Errorf("rtmp: wrong response %#v", v)
+	}
+
+	return nil
+}
+
+func (c *Conn) writePlay() error {
+	b := amf.EncodeItems("play", 5, nil, c.Stream)
+	if err := c.writeMessage(3, TypeCommand, 0, b); err != nil {
+		return err
+	}
+
+	// Reolink response with ID=0, other software respose with ID=5
+	v, err := c.readResponse(func(items []any) bool {
+		return len(items) >= 3 && items[0] == "onStatus"
+	})
+	if err != nil {
+		return nil
+	}
+
+	code := getString(v, 3, "code")
+	if !strings.HasPrefix(code, "NetStream.Play.") {
+		return fmt.Errorf("rtmp: wrong response %#v", v)
+	}
+
+	return nil
+}
+
+func (c *Conn) readSize(n uint32) ([]byte, error) {
+	b := make([]byte, n)
+	if _, err := io.ReadFull(c.rd, b); err != nil {
+		return nil, err
+	}
+	return b, nil
+}
+
+func PutUint24(b []byte, v uint32) {
+	_ = b[2]
+	b[0] = byte(v >> 16)
+	b[1] = byte(v >> 8)
+	b[2] = byte(v)
+}
+
+func Uint24(b []byte) uint32 {
+	_ = b[2]
+	return uint32(b[0])<<16 | uint32(b[1])<<8 | uint32(b[2])
+}
+
+func getString(v []any, i int, key string) string {
+	if len(v) <= i {
+		return ""
+	}
+	if v, ok := v[i].(map[string]any); ok {
+		if s, ok := v[key].(string); ok {
+			return s
+		}
+	}
+	return ""
+}
diff --git a/installs_on_host/go2rtc/pkg/rtmp/flv.go b/installs_on_host/go2rtc/pkg/rtmp/flv.go
new file mode 100644
index 0000000..350f4c3
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/rtmp/flv.go
@@ -0,0 +1,96 @@
+package rtmp
+
+import (
+	"github.com/AlexxIT/go2rtc/pkg/flv"
+)
+
+func (c *Conn) Producer() (*flv.Producer, error) {
+	c.rdBuf = []byte{
+		'F', 'L', 'V', // signature
+		1,          // version
+		0,          // flags (has video/audio)
+		0, 0, 0, 9, // header size
+	}
+
+	prod, err := flv.Open(c)
+	if err != nil {
+		return nil, err
+	}
+
+	prod.FormatName = "rtmp"
+	prod.Protocol = "rtmp"
+	prod.RemoteAddr = c.conn.RemoteAddr().String()
+	prod.URL = c.url
+
+	return prod, nil
+}
+
+// Read - convert RTMP to FLV format
+func (c *Conn) Read(p []byte) (n int, err error) {
+	// 1. Check temporary tempbuffer
+	if len(c.rdBuf) == 0 {
+		msgType, timeMS, payload, err2 := c.readMessage()
+		if err2 != nil {
+			return 0, err2
+		}
+
+		// previous tag size (4 byte) + header (11 byte) + payload
+		n = 4 + 11 + len(payload)
+
+		// 2. Check if the message fits in the buffer
+		if n <= len(p) {
+			encodeFLV(p, msgType, timeMS, payload)
+			return
+		}
+
+		// 3. Put the message into a temporary buffer
+		c.rdBuf = make([]byte, n)
+		encodeFLV(c.rdBuf, msgType, timeMS, payload)
+	}
+
+	// 4. Send temporary buffer
+	n = copy(p, c.rdBuf)
+	c.rdBuf = c.rdBuf[n:]
+	return
+}
+
+func encodeFLV(b []byte, msgType byte, time uint32, payload []byte) {
+	_ = b[4+11]
+
+	b[0] = 0
+	b[1] = 0
+	b[2] = 0
+	b[3] = 0
+	b[4+0] = msgType
+	PutUint24(b[4+1:], uint32(len(payload)))
+	PutUint24(b[4+4:], time)
+	b[4+7] = byte(time >> 24)
+
+	copy(b[4+11:], payload)
+}
+
+// Write - convert FLV format to RTMP format
+func (c *Conn) Write(p []byte) (n int, err error) {
+	n = len(p)
+
+	if p[0] == 'F' {
+		p = p[9+4:] // skip first msg with FLV header
+
+		for len(p) > 0 {
+			size := 11 + uint16(p[2])<<8 + uint16(p[3]) + 4
+			if _, err = c.Write(p[:size]); err != nil {
+				return 0, err
+			}
+			p = p[size:]
+		}
+		return
+	}
+
+	// decode FLV: 11 bytes header + payload + 4 byte size
+	tagType := p[0]
+	timeMS := uint32(p[4])<<16 | uint32(p[5])<<8 | uint32(p[6]) | uint32(p[7])<<24
+	payload := p[11 : len(p)-4]
+
+	err = c.writeMessage(4, tagType, timeMS, payload)
+	return
+}
diff --git a/installs_on_host/go2rtc/pkg/rtmp/server.go b/installs_on_host/go2rtc/pkg/rtmp/server.go
new file mode 100644
index 0000000..014b285
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/rtmp/server.go
@@ -0,0 +1,201 @@
+package rtmp
+
+import (
+	"bufio"
+	"crypto/rand"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/flv/amf"
+)
+
+func NewServer(conn net.Conn) (*Conn, error) {
+	c := &Conn{
+		conn: conn,
+		rd:   bufio.NewReaderSize(conn, core.BufferSize),
+		wr:   conn,
+
+		chunks: map[uint8]*chunk{},
+
+		rdPacketSize: 128,
+		wrPacketSize: 4096,
+	}
+
+	if err := c.serverHandshake(); err != nil {
+		return nil, err
+	}
+	if err := c.writePacketSize(); err != nil {
+		return nil, err
+	}
+
+	return c, nil
+}
+
+func (c *Conn) serverHandshake() error {
+	// based on https://rtmp.veriskope.com/docs/spec/
+	_ = c.conn.SetDeadline(time.Now().Add(core.ConnDeadline))
+
+	// read C0
+	b := make([]byte, 1)
+	if _, err := io.ReadFull(c.rd, b); err != nil {
+		return err
+	}
+
+	if b[0] != 3 {
+		return errors.New("rtmp: wrong handshake")
+	}
+
+	// write S0
+	if _, err := c.conn.Write([]byte{3}); err != nil {
+		return err
+	}
+
+	b = make([]byte, 1536)
+
+	// write S1
+	tsS1 := nowMS()
+	binary.BigEndian.PutUint32(b, tsS1)
+	binary.BigEndian.PutUint32(b[4:], 0)
+	_, _ = rand.Read(b[8:])
+	if _, err := c.conn.Write(b); err != nil {
+		return err
+	}
+
+	// read C1
+	if _, err := io.ReadFull(c.rd, b); err != nil {
+		return err
+	}
+
+	// write S2
+	tsS2 := nowMS()
+	binary.BigEndian.PutUint32(b, tsS1)
+	binary.BigEndian.PutUint32(b[4:], tsS2)
+	if _, err := c.conn.Write(b); err != nil {
+		return err
+	}
+
+	// read C2
+	if _, err := io.ReadFull(c.rd, b); err != nil {
+		return err
+	}
+
+	_ = c.conn.SetDeadline(time.Time{})
+	return nil
+}
+
+func (c *Conn) ReadCommands() error {
+	for {
+		msgType, _, b, err := c.readMessage()
+		if err != nil {
+			return err
+		}
+
+		//log.Printf("%d %.256x", msgType, b)
+
+		switch msgType {
+		case TypeSetPacketSize:
+			c.rdPacketSize = binary.BigEndian.Uint32(b)
+		case TypeCommand:
+			if err = c.acceptCommand(b); err != nil {
+				return err
+			}
+
+			if c.Intent != "" {
+				return nil
+			}
+		}
+	}
+}
+
+const (
+	CommandConnect       = "connect"
+	CommandReleaseStream = "releaseStream"
+	CommandFCPublish     = "FCPublish"
+	CommandCreateStream  = "createStream"
+	CommandPublish       = "publish"
+	CommandPlay          = "play"
+)
+
+func (c *Conn) acceptCommand(b []byte) error {
+	items, err := amf.NewReader(b).ReadItems()
+	if err != nil {
+		return nil
+	}
+
+	//log.Printf("%#v", items)
+
+	if len(items) < 2 {
+		return fmt.Errorf("rtmp: read command %x", b)
+	}
+
+	cmd, ok := items[0].(string)
+	if !ok {
+		return fmt.Errorf("rtmp: read command %x", b)
+	}
+
+	tID, ok := items[1].(float64) // transaction ID
+	if !ok {
+		return fmt.Errorf("rtmp: read command %x", b)
+	}
+
+	switch cmd {
+	case CommandConnect:
+		if len(items) == 3 {
+			if v, ok := items[2].(map[string]any); ok {
+				c.App, _ = v["app"].(string)
+			}
+		}
+
+		payload := amf.EncodeItems(
+			"_result", tID,
+			map[string]any{"fmsVer": "FMS/3,0,1,123"},
+			map[string]any{"code": "NetConnection.Connect.Success"},
+		)
+		return c.writeMessage(3, TypeCommand, 0, payload)
+
+	case CommandReleaseStream:
+		// if app is empty - will use key as app
+		if c.App == "" && len(items) == 4 {
+			c.App, _ = items[3].(string)
+		}
+
+		payload := amf.EncodeItems("_result", tID, nil)
+		return c.writeMessage(3, TypeCommand, 0, payload)
+
+	case CommandFCPublish: // no response
+
+	case CommandCreateStream:
+		payload := amf.EncodeItems("_result", tID, nil, 1)
+		return c.writeMessage(3, TypeCommand, 0, payload)
+
+	case CommandPublish, CommandPlay: // response later
+		c.Intent = cmd
+		c.streamID = 1
+
+	default:
+		println("rtmp: unknown command: " + cmd)
+	}
+
+	return nil
+}
+
+func (c *Conn) WriteStart() error {
+	var code string
+	if c.Intent == CommandPublish {
+		code = "NetStream.Publish.Start"
+	} else {
+		code = "NetStream.Play.Start"
+	}
+
+	payload := amf.EncodeItems("onStatus", 0, nil, map[string]any{"code": code})
+	return c.writeMessage(3, TypeCommand, 0, payload)
+}
+
+func nowMS() uint32 {
+	return uint32(time.Now().UnixNano() / int64(time.Millisecond))
+}
diff --git a/installs_on_host/go2rtc/pkg/rtsp/README.md b/installs_on_host/go2rtc/pkg/rtsp/README.md
new file mode 100644
index 0000000..ddaafdb
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/rtsp/README.md
@@ -0,0 +1,3 @@
+## Useful links
+
+- https://www.kurento.org/blog/rtp-i-intro-rtp-and-sdp
\ No newline at end of file
diff --git a/installs_on_host/go2rtc/pkg/rtsp/client.go b/installs_on_host/go2rtc/pkg/rtsp/client.go
new file mode 100644
index 0000000..c960732
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/rtsp/client.go
@@ -0,0 +1,456 @@
+package rtsp
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"net"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/tcp/websocket"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/tcp"
+)
+
+var Timeout = time.Second * 5
+
+func NewClient(uri string) *Conn {
+	return &Conn{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "rtsp",
+		},
+		uri: uri,
+	}
+}
+
+func (c *Conn) Dial() (err error) {
+	if c.URL, err = url.Parse(c.uri); err != nil {
+		return
+	}
+
+	var conn net.Conn
+
+	switch c.Transport {
+	case "", "tcp", "udp":
+		var timeout time.Duration
+		if c.Timeout != 0 {
+			timeout = time.Second * time.Duration(c.Timeout)
+		} else {
+			timeout = core.ConnDialTimeout
+		}
+		conn, err = tcp.Dial(c.URL, timeout)
+
+		if c.Transport != "udp" {
+			c.Protocol = "rtsp+tcp"
+		} else {
+			c.Protocol = "rtsp+udp"
+		}
+	default:
+		conn, err = websocket.Dial(c.Transport)
+		c.Protocol = "ws"
+	}
+	if err != nil {
+		return
+	}
+
+	// remove UserInfo from URL
+	c.auth = tcp.NewAuth(c.URL.User)
+	c.URL.User = nil
+
+	c.conn = conn
+	c.reader = bufio.NewReaderSize(conn, core.BufferSize)
+	c.session = ""
+	c.sequence = 0
+	c.state = StateConn
+
+	c.udpConn = nil
+	c.udpAddr = nil
+
+	c.Connection.RemoteAddr = conn.RemoteAddr().String()
+	c.Connection.Transport = conn
+	c.Connection.URL = c.uri
+
+	return nil
+}
+
+// Do send WriteRequest and receive and process WriteResponse
+func (c *Conn) Do(req *tcp.Request) (*tcp.Response, error) {
+	if err := c.WriteRequest(req); err != nil {
+		return nil, err
+	}
+
+	res, err := c.ReadResponse()
+	if err != nil {
+		return nil, err
+	}
+
+	c.Fire(res)
+
+	switch res.StatusCode {
+	case http.StatusOK:
+		return res, nil
+
+	case http.StatusMovedPermanently, http.StatusFound:
+		rawURL := res.Header.Get("Location")
+
+		var u *url.URL
+		if u, err = url.Parse(rawURL); err != nil {
+			return nil, err
+		}
+
+		if u.User == nil {
+			u.User = c.auth.UserInfo() // restore auth if we don't have it in the new URL
+		}
+
+		c.uri = u.String() // so auth will be saved on reconnect
+
+		_ = c.conn.Close()
+
+		if err = c.Dial(); err != nil {
+			return nil, err
+		}
+
+		req.URL = c.URL // because path was changed
+
+		return c.Do(req)
+
+	case http.StatusUnauthorized:
+		switch c.auth.Method {
+		case tcp.AuthNone:
+			if c.auth.ReadNone(res) {
+				return c.Do(req)
+			}
+			return nil, errors.New("user/pass not provided")
+		case tcp.AuthUnknown:
+			if c.auth.Read(res) {
+				return c.Do(req)
+			}
+		default:
+			return nil, errors.New("wrong user/pass")
+		}
+	}
+
+	return res, fmt.Errorf("wrong response on %s", req.Method)
+}
+
+func (c *Conn) Options() error {
+	req := &tcp.Request{Method: MethodOptions, URL: c.URL}
+
+	res, err := c.Do(req)
+	if err != nil {
+		return err
+	}
+
+	if val := res.Header.Get("Content-Base"); val != "" {
+		c.URL, err = urlParse(val)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (c *Conn) Describe() error {
+	// 5.3 Back channel connection
+	// https://www.onvif.org/specs/stream/ONVIF-Streaming-Spec.pdf
+	req := &tcp.Request{
+		Method: MethodDescribe,
+		URL:    c.URL,
+		Header: map[string][]string{
+			"Accept": {"application/sdp"},
+		},
+	}
+
+	if c.Backchannel {
+		req.Header.Set("Require", "www.onvif.org/ver20/backchannel")
+	}
+
+	if c.UserAgent != "" {
+		// this camera will answer with 401 on DESCRIBE without User-Agent
+		// https://github.com/AlexxIT/go2rtc/issues/235
+		req.Header.Set("User-Agent", c.UserAgent)
+	}
+
+	res, err := c.Do(req)
+	if err != nil {
+		return err
+	}
+
+	if val := res.Header.Get("Content-Base"); val != "" {
+		c.URL, err = urlParse(val)
+		if err != nil {
+			return err
+		}
+	}
+
+	c.SDP = string(res.Body) // for info
+
+	medias, err := UnmarshalSDP(res.Body)
+	if err != nil {
+		return err
+	}
+
+	if c.Media != "" {
+		clone := make([]*core.Media, 0, len(medias))
+		for _, media := range medias {
+			if strings.Contains(c.Media, media.Kind) {
+				clone = append(clone, media)
+			}
+		}
+		medias = clone
+	}
+
+	// TODO: rewrite more smart
+	if c.Medias == nil {
+		c.Medias = medias
+	} else if len(c.Medias) > len(medias) {
+		c.Medias = c.Medias[:len(medias)]
+	}
+
+	c.mode = core.ModeActiveProducer
+
+	return nil
+}
+
+func (c *Conn) Announce() (err error) {
+	req := &tcp.Request{
+		Method: MethodAnnounce,
+		URL:    c.URL,
+		Header: map[string][]string{
+			"Content-Type": {"application/sdp"},
+		},
+	}
+
+	req.Body, err = core.MarshalSDP(c.SessionName, c.Medias)
+	if err != nil {
+		return err
+	}
+
+	_, err = c.Do(req)
+	return
+}
+
+func (c *Conn) Record() (err error) {
+	req := &tcp.Request{
+		Method: MethodRecord,
+		URL:    c.URL,
+		Header: map[string][]string{
+			"Range": {"npt=0.000-"},
+		},
+	}
+
+	_, err = c.Do(req)
+	return
+}
+
+func (c *Conn) SetupMedia(media *core.Media) (byte, error) {
+	var transport string
+
+	if c.Transport == "udp" {
+		conn1, conn2, err := ListenUDPPair()
+		if err != nil {
+			return 0, err
+		}
+
+		c.udpConn = append(c.udpConn, conn1, conn2)
+
+		port := conn1.LocalAddr().(*net.UDPAddr).Port
+		transport = fmt.Sprintf("RTP/AVP;unicast;client_port=%d-%d", port, port+1)
+	} else {
+		// try to use media position as channel number
+		for i, m := range c.Medias {
+			if m.Equal(media) {
+				transport = fmt.Sprintf(
+					// i   - RTP (data channel)
+					// i+1 - RTCP (control channel)
+					"RTP/AVP/TCP;unicast;interleaved=%d-%d", i*2, i*2+1,
+				)
+				break
+			}
+		}
+	}
+
+	if transport == "" {
+		return 0, fmt.Errorf("wrong media: %v", media)
+	}
+
+	rawURL := media.ID // control
+	if !strings.Contains(rawURL, "://") {
+		rawURL = c.URL.String()
+		// prefix check for https://github.com/AlexxIT/go2rtc/issues/1236
+		if !strings.HasSuffix(rawURL, "/") && !strings.HasPrefix(media.ID, "/") {
+			rawURL += "/"
+		}
+		rawURL += media.ID
+	}
+	trackURL, err := urlParse(rawURL)
+	if err != nil {
+		return 0, err
+	}
+
+	req := &tcp.Request{
+		Method: MethodSetup,
+		URL:    trackURL,
+		Header: map[string][]string{
+			"Transport": {transport},
+		},
+	}
+
+	res, err := c.Do(req)
+	if err != nil {
+		// some Dahua/Amcrest cameras fail here because two simultaneous
+		// backchannel connections
+		if c.Backchannel {
+			c.Backchannel = false
+			if err = c.Reconnect(); err != nil {
+				return 0, err
+			}
+			return c.SetupMedia(media)
+		}
+
+		return 0, err
+	}
+
+	if c.session == "" {
+		// Session: 7116520596809429228
+		// Session: 216525287999;timeout=60
+		if s := res.Header.Get("Session"); s != "" {
+			if i := strings.IndexByte(s, ';'); i > 0 {
+				c.session = s[:i]
+				if i = strings.Index(s, "timeout="); i > 0 {
+					c.keepalive, _ = strconv.Atoi(s[i+8:])
+				}
+			} else {
+				c.session = s
+			}
+		}
+	}
+
+	// Parse server response
+	transport = res.Header.Get("Transport")
+
+	if c.Transport == "udp" {
+		channel := byte(len(c.udpConn) - 2)
+
+		// Dahua:   RTP/AVP/UDP;unicast;client_port=49292-49293;server_port=43670-43671;ssrc=7CB694B4
+		// OpenIPC: RTP/AVP/UDP;unicast;client_port=59612-59613
+		if s := core.Between(transport, "server_port=", ";"); s != "" {
+			s1, s2, _ := strings.Cut(s, "-")
+			port1 := core.Atoi(s1)
+			port2 := core.Atoi(s2)
+			// TODO: more smart handling empty server ports
+			if port1 > 0 && port2 > 0 {
+				remoteIP := c.conn.RemoteAddr().(*net.TCPAddr).IP
+				c.udpAddr = append(c.udpAddr,
+					&net.UDPAddr{IP: remoteIP, Port: port1},
+					&net.UDPAddr{IP: remoteIP, Port: port2},
+				)
+
+				go func() {
+					// Try to open a hole in the NAT router (to allow incoming UDP packets)
+					// by send a UDP packet for RTP and RTCP to the remote RTSP server.
+					// https://github.com/FFmpeg/FFmpeg/blob/aa91ae25b88e195e6af4248e0ab30605735ca1cd/libavformat/rtpdec.c#L416-L438
+					_, _ = c.WriteToUDP([]byte{0x80, 0x00, 0x00, 0x00}, channel)
+					_, _ = c.WriteToUDP([]byte{0x80, 0xC8, 0x00, 0x01}, channel+1)
+				}()
+			}
+		}
+
+		return channel, nil
+	} else {
+		// we send our `interleaved`, but camera can answer with another
+
+		// Transport: RTP/AVP/TCP;unicast;interleaved=10-11;ssrc=10117CB7
+		// Transport: RTP/AVP/TCP;unicast;destination=192.168.1.111;source=192.168.1.222;interleaved=0
+		// Transport: RTP/AVP/TCP;ssrc=22345682;interleaved=0-1
+		// Escam Q6 has a bug:
+		// Transport: RTP/AVP;unicast;destination=192.168.1.111;source=192.168.1.222;interleaved=0-1
+		s := core.Between(transport, "interleaved=", "-")
+		i, err := strconv.Atoi(s)
+		if err != nil {
+			return 0, fmt.Errorf("wrong transport: %s", transport)
+		}
+
+		return byte(i), nil
+	}
+}
+
+func (c *Conn) Play() (err error) {
+	req := &tcp.Request{Method: MethodPlay, URL: c.URL}
+	return c.WriteRequest(req)
+}
+
+func (c *Conn) Teardown() (err error) {
+	// allow TEARDOWN from any state (ex. ANNOUNCE > SETUP)
+	req := &tcp.Request{Method: MethodTeardown, URL: c.URL}
+	return c.WriteRequest(req)
+}
+
+func (c *Conn) Close() error {
+	if c.mode == core.ModeActiveProducer {
+		_ = c.Teardown()
+	}
+	if c.OnClose != nil {
+		_ = c.OnClose()
+	}
+	for _, conn := range c.udpConn {
+		_ = conn.Close()
+	}
+	return c.conn.Close()
+}
+
+func (c *Conn) WriteToUDP(b []byte, channel byte) (int, error) {
+	return c.udpConn[channel].WriteToUDP(b, c.udpAddr[channel])
+}
+
+const listenUDPAttemps = 10
+
+var listenUDPMu sync.Mutex
+
+func ListenUDPPair() (*net.UDPConn, *net.UDPConn, error) {
+	listenUDPMu.Lock()
+	defer listenUDPMu.Unlock()
+
+	for i := 0; i < listenUDPAttemps; i++ {
+		// Get a random even port from the OS
+		ln1, err := net.ListenUDP("udp", &net.UDPAddr{IP: nil, Port: 0})
+		if err != nil {
+			continue
+		}
+
+		var port1 = ln1.LocalAddr().(*net.UDPAddr).Port
+		var port2 int
+
+		// 11. RTP over Network and Transport Protocols (https://www.ietf.org/rfc/rfc3550.txt)
+		// For UDP and similar protocols,
+		// RTP SHOULD use an even destination port number and the corresponding
+		// RTCP stream SHOULD use the next higher (odd) destination port number
+		if port1&1 > 0 {
+			port2 = port1 - 1
+		} else {
+			port2 = port1 + 1
+		}
+
+		ln2, err := net.ListenUDP("udp", &net.UDPAddr{IP: nil, Port: port2})
+		if err != nil {
+			_ = ln1.Close()
+			continue
+		}
+
+		if port1 < port2 {
+			return ln1, ln2, nil
+		} else {
+			return ln2, ln1, nil
+		}
+	}
+
+	return nil, nil, fmt.Errorf("can't open two UDP ports")
+}
diff --git a/installs_on_host/go2rtc/pkg/rtsp/client_test.go b/installs_on_host/go2rtc/pkg/rtsp/client_test.go
new file mode 100644
index 0000000..5d714a5
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/rtsp/client_test.go
@@ -0,0 +1,95 @@
+package rtsp
+
+import (
+	"net"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestTimeout(t *testing.T) {
+	Timeout = time.Millisecond
+
+	ln, err := net.Listen("tcp", "localhost:0")
+	require.Nil(t, err)
+
+	client := NewClient("rtsp://" + ln.Addr().String() + "/stream")
+	client.Backchannel = true
+
+	err = client.Dial()
+	require.Nil(t, err)
+
+	err = client.Describe()
+	require.ErrorIs(t, err, os.ErrDeadlineExceeded)
+}
+
+func TestMissedControl(t *testing.T) {
+	Timeout = time.Millisecond
+
+	ln, err := net.Listen("tcp", "localhost:0")
+	require.Nil(t, err)
+
+	go func() {
+		conn, err := ln.Accept()
+		require.Nil(t, err)
+
+		b := make([]byte, 8192)
+		for {
+			n, err := conn.Read(b)
+			require.Nil(t, err)
+
+			req := string(b[:n])
+
+			switch req[:4] {
+			case "DESC":
+				_, _ = conn.Write([]byte(`RTSP/1.0 200 OK
+Cseq: 1
+Content-Length: 495
+Content-Type: application/sdp
+
+v=0
+o=- 1 1 IN IP4 0.0.0.0
+s=go2rtc/1.2.0
+c=IN IP4 0.0.0.0
+t=0 0
+m=audio 0 RTP/AVP 96
+a=rtpmap:96 MPEG4-GENERIC/48000/2
+a=fmtp:96 profile-level-id=1;mode=AAC-hbr;sizelength=13;indexlength=3;indexdeltalength=3; config=119056E500
+m=audio 0 RTP/AVP 97
+a=rtpmap:97 OPUS/48000/2
+a=fmtp:97 sprop-stereo=1
+m=video 0 RTP/AVP 98
+a=rtpmap:98 H264/90000
+a=fmtp:98 packetization-mode=1; sprop-parameter-sets=Z2QAKaw0yAeAIn5cBagICAoAAAfQAAE4gdDAAjhAACOEF3lxoYAEcIAARwgu8uFA,aO48MAA=; profile-level-id=640029
+`))
+
+			case "SETU":
+				_, _ = conn.Write([]byte(`RTSP/1.0 200 OK
+Transport: RTP/AVP/TCP;unicast;interleaved=4-5
+Cseq: 3
+Session: 1
+
+`))
+
+			default:
+				t.Fail()
+			}
+		}
+	}()
+
+	client := NewClient("rtsp://" + ln.Addr().String() + "/stream")
+	client.Backchannel = true
+
+	err = client.Dial()
+	require.Nil(t, err)
+
+	err = client.Describe()
+	require.Nil(t, err)
+	require.Len(t, client.Medias, 3)
+
+	ch, err := client.SetupMedia(client.Medias[2])
+	require.Nil(t, err)
+	require.Equal(t, ch, byte(4))
+}
diff --git a/installs_on_host/go2rtc/pkg/rtsp/conn.go b/installs_on_host/go2rtc/pkg/rtsp/conn.go
new file mode 100644
index 0000000..2984c78
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/rtsp/conn.go
@@ -0,0 +1,409 @@
+package rtsp
+
+import (
+	"bufio"
+	"context"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"net"
+	"net/url"
+	"strconv"
+	"sync"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/tcp"
+	"github.com/pion/rtp"
+)
+
+type Conn struct {
+	core.Connection
+	core.Listener
+
+	// public
+
+	Backchannel bool
+	Media       string
+	OnClose     func() error
+	PacketSize  uint16
+	SessionName string
+	Timeout     int
+	Transport   string // custom transport support, ex. RTSP over WebSocket
+
+	URL *url.URL
+
+	// internal
+
+	auth      *tcp.Auth
+	conn      net.Conn
+	keepalive int
+	mode      core.Mode
+	playOK    bool
+	playErr   error
+	reader    *bufio.Reader
+	sequence  int
+	session   string
+	uri       string
+
+	state   State
+	stateMu sync.Mutex
+
+	udpConn []*net.UDPConn
+	udpAddr []*net.UDPAddr
+}
+
+const (
+	ProtoRTSP      = "RTSP/1.0"
+	MethodOptions  = "OPTIONS"
+	MethodSetup    = "SETUP"
+	MethodTeardown = "TEARDOWN"
+	MethodDescribe = "DESCRIBE"
+	MethodPlay     = "PLAY"
+	MethodPause    = "PAUSE"
+	MethodAnnounce = "ANNOUNCE"
+	MethodRecord   = "RECORD"
+)
+
+type State byte
+
+func (s State) String() string {
+	switch s {
+	case StateNone:
+		return "NONE"
+	case StateConn:
+		return "CONN"
+	case StateSetup:
+		return MethodSetup
+	case StatePlay:
+		return MethodPlay
+	}
+	return strconv.Itoa(int(s))
+}
+
+const (
+	StateNone State = iota
+	StateConn
+	StateSetup
+	StatePlay
+)
+
+func (c *Conn) Handle() (err error) {
+	var timeout time.Duration
+
+	switch c.mode {
+	case core.ModeActiveProducer:
+		var keepaliveDT time.Duration
+
+		if c.keepalive > 5 {
+			keepaliveDT = time.Duration(c.keepalive-5) * time.Second
+		} else {
+			keepaliveDT = 25 * time.Second
+		}
+
+		ctx, cancel := context.WithCancel(context.Background())
+		go c.handleKeepalive(ctx, keepaliveDT)
+		defer cancel()
+
+		if c.Timeout == 0 {
+			// polling frames from remote RTSP Server (ex Camera)
+			timeout = time.Second * 5
+
+			if len(c.Receivers) == 0 || c.Transport == "udp" {
+				// if we only send audio to camera
+				// https://github.com/AlexxIT/go2rtc/issues/659
+				timeout += keepaliveDT
+			}
+		} else {
+			timeout = time.Second * time.Duration(c.Timeout)
+		}
+
+	case core.ModePassiveProducer:
+		// polling frames from remote RTSP Client (ex FFmpeg)
+		if c.Timeout == 0 {
+			timeout = time.Second * 15
+		} else {
+			timeout = time.Second * time.Duration(c.Timeout)
+		}
+
+	case core.ModePassiveConsumer:
+		// pushing frames to remote RTSP Client (ex VLC)
+		timeout = time.Second * 60
+
+	default:
+		return fmt.Errorf("wrong RTSP conn mode: %d", c.mode)
+	}
+
+	for i := 0; i < len(c.udpConn); i++ {
+		go c.handleUDPData(byte(i))
+	}
+
+	for c.state != StateNone {
+		ts := time.Now()
+
+		_ = c.conn.SetReadDeadline(ts.Add(timeout))
+
+		if err = c.handleTCPData(); err != nil {
+			return
+		}
+	}
+
+	return
+}
+
+func (c *Conn) handleKeepalive(ctx context.Context, d time.Duration) {
+	ticker := time.NewTicker(d)
+	for {
+		select {
+		case <-ticker.C:
+			req := &tcp.Request{Method: MethodOptions, URL: c.URL}
+			if err := c.WriteRequest(req); err != nil {
+				return
+			}
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
+func (c *Conn) handleUDPData(channel byte) {
+	// TODO: handle timeouts and drop TCP connection after any error
+	conn := c.udpConn[channel]
+
+	for {
+		// TP-Link Tapo camera has crazy 10000 bytes packet size
+		buf := make([]byte, 10240)
+
+		n, _, err := conn.ReadFromUDP(buf)
+		if err != nil {
+			return
+		}
+
+		if err = c.handleRawPacket(channel, buf[:n]); err != nil {
+			return
+		}
+	}
+}
+
+func (c *Conn) handleTCPData() error {
+	// we can read:
+	// 1. RTP interleaved: `$` + 1B channel number + 2B size
+	// 2. RTSP response:   RTSP/1.0 200 OK
+	// 3. RTSP request:    OPTIONS ...
+	var buf4 []byte // `$` + 1B channel number + 2B size
+	var err error
+
+	buf4, err = c.reader.Peek(4)
+	if err != nil {
+		return err
+	}
+
+	var channel byte
+	var size uint16
+
+	if buf4[0] != '$' {
+		switch string(buf4) {
+		case "RTSP":
+			var res *tcp.Response
+			if res, err = c.ReadResponse(); err != nil {
+				return err
+			}
+			c.Fire(res)
+			// for playing backchannel only after OK response on play
+			c.playOK = true
+			return nil
+
+		case "OPTI", "TEAR", "DESC", "SETU", "PLAY", "PAUS", "RECO", "ANNO", "GET_", "SET_":
+			var req *tcp.Request
+			if req, err = c.ReadRequest(); err != nil {
+				return err
+			}
+			c.Fire(req)
+			if req.Method == MethodOptions {
+				res := &tcp.Response{Request: req}
+				if err = c.WriteResponse(res); err != nil {
+					return err
+				}
+			}
+			return nil
+
+		default:
+			c.Fire("RTSP wrong input")
+
+			for i := 0; ; i++ {
+				// search next start symbol
+				if _, err = c.reader.ReadBytes('$'); err != nil {
+					return err
+				}
+
+				if channel, err = c.reader.ReadByte(); err != nil {
+					return err
+				}
+
+				// TODO: better check maximum good channel ID
+				if channel >= 20 {
+					continue
+				}
+
+				buf4 = make([]byte, 2)
+				if _, err = io.ReadFull(c.reader, buf4); err != nil {
+					return err
+				}
+
+				// check if size good for RTP
+				size = binary.BigEndian.Uint16(buf4)
+				if size <= 1500 {
+					break
+				}
+
+				// 10 tries to find good packet
+				if i >= 10 {
+					return fmt.Errorf("RTSP wrong input")
+				}
+			}
+		}
+	} else {
+		// hope that the odd channels are always RTCP
+		channel = buf4[1]
+
+		// get data size
+		size = binary.BigEndian.Uint16(buf4[2:])
+
+		// skip 4 bytes from c.reader.Peek
+		if _, err = c.reader.Discard(4); err != nil {
+			return err
+		}
+	}
+
+	// init memory for data
+	buf := make([]byte, size)
+	if _, err = io.ReadFull(c.reader, buf); err != nil {
+		return err
+	}
+
+	c.Recv += int(size)
+
+	return c.handleRawPacket(channel, buf)
+}
+
+func (c *Conn) handleRawPacket(channel byte, buf []byte) error {
+	if channel&1 == 0 {
+		packet := &rtp.Packet{}
+		if err := packet.Unmarshal(buf); err != nil {
+			return err
+		}
+
+		for _, receiver := range c.Receivers {
+			if receiver.ID == channel {
+				receiver.WriteRTP(packet)
+				break
+			}
+		}
+	} else {
+		msg := &RTCP{Channel: channel}
+
+		if err := msg.Header.Unmarshal(buf); err != nil {
+			return nil
+		}
+
+		//var err error
+		//msg.Packets, err = rtcp.Unmarshal(buf)
+		//if err != nil {
+		//	return nil
+		//}
+
+		c.Fire(msg)
+	}
+
+	return nil
+}
+
+func (c *Conn) WriteRequest(req *tcp.Request) error {
+	if req.Proto == "" {
+		req.Proto = ProtoRTSP
+	}
+
+	if req.Header == nil {
+		req.Header = make(map[string][]string)
+	}
+
+	c.sequence++
+	// important to send case sensitive CSeq
+	// https://github.com/AlexxIT/go2rtc/issues/7
+	req.Header["CSeq"] = []string{strconv.Itoa(c.sequence)}
+
+	c.auth.Write(req)
+
+	if c.session != "" {
+		req.Header.Set("Session", c.session)
+	}
+
+	if req.Body != nil {
+		val := strconv.Itoa(len(req.Body))
+		req.Header.Set("Content-Length", val)
+	}
+
+	c.Fire(req)
+
+	if err := c.conn.SetWriteDeadline(time.Now().Add(Timeout)); err != nil {
+		return err
+	}
+
+	return req.Write(c.conn)
+}
+
+func (c *Conn) ReadRequest() (*tcp.Request, error) {
+	if err := c.conn.SetReadDeadline(time.Now().Add(Timeout)); err != nil {
+		return nil, err
+	}
+	return tcp.ReadRequest(c.reader)
+}
+
+func (c *Conn) WriteResponse(res *tcp.Response) error {
+	if res.Proto == "" {
+		res.Proto = ProtoRTSP
+	}
+
+	if res.Status == "" {
+		res.Status = "200 OK"
+	}
+
+	if res.Header == nil {
+		res.Header = make(map[string][]string)
+	}
+
+	if res.Request != nil && res.Request.Header != nil {
+		seq := res.Request.Header.Get("CSeq")
+		if seq != "" {
+			res.Header.Set("CSeq", seq)
+		}
+	}
+
+	if c.session != "" {
+		if res.Request != nil && res.Request.Method == MethodSetup {
+			res.Header.Set("Session", c.session+";timeout=60")
+		} else {
+			res.Header.Set("Session", c.session)
+		}
+	}
+
+	if res.Body != nil {
+		val := strconv.Itoa(len(res.Body))
+		res.Header.Set("Content-Length", val)
+	}
+
+	c.Fire(res)
+
+	if err := c.conn.SetWriteDeadline(time.Now().Add(Timeout)); err != nil {
+		return err
+	}
+
+	return res.Write(c.conn)
+}
+
+func (c *Conn) ReadResponse() (*tcp.Response, error) {
+	if err := c.conn.SetReadDeadline(time.Now().Add(Timeout)); err != nil {
+		return nil, err
+	}
+	return tcp.ReadResponse(c.reader)
+}
diff --git a/installs_on_host/go2rtc/pkg/rtsp/consumer.go b/installs_on_host/go2rtc/pkg/rtsp/consumer.go
new file mode 100644
index 0000000..e6525d9
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/rtsp/consumer.go
@@ -0,0 +1,198 @@
+package rtsp
+
+import (
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/aac"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/h265"
+	"github.com/AlexxIT/go2rtc/pkg/mjpeg"
+	"github.com/AlexxIT/go2rtc/pkg/pcm"
+	"github.com/pion/rtp"
+)
+
+func (c *Conn) GetMedias() []*core.Media {
+	//core.Assert(c.Medias != nil)
+	return c.Medias
+}
+
+func (c *Conn) AddTrack(media *core.Media, codec *core.Codec, track *core.Receiver) (err error) {
+	var channel byte
+
+	switch c.mode {
+	case core.ModeActiveProducer: // backchannel
+		c.stateMu.Lock()
+		defer c.stateMu.Unlock()
+
+		if c.state == StatePlay {
+			if err = c.Reconnect(); err != nil {
+				return
+			}
+		}
+
+		if channel, err = c.SetupMedia(media); err != nil {
+			return
+		}
+
+		c.state = StateSetup
+
+	case core.ModePassiveConsumer:
+		channel = byte(len(c.Senders)) * 2
+
+		// for consumer is better to use original track codec
+		codec = track.Codec.Clone()
+		// generate new payload type, starting from 96
+		codec.PayloadType = byte(96 + len(c.Senders))
+
+	default:
+		panic(core.Caller())
+	}
+
+	// save original codec to sender (can have Codec.Name = ANY)
+	sender := core.NewSender(media, codec)
+	// important to send original codec for valid IsRTP check
+	sender.Handler = c.packetWriter(track.Codec, channel, codec.PayloadType)
+
+	if c.mode == core.ModeActiveProducer && track.Codec.Name == core.CodecPCMA {
+		// Fix Reolink Doorbell https://github.com/AlexxIT/go2rtc/issues/331
+		sender.Handler = pcm.RepackG711(true, sender.Handler)
+	}
+
+	sender.HandleRTP(track)
+
+	c.Senders = append(c.Senders, sender)
+	return nil
+}
+
+const (
+	startVideoBuf = 32 * 1024   // 32KB
+	startAudioBuf = 2 * 1024    // 2KB
+	maxBuf        = 1024 * 1024 // 1MB
+	rtpHdr        = 12          // basic RTP header size
+	intHdr        = 4           // interleaved header size
+)
+
+func (c *Conn) packetWriter(codec *core.Codec, channel, payloadType uint8) core.HandlerFunc {
+	var buf []byte
+	var n int
+
+	video := codec.IsVideo()
+	if video {
+		buf = make([]byte, startVideoBuf)
+	} else {
+		buf = make([]byte, startAudioBuf)
+	}
+
+	flushBuf := func() {
+		//log.Printf("[rtsp] channel:%2d write_size:%6d buffer_size:%6d", channel, n, len(buf))
+		if err := c.writeInterleavedData(buf[:n]); err != nil {
+			c.Send += n
+		}
+		n = 0
+	}
+
+	handlerFunc := func(packet *rtp.Packet) {
+		if c.state == StateNone {
+			return
+		}
+
+		clone := rtp.Packet{
+			Header: rtp.Header{
+				Version:        2,
+				Marker:         packet.Marker,
+				PayloadType:    payloadType,
+				SequenceNumber: packet.SequenceNumber,
+				Timestamp:      packet.Timestamp,
+				SSRC:           packet.SSRC,
+			},
+			Payload: packet.Payload,
+		}
+
+		if !video {
+			packet.Marker = true // better to have marker on all audio packets
+		}
+
+		size := rtpHdr + len(packet.Payload)
+
+		if l := len(buf); n+intHdr+size > l {
+			if l < maxBuf {
+				buf = append(buf, make([]byte, l)...) // double buffer size
+			} else {
+				flushBuf()
+			}
+		}
+
+		//log.Printf("[RTP] codec: %s, size: %6d, ts: %10d, pt: %2d, ssrc: %d, seq: %d, mark: %v", codec.Name, len(packet.Payload), packet.Timestamp, packet.PayloadType, packet.SSRC, packet.SequenceNumber, packet.Marker)
+
+		chunk := buf[n:]
+		_ = chunk[4] // bounds
+		chunk[0] = '$'
+		chunk[1] = channel
+		chunk[2] = byte(size >> 8)
+		chunk[3] = byte(size)
+
+		if _, err := clone.MarshalTo(chunk[4:]); err != nil {
+			return
+		}
+
+		n += 4 + size
+
+		if !packet.Marker || !c.playOK {
+			// collect continious video packets to buffer
+			// or wait OK for PLAY command for backchannel
+			//log.Printf("[rtsp] collecting buffer ok=%t", c.playOK)
+			return
+		}
+
+		flushBuf()
+	}
+
+	if !codec.IsRTP() {
+		switch codec.Name {
+		case core.CodecH264:
+			handlerFunc = h264.RTPPay(c.PacketSize, handlerFunc)
+		case core.CodecH265:
+			handlerFunc = h265.RTPPay(c.PacketSize, handlerFunc)
+		case core.CodecAAC:
+			handlerFunc = aac.RTPPay(handlerFunc)
+		case core.CodecJPEG:
+			handlerFunc = mjpeg.RTPPay(handlerFunc)
+		}
+	} else if codec.Name == core.CodecPCML {
+		handlerFunc = pcm.LittleToBig(handlerFunc)
+	} else if c.PacketSize != 0 {
+		switch codec.Name {
+		case core.CodecH264:
+			handlerFunc = h264.RTPPay(c.PacketSize, handlerFunc)
+			handlerFunc = h264.RTPDepay(codec, handlerFunc)
+		case core.CodecH265:
+			handlerFunc = h265.RTPPay(c.PacketSize, handlerFunc)
+			handlerFunc = h265.RTPDepay(codec, handlerFunc)
+		}
+	}
+
+	return handlerFunc
+}
+
+func (c *Conn) writeInterleavedData(data []byte) error {
+	if c.Transport != "udp" {
+		_ = c.conn.SetWriteDeadline(time.Now().Add(Timeout))
+		_, err := c.conn.Write(data)
+		return err
+	}
+
+	for len(data) >= 4 && data[0] == '$' {
+		channel := data[1]
+		size := uint16(data[2])<<8 | uint16(data[3])
+		rtpData := data[4 : 4+size]
+
+		if _, err := c.WriteToUDP(rtpData, channel); err != nil {
+			return err
+		}
+
+		data = data[4+size:]
+	}
+
+	return nil
+}
diff --git a/installs_on_host/go2rtc/pkg/rtsp/helpers.go b/installs_on_host/go2rtc/pkg/rtsp/helpers.go
new file mode 100644
index 0000000..c73bd0a
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/rtsp/helpers.go
@@ -0,0 +1,154 @@
+package rtsp
+
+import (
+	"bytes"
+	"io"
+	"net/url"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtcp"
+	"github.com/pion/sdp/v3"
+)
+
+type RTCP struct {
+	Channel byte
+	Header  rtcp.Header
+	Packets []rtcp.Packet
+}
+
+const sdpHeader = `v=0
+o=- 0 0 IN IP4 0.0.0.0
+s=-
+t=0 0`
+
+func UnmarshalSDP(rawSDP []byte) ([]*core.Media, error) {
+	sd := &sdp.SessionDescription{}
+	if err := sd.Unmarshal(rawSDP); err != nil {
+		// fix multiple `s=` https://github.com/AlexxIT/WebRTC/issues/417
+		rawSDP = regexp.MustCompile("\ns=[^\n]+").ReplaceAll(rawSDP, nil)
+
+		// fix broken `c=` https://github.com/AlexxIT/go2rtc/issues/1426
+		rawSDP = regexp.MustCompile("\nc=[^\n]+").ReplaceAll(rawSDP, nil)
+
+		// fix SDP header for some cameras
+		if i := bytes.Index(rawSDP, []byte("\nm=")); i > 0 {
+			rawSDP = append([]byte(sdpHeader), rawSDP[i:]...)
+		}
+
+		// Fix invalid media type (errSDPInvalidValue) caused by
+		// some TP-LINK IP camera, e.g. TL-IPC44GW
+		for _, b := range regexp.MustCompile("m=[^ ]+ ").FindAll(rawSDP, -1) {
+			switch string(b[2 : len(b)-1]) {
+			case "audio", "video", "application":
+			default:
+				rawSDP = bytes.Replace(rawSDP, b, []byte("m=application "), 1)
+			}
+		}
+
+		if err == io.EOF {
+			rawSDP = append(rawSDP, '\n')
+		}
+
+		sd = &sdp.SessionDescription{}
+		err = sd.Unmarshal(rawSDP)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// fix buggy camera https://github.com/AlexxIT/go2rtc/issues/771
+	forceDirection := sd.Origin.Username == "CV-RTSPHandler"
+
+	var medias []*core.Media
+
+	for _, md := range sd.MediaDescriptions {
+		media := core.UnmarshalMedia(md)
+
+		// Check buggy SDP with fmtp for H264 on another track
+		// https://github.com/AlexxIT/WebRTC/issues/419
+		for _, codec := range media.Codecs {
+			switch codec.Name {
+			case core.CodecH264:
+				if codec.FmtpLine == "" {
+					codec.FmtpLine = findFmtpLine(codec.PayloadType, sd.MediaDescriptions)
+				}
+			case core.CodecH265:
+				if codec.FmtpLine != "" {
+					// all three parameters are needed for a valid fmtp line
+					// https://github.com/AlexxIT/go2rtc/pull/1588
+					if !strings.Contains(codec.FmtpLine, "sprop-vps=") ||
+						!strings.Contains(codec.FmtpLine, "sprop-sps=") ||
+						!strings.Contains(codec.FmtpLine, "sprop-pps=") {
+						codec.FmtpLine = ""
+					}
+				}
+			case core.CodecOpus:
+				// fix OPUS for some cameras https://datatracker.ietf.org/doc/html/rfc7587
+				codec.ClockRate = 48000
+				codec.Channels = 2
+			}
+		}
+
+		if media.Direction == "" || forceDirection {
+			media.Direction = core.DirectionRecvonly
+		}
+
+		medias = append(medias, media)
+	}
+
+	return medias, nil
+}
+
+func findFmtpLine(payloadType uint8, descriptions []*sdp.MediaDescription) string {
+	s := strconv.Itoa(int(payloadType))
+	for _, md := range descriptions {
+		codec := core.UnmarshalCodec(md, s)
+		if codec.FmtpLine != "" {
+			return codec.FmtpLine
+		}
+	}
+	return ""
+}
+
+// urlParse fix bugs:
+// 1. Content-Base: rtsp://::ffff:192.168.1.123/onvif/profile.1/
+// 2. Content-Base: rtsp://rtsp://turret2-cam.lan:554/stream1/
+// 3. Content-Base: 192.168.253.220:1935/
+func urlParse(rawURL string) (*url.URL, error) {
+	// fix https://github.com/AlexxIT/go2rtc/issues/830
+	if strings.HasPrefix(rawURL, "rtsp://rtsp://") {
+		rawURL = rawURL[7:]
+	}
+
+	// fix https://github.com/AlexxIT/go2rtc/issues/1852
+	if !strings.Contains(rawURL, "://") {
+		rawURL = "rtsp://" + rawURL
+	}
+
+	u, err := url.Parse(rawURL)
+	if err != nil && strings.HasSuffix(err.Error(), "after host") {
+		if i := indexN(rawURL, '/', 3); i > 0 {
+			return urlParse(rawURL[:i] + ":" + rawURL[i:])
+		}
+	}
+
+	return u, err
+}
+
+func indexN(s string, c byte, n int) int {
+	var offset int
+	for {
+		i := strings.IndexByte(s[offset:], c)
+		if i < 0 {
+			break
+		}
+		if n--; n == 0 {
+			return offset + i
+		}
+		offset += i + 1
+	}
+	return -1
+}
diff --git a/installs_on_host/go2rtc/pkg/rtsp/producer.go b/installs_on_host/go2rtc/pkg/rtsp/producer.go
new file mode 100644
index 0000000..3d818b6
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/rtsp/producer.go
@@ -0,0 +1,143 @@
+package rtsp
+
+import (
+	"encoding/json"
+	"errors"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func (c *Conn) GetTrack(media *core.Media, codec *core.Codec) (*core.Receiver, error) {
+	core.Assert(media.Direction == core.DirectionRecvonly)
+
+	for _, track := range c.Receivers {
+		if track.Codec == codec {
+			return track, nil
+		}
+	}
+
+	c.stateMu.Lock()
+	defer c.stateMu.Unlock()
+
+	var channel byte
+
+	switch c.mode {
+	case core.ModeActiveProducer:
+		if c.state == StatePlay {
+			if err := c.Reconnect(); err != nil {
+				return nil, err
+			}
+		}
+
+		var err error
+		channel, err = c.SetupMedia(media)
+		if err != nil {
+			return nil, err
+		}
+
+		c.state = StateSetup
+	case core.ModePassiveConsumer:
+		// Backchannel
+		channel = byte(len(c.Senders)) * 2
+	default:
+		return nil, errors.New("rtsp: wrong mode for GetTrack")
+	}
+
+	track := core.NewReceiver(media, codec)
+	track.ID = channel
+	c.Receivers = append(c.Receivers, track)
+
+	return track, nil
+}
+
+func (c *Conn) Start() (err error) {
+	core.Assert(c.mode == core.ModeActiveProducer || c.mode == core.ModePassiveProducer)
+
+	for {
+		ok := false
+
+		c.stateMu.Lock()
+		switch c.state {
+		case StateNone:
+			err = nil
+		case StateConn:
+			err = errors.New("start from CONN state")
+		case StateSetup:
+			switch c.mode {
+			case core.ModeActiveProducer:
+				err = c.Play()
+			case core.ModePassiveProducer:
+				err = nil
+			default:
+				err = errors.New("start from wrong mode: " + c.mode.String())
+			}
+
+			if err == nil {
+				c.state = StatePlay
+				ok = true
+			}
+		}
+		c.stateMu.Unlock()
+
+		if !ok {
+			return
+		}
+
+		// Handler can return different states:
+		// 1. None after PLAY should exit without error
+		// 2. Play after PLAY should exit from Start with error
+		// 3. Setup after PLAY should Play once again
+		err = c.Handle()
+	}
+}
+
+func (c *Conn) Stop() (err error) {
+	for _, receiver := range c.Receivers {
+		receiver.Close()
+	}
+	for _, sender := range c.Senders {
+		sender.Close()
+	}
+
+	c.stateMu.Lock()
+	if c.state != StateNone {
+		c.state = StateNone
+		err = c.Close()
+	}
+	c.stateMu.Unlock()
+
+	return
+}
+
+func (c *Conn) MarshalJSON() ([]byte, error) {
+	return json.Marshal(c.Connection)
+}
+
+func (c *Conn) Reconnect() error {
+	c.Fire("RTSP reconnect")
+
+	// close current session
+	_ = c.Close()
+
+	// start new session
+	if err := c.Dial(); err != nil {
+		return err
+	}
+	if err := c.Describe(); err != nil {
+		return err
+	}
+
+	// restore previous medias
+	for _, receiver := range c.Receivers {
+		if _, err := c.SetupMedia(receiver.Media); err != nil {
+			return err
+		}
+	}
+	for _, sender := range c.Senders {
+		if _, err := c.SetupMedia(sender.Media); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
diff --git a/installs_on_host/go2rtc/pkg/rtsp/rtsp_test.go b/installs_on_host/go2rtc/pkg/rtsp/rtsp_test.go
new file mode 100644
index 0000000..282c04f
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/rtsp/rtsp_test.go
@@ -0,0 +1,275 @@
+package rtsp
+
+import (
+	"testing"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestURLParse(t *testing.T) {
+	// https://github.com/AlexxIT/WebRTC/issues/395
+	base := "rtsp://::ffff:192.168.1.123/onvif/profile.1/"
+	u, err := urlParse(base)
+	assert.NoError(t, err)
+	assert.Equal(t, "::ffff:192.168.1.123:", u.Host)
+
+	// https://github.com/AlexxIT/go2rtc/issues/208
+	base = "rtsp://rtsp://turret2-cam.lan:554/stream1/"
+	u, err = urlParse(base)
+	assert.NoError(t, err)
+	assert.Equal(t, "turret2-cam.lan:554", u.Host)
+
+	// https://github.com/AlexxIT/go2rtc/issues/1852
+	base = "192.168.253.220:1935/"
+	u, err = urlParse(base)
+	assert.NoError(t, err)
+	assert.Equal(t, "192.168.253.220:1935", u.Host)
+}
+
+func TestBugSDP1(t *testing.T) {
+	// https://github.com/AlexxIT/WebRTC/issues/417
+	s := `v=0
+o=- 91674849066 1 IN IP4 192.168.1.123
+s=RtspServer
+i=live
+t=0 0
+a=control:*
+a=range:npt=0-
+m=video 0 RTP/AVP 96
+c=IN IP4 0.0.0.0
+s=RtspServer
+i=live
+a=control:track0
+a=range:npt=0-
+a=rtpmap:96 H264/90000
+a=fmtp:96 packetization-mode=1;profile-level-id=42001E;sprop-parameter-sets=Z0IAHvQCgC3I,aM48gA==
+a=control:track0
+m=audio 0 RTP/AVP 97
+c=IN IP4 0.0.0.0
+s=RtspServer
+i=live
+a=control:track1
+a=range:npt=0-
+a=rtpmap:97 MPEG4-GENERIC/8000/1
+a=fmtp:97 profile-level-id=1;mode=AAC-hbr;sizelength=13;indexlength=3;indexdeltalength=3;config=1588
+a=control:track1
+`
+	medias, err := UnmarshalSDP([]byte(s))
+	assert.Nil(t, err)
+	assert.NotNil(t, medias)
+}
+
+func TestBugSDP2(t *testing.T) {
+	// https://github.com/AlexxIT/WebRTC/issues/419
+	s := `v=0
+o=- 1675628282 1675628283 IN IP4 192.168.1.123
+s=streamed by the RTSP server
+t=0 0
+m=video 0 RTP/AVP 96
+a=rtpmap:96 H264/90000
+a=control:track0
+m=audio 0 RTP/AVP 8
+a=rtpmap:0 pcma/8000/1
+a=control:track1
+a=framerate:25
+a=range:npt=now-
+a=fmtp:96 packetization-mode=1;profile-level-id=64001F;sprop-parameter-sets=Z0IAH5WoFAFuQA==,aM48gA==
+`
+	medias, err := UnmarshalSDP([]byte(s))
+	assert.Nil(t, err)
+	assert.NotNil(t, medias)
+	assert.NotEqual(t, "", medias[0].Codecs[0].FmtpLine)
+}
+
+func TestBugSDP3(t *testing.T) {
+	s := `v=0
+o=- 1680614126554766 1 IN IP4 192.168.0.3
+s=Session streamed by "preview"
+t=0 0
+a=tool:BC Streaming Media v202210012022.10.01
+a=type:broadcast
+a=control:*
+a=range:npt=now-
+a=x-qt-text-nam:Session streamed by "preview"
+m=video 0 RTP/AVP 96
+c=IN IP4 0.0.0.0
+b=AS:8192
+a=rtpmap:96 H264/90000
+a=range:npt=now-
+a=fmtp:96 packetization-mode=1;profile-level-id=640033;sprop-parameter-sets=Z2QAM6wVFKAoAPGQ,aO48sA==
+a=recvonly
+a=control:track1
+m=audio 0 RTP/AVP 97
+c=IN IP4 0.0.0.0
+b=AS:8192
+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
+a=control:track2
+m=audio 0 RTP/AVP 8
+a=control:track3
+a=rtpmap:8 PCMA/8000
+a=sendonly`
+	medias, err := UnmarshalSDP([]byte(s))
+	assert.Nil(t, err)
+	assert.Len(t, medias, 3)
+}
+
+func TestBugSDP4(t *testing.T) {
+	s := `v=0
+o=- 14665860 31787219 1 IN IP4 10.0.0.94
+s=Session streamed by "MERCURY RTSP Server"
+t=0 0
+m=video 0 RTP/AVP 96
+c=IN IP4 0.0.0.0
+b=AS:4096
+a=range:npt=0-
+a=control:track1
+a=rtpmap:96 H264/90000
+a=fmtp:96 packetization-mode=1; profile-level-id=640016; sprop-parameter-sets=Z2QAFqzGoCgPaEAAAAMAQAAAB6E=,aOqPLA==
+m=audio 0 RTP/AVP 8
+a=rtpmap:8 PCMA/8000
+a=control:track2
+m=application/MERCURY 0 RTP/AVP smart/1/90000
+a=rtpmap:95 MERCURY/90000
+a=control:track3
+`
+	medias, err := UnmarshalSDP([]byte(s))
+	assert.Nil(t, err)
+	assert.Len(t, medias, 3)
+}
+
+func TestBugSDP5(t *testing.T) {
+	s := `v=0
+o=CV-RTSPHandler 1123412 0 IN IP4 192.168.1.22
+s=Camera
+c=IN IP4 192.168.1.22
+t=0 0
+a=charset:Shift_JIS
+a=range:npt=0-
+a=control:*
+a=etag:1234567890
+m=video 0 RTP/AVP 99
+a=rtpmap:99 H264/90000
+a=fmtp:99 profile-level-id=42A01E;packetization-mode=1;sprop-parameter-sets=Z0KgKedAPAET8uAIEAABd2AAK/IGAAADAC+vCAAAHc1lP//jAAADABfXhAAADuayn//wIA==,aN48gA==
+a=control:trackID=1
+a=sendonly
+m=audio 0 RTP/AVP 127
+a=rtpmap:127 mpeg4-generic/8000/1
+a=fmtp:127 streamtype=5; profile-level-id=15; mode=AAC-hbr; sizeLength=13; indexLength=3; indexDeltalength=3; config=1588; CTSDeltaLength=0; DTSDeltaLength=0;
+a=control:trackID=2
+`
+	medias, err := UnmarshalSDP([]byte(s))
+	assert.Nil(t, err)
+	assert.Len(t, medias, 2)
+	assert.Equal(t, "recvonly", medias[0].Direction)
+	assert.Equal(t, "recvonly", medias[1].Direction)
+}
+
+func TestBugSDP6(t *testing.T) {
+	// https://github.com/AlexxIT/go2rtc/issues/1278
+	s := `v=0
+o=- 3730506281693 1 IN IP4 172.20.0.215
+s=IP camera Live streaming
+i=stream1
+t=0 0
+a=tool:LIVE555 Streaming Media v2014.02.04
+a=type:broadcast
+a=control:*
+a=range:npt=0-
+a=x-qt-text-nam:IP camera Live streaming
+a=x-qt-text-inf:stream1
+m=video 0 RTP/AVP 26
+c=IN IP4 172.20.0.215
+b=AS:1500
+a=x-bufferdelay:0.55000
+a=x-dimensions:1280,960
+a=control:track1
+m=audio 0 RTP/AVP 0
+c=IN IP4 172.20.0.215
+b=AS:64
+a=x-bufferdelay:0.55000
+a=control:track2
+m=application 0 RTP/AVP 107
+c=IN IP4 172.20.0.215
+b=AS:1
+a=x-bufferdelay:0.55000
+a=rtpmap:107 vnd.onvif.metadata/90000/500
+a=control:track4
+m=vana 0 RTP/AVP 108
+c=IN IP4 172.20.0.215
+b=AS:1
+a=x-bufferdelay:0.55000
+a=rtpmap:108 video.analysis/90000/500
+a=control:track5
+`
+	medias, err := UnmarshalSDP([]byte(s))
+	assert.Nil(t, err)
+	assert.Len(t, medias, 4)
+}
+
+func TestBugSDP7(t *testing.T) {
+	// https://github.com/AlexxIT/go2rtc/issues/1426
+	s := `v=0
+o=- 1001 1 IN
+s=VCP IPC Realtime stream
+m=video 0 RTP/AVP 105
+c=IN
+a=control:rtsp://1.0.1.113/media/video2/video
+a=rtpmap:105 H264/90000
+a=fmtp:105 profile-level-id=640016; packetization-mode=1; sprop-parameter-sets=Z2QAFqw7UFAX/LCAAAH0AABOIEI=,aOqPLA==
+a=recvonly
+m=audio 0 RTP/AVP 0
+c=IN
+a=fmtp:0 RTCP=0
+a=control:rtsp://1.0.1.113/media/video2/audio1
+a=recvonly
+m=audio 0 RTP/AVP 0
+c=IN
+a=control:rtsp://1.0.1.113/media/video2/backchannel
+a=rtpmap:0 PCMA/8000
+a=rtpmap:0 PCMU/8000
+a=sendonly
+m=application 0 RTP/AVP 107
+c=IN
+a=control:rtsp://1.0.1.113/media/video2/metadata
+a=rtpmap:107 vnd.onvif.metadata/90000
+a=fmtp:107 DecoderTag=h3c-v3 RTCP=0
+a=recvonly
+`
+	medias, err := UnmarshalSDP([]byte(s))
+	assert.Nil(t, err)
+	assert.Len(t, medias, 4)
+}
+
+func TestHikvisionPCM(t *testing.T) {
+	s := `v=0
+o=- 1721969533379665 1721969533379665 IN IP4 192.168.1.12
+s=Media Presentation
+e=NONE
+b=AS:5100
+t=0 0
+a=control:rtsp://192.168.1.12:554/Streaming/channels/101/
+m=video 0 RTP/AVP 96
+c=IN IP4 0.0.0.0
+b=AS:5000
+a=recvonly
+a=x-dimensions:3200,1800
+a=control:rtsp://192.168.1.12:554/Streaming/channels/101/trackID=1
+a=rtpmap:96 H264/90000
+a=fmtp:96 profile-level-id=420029; packetization-mode=1; sprop-parameter-sets=Z2QAM6wVFKAyAOP5f/AAEAAWyAAAH0AAB1MAIA==,aO48sA==
+m=audio 0 RTP/AVP 11
+c=IN IP4 0.0.0.0
+b=AS:50
+a=recvonly
+a=control:rtsp://192.168.1.12:554/Streaming/channels/101/trackID=2
+a=rtpmap:11 PCM/48000
+a=Media_header:MEDIAINFO=494D4B4801030000040000010170011080BB0000007D000000000000000000000000000000000000;
+a=appversion:1.0
+`
+	medias, err := UnmarshalSDP([]byte(s))
+	assert.Nil(t, err)
+	assert.Len(t, medias, 2)
+	assert.Equal(t, core.CodecPCML, medias[1].Codecs[0].Name)
+}
diff --git a/installs_on_host/go2rtc/pkg/rtsp/server.go b/installs_on_host/go2rtc/pkg/rtsp/server.go
new file mode 100644
index 0000000..343bdc6
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/rtsp/server.go
@@ -0,0 +1,235 @@
+package rtsp
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"net"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/tcp"
+)
+
+var FailedAuth = errors.New("failed authentication")
+
+func NewServer(conn net.Conn) *Conn {
+	return &Conn{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "rtsp",
+			Protocol:   "rtsp+tcp",
+			RemoteAddr: conn.RemoteAddr().String(),
+		},
+		conn:   conn,
+		reader: bufio.NewReader(conn),
+	}
+}
+
+func (c *Conn) Auth(username, password string) {
+	info := url.UserPassword(username, password)
+	c.auth = tcp.NewAuth(info)
+}
+
+func (c *Conn) Accept() error {
+	for {
+		req, err := c.ReadRequest()
+		if err != nil {
+			return err
+		}
+
+		if c.URL == nil {
+			c.URL = req.URL
+			c.UserAgent = req.Header.Get("User-Agent")
+		}
+
+		c.Fire(req)
+
+		if valid, empty := c.auth.Validate(req); !valid {
+			res := &tcp.Response{
+				Status:  "401 Unauthorized",
+				Header:  map[string][]string{"Www-Authenticate": {`Basic realm="go2rtc"`}},
+				Request: req,
+			}
+			if err = c.WriteResponse(res); err != nil {
+				return err
+			}
+			if empty {
+				// eliminate false positive: ffmpeg sends first request without
+				// authorization header even if the user provides credentials
+				continue
+			}
+			return FailedAuth
+		}
+
+		// Receiver: OPTIONS > DESCRIBE > SETUP... > PLAY > TEARDOWN
+		// Sender: OPTIONS > ANNOUNCE > SETUP... > RECORD > TEARDOWN
+		switch req.Method {
+		case MethodOptions:
+			res := &tcp.Response{
+				Header: map[string][]string{
+					"Public": {"OPTIONS, SETUP, TEARDOWN, DESCRIBE, PLAY, PAUSE, ANNOUNCE, RECORD"},
+				},
+				Request: req,
+			}
+			if err = c.WriteResponse(res); err != nil {
+				return err
+			}
+
+		case MethodAnnounce:
+			if req.Header.Get("Content-Type") != "application/sdp" {
+				return errors.New("wrong content type")
+			}
+
+			c.SDP = string(req.Body) // for info
+
+			c.Medias, err = UnmarshalSDP(req.Body)
+			if err != nil {
+				return err
+			}
+
+			// TODO: fix someday...
+			for i, media := range c.Medias {
+				track := core.NewReceiver(media, media.Codecs[0])
+				track.ID = byte(i * 2)
+				c.Receivers = append(c.Receivers, track)
+			}
+
+			c.mode = core.ModePassiveProducer
+			c.Fire(MethodAnnounce)
+
+			res := &tcp.Response{Request: req}
+			if err = c.WriteResponse(res); err != nil {
+				return err
+			}
+
+		case MethodDescribe:
+			c.mode = core.ModePassiveConsumer
+			c.Fire(MethodDescribe)
+
+			if c.Senders == nil {
+				res := &tcp.Response{
+					Status:  "404 Not Found",
+					Request: req,
+				}
+				return c.WriteResponse(res)
+			}
+
+			res := &tcp.Response{
+				Header: map[string][]string{
+					"Content-Type": {"application/sdp"},
+				},
+				Request: req,
+			}
+
+			// convert tracks to real output medias medias
+			var medias []*core.Media
+			for i, track := range c.Senders {
+				media := &core.Media{
+					Kind:      core.GetKind(track.Codec.Name),
+					Direction: core.DirectionRecvonly,
+					Codecs:    []*core.Codec{track.Codec},
+					ID:        "trackID=" + strconv.Itoa(i),
+				}
+				medias = append(medias, media)
+			}
+
+			for i, track := range c.Receivers {
+				media := &core.Media{
+					Kind:      core.GetKind(track.Codec.Name),
+					Direction: core.DirectionSendonly,
+					Codecs:    []*core.Codec{track.Codec},
+					ID:        "trackID=" + strconv.Itoa(i+len(c.Senders)),
+				}
+				medias = append(medias, media)
+			}
+
+			res.Body, err = core.MarshalSDP(c.SessionName, medias)
+			if err != nil {
+				return err
+			}
+
+			c.SDP = string(res.Body) // for info
+
+			if err = c.WriteResponse(res); err != nil {
+				return err
+			}
+
+		case MethodSetup:
+			res := &tcp.Response{
+				Header:  map[string][]string{},
+				Request: req,
+			}
+
+			// Test if client requests TCP transport, otherwise return 461 Transport not supported
+			// This allows smart clients who initially requested UDP to fall back on TCP transport
+			if tr := req.Header.Get("Transport"); strings.HasPrefix(tr, "RTP/AVP/TCP") {
+				c.session = core.RandString(8, 10)
+				c.state = StateSetup
+
+				if c.mode == core.ModePassiveConsumer {
+					if i := reqTrackID(req); i >= 0 && i < len(c.Senders)+len(c.Receivers) {
+						if i < len(c.Senders) {
+							c.Senders[i].Media.ID = MethodSetup
+						} else {
+							c.Receivers[i-len(c.Senders)].Media.ID = MethodSetup
+						}
+						tr = fmt.Sprintf("RTP/AVP/TCP;unicast;interleaved=%d-%d", i*2, i*2+1)
+						res.Header.Set("Transport", tr)
+					} else {
+						res.Status = "400 Bad Request"
+					}
+				} else {
+					res.Header.Set("Transport", tr)
+				}
+			} else {
+				res.Status = "461 Unsupported transport"
+			}
+
+			if err = c.WriteResponse(res); err != nil {
+				return err
+			}
+
+		case MethodRecord, MethodPlay:
+			if c.mode == core.ModePassiveConsumer {
+				// stop unconfigured senders
+				for _, track := range c.Senders {
+					if track.Media.ID != MethodSetup {
+						track.Close()
+					}
+				}
+			}
+
+			res := &tcp.Response{Request: req}
+			err = c.WriteResponse(res)
+			c.playOK = true
+			return err
+
+		case MethodTeardown:
+			res := &tcp.Response{Request: req}
+			_ = c.WriteResponse(res)
+			c.state = StateNone
+			return c.conn.Close()
+
+		default:
+			return fmt.Errorf("unsupported method: %s", req.Method)
+		}
+	}
+}
+
+func reqTrackID(req *tcp.Request) int {
+	var s string
+	if req.URL.RawQuery != "" {
+		s = req.URL.RawQuery
+	} else {
+		s = req.URL.Path
+	}
+	if i := strings.LastIndexByte(s, '='); i > 0 {
+		if i, err := strconv.Atoi(s[i+1:]); err == nil {
+			return i
+		}
+	}
+	return -1
+}
diff --git a/installs_on_host/go2rtc/pkg/shell/command.go b/installs_on_host/go2rtc/pkg/shell/command.go
new file mode 100644
index 0000000..b7c8189
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/shell/command.go
@@ -0,0 +1,59 @@
+package shell
+
+import (
+	"context"
+	"os/exec"
+)
+
+// Command like exec.Cmd, but with support:
+// - io.Closer interface
+// - Wait from multiple places
+// - Done channel
+type Command struct {
+	*exec.Cmd
+	ctx    context.Context
+	cancel context.CancelFunc
+	err    error
+}
+
+func NewCommand(s string) *Command {
+	ctx, cancel := context.WithCancel(context.Background())
+	args := QuoteSplit(s)
+	cmd := exec.CommandContext(ctx, args[0], args[1:]...)
+	cmd.SysProcAttr = procAttr
+	return &Command{cmd, ctx, cancel, nil}
+}
+
+func (c *Command) Start() error {
+	if err := c.Cmd.Start(); err != nil {
+		return err
+	}
+
+	go func() {
+		c.err = c.Cmd.Wait()
+		c.cancel() // release context resources
+	}()
+
+	return nil
+}
+
+func (c *Command) Wait() error {
+	<-c.ctx.Done()
+	return c.err
+}
+
+func (c *Command) Run() error {
+	if err := c.Start(); err != nil {
+		return err
+	}
+	return c.Wait()
+}
+
+func (c *Command) Done() <-chan struct{} {
+	return c.ctx.Done()
+}
+
+func (c *Command) Close() error {
+	c.cancel()
+	return nil
+}
diff --git a/installs_on_host/go2rtc/pkg/shell/procattr.go b/installs_on_host/go2rtc/pkg/shell/procattr.go
new file mode 100644
index 0000000..fffdc2a
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/shell/procattr.go
@@ -0,0 +1,7 @@
+//go:build !linux
+
+package shell
+
+import "syscall"
+
+var procAttr *syscall.SysProcAttr
diff --git a/installs_on_host/go2rtc/pkg/shell/procattr_linux.go b/installs_on_host/go2rtc/pkg/shell/procattr_linux.go
new file mode 100644
index 0000000..cef1d15
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/shell/procattr_linux.go
@@ -0,0 +1,6 @@
+package shell
+
+import "syscall"
+
+// will stop child if parent died (even with SIGKILL)
+var procAttr = &syscall.SysProcAttr{Pdeathsig: syscall.SIGTERM}
diff --git a/installs_on_host/go2rtc/pkg/shell/shell.go b/installs_on_host/go2rtc/pkg/shell/shell.go
new file mode 100644
index 0000000..e04a58c
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/shell/shell.go
@@ -0,0 +1,43 @@
+package shell
+
+import (
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+)
+
+func QuoteSplit(s string) []string {
+	var a []string
+
+	for len(s) > 0 {
+		switch c := s[0]; c {
+		case '\t', '\n', '\r', ' ': // unicode.IsSpace
+			s = s[1:]
+		case '"', '\'': // quote chars
+			if i := strings.IndexByte(s[1:], c); i > 0 {
+				a = append(a, s[1:i+1])
+				s = s[i+2:]
+			} else {
+				return nil // error
+			}
+		default:
+			i := strings.IndexAny(s, "\t\n\r ")
+			if i > 0 {
+				a = append(a, s[:i])
+				s = s[i:]
+			} else {
+				a = append(a, s)
+				s = ""
+			}
+		}
+	}
+
+	return a
+}
+
+func RunUntilSignal() {
+	sigs := make(chan os.Signal, 1)
+	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
+	println("exit with signal:", (<-sigs).String())
+}
diff --git a/installs_on_host/go2rtc/pkg/shell/shell_test.go b/installs_on_host/go2rtc/pkg/shell/shell_test.go
new file mode 100644
index 0000000..0910270
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/shell/shell_test.go
@@ -0,0 +1,18 @@
+package shell
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestQuoteSplit(t *testing.T) {
+	s := `
+python "-c" 'import time
+print("time", time.time())'
+`
+	require.Equal(t, []string{"python", "-c", "import time\nprint(\"time\", time.time())"}, QuoteSplit(s))
+
+	s = `ffmpeg -i "video=FaceTime HD Camera" -i "DeckLink SDI (2)"`
+	require.Equal(t, []string{"ffmpeg", "-i", `video=FaceTime HD Camera`, "-i", "DeckLink SDI (2)"}, QuoteSplit(s))
+}
diff --git a/installs_on_host/go2rtc/pkg/srtp/server.go b/installs_on_host/go2rtc/pkg/srtp/server.go
new file mode 100644
index 0000000..1e396f2
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/srtp/server.go
@@ -0,0 +1,102 @@
+package srtp
+
+import (
+	"encoding/binary"
+	"net"
+	"strconv"
+	"sync"
+)
+
+type Server struct {
+	address  string
+	conn     net.PacketConn
+	sessions map[uint32]*Session
+	mu       sync.Mutex
+}
+
+func NewServer(address string) *Server {
+	return &Server{
+		address:  address,
+		sessions: map[uint32]*Session{},
+	}
+}
+
+func (s *Server) Port() int {
+	if s.conn != nil {
+		return s.conn.LocalAddr().(*net.UDPAddr).Port
+	}
+
+	_, a, _ := net.SplitHostPort(s.address)
+	i, _ := strconv.Atoi(a)
+	return i
+}
+
+func (s *Server) AddSession(session *Session) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if err := session.init(); err != nil {
+		return
+	}
+
+	if len(s.sessions) == 0 {
+		var err error
+		if s.conn, err = net.ListenPacket("udp", s.address); err != nil {
+			return
+		}
+		go s.handle()
+	}
+
+	session.conn = s.conn
+
+	s.sessions[session.Remote.SSRC] = session
+}
+
+func (s *Server) DelSession(session *Session) {
+	s.mu.Lock()
+
+	delete(s.sessions, session.Remote.SSRC)
+
+	// check s.conn for https://github.com/AlexxIT/go2rtc/issues/734
+	if len(s.sessions) == 0 && s.conn != nil {
+		_ = s.conn.Close()
+	}
+
+	s.mu.Unlock()
+}
+
+func (s *Server) GetSession(ssrc uint32) (session *Session) {
+	s.mu.Lock()
+	session = s.sessions[ssrc]
+	s.mu.Unlock()
+	return
+}
+
+func (s *Server) handle() error {
+	b := make([]byte, 2048)
+	for {
+		n, _, err := s.conn.ReadFrom(b)
+		if err != nil {
+			return err
+		}
+
+		// Multiplexing RTP Data and Control Packets on a Single Port
+		// https://datatracker.ietf.org/doc/html/rfc5761
+
+		switch packetType := b[1]; packetType {
+		case 99, 110, 0x80 | 99, 0x80 | 110:
+			// this is default position for SSRC in RTP packet
+			ssrc := binary.BigEndian.Uint32(b[8:])
+			if session := s.GetSession(ssrc); session != nil {
+				session.ReadRTP(b[:n])
+			}
+
+		case 200, 201, 202, 203, 204, 205, 206, 207:
+			// this is default position for SSRC in RTCP packet
+			ssrc := binary.BigEndian.Uint32(b[4:])
+			if session := s.GetSession(ssrc); session != nil {
+				session.ReadRTCP(b[:n])
+			}
+		}
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/srtp/session.go b/installs_on_host/go2rtc/pkg/srtp/session.go
new file mode 100644
index 0000000..0ab8164
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/srtp/session.go
@@ -0,0 +1,160 @@
+package srtp
+
+import (
+	"net"
+	"time"
+
+	"github.com/pion/rtcp"
+	"github.com/pion/rtp"
+	"github.com/pion/srtp/v3"
+)
+
+type Session struct {
+	Local  *Endpoint
+	Remote *Endpoint
+
+	OnReadRTP func(packet *rtp.Packet)
+
+	Recv int // bytes recv
+	Send int // bytes send
+
+	conn net.PacketConn // local conn endpoint
+
+	PayloadType  uint8
+	RTCPInterval time.Duration
+
+	senderRTCP rtcp.SenderReport
+	senderTime time.Time
+}
+
+type Endpoint struct {
+	Addr       string
+	Port       uint16
+	MasterKey  []byte
+	MasterSalt []byte
+	SSRC       uint32
+
+	addr net.Addr
+	srtp *srtp.Context
+}
+
+func (e *Endpoint) init() (err error) {
+	e.addr = &net.UDPAddr{IP: net.ParseIP(e.Addr), Port: int(e.Port)}
+	e.srtp, err = srtp.CreateContext(e.MasterKey, e.MasterSalt, profile(e.MasterKey))
+	return
+}
+
+func profile(key []byte) srtp.ProtectionProfile {
+	switch len(key) {
+	case 16:
+		return srtp.ProtectionProfileAes128CmHmacSha1_80
+		//case 32:
+		//	return srtp.ProtectionProfileAes256CmHmacSha1_80
+	}
+	return 0
+}
+
+func (s *Session) init() error {
+	if err := s.Local.init(); err != nil {
+		return err
+	}
+	if err := s.Remote.init(); err != nil {
+		return err
+	}
+
+	s.senderRTCP.SSRC = s.Local.SSRC
+	s.senderTime = time.Now().Add(s.RTCPInterval)
+
+	return nil
+}
+
+func (s *Session) WriteRTP(packet *rtp.Packet) (int, error) {
+	if s.Local.srtp == nil {
+		return 0, nil // before init call
+	}
+
+	if now := time.Now(); now.After(s.senderTime) {
+		s.senderRTCP.NTPTime = uint64(now.UnixNano())
+		s.senderTime = now.Add(s.RTCPInterval)
+		_, _ = s.WriteRTCP(&s.senderRTCP)
+	}
+
+	clone := rtp.Packet{
+		Header: rtp.Header{
+			Version:        2,
+			Marker:         packet.Marker,
+			PayloadType:    s.PayloadType,
+			SequenceNumber: packet.SequenceNumber,
+			Timestamp:      packet.Timestamp,
+			SSRC:           s.Local.SSRC,
+		},
+		Payload: packet.Payload,
+	}
+
+	b, err := clone.Marshal()
+	if err != nil {
+		return 0, err
+	}
+
+	s.senderRTCP.PacketCount++
+	s.senderRTCP.RTPTime = clone.Timestamp
+	s.senderRTCP.OctetCount += uint32(len(clone.Payload))
+
+	if b, err = s.Local.srtp.EncryptRTP(nil, b, nil); err != nil {
+		return 0, err
+	}
+
+	return s.conn.WriteTo(b, s.Remote.addr)
+}
+
+func (s *Session) WriteRTCP(packet rtcp.Packet) (int, error) {
+	b, err := packet.Marshal()
+	if err != nil {
+		return 0, err
+	}
+	b, err = s.Local.srtp.EncryptRTCP(nil, b, nil)
+	if err != nil {
+		return 0, err
+	}
+	return s.conn.WriteTo(b, s.Remote.addr)
+}
+
+func (s *Session) ReadRTP(b []byte) {
+	packet := &rtp.Packet{}
+
+	b, err := s.Remote.srtp.DecryptRTP(nil, b, &packet.Header)
+	if err != nil {
+		return
+	}
+
+	if err = packet.Unmarshal(b); err != nil {
+		return
+	}
+
+	if s.OnReadRTP != nil {
+		s.OnReadRTP(packet)
+	}
+}
+
+func (s *Session) ReadRTCP(b []byte) {
+	header := rtcp.Header{}
+	b, err := s.Remote.srtp.DecryptRTCP(nil, b, &header)
+	if err != nil {
+		return
+	}
+
+	//packets, err := rtcp.Unmarshal(b)
+	//if err != nil {
+	//	return
+	//}
+	//if report, ok := packets[0].(*rtcp.SenderReport); ok {
+	//	log.Printf("[srtp] rtcp type=%d report=%v", header.Type, report)
+	//}
+
+	if header.Type != rtcp.TypeSenderReport {
+		return
+	}
+
+	receiverRTCP := rtcp.ReceiverReport{SSRC: s.Local.SSRC}
+	_, _ = s.WriteRTCP(&receiverRTCP)
+}
diff --git a/installs_on_host/go2rtc/pkg/tapo/backchannel.go b/installs_on_host/go2rtc/pkg/tapo/backchannel.go
new file mode 100644
index 0000000..b494126
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tapo/backchannel.go
@@ -0,0 +1,62 @@
+package tapo
+
+import (
+	"bytes"
+	"strconv"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/mpegts"
+	"github.com/pion/rtp"
+)
+
+func (c *Client) AddTrack(media *core.Media, _ *core.Codec, track *core.Receiver) error {
+	if c.sender == nil {
+		if err := c.SetupBackchannel(); err != nil {
+			return err
+		}
+
+		muxer := mpegts.NewMuxer()
+		pid := muxer.AddTrack(mpegts.StreamTypePCMATapo)
+		if err := c.WriteBackchannel(muxer.GetHeader()); err != nil {
+			return err
+		}
+
+		c.sender = core.NewSender(media, track.Codec)
+		c.sender.Handler = func(packet *rtp.Packet) {
+			b := muxer.GetPayload(pid, packet.Timestamp, packet.Payload)
+			_ = c.WriteBackchannel(b)
+		}
+	}
+
+	c.sender.HandleRTP(track)
+	return nil
+}
+
+func (c *Client) SetupBackchannel() (err error) {
+	// if conn1 is not used - we will use it for backchannel
+	// or we need to start another conn for session2
+	if c.session1 != "" {
+		if c.conn2, err = c.newConn(); err != nil {
+			return
+		}
+	} else {
+		c.conn2 = c.conn1
+	}
+
+	c.session2, err = c.Request(c.conn2, []byte(`{"params":{"talk":{"mode":"aec"},"method":"get"},"seq":3,"type":"request"}`))
+	return
+}
+
+func (c *Client) WriteBackchannel(body []byte) (err error) {
+	// TODO: fixme (size)
+	buf := bytes.NewBuffer(nil)
+	buf.WriteString("----client-stream-boundary--\r\n")
+	buf.WriteString("Content-Type: audio/mp2t\r\n")
+	buf.WriteString("X-If-Encrypt: 0\r\n")
+	buf.WriteString("X-Session-Id: " + c.session2 + "\r\n")
+	buf.WriteString("Content-Length: " + strconv.Itoa(len(body)) + "\r\n\r\n")
+	buf.Write(body)
+
+	_, err = buf.WriteTo(c.conn2)
+	return
+}
diff --git a/installs_on_host/go2rtc/pkg/tapo/client.go b/installs_on_host/go2rtc/pkg/tapo/client.go
new file mode 100644
index 0000000..e52250c
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tapo/client.go
@@ -0,0 +1,407 @@
+package tapo
+
+import (
+	"bufio"
+	"bytes"
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/md5"
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/mpegts"
+	"github.com/AlexxIT/go2rtc/pkg/pcm"
+	"github.com/AlexxIT/go2rtc/pkg/tcp"
+)
+
+// Deprecated: should be rewritten to core.Connection
+type Client struct {
+	core.Listener
+
+	url *url.URL
+
+	medias    []*core.Media
+	receivers []*core.Receiver
+	sender    *core.Sender
+
+	conn1 net.Conn
+	conn2 net.Conn
+
+	decrypt func(b []byte) []byte
+
+	session1 string
+	session2 string
+	request  string
+
+	recv int
+	send int
+}
+
+// block ciphers using cipher block chaining.
+type cbcMode interface {
+	cipher.BlockMode
+	SetIV([]byte)
+}
+
+// Dial support different urls:
+//   - tapo://{cloud-password}@192.168.1.123 - auth to Tapo cameras
+//     with cloud password (autodetect hash method)
+//   - tapo://admin:{hashed-cloud-password}@192.168.1.123 - auth to Tapo cameras
+//     with pre-hashed cloud password
+//   - vigi://admin:{password}@192.168.1.123 - auth to Vigi cameras with password
+//     for admin account (other not supported)
+func Dial(rawURL string) (*Client, error) {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	if u.Port() == "" {
+		u.Host += ":8800"
+	}
+
+	c := &Client{url: u}
+	if c.conn1, err = c.newConn(); err != nil {
+		return nil, err
+	}
+	return c, nil
+}
+
+func (c *Client) newConn() (net.Conn, error) {
+	req, err := http.NewRequest("POST", "http://"+c.url.Host+"/stream", nil)
+	if err != nil {
+		return nil, err
+	}
+
+	query := c.url.Query()
+
+	if deviceId := query.Get("deviceId"); deviceId != "" {
+		req.URL.RawQuery = "deviceId=" + deviceId
+	}
+
+	req.Header.Set("Content-Type", "multipart/mixed; boundary=--client-stream-boundary--")
+
+	username := c.url.User.Username()
+	password, _ := c.url.User.Password()
+
+	conn, res, err := dial(req, c.url.Scheme, username, password)
+	if err != nil {
+		return nil, err
+	}
+
+	if res.StatusCode != http.StatusOK {
+		return nil, errors.New(res.Status)
+	}
+
+	if c.decrypt == nil {
+		c.newDectypter(res, c.url.Scheme, username, password)
+	}
+
+	channel := query.Get("channel")
+	if channel == "" {
+		channel = "0"
+	}
+
+	subtype := query.Get("subtype")
+	switch subtype {
+	case "", "0":
+		subtype = "HD"
+	case "1":
+		subtype = "VGA"
+	}
+
+	c.request = fmt.Sprintf(
+		`{"params":{"preview":{"audio":["default"],"channels":[%s],"resolutions":["%s"]},"method":"get"},"seq":1,"type":"request"}`,
+		channel, subtype,
+	)
+
+	return conn, nil
+}
+
+func (c *Client) newDectypter(res *http.Response, brand, username, password string) {
+	exchange := res.Header.Get("Key-Exchange")
+	nonce := core.Between(exchange, `nonce="`, `"`)
+
+	if brand == "tapo" && password == "" {
+		if strings.Contains(exchange, `encrypt_type="3"`) {
+			password = fmt.Sprintf("%32X", sha256.Sum256([]byte(username)))
+		} else {
+			password = fmt.Sprintf("%16X", md5.Sum([]byte(username)))
+		}
+		username = "admin"
+	}
+
+	if strings.Contains(exchange, `username="none"`) {
+		// https://nvd.nist.gov/vuln/detail/CVE-2022-37255
+		username = "none"
+		password = "TPL075526460603"
+	}
+
+	key := md5.Sum([]byte(nonce + ":" + password))
+	iv := md5.Sum([]byte(username + ":" + nonce))
+
+	block, err := aes.NewCipher(key[:])
+	if err != nil {
+		return
+	}
+
+	cbc := cipher.NewCBCDecrypter(block, iv[:]).(cbcMode)
+
+	c.decrypt = func(b []byte) []byte {
+		// restore IV
+		cbc.SetIV(iv[:])
+
+		// decrypt
+		cbc.CryptBlocks(b, b)
+
+		// unpad
+		n := len(b)
+		padSize := int(b[n-1])
+		return b[:n-padSize]
+	}
+}
+
+func (c *Client) SetupStream() (err error) {
+	if c.session1 != "" {
+		return
+	}
+
+	// audio: default, disable, enable
+	c.session1, err = c.Request(c.conn1, []byte(c.request))
+	return
+}
+
+// Handle - first run will be in probe state
+func (c *Client) Handle() error {
+	rd := multipart.NewReader(c.conn1, "--device-stream-boundary--")
+	demux := mpegts.NewDemuxer()
+
+	var transcode func([]byte) []byte
+
+	for {
+		p, err := rd.NextRawPart()
+		if err != nil {
+			return err
+		}
+
+		if ct := p.Header.Get("Content-Type"); ct != "video/mp2t" {
+			continue
+		}
+
+		cl := p.Header.Get("Content-Length")
+		size, err := strconv.Atoi(cl)
+		if err != nil {
+			return err
+		}
+
+		c.recv += size
+
+		body := make([]byte, size)
+
+		b := body
+		for {
+			if n, err2 := p.Read(b); err2 == nil {
+				b = b[n:]
+			} else {
+				break
+			}
+		}
+
+		body = c.decrypt(body)
+		bytesRd := bytes.NewReader(body)
+
+		for {
+			pkt, err2 := demux.ReadPacket(bytesRd)
+			if pkt == nil || err2 == io.EOF {
+				break
+			}
+			if err2 != nil {
+				return err2
+			}
+
+			if pkt.PayloadType == mpegts.StreamTypePCMUTapo {
+				// TODO: rewrite this part in the future
+				// Some cameras in the new firmware began to use PCMU/16000.
+				// https://github.com/AlexxIT/go2rtc/issues/1954
+				// I don't know why Tapo considers this an improvement. The codec is no better than the previous one.
+				// Unfortunately, we don't know in advance what codec the camera will use.
+				// Therefore, it's easier to transcode to a standard codec that all Tapo cameras have.
+				if transcode == nil {
+					transcode = pcm.Transcode(
+						&core.Codec{Name: core.CodecPCMA, ClockRate: 8000},
+						&core.Codec{Name: core.CodecPCMU, ClockRate: 16000},
+					)
+				}
+				pkt.PayloadType = mpegts.StreamTypePCMATapo
+				pkt.Payload = transcode(pkt.Payload)
+			}
+
+			for _, receiver := range c.receivers {
+				if receiver.ID == pkt.PayloadType {
+					mpegts.TimestampToRTP(pkt, receiver.Codec)
+					receiver.WriteRTP(pkt)
+					break
+				}
+			}
+		}
+	}
+}
+
+func (c *Client) Close() (err error) {
+	if c.conn1 != nil {
+		err = c.conn1.Close()
+	}
+	if c.conn2 != nil {
+		_ = c.conn2.Close()
+	}
+	return
+}
+
+func (c *Client) Request(conn net.Conn, body []byte) (string, error) {
+	// TODO: fixme (size)
+	buf := bytes.NewBuffer(nil)
+	buf.WriteString("----client-stream-boundary--\r\n")
+	buf.WriteString("Content-Type: application/json\r\n")
+	buf.WriteString("Content-Length: " + strconv.Itoa(len(body)) + "\r\n\r\n")
+	buf.Write(body)
+	buf.WriteString("\r\n")
+
+	if _, err := buf.WriteTo(conn); err != nil {
+		return "", err
+	}
+
+	mpReader := multipart.NewReader(conn, "--device-stream-boundary--")
+
+	for {
+		p, err := mpReader.NextRawPart()
+		if err != nil {
+			return "", err
+		}
+
+		var v struct {
+			Params struct {
+				SessionID string `json:"session_id"`
+			} `json:"params"`
+		}
+
+		if err = json.NewDecoder(p).Decode(&v); err != nil {
+			return "", err
+		}
+
+		return v.Params.SessionID, nil
+	}
+}
+
+func dial(req *http.Request, brand, username, password string) (net.Conn, *http.Response, error) {
+	conn, err := net.DialTimeout("tcp", req.URL.Host, core.ConnDialTimeout)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if err = req.Write(conn); err != nil {
+		return nil, nil, err
+	}
+
+	r := bufio.NewReader(conn)
+
+	res, err := http.ReadResponse(r, req)
+	if err != nil {
+		return nil, nil, err
+	}
+	_, _ = io.Copy(io.Discard, res.Body) // discard leftovers
+	_ = res.Body.Close()                 // ignore response body
+
+	auth := res.Header.Get("WWW-Authenticate")
+
+	if res.StatusCode != http.StatusUnauthorized || !strings.HasPrefix(auth, "Digest") {
+		return nil, nil, errors.New("tapo: wrond status: " + res.Status)
+	}
+
+	if brand == "tapo" && password == "" {
+		// support cloud password in place of username
+		if strings.Contains(auth, `encrypt_type="3"`) {
+			password = fmt.Sprintf("%32X", sha256.Sum256([]byte(username)))
+		} else {
+			password = fmt.Sprintf("%16X", md5.Sum([]byte(username)))
+		}
+		username = "admin"
+	} else if brand == "vigi" && username == "admin" {
+		password = securityEncode(password)
+	}
+
+	realm := tcp.Between(auth, `realm="`, `"`)
+	nonce := tcp.Between(auth, `nonce="`, `"`)
+	qop := tcp.Between(auth, `qop="`, `"`)
+	uri := req.URL.RequestURI()
+	ha1 := tcp.HexMD5(username, realm, password)
+	ha2 := tcp.HexMD5(req.Method, uri)
+	nc := "00000001"
+	cnonce := core.RandString(32, 64)
+	response := tcp.HexMD5(ha1, nonce, nc, cnonce, qop, ha2)
+
+	// https://datatracker.ietf.org/doc/html/rfc7616
+	header := fmt.Sprintf(
+		`Digest username="%s", realm="%s", nonce="%s", uri="%s", qop=%s, nc=%s, cnonce="%s", response="%s"`,
+		username, realm, nonce, uri, qop, nc, cnonce, response,
+	)
+
+	if opaque := tcp.Between(auth, `opaque="`, `"`); opaque != "" {
+		header += fmt.Sprintf(`, opaque="%s", algorithm=MD5`, opaque)
+	}
+
+	req.Header.Set("Authorization", header)
+
+	if err = req.Write(conn); err != nil {
+		return nil, nil, err
+	}
+
+	if res, err = http.ReadResponse(r, req); err != nil {
+		return nil, nil, err
+	}
+
+	return conn, res, nil
+}
+
+const (
+	keyShort = "RDpbLfCPsJZ7fiv"
+	keyLong  = "yLwVl0zKqws7LgKPRQ84Mdt708T1qQ3Ha7xv3H7NyU84p21BriUWBU43odz3iP4rBL3cD02KZciXTysVXiV8ngg6vL48rPJyAUw0HurW20xqxv9aYb4M9wK1Ae0wlro510qXeU07kV57fQMc8L6aLgMLwygtc0F10a0Dg70TOoouyFhdysuRMO51yY5ZlOZZLEal1h0t9YQW0Ko7oBwmCAHoic4HYbUyVeU3sfQ1xtXcPcf1aT303wAQhv66qzW"
+)
+
+func securityEncode(s string) string {
+	size := len(s)
+
+	var n int // max
+	if size > len(keyShort) {
+		n = size
+	} else {
+		n = len(keyShort)
+	}
+
+	b := make([]byte, n)
+
+	for i := 0; i < n; i++ {
+		c1 := 187
+		c2 := 187
+		if i >= size {
+			c1 = int(keyShort[i])
+		} else if i >= len(keyShort) {
+			c2 = int(s[i])
+		} else {
+			c1 = int(keyShort[i])
+			c2 = int(s[i])
+		}
+		b[i] = keyLong[(c1^c2)%len(keyLong)]
+	}
+
+	return string(b)
+}
diff --git a/installs_on_host/go2rtc/pkg/tapo/producer.go b/installs_on_host/go2rtc/pkg/tapo/producer.go
new file mode 100644
index 0000000..87a91ff
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tapo/producer.go
@@ -0,0 +1,94 @@
+package tapo
+
+import (
+	"encoding/json"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/mpegts"
+)
+
+func (c *Client) GetMedias() []*core.Media {
+	if c.medias == nil {
+		// don't know if all Tapo has this capabilities...
+		c.medias = []*core.Media{
+			{
+				Kind:      core.KindVideo,
+				Direction: core.DirectionRecvonly,
+				Codecs: []*core.Codec{
+					{Name: core.CodecH264, ClockRate: 90000, PayloadType: core.PayloadTypeRAW},
+				},
+			},
+			{
+				Kind:      core.KindAudio,
+				Direction: core.DirectionRecvonly,
+				Codecs: []*core.Codec{
+					{Name: core.CodecPCMA, ClockRate: 8000, PayloadType: 8},
+				},
+			},
+			{
+				Kind:      core.KindAudio,
+				Direction: core.DirectionSendonly,
+				Codecs: []*core.Codec{
+					{Name: core.CodecPCMA, ClockRate: 8000, PayloadType: 8},
+				},
+			},
+		}
+	}
+
+	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
+		}
+	}
+
+	if err := c.SetupStream(); err != nil {
+		return nil, err
+	}
+
+	track := core.NewReceiver(media, codec)
+	switch media.Kind {
+	case core.KindVideo:
+		track.ID = mpegts.StreamTypeH264
+	case core.KindAudio:
+		track.ID = mpegts.StreamTypePCMATapo
+	}
+	c.receivers = append(c.receivers, track)
+	return track, nil
+}
+
+func (c *Client) Start() error {
+	return c.Handle()
+}
+
+func (c *Client) Stop() error {
+	for _, receiver := range c.receivers {
+		receiver.Close()
+	}
+	if c.sender != nil {
+		c.sender.Close()
+	}
+	return c.Close()
+}
+
+func (c *Client) MarshalJSON() ([]byte, error) {
+	info := &core.Connection{
+		ID:         core.ID(c),
+		FormatName: c.url.Scheme,
+		Protocol:   "http",
+		Medias:     c.medias,
+		Recv:       c.recv,
+		Receivers:  c.receivers,
+		Send:       c.send,
+	}
+	if c.sender != nil {
+		info.Senders = []*core.Sender{c.sender}
+	}
+	if c.conn1 != nil {
+		info.RemoteAddr = c.conn1.RemoteAddr().String()
+	}
+	return json.Marshal(info)
+}
diff --git a/installs_on_host/go2rtc/pkg/tcp/auth.go b/installs_on_host/go2rtc/pkg/tcp/auth.go
new file mode 100644
index 0000000..9cc56ba
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tcp/auth.go
@@ -0,0 +1,140 @@
+package tcp
+
+import (
+	"crypto/md5"
+	"encoding/base64"
+	"encoding/hex"
+	"fmt"
+	"net/url"
+	"strings"
+)
+
+type Auth struct {
+	Method  byte
+	user    string
+	pass    string
+	header  string
+	h1nonce string
+}
+
+const (
+	AuthNone byte = iota
+	AuthUnknown
+	AuthBasic
+	AuthDigest
+	AuthTPLink // https://drmnsamoliu.github.io/video.html
+)
+
+func NewAuth(user *url.Userinfo) *Auth {
+	a := new(Auth)
+	a.user = user.Username()
+	a.pass, _ = user.Password()
+	if a.user != "" {
+		a.Method = AuthUnknown
+	}
+	return a
+}
+
+func (a *Auth) Read(res *Response) bool {
+	auth := res.Header.Get("WWW-Authenticate")
+	if len(auth) < 6 {
+		return false
+	}
+
+	switch auth[:6] {
+	case "Basic ":
+		a.header = "Basic " + B64(a.user, a.pass)
+		a.Method = AuthBasic
+		return true
+	case "Digest":
+		realm := Between(auth, `realm="`, `"`)
+		nonce := Between(auth, `nonce="`, `"`)
+
+		a.h1nonce = HexMD5(a.user, realm, a.pass) + ":" + nonce
+		a.header = fmt.Sprintf(
+			`Digest username="%s", realm="%s", nonce="%s"`,
+			a.user, realm, nonce,
+		)
+		a.Method = AuthDigest
+		return true
+	default:
+		return false
+	}
+}
+
+func (a *Auth) Write(req *Request) {
+	if a == nil {
+		return
+	}
+
+	switch a.Method {
+	case AuthBasic:
+		req.Header.Set("Authorization", a.header)
+	case AuthDigest:
+		// important to use String except RequestURL for RtspServer:
+		// https://github.com/AlexxIT/go2rtc/issues/244
+		uri := req.URL.String()
+		h2 := HexMD5(req.Method, uri)
+		response := HexMD5(a.h1nonce, h2)
+		header := a.header + fmt.Sprintf(
+			`, uri="%s", response="%s"`, uri, response,
+		)
+		req.Header.Set("Authorization", header)
+	case AuthTPLink:
+		req.URL.Host = "127.0.0.1"
+	}
+}
+
+func (a *Auth) Validate(req *Request) (valid, empty bool) {
+	if a == nil {
+		return true, true
+	}
+
+	header := req.Header.Get("Authorization")
+	if header == "" {
+		return false, true
+	}
+
+	if a.Method == AuthUnknown {
+		a.Method = AuthBasic
+		a.header = "Basic " + B64(a.user, a.pass)
+	}
+
+	return header == a.header, false
+}
+
+func (a *Auth) ReadNone(res *Response) bool {
+	auth := res.Header.Get("WWW-Authenticate")
+	if strings.Contains(auth, "TP-LINK Streaming Media") {
+		a.Method = AuthTPLink
+		return true
+	}
+	return false
+}
+
+func (a *Auth) UserInfo() *url.Userinfo {
+	return url.UserPassword(a.user, a.pass)
+}
+
+func Between(s, sub1, sub2 string) string {
+	i := strings.Index(s, sub1)
+	if i < 0 {
+		return ""
+	}
+	s = s[i+len(sub1):]
+	i = strings.Index(s, sub2)
+	if i < 0 {
+		return ""
+	}
+	return s[:i]
+}
+
+func HexMD5(s ...string) string {
+	b := md5.Sum([]byte(strings.Join(s, ":")))
+	return hex.EncodeToString(b[:])
+}
+
+func B64(s ...string) string {
+	b := []byte(strings.Join(s, ":"))
+	return base64.StdEncoding.EncodeToString(b)
+}
diff --git a/installs_on_host/go2rtc/pkg/tcp/dial.go b/installs_on_host/go2rtc/pkg/tcp/dial.go
new file mode 100644
index 0000000..447d4d3
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tcp/dial.go
@@ -0,0 +1,64 @@
+package tcp
+
+import (
+	"crypto/tls"
+	"errors"
+	"net"
+	"net/url"
+	"strings"
+	"time"
+)
+
+// Dial - for RTSP(S|X) and RTMP(S|X)
+func Dial(u *url.URL, timeout time.Duration) (net.Conn, error) {
+	var address string
+	var hostname string // without port
+	if i := strings.IndexByte(u.Host, ':'); i > 0 {
+		address = u.Host
+		hostname = u.Host[:i]
+	} else {
+		switch u.Scheme {
+		case "rtsp", "rtsps", "rtspx":
+			address = u.Host + ":554"
+		case "rtmp":
+			address = u.Host + ":1935"
+		case "rtmps", "rtmpx":
+			address = u.Host + ":443"
+		}
+		hostname = u.Host
+	}
+
+	var secure *tls.Config
+
+	switch u.Scheme {
+	case "rtsp", "rtmp":
+	case "rtsps", "rtspx", "rtmps", "rtmpx":
+		if u.Scheme[4] == 'x' || IsIP(hostname) {
+			secure = &tls.Config{InsecureSkipVerify: true}
+		} else {
+			secure = &tls.Config{ServerName: hostname}
+		}
+	default:
+		return nil, errors.New("unsupported scheme: " + u.Scheme)
+	}
+
+	conn, err := net.DialTimeout("tcp", address, timeout)
+	if err != nil {
+		return nil, err
+	}
+
+	if secure == nil {
+		return conn, nil
+	}
+
+	tlsConn := tls.Client(conn, secure)
+	if err = tlsConn.Handshake(); err != nil {
+		return nil, err
+	}
+
+	if u.Scheme[4] == 'x' {
+		u.Scheme = u.Scheme[:4] + "s"
+	}
+
+	return tlsConn, nil
+}
diff --git a/installs_on_host/go2rtc/pkg/tcp/request.go b/installs_on_host/go2rtc/pkg/tcp/request.go
new file mode 100644
index 0000000..74fd413
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tcp/request.go
@@ -0,0 +1,172 @@
+package tcp
+
+import (
+	"context"
+	"crypto/tls"
+	"errors"
+	"fmt"
+	"net"
+	"net/http"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+// Do - http.Client with support Digest Authorization
+func Do(req *http.Request) (*http.Response, error) {
+	var secure *tls.Config
+
+	switch req.URL.Scheme {
+	case "httpx":
+		secure = insecureConfig
+		req.URL.Scheme = "https"
+	case "https":
+		if hostname := req.URL.Hostname(); IsIP(hostname) {
+			secure = insecureConfig
+		}
+	}
+
+	if secure != nil {
+		ctx := context.WithValue(req.Context(), secureKey, secure)
+		req = req.WithContext(ctx)
+	}
+
+	if client == nil {
+		transport := http.DefaultTransport.(*http.Transport).Clone()
+
+		dial := transport.DialContext
+		transport.DialContext = func(ctx context.Context, network, addr string) (net.Conn, error) {
+			conn, err := dial(ctx, network, addr)
+			if pconn, ok := ctx.Value(connKey).(*net.Conn); ok {
+				*pconn = conn
+			}
+			return conn, err
+		}
+		transport.DialTLSContext = func(ctx context.Context, network, addr string) (net.Conn, error) {
+			conn, err := dial(ctx, network, addr)
+			if err != nil {
+				return nil, err
+			}
+
+			var conf *tls.Config
+			if v, ok := ctx.Value(secureKey).(*tls.Config); ok {
+				conf = v
+			} else if host, _, err := net.SplitHostPort(addr); err != nil {
+				conf = &tls.Config{ServerName: addr}
+			} else {
+				conf = &tls.Config{ServerName: host}
+			}
+
+			tlsConn := tls.Client(conn, conf)
+			if err = tlsConn.Handshake(); err != nil {
+				return nil, err
+			}
+
+			if pconn, ok := ctx.Value(connKey).(*net.Conn); ok {
+				*pconn = tlsConn
+			}
+			return tlsConn, err
+		}
+
+		client = &http.Client{Transport: transport}
+	}
+
+	user := req.URL.User
+
+	// Hikvision won't answer on Basic auth with any headers
+	if strings.HasPrefix(req.URL.Path, "/ISAPI/") {
+		req.URL.User = nil
+	}
+
+	res, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	if res.StatusCode == http.StatusUnauthorized && user != nil {
+		Close(res)
+
+		auth := res.Header.Get("WWW-Authenticate")
+		if !strings.HasPrefix(auth, "Digest") {
+			return nil, errors.New("unsupported auth: " + auth)
+		}
+
+		realm := Between(auth, `realm="`, `"`)
+		nonce := Between(auth, `nonce="`, `"`)
+		qop := Between(auth, `qop="`, `"`)
+
+		username := user.Username()
+		password, _ := user.Password()
+		ha1 := HexMD5(username, realm, password)
+
+		uri := req.URL.RequestURI()
+		ha2 := HexMD5(req.Method, uri)
+
+		var header string
+
+		switch qop {
+		case "":
+			response := HexMD5(ha1, nonce, ha2)
+			header = fmt.Sprintf(
+				`Digest username="%s", realm="%s", nonce="%s", uri="%s", response="%s"`,
+				username, realm, nonce, uri, response,
+			)
+		case "auth":
+			nc := "00000001"
+			cnonce := core.RandString(32, 64)
+			response := HexMD5(ha1, nonce, nc, cnonce, qop, ha2)
+			header = fmt.Sprintf(
+				`Digest username="%s", realm="%s", nonce="%s", uri="%s", qop=%s, nc=%s, cnonce="%s", response="%s"`,
+				username, realm, nonce, uri, qop, nc, cnonce, response,
+			)
+		default:
+			return nil, errors.New("unsupported qop: " + auth)
+		}
+
+		req.Header.Set("Authorization", header)
+
+		if res, err = client.Do(req); err != nil {
+			return nil, err
+		}
+	}
+
+	return res, nil
+}
+
+var client *http.Client
+
+type key string
+
+var connKey = key("conn")
+var secureKey = key("secure")
+
+var insecureConfig = &tls.Config{
+	InsecureSkipVerify: true,
+	CipherSuites: []uint16{
+		tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+		tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+		tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305, tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
+		tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
+		tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
+
+		// this cipher suites disabled starting from https://tip.golang.org/doc/go1.22
+		// but cameras can't work without them https://github.com/AlexxIT/go2rtc/issues/1172
+		tls.TLS_RSA_WITH_AES_128_GCM_SHA256, // insecure
+		tls.TLS_RSA_WITH_AES_256_GCM_SHA384, // insecure
+	},
+}
+
+func WithConn() (context.Context, *net.Conn) {
+	pconn := new(net.Conn)
+	return context.WithValue(context.Background(), connKey, pconn), pconn
+}
+
+func Close(res *http.Response) {
+	if res.Body != nil {
+		_ = res.Body.Close()
+	}
+}
+
+func IsIP(hostname string) bool {
+	return net.ParseIP(hostname) != nil
+}
diff --git a/installs_on_host/go2rtc/pkg/tcp/textproto.go b/installs_on_host/go2rtc/pkg/tcp/textproto.go
new file mode 100644
index 0000000..c629015
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tcp/textproto.go
@@ -0,0 +1,150 @@
+package tcp
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"io"
+	"net/textproto"
+	"net/url"
+	"strconv"
+	"strings"
+)
+
+const EndLine = "\r\n"
+
+// Response like http.Response, but with any proto
+type Response struct {
+	Status     string
+	StatusCode int
+	Proto      string
+	Header     textproto.MIMEHeader
+	Body       []byte
+	Request    *Request
+}
+
+func (r Response) String() string {
+	s := r.Proto + " " + r.Status + EndLine
+	for k, v := range r.Header {
+		s += k + ": " + v[0] + EndLine
+	}
+	s += EndLine
+	if r.Body != nil {
+		s += string(r.Body)
+	}
+	return s
+}
+
+func (r *Response) Write(w io.Writer) (err error) {
+	_, err = w.Write([]byte(r.String()))
+	return
+}
+
+func ReadResponse(r *bufio.Reader) (*Response, error) {
+	tp := textproto.NewReader(r)
+
+	line, err := tp.ReadLine()
+	if err != nil {
+		return nil, err
+	}
+	if line == "" {
+		return nil, errors.New("empty response on RTSP request")
+	}
+
+	ss := strings.SplitN(line, " ", 3)
+	if len(ss) != 3 {
+		return nil, fmt.Errorf("malformed response: %s", line)
+	}
+
+	res := &Response{
+		Status: ss[1] + " " + ss[2],
+		Proto:  ss[0],
+	}
+
+	res.StatusCode, err = strconv.Atoi(ss[1])
+	if err != nil {
+		return nil, err
+	}
+
+	res.Header, err = tp.ReadMIMEHeader()
+	if err != nil {
+		return nil, err
+	}
+
+	if val := res.Header.Get("Content-Length"); val != "" {
+		var i int
+		i, err = strconv.Atoi(val)
+		res.Body = make([]byte, i)
+		if _, err = io.ReadAtLeast(r, res.Body, i); err != nil {
+			return nil, err
+		}
+	}
+
+	return res, nil
+}
+
+// Request like http.Request, but with any proto
+type Request struct {
+	Method string
+	URL    *url.URL
+	Proto  string
+	Header textproto.MIMEHeader
+	Body   []byte
+}
+
+func (r *Request) String() string {
+	s := r.Method + " " + r.URL.String() + " " + r.Proto + EndLine
+	for k, v := range r.Header {
+		s += k + ": " + v[0] + EndLine
+	}
+	s += EndLine
+	if r.Body != nil {
+		s += string(r.Body)
+	}
+	return s
+}
+
+func (r *Request) Write(w io.Writer) (err error) {
+	_, err = w.Write([]byte(r.String()))
+	return
+}
+
+func ReadRequest(r *bufio.Reader) (*Request, error) {
+	tp := textproto.NewReader(r)
+
+	line, err := tp.ReadLine()
+	if err != nil {
+		return nil, err
+	}
+
+	ss := strings.SplitN(line, " ", 3)
+	if len(ss) != 3 {
+		return nil, fmt.Errorf("wrong request: %s", line)
+	}
+
+	req := &Request{
+		Method: ss[0],
+		Proto:  ss[2],
+	}
+
+	req.URL, err = url.Parse(ss[1])
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header, err = tp.ReadMIMEHeader()
+	if err != nil {
+		return nil, err
+	}
+
+	if val := req.Header.Get("Content-Length"); val != "" {
+		var i int
+		i, err = strconv.Atoi(val)
+		req.Body = make([]byte, i)
+		if _, err = io.ReadAtLeast(r, req.Body, i); err != nil {
+			return nil, err
+		}
+	}
+
+	return req, nil
+}
diff --git a/installs_on_host/go2rtc/pkg/tcp/textproto_test.go b/installs_on_host/go2rtc/pkg/tcp/textproto_test.go
new file mode 100644
index 0000000..08bc5a1
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tcp/textproto_test.go
@@ -0,0 +1,30 @@
+package tcp
+
+import (
+	"bufio"
+	"bytes"
+	"net/http"
+	"testing"
+)
+
+func assert(t *testing.T, one, two any) {
+	if one != two {
+		t.FailNow()
+	}
+}
+
+func TestName(t *testing.T) {
+	data := []byte(`RTSP/1.0 401 Unauthorized
+WWW-Authenticate: Digest realm="testrealm@host.com",
+                        nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093",
+
+`)
+
+	buf := bytes.NewBuffer(data)
+	r := bufio.NewReader(buf)
+
+	res, err := ReadResponse(r)
+	assert(t, err, nil)
+
+	assert(t, res.StatusCode, http.StatusUnauthorized)
+}
diff --git a/installs_on_host/go2rtc/pkg/tcp/websocket/client.go b/installs_on_host/go2rtc/pkg/tcp/websocket/client.go
new file mode 100644
index 0000000..e95ce1e
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tcp/websocket/client.go
@@ -0,0 +1,130 @@
+package websocket
+
+import (
+	cryptorand "crypto/rand"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"net"
+	"time"
+)
+
+const BinaryMessage = 2
+
+type Client struct {
+	conn   net.Conn
+	remain int
+}
+
+func NewClient(conn net.Conn) *Client {
+	return &Client{conn: conn}
+}
+
+const finalBit = 0x80
+const maskBit = 0x80
+
+func (w *Client) Read(b []byte) (n int, err error) {
+	if w.remain == 0 {
+		b2 := make([]byte, 2)
+		if _, err = io.ReadFull(w.conn, b2); err != nil {
+			return 0, err
+		}
+
+		frameType := b2[0] & 0xF
+		w.remain = int(b2[1] & 0x7F)
+
+		switch frameType {
+		case BinaryMessage:
+		default:
+			return 0, fmt.Errorf("unsupported frame type: %d", frameType)
+		}
+
+		switch w.remain {
+		case 126:
+			if _, err = io.ReadFull(w.conn, b2); err != nil {
+				return 0, err
+			}
+			w.remain = int(binary.BigEndian.Uint16(b2))
+		case 127:
+			b8 := make([]byte, 8)
+			if _, err = io.ReadFull(w.conn, b8); err != nil {
+				return 0, err
+			}
+			w.remain = int(binary.BigEndian.Uint64(b8))
+		}
+	}
+
+	if w.remain > len(b) {
+		n, err = io.ReadFull(w.conn, b)
+		w.remain -= n
+		return
+	}
+
+	n, err = io.ReadFull(w.conn, b[:w.remain])
+	w.remain = 0
+
+	return
+}
+
+func (w *Client) Write(b []byte) (n int, err error) {
+	var data []byte
+	var start byte
+
+	size := len(b)
+
+	switch {
+	case size > 65535:
+		start = 10
+		data = make([]byte, size+14)
+		data[1] = maskBit | 127
+		binary.BigEndian.PutUint64(data[2:], uint64(size))
+	case size > 125:
+		start = 4
+		data = make([]byte, size+8)
+		data[1] = maskBit | 126
+		binary.BigEndian.PutUint16(data[2:], uint16(size))
+	default:
+		start = 2
+		data = make([]byte, size+6)
+		data[1] = maskBit | byte(size)
+	}
+
+	data[0] = BinaryMessage | finalBit
+
+	mask := data[start : start+4]
+	msg := data[start+4:]
+
+	if _, err = cryptorand.Read(mask); err != nil {
+		return 0, err
+	}
+
+	for i := 0; i < len(b); i++ {
+		msg[i] = b[i] ^ mask[i%4]
+	}
+
+	return w.conn.Write(data)
+}
+
+func (w *Client) Close() error {
+	return w.conn.Close()
+}
+
+func (w *Client) LocalAddr() net.Addr {
+	return w.conn.LocalAddr()
+}
+
+func (w *Client) RemoteAddr() net.Addr {
+	return w.conn.RemoteAddr()
+}
+
+func (w *Client) SetDeadline(t time.Time) error {
+	return w.conn.SetDeadline(t)
+}
+
+func (w *Client) SetReadDeadline(t time.Time) error {
+	return w.conn.SetReadDeadline(t)
+}
+
+func (w *Client) SetWriteDeadline(t time.Time) error {
+	return w.conn.SetWriteDeadline(t)
+}
diff --git a/installs_on_host/go2rtc/pkg/tcp/websocket/dial.go b/installs_on_host/go2rtc/pkg/tcp/websocket/dial.go
new file mode 100644
index 0000000..3e1fd48
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tcp/websocket/dial.go
@@ -0,0 +1,65 @@
+package websocket
+
+import (
+	cryptorand "crypto/rand"
+	"crypto/sha1"
+	"encoding/base64"
+	"errors"
+	"net"
+	"net/http"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/pkg/tcp"
+)
+
+func Dial(address string) (net.Conn, error) {
+	if strings.HasPrefix(address, "ws") {
+		address = "http" + address[2:] // support http and https
+	}
+
+	// using custom client for support Digest Auth
+	// https://github.com/AlexxIT/go2rtc/issues/415
+	ctx, pconn := tcp.WithConn()
+
+	req, err := http.NewRequestWithContext(ctx, "GET", address, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	key, accept := GetKeyAccept()
+
+	// Version, Key, Protocol important for Axis cameras
+	req.Header.Set("Connection", "Upgrade")
+	req.Header.Set("Upgrade", "websocket")
+	req.Header.Set("Sec-WebSocket-Version", "13")
+	req.Header.Set("Sec-WebSocket-Key", key)
+	req.Header.Set("Sec-WebSocket-Protocol", "binary")
+
+	res, err := tcp.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	if res.StatusCode != http.StatusSwitchingProtocols {
+		return nil, errors.New("wrong status: " + res.Status)
+	}
+
+	if res.Header.Get("Sec-Websocket-Accept") != accept {
+		return nil, errors.New("wrong websocket accept")
+	}
+
+	return NewClient(*pconn), nil
+}
+
+func GetKeyAccept() (key, accept string) {
+	b := make([]byte, 16)
+	_, _ = cryptorand.Read(b)
+	key = base64.StdEncoding.EncodeToString(b)
+
+	h := sha1.New()
+	h.Write([]byte(key))
+	h.Write([]byte("258EAFA5-E914-47DA-95CA-C5AB0DC85B11"))
+	accept = base64.StdEncoding.EncodeToString(h.Sum(nil))
+
+	return
+}
diff --git a/installs_on_host/go2rtc/pkg/tutk/codec.go b/installs_on_host/go2rtc/pkg/tutk/codec.go
new file mode 100644
index 0000000..9ec7d8c
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tutk/codec.go
@@ -0,0 +1,59 @@
+package tutk
+
+// https://github.com/seydx/tutk_wyze#11-codec-reference
+const (
+	CodecMPEG4 byte = 0x4C
+	CodecH263  byte = 0x4D
+	CodecH264  byte = 0x4E
+	CodecMJPEG byte = 0x4F
+	CodecH265  byte = 0x50
+)
+
+const (
+	CodecAACRaw  byte = 0x86
+	CodecAACADTS byte = 0x87
+	CodecAACLATM byte = 0x88
+	CodecPCMU    byte = 0x89
+	CodecPCMA    byte = 0x8A
+	CodecADPCM   byte = 0x8B
+	CodecPCML    byte = 0x8C
+	CodecSPEEX   byte = 0x8D
+	CodecMP3     byte = 0x8E
+	CodecG726    byte = 0x8F
+	CodecAACAlt  byte = 0x90
+	CodecOpus    byte = 0x92
+)
+
+var sampleRates = [9]uint32{8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000}
+
+func GetSampleRateIndex(sampleRate uint32) uint8 {
+	for i, rate := range sampleRates {
+		if rate == sampleRate {
+			return uint8(i)
+		}
+	}
+	return 3 // default 16kHz
+}
+
+func GetSamplesPerFrame(codecID byte) uint32 {
+	switch codecID {
+	case CodecAACRaw, CodecAACADTS, CodecAACLATM, CodecAACAlt:
+		return 1024
+	case CodecPCMU, CodecPCMA, CodecPCML, CodecADPCM, CodecSPEEX, CodecG726:
+		return 160
+	case CodecMP3:
+		return 1152
+	case CodecOpus:
+		return 960
+	default:
+		return 1024
+	}
+}
+
+func IsVideoCodec(id byte) bool {
+	return id >= CodecMPEG4 && id <= CodecH265
+}
+
+func IsAudioCodec(id byte) bool {
+	return id >= CodecAACRaw && id <= CodecOpus
+}
diff --git a/installs_on_host/go2rtc/pkg/tutk/conn.go b/installs_on_host/go2rtc/pkg/tutk/conn.go
new file mode 100644
index 0000000..e061069
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tutk/conn.go
@@ -0,0 +1,264 @@
+package tutk
+
+import (
+	"fmt"
+	"io"
+	"net"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+func Dial(host, uid, username, password string) (*Conn, error) {
+	addr, err := net.ResolveUDPAddr("udp", host)
+	if err != nil {
+		// Default port for listening incoming LAN connections.
+		// Important. It's not using for real connection.
+		addr = &net.UDPAddr{IP: net.ParseIP(host), Port: 32761}
+	}
+
+	udpConn, err := net.ListenUDP("udp", nil)
+	if err != nil {
+		return nil, err
+	}
+
+	c := &Conn{UDPConn: udpConn, addr: addr}
+
+	sid := GenSessionID()
+
+	_ = c.SetDeadline(time.Now().Add(5 * time.Second))
+
+	if addr.Port != 10001 {
+		err = c.connectDirect(uid, sid)
+	} else {
+		err = c.connectRemote(uid, sid)
+	}
+	if err != nil {
+		_ = c.Close()
+		return nil, err
+	}
+
+	if c.ver[0] >= 25 {
+		c.session = NewSession25(c, sid)
+	} else {
+		c.session = NewSession16(c, sid)
+	}
+
+	if err = c.clientStart(username, password); err != nil {
+		_ = c.Close()
+		return nil, err
+	}
+
+	go c.worker()
+
+	return c, nil
+}
+
+type Conn struct {
+	*net.UDPConn
+	addr    *net.UDPAddr
+	session Session
+
+	ver    []byte
+	err    error
+	cmdMu  sync.Mutex
+	cmdAck func()
+}
+
+// Read overwrite net.Conn
+func (c *Conn) Read(buf []byte) (n int, err error) {
+	for {
+		var addr *net.UDPAddr
+		if n, addr, err = c.UDPConn.ReadFromUDP(buf); err != nil {
+			return 0, err
+		}
+
+		if string(c.addr.IP) != string(addr.IP) || n < 16 {
+			continue // skip messages from another IP
+		}
+
+		if c.addr.Port != addr.Port {
+			c.addr.Port = addr.Port
+		}
+
+		ReverseTransCodePartial(buf, buf[:n])
+		//log.Printf("<- %x", buf[:n])
+		return n, nil
+	}
+}
+
+// Write overwrite net.Conn
+func (c *Conn) Write(b []byte) (n int, err error) {
+	//log.Printf("-> %x", b)
+	return c.UDPConn.WriteToUDP(TransCodePartial(nil, b), c.addr)
+}
+
+// RemoteAddr overwrite net.Conn
+func (c *Conn) RemoteAddr() net.Addr {
+	return c.addr
+}
+
+func (c *Conn) Protocol() string {
+	return "tutk+udp"
+}
+
+func (c *Conn) Version() string {
+	if len(c.ver) == 1 {
+		return fmt.Sprintf("TUTK/%d", c.ver[0])
+	}
+	return fmt.Sprintf("TUTK/%d SDK %d.%d.%d.%d", c.ver[0], c.ver[1], c.ver[2], c.ver[3], c.ver[4])
+}
+
+func (c *Conn) ReadCommand() (ctrlType uint32, ctrlData []byte, err error) {
+	return c.session.RecvIOCtrl()
+}
+
+func (c *Conn) WriteCommand(ctrlType uint32, ctrlData []byte) error {
+	c.cmdMu.Lock()
+	defer c.cmdMu.Unlock()
+
+	var repeat atomic.Int32
+	repeat.Store(5)
+
+	timeout := time.NewTicker(time.Second)
+	defer timeout.Stop()
+
+	c.cmdAck = func() {
+		repeat.Store(0)
+		timeout.Reset(1)
+	}
+
+	buf := c.session.SendIOCtrl(ctrlType, ctrlData)
+
+	for {
+		if err := c.session.SessionWrite(0, buf); err != nil {
+			return err
+		}
+		<-timeout.C
+		r := repeat.Add(-1)
+		if r < 0 {
+			return nil
+		}
+		if r == 0 {
+			return fmt.Errorf("%s: can't send command %d", "tutk", ctrlType)
+		}
+	}
+}
+
+func (c *Conn) ReadPacket() (hdr, payload []byte, err error) {
+	return c.session.RecvFrameData()
+}
+
+func (c *Conn) WritePacket(hdr, payload []byte) error {
+	buf := c.session.SendFrameData(hdr, payload)
+	return c.session.SessionWrite(1, buf)
+}
+
+func (c *Conn) Error() error {
+	if c.err != nil {
+		return c.err
+	}
+	return io.EOF
+}
+
+func (c *Conn) worker() {
+	defer c.session.Close()
+
+	buf := make([]byte, 1200)
+
+	for {
+		n, err := c.Read(buf)
+		if err != nil {
+			c.err = fmt.Errorf("%s: %w", "tutk", err)
+			return
+		}
+
+		switch c.handleMsg(buf[:n]) {
+		case msgUnknown:
+			fmt.Printf("tutk: unknown msg: %x\n", buf[:n])
+		case msgError:
+			return
+		case msgCommandAck:
+			if c.cmdAck != nil {
+				c.cmdAck()
+			}
+		}
+	}
+}
+
+const (
+	msgUnknown = iota
+	msgError
+	msgPing
+	msgUnknownPing
+	msgClientStart
+	msgClientStart2
+	msgClientStartAck2
+	msgCommand
+	msgCommandAck
+	msgCounters
+	msgMediaChunk
+	msgMediaFrame
+	msgMediaReorder
+	msgMediaLost
+	msgCh5
+
+	msgUnknown0007 // time sync without data?
+	msgUnknown0008 // time sync with data?
+	msgUnknown0010
+	msgUnknown0013
+	msgUnknown0900
+	msgUnknown0a08
+	msgUnknownCh1c
+	msgDafang0012
+)
+
+func (c *Conn) handleMsg(msg []byte) int {
+	// off sample
+	// 0   0402      tutk magic
+	// 2   120a      tutk version (120a, 190a...)
+	// 4   0800      msg size = len(b)-16
+	// 6   0000      channel seq
+	// 8   28041200  msg type
+	// 14  0100      channel (not all msg)
+	// 28  0700      msg data (not all msg)
+	switch msg[8] {
+	case 0x08:
+		switch ch := msg[14]; ch {
+		case 0, 1:
+			return c.session.SessionRead(ch, msg[28:])
+		case 5:
+			if len(msg) == 48 {
+				_, _ = c.Write(msgAckCh5(msg))
+				return msgCh5
+			}
+		case 0x1c:
+			return msgUnknownCh1c
+		}
+	case 0x18:
+		return msgUnknownPing
+	case 0x28:
+		if len(msg) == 24 {
+			_, _ = c.Write(msgAckPing(msg))
+			return msgPing
+		}
+	}
+	return msgUnknown
+}
+
+func msgAckPing(msg []byte) []byte {
+	// <- [24] 0402120a 08000000 28041200 000000005b0d4202070aa8c0
+	// -> [24] 04021a0a 08000000 27042100 000000005b0d4202070aa8c0
+	msg[8] = 0x27
+	msg[10] = 0x21
+	return msg
+}
+
+func msgAckCh5(msg []byte) []byte {
+	// <- [48] 0402190a 20000400 07042100 7ecc05000c0000007ecc93c456c2561f 5a97c2f101050000000000000000000000010000
+	// -> [48] 0402190a 20000400 08041200 7ecc05000c0000007ecc93c456c2561f 5a97c2f141050000000000000000000000010000
+	msg[8] = 0x07
+	msg[10] = 0x21
+	msg[32] = 0x41
+	return msg
+}
diff --git a/installs_on_host/go2rtc/pkg/tutk/crypto.go b/installs_on_host/go2rtc/pkg/tutk/crypto.go
new file mode 100644
index 0000000..469bd2b
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tutk/crypto.go
@@ -0,0 +1,279 @@
+package tutk
+
+import (
+	"encoding/binary"
+	"math/bits"
+)
+
+// I'd like to say hello to Charlie. Your name is forever etched into the history of streaming software.
+const charlie = "Charlie is the designer of P2P!!"
+
+func ReverseTransCodePartial(dst, src []byte) []byte {
+	n := len(src)
+	tmp := make([]byte, n)
+	if len(dst) < n {
+		dst = make([]byte, n)
+	}
+
+	src16 := src
+	tmp16 := tmp
+	dst16 := dst
+
+	for ; n >= 16; n -= 16 {
+		for i := 0; i != 16; i += 4 {
+			x := binary.LittleEndian.Uint32(src16[i:])
+			binary.LittleEndian.PutUint32(tmp16[i:], bits.RotateLeft32(x, i+3))
+		}
+
+		swap(dst16, tmp16, 16)
+
+		for i := 0; i != 16; i++ {
+			tmp16[i] = dst16[i] ^ charlie[i]
+		}
+
+		for i := 0; i != 16; i += 4 {
+			x := binary.LittleEndian.Uint32(tmp16[i:])
+			binary.LittleEndian.PutUint32(dst16[i:], bits.RotateLeft32(x, i+1))
+		}
+
+		tmp16 = tmp16[16:]
+		dst16 = dst16[16:]
+		src16 = src16[16:]
+	}
+
+	swap(tmp16, src16, n)
+
+	for i := 0; i < n; i++ {
+		dst16[i] = tmp16[i] ^ charlie[i]
+	}
+
+	return dst
+}
+
+func ReverseTransCodeBlob(src []byte) []byte {
+	if len(src) < 16 {
+		return ReverseTransCodePartial(nil, src)
+	}
+
+	dst := make([]byte, len(src))
+	header := ReverseTransCodePartial(nil, src[:16])
+	copy(dst, header)
+
+	if len(src) > 16 {
+		if dst[3]&1 != 0 { // Partial encryption (check decrypted header)
+			remaining := len(src) - 16
+			decryptLen := min(remaining, 48)
+			if decryptLen > 0 {
+				decrypted := ReverseTransCodePartial(nil, src[16:16+decryptLen])
+				copy(dst[16:], decrypted)
+			}
+			if remaining > 48 {
+				copy(dst[64:], src[64:])
+			}
+		} else { // Full decryption
+			decrypted := ReverseTransCodePartial(nil, src[16:])
+			copy(dst[16:], decrypted)
+		}
+	}
+	return dst
+}
+
+func TransCodePartial(dst, src []byte) []byte {
+	n := len(src)
+	tmp := make([]byte, n)
+	if len(dst) < n {
+		dst = make([]byte, n)
+	}
+
+	src16 := src
+	tmp16 := tmp
+	dst16 := dst
+
+	for ; n >= 16; n -= 16 {
+		for i := 0; i != 16; i += 4 {
+			x := binary.LittleEndian.Uint32(src16[i:])
+			binary.LittleEndian.PutUint32(tmp16[i:], bits.RotateLeft32(x, -i-1))
+		}
+
+		for i := 0; i != 16; i++ {
+			dst16[i] = tmp16[i] ^ charlie[i]
+		}
+
+		swap(tmp16, dst16, 16)
+
+		for i := 0; i != 16; i += 4 {
+			x := binary.LittleEndian.Uint32(tmp16[i:])
+			binary.LittleEndian.PutUint32(dst16[i:], bits.RotateLeft32(x, -i-3))
+		}
+
+		tmp16 = tmp16[16:]
+		dst16 = dst16[16:]
+		src16 = src16[16:]
+	}
+
+	for i := 0; i < n; i++ {
+		tmp16[i] = src16[i] ^ charlie[i]
+	}
+
+	swap(dst16, tmp16, n)
+
+	return dst
+}
+
+func TransCodeBlob(src []byte) []byte {
+	if len(src) < 16 {
+		return TransCodePartial(nil, src)
+	}
+
+	dst := make([]byte, len(src))
+	header := TransCodePartial(nil, src[:16])
+	copy(dst, header)
+
+	if len(src) > 16 {
+		if src[3]&1 != 0 { // Partial encryption
+			remaining := len(src) - 16
+			encryptLen := min(remaining, 48)
+			if encryptLen > 0 {
+				encrypted := TransCodePartial(nil, src[16:16+encryptLen])
+				copy(dst[16:], encrypted)
+			}
+			if remaining > 48 {
+				copy(dst[64:], src[64:])
+			}
+		} else { // Full encryption
+			encrypted := TransCodePartial(nil, src[16:])
+			copy(dst[16:], encrypted)
+		}
+	}
+	return dst
+}
+
+func swap(dst, src []byte, n int) {
+	switch n {
+	case 2:
+		_, _ = src[1], dst[1]
+		dst[0] = src[1]
+		dst[1] = src[0]
+		return
+	case 4:
+		_, _ = src[3], dst[3]
+		dst[0] = src[2]
+		dst[1] = src[3]
+		dst[2] = src[0]
+		dst[3] = src[1]
+		return
+	case 8:
+		_, _ = src[7], dst[7]
+		dst[0] = src[7]
+		dst[1] = src[4]
+		dst[2] = src[3]
+		dst[3] = src[2]
+		dst[4] = src[1]
+		dst[5] = src[6]
+		dst[6] = src[5]
+		dst[7] = src[0]
+		return
+	case 16:
+		_, _ = src[15], dst[15]
+		dst[0] = src[11]
+		dst[1] = src[9]
+		dst[2] = src[8]
+		dst[3] = src[15]
+		dst[4] = src[13]
+		dst[5] = src[10]
+		dst[6] = src[12]
+		dst[7] = src[14]
+		dst[8] = src[2]
+		dst[9] = src[1]
+		dst[10] = src[5]
+		dst[11] = src[0]
+		dst[12] = src[6]
+		dst[13] = src[4]
+		dst[14] = src[7]
+		dst[15] = src[3]
+		return
+	}
+	copy(dst, src[:n])
+}
+
+const delta = 0x9e3779b9
+
+func XXTEADecrypt(dst, src, key []byte) {
+	const n = int8(4) // support only 16 bytes src
+
+	var w, k [n]uint32
+	for i := int8(0); i < n; i++ {
+		w[i] = binary.LittleEndian.Uint32(src)
+		k[i] = binary.LittleEndian.Uint32(key)
+		src = src[4:]
+		key = key[4:]
+	}
+
+	rounds := 52/n + 6
+	sum := uint32(rounds) * delta
+	for ; rounds > 0; rounds-- {
+		w0 := w[0]
+		i2 := int8((sum >> 2) & 3)
+		for i := n - 1; i >= 0; i-- {
+			wi := w[(i-1)&3]
+			ki := k[i^i2]
+			t1 := (w0 ^ sum) + (wi ^ ki)
+			t2 := (wi >> 5) ^ (w0 << 2)
+			t3 := (w0 >> 3) ^ (wi << 4)
+			w[i] -= t1 ^ (t2 + t3)
+			w0 = w[i]
+		}
+		sum -= delta
+	}
+
+	for _, i := range w {
+		binary.LittleEndian.PutUint32(dst, i)
+		dst = dst[4:]
+	}
+}
+
+func XXTEADecryptVar(data, key []byte) []byte {
+	if len(data) < 8 || len(key) < 16 {
+		return nil
+	}
+
+	k := make([]uint32, 4)
+	for i := range 4 {
+		k[i] = binary.LittleEndian.Uint32(key[i*4:])
+	}
+
+	n := max(len(data)/4, 2)
+	v := make([]uint32, n)
+	for i := 0; i < len(data)/4; i++ {
+		v[i] = binary.LittleEndian.Uint32(data[i*4:])
+	}
+
+	rounds := 6 + 52/n
+	sum := uint32(rounds) * delta
+	y := v[0]
+
+	for rounds > 0 {
+		e := (sum >> 2) & 3
+		for p := n - 1; p > 0; p-- {
+			z := v[p-1]
+			v[p] -= xxteaMX(sum, y, z, p, e, k)
+			y = v[p]
+		}
+		z := v[n-1]
+		v[0] -= xxteaMX(sum, y, z, 0, e, k)
+		y = v[0]
+		sum -= delta
+		rounds--
+	}
+
+	result := make([]byte, n*4)
+	for i := range n {
+		binary.LittleEndian.PutUint32(result[i*4:], v[i])
+	}
+
+	return result[:len(data)]
+}
+
+func xxteaMX(sum, y, z uint32, p int, e uint32, k []uint32) uint32 {
+	return ((z>>5 ^ y<<2) + (y>>3 ^ z<<4)) ^ ((sum ^ y) + (k[(p&3)^int(e)] ^ z))
+}
diff --git a/installs_on_host/go2rtc/pkg/tutk/crypto_test.go b/installs_on_host/go2rtc/pkg/tutk/crypto_test.go
new file mode 100644
index 0000000..1f1be3f
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tutk/crypto_test.go
@@ -0,0 +1,14 @@
+package tutk
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestXXTEADecrypt(t *testing.T) {
+	buf := []byte("WERhJxb87WF3zgPa")
+	key := []byte("GAgDiwVPg2E4GMke")
+	XXTEADecrypt(buf, buf, key)
+	require.Equal(t, "\xc4\xa6\x2c\xa1\x10\x64\x17\xa5\xda\x02\xe1\x62\xa5\xf0\x62\x71", string(buf))
+}
diff --git a/installs_on_host/go2rtc/pkg/tutk/dtls/auth.go b/installs_on_host/go2rtc/pkg/tutk/dtls/auth.go
new file mode 100644
index 0000000..7354428
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tutk/dtls/auth.go
@@ -0,0 +1,35 @@
+package dtls
+
+import (
+	"crypto/sha256"
+	"encoding/base64"
+	"strings"
+)
+
+func CalculateAuthKey(enr, mac string) []byte {
+	data := enr + strings.ToUpper(mac)
+	hash := sha256.Sum256([]byte(data))
+	b64 := base64.StdEncoding.EncodeToString(hash[:6])
+	b64 = strings.ReplaceAll(b64, "+", "Z")
+	b64 = strings.ReplaceAll(b64, "/", "9")
+	b64 = strings.ReplaceAll(b64, "=", "A")
+	return []byte(b64)
+}
+
+func DerivePSK(enr string) []byte {
+	// DerivePSK derives the DTLS PSK from ENR
+	// TUTK SDK treats the PSK as a NULL-terminated C string, so if SHA256(ENR)
+	// contains a 0x00 byte, the PSK is truncated at that position.
+	hash := sha256.Sum256([]byte(enr))
+	pskLen := 32
+	for i := range 32 {
+		if hash[i] == 0x00 {
+			pskLen = i
+			break
+		}
+	}
+
+	psk := make([]byte, 32)
+	copy(psk[:pskLen], hash[:pskLen])
+	return psk
+}
diff --git a/installs_on_host/go2rtc/pkg/tutk/dtls/cipher.go b/installs_on_host/go2rtc/pkg/tutk/dtls/cipher.go
new file mode 100644
index 0000000..e987ff8
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tutk/dtls/cipher.go
@@ -0,0 +1,218 @@
+package dtls
+
+import (
+	"crypto/cipher"
+	"crypto/sha256"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"hash"
+	"sync/atomic"
+
+	"github.com/pion/dtls/v3"
+	"github.com/pion/dtls/v3/pkg/crypto/clientcertificate"
+	"github.com/pion/dtls/v3/pkg/crypto/prf"
+	"github.com/pion/dtls/v3/pkg/protocol"
+	"github.com/pion/dtls/v3/pkg/protocol/recordlayer"
+	"golang.org/x/crypto/chacha20poly1305"
+)
+
+const CipherSuiteID_CCAC dtls.CipherSuiteID = 0xCCAC
+
+const (
+	chachaTagLength   = 16
+	chachaNonceLength = 12
+)
+
+var (
+	errDecryptPacket      = &protocol.TemporaryError{Err: errors.New("failed to decrypt packet")}
+	errCipherSuiteNotInit = &protocol.TemporaryError{Err: errors.New("CipherSuite not initialized")}
+)
+
+type ChaCha20Poly1305Cipher struct {
+	localCipher, remoteCipher   cipher.AEAD
+	localWriteIV, remoteWriteIV []byte
+}
+
+func NewChaCha20Poly1305Cipher(localKey, localWriteIV, remoteKey, remoteWriteIV []byte) (*ChaCha20Poly1305Cipher, error) {
+	localCipher, err := chacha20poly1305.New(localKey)
+	if err != nil {
+		return nil, err
+	}
+
+	remoteCipher, err := chacha20poly1305.New(remoteKey)
+	if err != nil {
+		return nil, err
+	}
+
+	return &ChaCha20Poly1305Cipher{
+		localCipher:   localCipher,
+		localWriteIV:  localWriteIV,
+		remoteCipher:  remoteCipher,
+		remoteWriteIV: remoteWriteIV,
+	}, nil
+}
+
+func generateAEADAdditionalData(h *recordlayer.Header, payloadLen int) []byte {
+	var additionalData [13]byte
+
+	binary.BigEndian.PutUint64(additionalData[:], h.SequenceNumber)
+	binary.BigEndian.PutUint16(additionalData[:], h.Epoch)
+	additionalData[8] = byte(h.ContentType)
+	additionalData[9] = h.Version.Major
+	additionalData[10] = h.Version.Minor
+	binary.BigEndian.PutUint16(additionalData[11:], uint16(payloadLen))
+
+	return additionalData[:]
+}
+
+func computeNonce(iv []byte, epoch uint16, sequenceNumber uint64) []byte {
+	nonce := make([]byte, chachaNonceLength)
+
+	binary.BigEndian.PutUint64(nonce[4:], sequenceNumber)
+	binary.BigEndian.PutUint16(nonce[4:], epoch)
+
+	for i := range chachaNonceLength {
+		nonce[i] ^= iv[i]
+	}
+
+	return nonce
+}
+
+func (c *ChaCha20Poly1305Cipher) Encrypt(pkt *recordlayer.RecordLayer, raw []byte) ([]byte, error) {
+	payload := raw[pkt.Header.Size():]
+	raw = raw[:pkt.Header.Size()]
+
+	nonce := computeNonce(c.localWriteIV, pkt.Header.Epoch, pkt.Header.SequenceNumber)
+	additionalData := generateAEADAdditionalData(&pkt.Header, len(payload))
+	encryptedPayload := c.localCipher.Seal(nil, nonce, payload, additionalData)
+
+	r := make([]byte, len(raw)+len(encryptedPayload))
+	copy(r, raw)
+	copy(r[len(raw):], encryptedPayload)
+
+	binary.BigEndian.PutUint16(r[pkt.Header.Size()-2:], uint16(len(r)-pkt.Header.Size()))
+
+	return r, nil
+}
+
+func (c *ChaCha20Poly1305Cipher) Decrypt(header recordlayer.Header, in []byte) ([]byte, error) {
+	err := header.Unmarshal(in)
+	switch {
+	case err != nil:
+		return nil, err
+	case header.ContentType == protocol.ContentTypeChangeCipherSpec:
+		return in, nil
+	case len(in) <= header.Size()+chachaTagLength:
+		return nil, fmt.Errorf("ciphertext too short: %d <= %d", len(in), header.Size()+chachaTagLength)
+	}
+
+	nonce := computeNonce(c.remoteWriteIV, header.Epoch, header.SequenceNumber)
+	out := in[header.Size():]
+	additionalData := generateAEADAdditionalData(&header, len(out)-chachaTagLength)
+
+	out, err = c.remoteCipher.Open(out[:0], nonce, out, additionalData)
+	if err != nil {
+		return nil, fmt.Errorf("%w: %v", errDecryptPacket, err)
+	}
+
+	return append(in[:header.Size()], out...), nil
+}
+
+type TLSEcdhePskWithChacha20Poly1305Sha256 struct {
+	aead atomic.Value
+}
+
+func NewTLSEcdhePskWithChacha20Poly1305Sha256() *TLSEcdhePskWithChacha20Poly1305Sha256 {
+	return &TLSEcdhePskWithChacha20Poly1305Sha256{}
+}
+
+func (c *TLSEcdhePskWithChacha20Poly1305Sha256) CertificateType() clientcertificate.Type {
+	return clientcertificate.Type(0)
+}
+
+func (c *TLSEcdhePskWithChacha20Poly1305Sha256) KeyExchangeAlgorithm() dtls.CipherSuiteKeyExchangeAlgorithm {
+	return dtls.CipherSuiteKeyExchangeAlgorithmPsk | dtls.CipherSuiteKeyExchangeAlgorithmEcdhe
+}
+
+func (c *TLSEcdhePskWithChacha20Poly1305Sha256) ECC() bool {
+	return true
+}
+
+func (c *TLSEcdhePskWithChacha20Poly1305Sha256) ID() dtls.CipherSuiteID {
+	return CipherSuiteID_CCAC
+}
+
+func (c *TLSEcdhePskWithChacha20Poly1305Sha256) String() string {
+	return "TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256"
+}
+
+func (c *TLSEcdhePskWithChacha20Poly1305Sha256) HashFunc() func() hash.Hash {
+	return sha256.New
+}
+
+func (c *TLSEcdhePskWithChacha20Poly1305Sha256) AuthenticationType() dtls.CipherSuiteAuthenticationType {
+	return dtls.CipherSuiteAuthenticationTypePreSharedKey
+}
+
+func (c *TLSEcdhePskWithChacha20Poly1305Sha256) IsInitialized() bool {
+	return c.aead.Load() != nil
+}
+
+func (c *TLSEcdhePskWithChacha20Poly1305Sha256) Init(masterSecret, clientRandom, serverRandom []byte, isClient bool) error {
+	const (
+		prfMacLen = 0
+		prfKeyLen = 32
+		prfIvLen  = 12
+	)
+
+	keys, err := prf.GenerateEncryptionKeys(
+		masterSecret, clientRandom, serverRandom,
+		prfMacLen, prfKeyLen, prfIvLen,
+		c.HashFunc(),
+	)
+	if err != nil {
+		return err
+	}
+
+	var aead *ChaCha20Poly1305Cipher
+	if isClient {
+		aead, err = NewChaCha20Poly1305Cipher(
+			keys.ClientWriteKey, keys.ClientWriteIV,
+			keys.ServerWriteKey, keys.ServerWriteIV,
+		)
+	} else {
+		aead, err = NewChaCha20Poly1305Cipher(
+			keys.ServerWriteKey, keys.ServerWriteIV,
+			keys.ClientWriteKey, keys.ClientWriteIV,
+		)
+	}
+	if err != nil {
+		return err
+	}
+
+	c.aead.Store(aead)
+	return nil
+}
+
+func (c *TLSEcdhePskWithChacha20Poly1305Sha256) Encrypt(pkt *recordlayer.RecordLayer, raw []byte) ([]byte, error) {
+	aead, ok := c.aead.Load().(*ChaCha20Poly1305Cipher)
+	if !ok {
+		return nil, fmt.Errorf("%w: unable to encrypt", errCipherSuiteNotInit)
+	}
+	return aead.Encrypt(pkt, raw)
+}
+
+func (c *TLSEcdhePskWithChacha20Poly1305Sha256) Decrypt(h recordlayer.Header, raw []byte) ([]byte, error) {
+	aead, ok := c.aead.Load().(*ChaCha20Poly1305Cipher)
+	if !ok {
+		return nil, fmt.Errorf("%w: unable to decrypt", errCipherSuiteNotInit)
+	}
+	return aead.Decrypt(h, raw)
+}
+
+func CustomCipherSuites() []dtls.CipherSuite {
+	return []dtls.CipherSuite{
+		NewTLSEcdhePskWithChacha20Poly1305Sha256(),
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/tutk/dtls/conn_dtls.go b/installs_on_host/go2rtc/pkg/tutk/dtls/conn_dtls.go
new file mode 100644
index 0000000..c1d5f6c
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tutk/dtls/conn_dtls.go
@@ -0,0 +1,987 @@
+package dtls
+
+import (
+	"context"
+	"crypto/hmac"
+	"crypto/sha1"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"net"
+	"sync"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/tutk"
+	"github.com/pion/dtls/v3"
+)
+
+const (
+	magicCC51    = "\x51\xcc"         // (wyze specific?)
+	sdkVersion42 = "\x01\x01\x02\x04" // 4.2.1.1
+	sdkVersion43 = "\x00\x08\x03\x04" // 4.3.8.0
+)
+
+const (
+	cmdDiscoReq     uint16 = 0x0601
+	cmdDiscoRes     uint16 = 0x0602
+	cmdSessionReq   uint16 = 0x0402
+	cmdSessionRes   uint16 = 0x0404
+	cmdDataTX       uint16 = 0x0407
+	cmdDataRX       uint16 = 0x0408
+	cmdKeepaliveReq uint16 = 0x0427
+	cmdKeepaliveRes uint16 = 0x0428
+
+	headerSize    = 16
+	discoBodySize = 72
+	discoSize     = headerSize + discoBodySize
+	sessionBody   = 36
+	sessionSize   = headerSize + sessionBody
+)
+
+const (
+	cmdDiscoCC51      uint16 = 0x1002
+	cmdKeepaliveCC51  uint16 = 0x1202
+	cmdDTLSCC51       uint16 = 0x1502
+	payloadSizeCC51   uint16 = 0x0028
+	packetSizeCC51           = 52
+	headerSizeCC51           = 28
+	authSizeCC51             = 20
+	keepaliveSizeCC51        = 48
+)
+
+const (
+	magicAVLoginResp uint16 = 0x2100
+	magicIOCtrl      uint16 = 0x7000
+	magicChannelMsg  uint16 = 0x1000
+	magicACK         uint16 = 0x0009
+	magicAVLogin1    uint16 = 0x0000
+	magicAVLogin2    uint16 = 0x2000
+)
+
+const (
+	protoVersion uint16 = 0x000c
+	defaultCaps  uint32 = 0x001f07fb
+)
+
+const (
+	iotcChannelMain = 0 // Main AV (we = DTLS Client)
+	iotcChannelBack = 1 // Backchannel (we = DTLS Server)
+)
+
+type DTLSConn struct {
+	conn    *net.UDPConn
+	addr    *net.UDPAddr
+	frames  *tutk.FrameHandler
+	err     error
+	verbose bool
+	ctx     context.Context
+	cancel  context.CancelFunc
+	wg      sync.WaitGroup
+	mu      sync.RWMutex
+
+	// DTLS
+	clientConn *dtls.Conn
+	serverConn *dtls.Conn
+	clientBuf  chan []byte
+	serverBuf  chan []byte
+	rawCmd     chan []byte
+
+	// Identity
+	uid     string
+	authKey string
+	enr     string
+	psk     []byte
+
+	// Session
+	sid                []byte
+	ticket             uint16
+	hasTwoWayStreaming bool
+
+	// Protocol
+	isCC51       bool
+	seq          uint16
+	seqCmd       uint16
+	avSeq        uint32
+	kaSeq        uint32
+	audioSeq     uint32
+	audioFrameNo uint32
+
+	// Ack
+	ackFlags   uint16
+	rxSeqStart uint16
+	rxSeqEnd   uint16
+	rxSeqInit  bool
+	cmdAck     func()
+}
+
+func DialDTLS(host string, port int, uid, authKey, enr string, verbose bool) (*DTLSConn, error) {
+	udp, err := net.ListenUDP("udp", nil)
+	if err != nil {
+		return nil, err
+	}
+
+	_ = udp.SetReadBuffer(2 * 1024 * 1024)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	psk := DerivePSK(enr)
+
+	if port == 0 {
+		port = 32761
+	}
+
+	c := &DTLSConn{
+		conn:       udp,
+		addr:       &net.UDPAddr{IP: net.ParseIP(host), Port: port},
+		uid:        uid,
+		authKey:    authKey,
+		enr:        enr,
+		psk:        psk,
+		verbose:    verbose,
+		ctx:        ctx,
+		cancel:     cancel,
+		rxSeqStart: 0xffff,
+		rxSeqEnd:   0xffff,
+	}
+
+	if err = c.discovery(); err != nil {
+		_ = c.Close()
+		return nil, err
+	}
+
+	c.clientBuf = make(chan []byte, 64)
+	c.serverBuf = make(chan []byte, 64)
+	c.rawCmd = make(chan []byte, 16)
+	c.frames = tutk.NewFrameHandler(c.verbose)
+
+	c.wg.Add(1)
+	go c.reader()
+
+	if err = c.connect(); err != nil {
+		_ = c.Close()
+		return nil, err
+	}
+
+	c.wg.Add(1)
+	go c.worker()
+
+	return c, nil
+}
+
+func (c *DTLSConn) AVClientStart(timeout time.Duration) error {
+	randomID := tutk.GenSessionID()
+	pkt1 := c.msgAVLogin(magicAVLogin1, 570, 0x0001, randomID)
+	pkt2 := c.msgAVLogin(magicAVLogin2, 572, 0x0000, randomID)
+	pkt2[20]++ // pkt2 has randomID incremented by 1
+
+	if _, err := c.clientConn.Write(pkt1); err != nil {
+		return fmt.Errorf("av login 1 failed: %w", err)
+	}
+
+	time.Sleep(10 * time.Millisecond)
+
+	if _, err := c.clientConn.Write(pkt2); err != nil {
+		return fmt.Errorf("av login 2 failed: %w", err)
+	}
+
+	// Wait for response
+	timer := time.NewTimer(timeout)
+	defer timer.Stop()
+	for {
+		select {
+		case data, ok := <-c.rawCmd:
+			if !ok {
+				return io.EOF
+			}
+			if len(data) >= 32 && binary.LittleEndian.Uint16(data) == magicAVLoginResp {
+				c.hasTwoWayStreaming = data[31] == 1
+
+				ack := c.msgACK()
+				c.clientConn.Write(ack)
+
+				// Start ACK sender for continuous streaming
+				c.wg.Add(1)
+				go func() {
+					defer c.wg.Done()
+					ackTicker := time.NewTicker(100 * time.Millisecond)
+					defer ackTicker.Stop()
+
+					for {
+						select {
+						case <-c.ctx.Done():
+							return
+						case <-ackTicker.C:
+							if c.clientConn != nil {
+								ack := c.msgACK()
+								c.clientConn.Write(ack)
+							}
+						}
+					}
+				}()
+
+				return nil
+			}
+		case <-timer.C:
+			return context.DeadlineExceeded
+		}
+	}
+}
+
+func (c *DTLSConn) AVServStart() error {
+	conn, err := NewDTLSServer(c.ctx, iotcChannelBack, c.addr, c.WriteDTLS, c.serverBuf, c.psk)
+	if err != nil {
+		return fmt.Errorf("dtls: server handshake failed: %w", err)
+	}
+
+	if c.verbose {
+		fmt.Printf("[DTLS] Server handshake complete on channel %d\n", iotcChannelBack)
+		fmt.Printf("[SERVER] Waiting for AV Login request from camera...\n")
+	}
+
+	// Wait for AV Login request from camera
+	buf := make([]byte, 1024)
+	conn.SetReadDeadline(time.Now().Add(5 * time.Second))
+	n, err := conn.Read(buf)
+	if err != nil {
+		go conn.Close()
+		return fmt.Errorf("read av login: %w", err)
+	}
+
+	if c.verbose {
+		fmt.Printf("[SERVER] AV Login request len=%d data:\n%s", n, hexDump(buf[:n]))
+	}
+
+	if n < 24 {
+		go conn.Close()
+		return fmt.Errorf("av login too short: %d bytes", n)
+	}
+
+	checksum := binary.LittleEndian.Uint32(buf[20:])
+	resp := c.msgAVLoginResponse(checksum)
+
+	if c.verbose {
+		fmt.Printf("[SERVER] Sending AV Login response: %d bytes\n", len(resp))
+	}
+
+	if _, err = conn.Write(resp); err != nil {
+		go conn.Close()
+		return fmt.Errorf("write av login response: %w", err)
+	}
+
+	if c.verbose {
+		fmt.Printf("[SERVER] AV Login response sent, waiting for possible resend...\n")
+	}
+
+	// Camera may resend, respond again
+	conn.SetReadDeadline(time.Now().Add(500 * time.Millisecond))
+	if n, _ = conn.Read(buf); n > 0 {
+		if c.verbose {
+			fmt.Printf("[SERVER] Received AV Login resend: %d bytes\n", n)
+		}
+		conn.Write(resp)
+	}
+
+	conn.SetReadDeadline(time.Time{})
+
+	if c.verbose {
+		fmt.Printf("[SERVER] AV Login complete, ready for two way streaming\n")
+	}
+
+	c.mu.Lock()
+	c.serverConn = conn
+	c.mu.Unlock()
+
+	return nil
+}
+
+func (c *DTLSConn) AVServStop() error {
+	c.mu.Lock()
+	serverConn := c.serverConn
+	c.serverConn = nil
+
+	// Reset audio TX state
+	c.audioSeq = 0
+	c.audioFrameNo = 0
+	c.mu.Unlock()
+
+	if serverConn == nil {
+		return nil
+	}
+
+	go serverConn.Close()
+
+	return nil
+}
+
+func (c *DTLSConn) AVRecvFrameData() (*tutk.Packet, error) {
+	select {
+	case pkt, ok := <-c.frames.Recv():
+		if !ok {
+			return nil, c.Error()
+		}
+		return pkt, nil
+	case <-c.ctx.Done():
+		return nil, c.Error()
+	}
+}
+
+func (c *DTLSConn) AVSendAudioData(codec byte, payload []byte, timestampUS uint32, sampleRate uint32, channels uint8) error {
+	c.mu.Lock()
+	conn := c.serverConn
+	if conn == nil {
+		c.mu.Unlock()
+		return fmt.Errorf("av server not ready")
+	}
+
+	frame := c.msgAudioFrame(payload, timestampUS, codec, sampleRate, channels)
+
+	c.mu.Unlock()
+
+	n, err := conn.Write(frame)
+	if c.verbose {
+		if err != nil {
+			fmt.Printf("[SERVER TX] DTLS Write ERROR: %v\n", err)
+		} else {
+			fmt.Printf("[SERVER TX] len=%d, data:\n%s", n, hexDump(frame))
+		}
+	}
+	return err
+}
+
+func (c *DTLSConn) Write(data []byte) error {
+	if c.isCC51 {
+		_, err := c.conn.WriteToUDP(data, c.addr)
+		return err
+	}
+	_, err := c.conn.WriteToUDP(tutk.TransCodeBlob(data), c.addr)
+	return err
+}
+
+func (c *DTLSConn) WriteDTLS(payload []byte, channel byte) error {
+	var frame []byte
+	if c.isCC51 {
+		frame = c.msgTxDataCC51(payload, channel)
+	} else {
+		frame = c.msgTxData(payload, channel)
+	}
+
+	return c.Write(frame)
+}
+
+func (c *DTLSConn) WriteIOCtrl(payload []byte) error {
+	_, err := c.conn.Write(c.msgIOCtrl(payload))
+	return err
+}
+
+func (c *DTLSConn) WriteAndWait(req []byte, ok func(res []byte) bool) ([]byte, error) {
+	var t *time.Timer
+	t = time.AfterFunc(1, func() {
+		if err := c.Write(req); err == nil && t != nil {
+			t.Reset(time.Second)
+		}
+	})
+	defer t.Stop()
+
+	_ = c.conn.SetDeadline(time.Now().Add(5 * time.Second))
+	defer c.conn.SetDeadline(time.Time{})
+
+	buf := make([]byte, 2048)
+	for {
+		n, addr, err := c.conn.ReadFromUDP(buf)
+		if err != nil {
+			return nil, err
+		}
+		if string(addr.IP) != string(c.addr.IP) || n < 16 {
+			continue
+		}
+
+		var res []byte
+		if c.isCC51 {
+			res = buf[:n]
+		} else {
+			res = tutk.ReverseTransCodeBlob(buf[:n])
+		}
+
+		if ok(res) {
+			c.addr.Port = addr.Port
+			return res, nil
+		}
+	}
+}
+
+func (c *DTLSConn) WriteAndWaitIOCtrl(payload []byte, match func([]byte) bool, timeout time.Duration) ([]byte, error) {
+	frame := c.msgIOCtrl(payload)
+	var t *time.Timer
+	t = time.AfterFunc(1, func() {
+		c.mu.RLock()
+		conn := c.clientConn
+		c.mu.RUnlock()
+		if conn != nil {
+			if _, err := conn.Write(frame); err == nil && t != nil {
+				t.Reset(time.Second)
+			}
+		}
+	})
+	defer t.Stop()
+
+	timer := time.NewTimer(timeout)
+	defer timer.Stop()
+
+	for {
+		select {
+		case data, ok := <-c.rawCmd:
+			if !ok {
+				return nil, io.EOF
+			}
+
+			ack := c.msgACK()
+			c.clientConn.Write(ack)
+
+			if match(data) {
+				return data, nil
+			}
+		case <-timer.C:
+			return nil, fmt.Errorf("timeout waiting for response")
+		}
+	}
+}
+
+func (c *DTLSConn) HasTwoWayStreaming() bool {
+	return c.hasTwoWayStreaming
+}
+
+func (c *DTLSConn) IsBackchannelReady() bool {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	return c.serverConn != nil
+}
+
+func (c *DTLSConn) RemoteAddr() *net.UDPAddr {
+	return c.addr
+}
+
+func (c *DTLSConn) LocalAddr() *net.UDPAddr {
+	return c.conn.LocalAddr().(*net.UDPAddr)
+}
+
+func (c *DTLSConn) SetDeadline(t time.Time) error {
+	return c.conn.SetDeadline(t)
+}
+
+func (c *DTLSConn) Close() error {
+	c.cancel()
+
+	c.mu.Lock()
+	if conn := c.serverConn; conn != nil {
+		c.serverConn = nil
+		go conn.Close()
+	}
+	if conn := c.clientConn; conn != nil {
+		c.clientConn = nil
+		go conn.Close()
+	}
+	if c.frames != nil {
+		c.frames.Close()
+	}
+	c.mu.Unlock()
+
+	c.wg.Wait()
+
+	return c.conn.Close()
+}
+
+func (c *DTLSConn) Error() error {
+	if c.err != nil {
+		return c.err
+	}
+	return io.EOF
+}
+
+func (c *DTLSConn) discovery() error {
+	c.sid = tutk.GenSessionID()
+
+	pktIOTC := tutk.TransCodeBlob(c.msgDisco(1))
+	pktCC51 := c.msgDiscoCC51(0, 0, false)
+
+	buf := make([]byte, 2048)
+	deadline := time.Now().Add(5 * time.Second)
+
+	for time.Now().Before(deadline) {
+		c.conn.WriteToUDP(pktIOTC, c.addr)
+		c.conn.WriteToUDP(pktCC51, c.addr)
+
+		c.conn.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
+		n, addr, err := c.conn.ReadFromUDP(buf)
+		if err != nil {
+			continue
+		}
+		if !addr.IP.Equal(c.addr.IP) {
+			continue
+		}
+
+		// CC51 protocol
+		if n >= packetSizeCC51 && string(buf[:2]) == magicCC51 {
+			if binary.LittleEndian.Uint16(buf[4:]) == cmdDiscoCC51 {
+				c.addr, c.isCC51, c.ticket = addr, true, binary.LittleEndian.Uint16(buf[14:])
+				if n >= 24 {
+					copy(c.sid, buf[16:24])
+				}
+				return c.discoDoneCC51()
+			}
+			continue
+		}
+
+		// IOTC Protocol (Basis)
+		data := tutk.ReverseTransCodeBlob(buf[:n])
+		if len(data) >= 16 && binary.LittleEndian.Uint16(data[8:]) == cmdDiscoRes {
+			c.addr, c.isCC51 = addr, false
+			return c.discoDone()
+		}
+	}
+
+	return fmt.Errorf("discovery timeout")
+}
+
+func (c *DTLSConn) discoDone() error {
+	c.Write(c.msgDisco(2))
+	time.Sleep(100 * time.Millisecond)
+	_, err := c.WriteAndWait(c.msgSession(), func(res []byte) bool {
+		return len(res) >= 16 && binary.LittleEndian.Uint16(res[8:]) == cmdSessionRes
+	})
+	return err
+}
+
+func (c *DTLSConn) discoDoneCC51() error {
+	_, err := c.WriteAndWait(c.msgDiscoCC51(2, c.ticket, false), func(res []byte) bool {
+		if len(res) < packetSizeCC51 || string(res[:2]) != magicCC51 {
+			return false
+		}
+		cmd := binary.LittleEndian.Uint16(res[4:])
+		dir := binary.LittleEndian.Uint16(res[8:])
+		seq := binary.LittleEndian.Uint16(res[12:])
+		return cmd == cmdDiscoCC51 && dir == 0xFFFF && seq == 3
+	})
+	return err
+}
+
+func (c *DTLSConn) connect() error {
+	conn, err := NewDTLSClient(c.ctx, iotcChannelMain, c.addr, c.WriteDTLS, c.clientBuf, c.psk)
+	if err != nil {
+		return fmt.Errorf("dtls: client handshake failed: %w", err)
+	}
+
+	c.mu.Lock()
+	c.clientConn = conn
+	c.mu.Unlock()
+
+	if c.verbose {
+		fmt.Printf("[DTLS] Client handshake complete on channel %d\n", iotcChannelMain)
+	}
+
+	return nil
+}
+
+func (c *DTLSConn) worker() {
+	defer c.wg.Done()
+
+	buf := make([]byte, 2048)
+
+	for {
+		select {
+		case <-c.ctx.Done():
+			return
+		default:
+		}
+
+		n, err := c.clientConn.Read(buf)
+		if err != nil {
+			c.err = err
+			return
+		}
+
+		if n < 2 {
+			continue
+		}
+
+		data := buf[:n]
+		magic := binary.LittleEndian.Uint16(data)
+
+		if c.verbose {
+			fmt.Printf("[DTLS RX] magic=0x%04x len=%d\n", magic, n)
+		}
+
+		switch magic {
+		case magicAVLoginResp:
+			c.queue(c.rawCmd, data)
+
+		case magicIOCtrl, magicChannelMsg:
+			c.queue(c.rawCmd, data)
+
+		case protoVersion:
+			// Seq-Tracking
+			if len(data) >= 8 {
+				seq := binary.LittleEndian.Uint16(data[4:])
+				if !c.rxSeqInit {
+					c.rxSeqInit = true
+				}
+				if seq > c.rxSeqEnd || c.rxSeqEnd == 0xffff {
+					c.rxSeqEnd = seq
+				}
+			}
+			c.queue(c.rawCmd, data)
+
+		case magicACK:
+			c.mu.RLock()
+			ack := c.cmdAck
+			c.mu.RUnlock()
+			if ack != nil {
+				ack()
+			}
+
+		default:
+			channel := data[0]
+			if channel == tutk.ChannelAudio || channel == tutk.ChannelIVideo || channel == tutk.ChannelPVideo {
+				c.frames.Handle(data)
+			}
+		}
+	}
+}
+
+func (c *DTLSConn) reader() {
+	defer c.wg.Done()
+
+	buf := make([]byte, 2048)
+
+	for {
+		select {
+		case <-c.ctx.Done():
+			return
+		default:
+		}
+
+		c.conn.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
+		n, addr, err := c.conn.ReadFromUDP(buf)
+		if err != nil {
+			if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
+				continue
+			}
+			return
+		}
+
+		if !addr.IP.Equal(c.addr.IP) {
+			if c.verbose {
+				fmt.Printf("Ignored packet from unknown IP: %s\n", addr.IP.String())
+			}
+			continue
+		}
+		if addr.Port != c.addr.Port {
+			c.addr.Port = addr.Port
+		}
+
+		// CC51 Protocol
+		if c.isCC51 && n >= 12 && string(buf[:2]) == magicCC51 {
+			cmd := binary.LittleEndian.Uint16(buf[4:])
+			switch cmd {
+			case cmdKeepaliveCC51:
+				if n >= keepaliveSizeCC51 {
+					_ = c.Write(c.msgKeepaliveCC51())
+				}
+			case cmdDTLSCC51:
+				if n >= headerSizeCC51+authSizeCC51 {
+					ch := byte(binary.LittleEndian.Uint16(buf[12:]) >> 8)
+					dtlsData := buf[headerSizeCC51 : n-authSizeCC51]
+					switch ch {
+					case iotcChannelMain:
+						c.queue(c.clientBuf, dtlsData)
+					case iotcChannelBack:
+						c.queue(c.serverBuf, dtlsData)
+					}
+				}
+			}
+			continue
+		}
+
+		// IOTC Protocol (Basis)
+		data := tutk.ReverseTransCodeBlob(buf[:n])
+		if len(data) < 16 {
+			continue
+		}
+
+		switch binary.LittleEndian.Uint16(data[8:]) {
+		case cmdKeepaliveRes:
+			if len(data) > 24 {
+				_ = c.Write(c.msgKeepalive(data[16:]))
+			}
+		case cmdDataRX:
+			if len(data) > 28 {
+				ch := data[14]
+				switch ch {
+				case iotcChannelMain:
+					c.queue(c.clientBuf, data[28:])
+				case iotcChannelBack:
+					c.queue(c.serverBuf, data[28:])
+				}
+			}
+		}
+	}
+}
+
+func (c *DTLSConn) queue(ch chan []byte, data []byte) {
+	b := make([]byte, len(data))
+	copy(b, data)
+	select {
+	case ch <- b:
+	default:
+		select {
+		case <-ch:
+		default:
+		}
+		ch <- b
+	}
+}
+
+func (c *DTLSConn) msgDisco(stage byte) []byte {
+	b := make([]byte, discoSize)
+	copy(b, "\x04\x02\x1a\x02")                         // marker + mode
+	binary.LittleEndian.PutUint16(b[4:], discoBodySize) // body size
+	binary.LittleEndian.PutUint16(b[8:], cmdDiscoReq)   // 0x0601
+	binary.LittleEndian.PutUint16(b[10:], 0x0021)       // flags
+	body := b[headerSize:]
+	copy(body[:20], c.uid)
+	copy(body[36:], sdkVersion42) // SDK 4.2.1.1
+	copy(body[40:], c.sid)
+	body[48] = stage
+	if stage == 1 && len(c.authKey) > 0 {
+		copy(body[58:], c.authKey)
+	}
+	return b
+}
+
+func (c *DTLSConn) msgDiscoCC51(seq, ticket uint16, isResponse bool) []byte {
+	b := make([]byte, packetSizeCC51)
+	copy(b[:2], magicCC51)
+	binary.LittleEndian.PutUint16(b[4:], cmdDiscoCC51)    // 0x1002
+	binary.LittleEndian.PutUint16(b[6:], payloadSizeCC51) // 40 bytes
+	if isResponse {
+		binary.LittleEndian.PutUint16(b[8:], 0xFFFF) // response
+	}
+	binary.LittleEndian.PutUint16(b[12:], seq)
+	binary.LittleEndian.PutUint16(b[14:], ticket)
+	copy(b[16:24], c.sid)
+	copy(b[24:28], sdkVersion43) // SDK 4.3.8.0
+	b[28] = 0x1d                 // unknown field (capability/build flag?)
+	h := hmac.New(sha1.New, append([]byte(c.uid), c.authKey...))
+	h.Write(b[:32])
+	copy(b[32:52], h.Sum(nil))
+	return b
+}
+
+func (c *DTLSConn) msgKeepaliveCC51() []byte {
+	c.kaSeq += 2
+	b := make([]byte, keepaliveSizeCC51)
+	copy(b[:2], magicCC51)
+	binary.LittleEndian.PutUint16(b[4:], cmdKeepaliveCC51) // 0x1202
+	binary.LittleEndian.PutUint16(b[6:], 0x0024)           // 36 bytes payload
+	binary.LittleEndian.PutUint32(b[16:], c.kaSeq)         // counter
+	copy(b[20:28], c.sid)                                  // session ID
+	h := hmac.New(sha1.New, append([]byte(c.uid), c.authKey...))
+	h.Write(b[:28])
+	copy(b[28:48], h.Sum(nil))
+	return b
+}
+
+func (c *DTLSConn) msgSession() []byte {
+	b := make([]byte, sessionSize)
+	copy(b, "\x04\x02\x1a\x02")                         // marker + mode
+	binary.LittleEndian.PutUint16(b[4:], sessionBody)   // body size
+	binary.LittleEndian.PutUint16(b[8:], cmdSessionReq) // 0x0402
+	binary.LittleEndian.PutUint16(b[10:], 0x0033)       // flags
+	body := b[headerSize:]
+	copy(body[:20], c.uid)
+	copy(body[20:], c.sid)
+	binary.LittleEndian.PutUint32(body[32:], uint32(time.Now().Unix()))
+	return b
+}
+
+func (c *DTLSConn) msgAVLogin(magic uint16, size int, flags uint16, randomID []byte) []byte {
+	b := make([]byte, size)
+	binary.LittleEndian.PutUint16(b, magic)
+	binary.LittleEndian.PutUint16(b[2:], protoVersion)
+	binary.LittleEndian.PutUint16(b[16:], uint16(size-24)) // payload size
+	binary.LittleEndian.PutUint16(b[18:], flags)
+	copy(b[20:], randomID[:4])
+	copy(b[24:], "admin")                               // username
+	copy(b[280:], c.enr)                                // password/ENR
+	binary.LittleEndian.PutUint32(b[540:], 4)           // security_mode ?
+	binary.LittleEndian.PutUint32(b[552:], defaultCaps) // capabilities
+	return b
+}
+
+func (c *DTLSConn) msgAVLoginResponse(checksum uint32) []byte {
+	b := make([]byte, 60)
+	binary.LittleEndian.PutUint16(b, 0x2100)        // magic
+	binary.LittleEndian.PutUint16(b[2:], 0x000c)    // version
+	b[4] = 0x10                                     // success
+	binary.LittleEndian.PutUint32(b[16:], 0x24)     // payload size
+	binary.LittleEndian.PutUint32(b[20:], checksum) // echo checksum
+	b[29] = 0x01                                    // enable flag
+	b[31] = 0x01                                    // two-way streaming
+	binary.LittleEndian.PutUint32(b[36:], 0x04)     // buffer config
+	binary.LittleEndian.PutUint32(b[40:], defaultCaps)
+	binary.LittleEndian.PutUint16(b[54:], 0x0003) // channel info
+	binary.LittleEndian.PutUint16(b[56:], 0x0002)
+	return b
+}
+
+func (c *DTLSConn) msgAudioFrame(payload []byte, timestampUS uint32, codec byte, sampleRate uint32, channels uint8) []byte {
+	c.audioSeq++
+	c.audioFrameNo++
+	prevFrame := uint32(0)
+	if c.audioFrameNo > 1 {
+		prevFrame = c.audioFrameNo - 1
+	}
+
+	totalPayload := len(payload) + 16 // payload + frameinfo
+	b := make([]byte, 36+totalPayload)
+
+	// Outer header (36 bytes)
+	b[0] = tutk.ChannelAudio      // 0x03
+	b[1] = tutk.FrameTypeStartAlt // 0x09
+	binary.LittleEndian.PutUint16(b[2:], protoVersion)
+	binary.LittleEndian.PutUint32(b[4:], c.audioSeq)
+	binary.LittleEndian.PutUint32(b[8:], timestampUS)
+	if c.audioFrameNo == 1 {
+		binary.LittleEndian.PutUint32(b[12:], 0x00000001)
+	} else {
+		binary.LittleEndian.PutUint32(b[12:], 0x00100001)
+	}
+
+	// Inner header
+	b[16] = tutk.ChannelAudio
+	b[17] = tutk.FrameTypeEndSingle
+	binary.LittleEndian.PutUint16(b[18:], uint16(prevFrame))
+	binary.LittleEndian.PutUint16(b[20:], 0x0001) // pkt_total
+	binary.LittleEndian.PutUint16(b[22:], 0x0010) // flags
+	binary.LittleEndian.PutUint32(b[24:], uint32(totalPayload))
+	binary.LittleEndian.PutUint32(b[28:], prevFrame)
+	binary.LittleEndian.PutUint32(b[32:], c.audioFrameNo)
+	copy(b[36:], payload) // Payload + FrameInfo
+	fi := b[36+len(payload):]
+	fi[0] = codec // Codec ID (low byte)
+	fi[1] = 0     // Codec ID (high byte, unused)
+	// Audio flags: [3:2]=sampleRateIdx [1]=16bit [0]=stereo
+	srIdx := tutk.GetSampleRateIndex(sampleRate)
+	fi[2] = (srIdx << 2) | 0x02 // 16-bit always set
+	if channels == 2 {
+		fi[2] |= 0x01
+	}
+	fi[4] = 1 // online
+	binary.LittleEndian.PutUint32(fi[12:], (c.audioFrameNo-1)*tutk.GetSamplesPerFrame(codec)*1000/sampleRate)
+	return b
+}
+
+func (c *DTLSConn) msgTxData(payload []byte, channel byte) []byte {
+	bodySize := 12 + len(payload)
+	b := make([]byte, 16+bodySize)
+	copy(b, "\x04\x02\x1a\x0b")                            // marker + mode=data
+	binary.LittleEndian.PutUint16(b[4:], uint16(bodySize)) // body size
+	binary.LittleEndian.PutUint16(b[6:], c.seq)            // sequence
+	c.seq++
+	binary.LittleEndian.PutUint16(b[8:], cmdDataTX)   // 0x0407
+	binary.LittleEndian.PutUint16(b[10:], 0x0021)     // flags
+	copy(b[12:], c.sid[:2])                           // rid[0:2]
+	b[14] = channel                                   // channel
+	b[15] = 0x01                                      // marker
+	binary.LittleEndian.PutUint32(b[16:], 0x0000000c) // const
+	copy(b[20:], c.sid[:8])                           // rid
+	copy(b[28:], payload)
+	return b
+}
+
+func (c *DTLSConn) msgTxDataCC51(payload []byte, channel byte) []byte {
+	payloadSize := uint16(16 + len(payload) + authSizeCC51)
+	b := make([]byte, headerSizeCC51+len(payload)+authSizeCC51)
+	copy(b[:2], magicCC51)
+	binary.LittleEndian.PutUint16(b[4:], cmdDTLSCC51) // 0x1502
+	binary.LittleEndian.PutUint16(b[6:], payloadSize)
+	binary.LittleEndian.PutUint16(b[12:], uint16(0x0010)|(uint16(channel)<<8)) // channel in high byte
+	binary.LittleEndian.PutUint16(b[14:], c.ticket)
+	copy(b[16:24], c.sid)
+	binary.LittleEndian.PutUint32(b[24:], 1) // const
+	copy(b[headerSizeCC51:], payload)
+	h := hmac.New(sha1.New, append([]byte(c.uid), c.authKey...))
+	h.Write(b[:headerSizeCC51])
+	copy(b[headerSizeCC51+len(payload):], h.Sum(nil))
+	return b
+}
+
+func (c *DTLSConn) msgACK() []byte {
+	c.ackFlags++
+	b := make([]byte, 24)
+	binary.LittleEndian.PutUint16(b[0:], magicACK)     // 0x0009
+	binary.LittleEndian.PutUint16(b[2:], protoVersion) // 0x000c
+	binary.LittleEndian.PutUint32(b[4:], c.avSeq)      // TX seq
+	c.avSeq++
+	binary.LittleEndian.PutUint16(b[8:], c.rxSeqStart) // RX start (last acked)
+	binary.LittleEndian.PutUint16(b[10:], c.rxSeqEnd)  // RX end (highest received)
+	if c.rxSeqInit {
+		c.rxSeqStart = c.rxSeqEnd
+	}
+	binary.LittleEndian.PutUint16(b[12:], c.ackFlags)             // AckFlags
+	binary.LittleEndian.PutUint32(b[16:], uint32(c.ackFlags)<<16) // AckCounter
+	ts := uint32(time.Now().UnixMilli() & 0xFFFF)
+	binary.LittleEndian.PutUint16(b[20:], uint16(ts)) // Timestamp
+	return b
+}
+
+func (c *DTLSConn) msgKeepalive(incoming []byte) []byte {
+	b := make([]byte, 24)
+	copy(b, "\x04\x02\x1a\x0a")                           // marker + mode
+	binary.LittleEndian.PutUint16(b[4:], 8)               // body size
+	binary.LittleEndian.PutUint16(b[8:], cmdKeepaliveReq) // 0x0427
+	binary.LittleEndian.PutUint16(b[10:], 0x0021)         // flags
+	if len(incoming) >= 8 {
+		copy(b[16:], incoming[:8]) // echo payload
+	}
+	return b
+}
+
+func (c *DTLSConn) msgIOCtrl(payload []byte) []byte {
+	b := make([]byte, 40+len(payload))
+	binary.LittleEndian.PutUint16(b, protoVersion)     // magic
+	binary.LittleEndian.PutUint16(b[2:], protoVersion) // version
+	binary.LittleEndian.PutUint32(b[4:], c.avSeq)      // av seq
+	c.avSeq++
+	binary.LittleEndian.PutUint16(b[16:], magicIOCtrl)            // 0x7000
+	binary.LittleEndian.PutUint16(b[18:], c.seqCmd)               // sub channel
+	binary.LittleEndian.PutUint32(b[20:], 1)                      // ioctl seq
+	binary.LittleEndian.PutUint32(b[24:], uint32(len(payload)+4)) // payload size
+	binary.LittleEndian.PutUint32(b[28:], uint32(c.seqCmd))       // flag
+	b[37] = 0x01
+	copy(b[40:], payload)
+	c.seqCmd++
+	return b
+}
+
+func hexDump(data []byte) string {
+	const maxBytes = 650
+	totalLen := len(data)
+	truncated := totalLen > maxBytes
+	if truncated {
+		data = data[:maxBytes]
+	}
+
+	var result string
+	for i := 0; i < len(data); i += 16 {
+		end := min(i+16, len(data))
+		line := fmt.Sprintf("    %04x:", i)
+		for j := i; j < end; j++ {
+			line += fmt.Sprintf(" %02x", data[j])
+		}
+		result += line + "\n"
+	}
+
+	if truncated {
+		result += fmt.Sprintf("    ... (truncated, showing %d of %d bytes)\n", maxBytes, totalLen)
+	}
+	return result
+}
diff --git a/installs_on_host/go2rtc/pkg/tutk/dtls/dtls.go b/installs_on_host/go2rtc/pkg/tutk/dtls/dtls.go
new file mode 100644
index 0000000..3b0573a
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tutk/dtls/dtls.go
@@ -0,0 +1,146 @@
+package dtls
+
+import (
+	"context"
+	"net"
+	"sync"
+	"time"
+
+	"github.com/pion/dtls/v3"
+)
+
+func NewDTLSClient(ctx context.Context, channel uint8, addr net.Addr, writeFn func([]byte, uint8) error, readChan chan []byte, psk []byte) (*dtls.Conn, error) {
+	return dialDTLS(ctx, channel, addr, writeFn, readChan, psk, false)
+}
+
+func NewDTLSServer(ctx context.Context, channel uint8, addr net.Addr, writeFn func([]byte, uint8) error, readChan chan []byte, psk []byte) (*dtls.Conn, error) {
+	return dialDTLS(ctx, channel, addr, writeFn, readChan, psk, true)
+}
+
+func dialDTLS(ctx context.Context, channel uint8, addr net.Addr, writeFn func([]byte, uint8) error, readChan chan []byte, psk []byte, isServer bool) (*dtls.Conn, error) {
+	adapter := &channelAdapter{
+		ctx:      ctx,
+		channel:  channel,
+		addr:     addr,
+		writeFn:  writeFn,
+		readChan: readChan,
+	}
+
+	var conn *dtls.Conn
+	var err error
+
+	if isServer {
+		conn, err = dtls.Server(adapter, addr, buildDTLSConfig(psk, true))
+	} else {
+		conn, err = dtls.Client(adapter, addr, buildDTLSConfig(psk, false))
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	timeout := 5 * time.Second
+	adapter.SetReadDeadline(time.Now().Add(timeout))
+	hsCtx, cancel := context.WithTimeout(ctx, timeout)
+	defer cancel()
+
+	if err := conn.HandshakeContext(hsCtx); err != nil {
+		go conn.Close()
+		return nil, err
+	}
+
+	adapter.SetReadDeadline(time.Time{})
+	return conn, nil
+}
+
+func buildDTLSConfig(psk []byte, isServer bool) *dtls.Config {
+	config := &dtls.Config{
+		PSK: func(hint []byte) ([]byte, error) {
+			return psk, nil
+		},
+		PSKIdentityHint:         []byte("AUTHPWD_admin"),
+		InsecureSkipVerify:      true,
+		InsecureSkipVerifyHello: true,
+		MTU:                     1200,
+		FlightInterval:          300 * time.Millisecond,
+		ExtendedMasterSecret:    dtls.DisableExtendedMasterSecret,
+	}
+
+	if isServer {
+		config.CipherSuites = []dtls.CipherSuiteID{dtls.TLS_PSK_WITH_AES_128_CBC_SHA256}
+	} else {
+		config.CustomCipherSuites = CustomCipherSuites
+	}
+
+	return config
+}
+
+type channelAdapter struct {
+	ctx          context.Context
+	channel      uint8
+	writeFn      func([]byte, uint8) error
+	readChan     chan []byte
+	addr         net.Addr
+	mu           sync.Mutex
+	readDeadline time.Time
+}
+
+func (a *channelAdapter) ReadFrom(p []byte) (n int, addr net.Addr, err error) {
+	a.mu.Lock()
+	deadline := a.readDeadline
+	a.mu.Unlock()
+
+	if !deadline.IsZero() {
+		timeout := time.Until(deadline)
+		if timeout <= 0 {
+			return 0, nil, &timeoutError{}
+		}
+
+		timer := time.NewTimer(timeout)
+		defer timer.Stop()
+
+		select {
+		case data := <-a.readChan:
+			return copy(p, data), a.addr, nil
+		case <-timer.C:
+			return 0, nil, &timeoutError{}
+		case <-a.ctx.Done():
+			return 0, nil, net.ErrClosed
+		}
+	}
+
+	select {
+	case data := <-a.readChan:
+		return copy(p, data), a.addr, nil
+	case <-a.ctx.Done():
+		return 0, nil, net.ErrClosed
+	}
+}
+
+func (a *channelAdapter) WriteTo(p []byte, _ net.Addr) (int, error) {
+	if err := a.writeFn(p, a.channel); err != nil {
+		return 0, err
+	}
+	return len(p), nil
+}
+
+func (a *channelAdapter) Close() error        { return nil }
+func (a *channelAdapter) LocalAddr() net.Addr { return &net.UDPAddr{} }
+func (a *channelAdapter) SetDeadline(t time.Time) error {
+	a.mu.Lock()
+	a.readDeadline = t
+	a.mu.Unlock()
+	return nil
+}
+func (a *channelAdapter) SetReadDeadline(t time.Time) error {
+	a.mu.Lock()
+	a.readDeadline = t
+	a.mu.Unlock()
+	return nil
+}
+func (a *channelAdapter) SetWriteDeadline(time.Time) error { return nil }
+
+type timeoutError struct{}
+
+func (e *timeoutError) Error() string   { return "i/o timeout" }
+func (e *timeoutError) Timeout() bool   { return true }
+func (e *timeoutError) Temporary() bool { return true }
diff --git a/installs_on_host/go2rtc/pkg/tutk/frame.go b/installs_on_host/go2rtc/pkg/tutk/frame.go
new file mode 100644
index 0000000..db5bf07
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tutk/frame.go
@@ -0,0 +1,571 @@
+package tutk
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+	"sync"
+
+	"github.com/AlexxIT/go2rtc/pkg/aac"
+)
+
+const (
+	FrameTypeStart     uint8 = 0x08 // Extended start (36-byte header)
+	FrameTypeStartAlt  uint8 = 0x09 // StartAlt (36-byte header)
+	FrameTypeCont      uint8 = 0x00 // Continuation (28-byte header)
+	FrameTypeContAlt   uint8 = 0x04 // Continuation alt
+	FrameTypeEndSingle uint8 = 0x01 // Single-packet frame (28-byte)
+	FrameTypeEndMulti  uint8 = 0x05 // Multi-packet end (28-byte)
+	FrameTypeEndExt    uint8 = 0x0d // Extended end (36-byte)
+)
+
+const (
+	ChannelIVideo uint8 = 0x05
+	ChannelAudio  uint8 = 0x03
+	ChannelPVideo uint8 = 0x07
+)
+
+const frameInfoSize = 40
+
+// FrameInfo - Wyze extended FRAMEINFO (40 bytes at end of packet)
+// Video: 40 bytes, Audio: 16 bytes (uses same struct, fields 16+ are zero)
+//
+// Offset  Size  Field
+// 0-1     2     CodecID     - 0x4E=H264, 0x7B=H265, 0x90=AAC_WYZE
+// 2       1     Flags       - Video: 1=Keyframe, 0=P-frame | Audio: sample rate/bits/channels
+// 3       1     CamIndex    - Camera index
+// 4       1     OnlineNum   - Online number
+// 5       1     FPS         - Framerate (e.g. 20)
+// 6       1     ResTier     - Video: 1=Low(360P), 4=High(HD/2K) | Audio: 0
+// 7       1     Bitrate     - Video: 30=360P, 100=HD, 200=2K | Audio: 1
+// 8-11    4     Timestamp   - Timestamp (increases ~50000/frame for 20fps video)
+// 12-15   4     SessionID   - Session marker (constant per stream)
+// 16-19   4     PayloadSize - Frame payload size in bytes
+// 20-23   4     FrameNo     - Global frame number
+// 24-35   12    DeviceID    - MAC address (ASCII) - video only
+// 36-39   4     Padding     - Always 0 - video only
+type FrameInfo struct {
+	CodecID     byte   // 0 (only low byte used)
+	Flags       uint8  // 2
+	CamIndex    uint8  // 3
+	OnlineNum   uint8  // 4
+	FPS         uint8  // 5: Framerate
+	ResTier     uint8  // 6: Resolution tier (1=Low, 4=High)
+	Bitrate     uint8  // 7: Bitrate index (30=360P, 100=HD, 200=2K)
+	Timestamp   uint32 // 8-11: Timestamp
+	SessionID   uint32 // 12-15: Session marker (constant)
+	PayloadSize uint32 // 16-19: Payload size
+	FrameNo     uint32 // 20-23: Frame number
+}
+
+func (fi *FrameInfo) IsKeyframe() bool {
+	return fi.Flags == 0x01
+}
+
+func (fi *FrameInfo) SampleRate() uint32 {
+	idx := (fi.Flags >> 2) & 0x0F
+	if idx < uint8(len(sampleRates)) {
+		return sampleRates[idx]
+	}
+	return 16000
+}
+
+func (fi *FrameInfo) Channels() uint8 {
+	if fi.Flags&0x01 == 1 {
+		return 2
+	}
+	return 1
+}
+
+func ParseFrameInfo(data []byte) *FrameInfo {
+	if len(data) < frameInfoSize {
+		return nil
+	}
+
+	offset := len(data) - frameInfoSize
+	fi := data[offset:]
+
+	return &FrameInfo{
+		CodecID:     fi[0],
+		Flags:       fi[2],
+		CamIndex:    fi[3],
+		OnlineNum:   fi[4],
+		FPS:         fi[5],
+		ResTier:     fi[6],
+		Bitrate:     fi[7],
+		Timestamp:   binary.LittleEndian.Uint32(fi[8:]),
+		SessionID:   binary.LittleEndian.Uint32(fi[12:]),
+		PayloadSize: binary.LittleEndian.Uint32(fi[16:]),
+		FrameNo:     binary.LittleEndian.Uint32(fi[20:]),
+	}
+}
+
+type Packet struct {
+	Channel    uint8
+	Codec      byte
+	Timestamp  uint32
+	Payload    []byte
+	IsKeyframe bool
+	FrameNo    uint32
+	SampleRate uint32
+	Channels   uint8
+}
+
+type PacketHeader struct {
+	Channel      byte
+	FrameType    byte
+	HeaderSize   int
+	FrameNo      uint32
+	PktIdx       uint16
+	PktTotal     uint16
+	PayloadSize  uint16
+	HasFrameInfo bool
+}
+
+func ParsePacketHeader(data []byte) *PacketHeader {
+	if len(data) < 28 {
+		return nil
+	}
+
+	frameType := data[1]
+	hdr := &PacketHeader{
+		Channel:   data[0],
+		FrameType: frameType,
+	}
+
+	switch frameType {
+	case FrameTypeStart, FrameTypeStartAlt, FrameTypeEndExt:
+		hdr.HeaderSize = 36
+	default:
+		hdr.HeaderSize = 28
+	}
+
+	if len(data) < hdr.HeaderSize {
+		return nil
+	}
+
+	if hdr.HeaderSize == 28 {
+		hdr.PktTotal = binary.LittleEndian.Uint16(data[12:])
+		pktIdxOrMarker := binary.LittleEndian.Uint16(data[14:])
+		hdr.PayloadSize = binary.LittleEndian.Uint16(data[16:])
+		hdr.FrameNo = binary.LittleEndian.Uint32(data[24:])
+
+		if pktIdxOrMarker == 0x0028 && (IsEndFrame(frameType) || hdr.PktTotal == 1) {
+			hdr.HasFrameInfo = true
+			if hdr.PktTotal > 0 {
+				hdr.PktIdx = hdr.PktTotal - 1
+			}
+		} else {
+			hdr.PktIdx = pktIdxOrMarker
+		}
+	} else {
+		hdr.PktTotal = binary.LittleEndian.Uint16(data[20:])
+		pktIdxOrMarker := binary.LittleEndian.Uint16(data[22:])
+		hdr.PayloadSize = binary.LittleEndian.Uint16(data[24:])
+		hdr.FrameNo = binary.LittleEndian.Uint32(data[32:])
+
+		if pktIdxOrMarker == 0x0028 && (IsEndFrame(frameType) || hdr.PktTotal == 1) {
+			hdr.HasFrameInfo = true
+			if hdr.PktTotal > 0 {
+				hdr.PktIdx = hdr.PktTotal - 1
+			}
+		} else {
+			hdr.PktIdx = pktIdxOrMarker
+		}
+	}
+
+	return hdr
+}
+
+func IsStartFrame(frameType uint8) bool {
+	return frameType == FrameTypeStart || frameType == FrameTypeStartAlt
+}
+
+func IsEndFrame(frameType uint8) bool {
+	return frameType == FrameTypeEndSingle ||
+		frameType == FrameTypeEndMulti ||
+		frameType == FrameTypeEndExt
+}
+
+func IsContinuationFrame(frameType uint8) bool {
+	return frameType == FrameTypeCont || frameType == FrameTypeContAlt
+}
+
+type channelState struct {
+	frameNo    uint32     // current frame being assembled
+	pktTotal   uint16     // expected total packets
+	waitSeq    uint16     // next expected packet index (0, 1, 2, ...)
+	waitData   []byte     // accumulated payload data
+	frameInfo  *FrameInfo // frame info (from end packet)
+	hasStarted bool       // received first packet of frame
+	lastPktIdx uint16     // last received packet index (for OOO detection)
+}
+
+func (cs *channelState) reset() {
+	cs.frameNo = 0
+	cs.pktTotal = 0
+	cs.waitSeq = 0
+	cs.waitData = cs.waitData[:0]
+	cs.frameInfo = nil
+	cs.hasStarted = false
+	cs.lastPktIdx = 0
+}
+
+const tsWrapPeriod uint32 = 1000000
+
+type tsTracker struct {
+	lastRawTS uint32
+	accumUS   uint64
+	firstTS   bool
+}
+
+func (t *tsTracker) update(rawTS uint32) uint64 {
+	if !t.firstTS {
+		t.firstTS = true
+		t.lastRawTS = rawTS
+		return 0
+	}
+
+	var delta uint32
+	if rawTS >= t.lastRawTS {
+		delta = rawTS - t.lastRawTS
+	} else {
+		// Wrapped: delta = (wrap - last) + new
+		delta = (tsWrapPeriod - t.lastRawTS) + rawTS
+	}
+
+	t.accumUS += uint64(delta)
+	t.lastRawTS = rawTS
+
+	return t.accumUS
+}
+
+type FrameHandler struct {
+	channels map[byte]*channelState
+	videoTS  tsTracker
+	audioTS  tsTracker
+	output   chan *Packet
+	verbose  bool
+	closed   bool
+	closeMu  sync.Mutex
+}
+
+func NewFrameHandler(verbose bool) *FrameHandler {
+	return &FrameHandler{
+		channels: make(map[byte]*channelState),
+		output:   make(chan *Packet, 128),
+		verbose:  verbose,
+	}
+}
+
+func (h *FrameHandler) Recv() <-chan *Packet {
+	return h.output
+}
+
+func (h *FrameHandler) Close() {
+	h.closeMu.Lock()
+	defer h.closeMu.Unlock()
+
+	if h.closed {
+		return
+	}
+	h.closed = true
+	close(h.output)
+}
+
+func (h *FrameHandler) Handle(data []byte) {
+	hdr := ParsePacketHeader(data)
+	if hdr == nil {
+		return
+	}
+
+	payload, fi := h.extractPayload(data, hdr.Channel)
+	if payload == nil {
+		return
+	}
+
+	if h.verbose {
+		fiStr := ""
+		if hdr.HasFrameInfo {
+			fiStr = " +FI"
+		}
+		fmt.Printf("[RX] ch=0x%02x type=0x%02x #%d pkt=%d/%d data=%dB%s\n",
+			hdr.Channel, hdr.FrameType,
+			hdr.FrameNo, hdr.PktIdx, hdr.PktTotal, len(payload), fiStr)
+	}
+
+	switch hdr.Channel {
+	case ChannelAudio:
+		h.handleAudio(payload, fi)
+	case ChannelIVideo, ChannelPVideo:
+		h.handleVideo(hdr.Channel, hdr, payload, fi)
+	}
+}
+
+func (h *FrameHandler) extractPayload(data []byte, channel byte) ([]byte, *FrameInfo) {
+	if len(data) < 2 {
+		return nil, nil
+	}
+
+	frameType := data[1]
+
+	headerSize := 28
+	fiSize := 0
+
+	switch frameType {
+	case FrameTypeStart:
+		headerSize = 36
+	case FrameTypeStartAlt:
+		headerSize = 36
+		if len(data) >= 22 {
+			pktTotal := binary.LittleEndian.Uint16(data[20:])
+			if pktTotal == 1 {
+				fiSize = frameInfoSize
+			}
+		}
+	case FrameTypeCont, FrameTypeContAlt:
+		headerSize = 28
+	case FrameTypeEndSingle, FrameTypeEndMulti:
+		headerSize = 28
+		fiSize = frameInfoSize
+	case FrameTypeEndExt:
+		headerSize = 36
+		fiSize = frameInfoSize
+	default:
+		headerSize = 28
+	}
+
+	if len(data) < headerSize {
+		return nil, nil
+	}
+
+	if fiSize == 0 {
+		return data[headerSize:], nil
+	}
+
+	if len(data) < headerSize+fiSize {
+		return data[headerSize:], nil
+	}
+
+	fi := ParseFrameInfo(data)
+
+	validCodec := false
+	switch channel {
+	case ChannelIVideo, ChannelPVideo:
+		validCodec = IsVideoCodec(fi.CodecID)
+	case ChannelAudio:
+		validCodec = IsAudioCodec(fi.CodecID)
+	}
+
+	if validCodec {
+		payload := data[headerSize : len(data)-fiSize]
+		return payload, fi
+	}
+
+	return data[headerSize:], nil
+}
+
+func (h *FrameHandler) handleVideo(channel byte, hdr *PacketHeader, payload []byte, fi *FrameInfo) {
+	cs := h.channels[channel]
+	if cs == nil {
+		cs = &channelState{}
+		h.channels[channel] = cs
+	}
+
+	// New frame number - reset and start fresh
+	if hdr.FrameNo != cs.frameNo {
+		// Check if previous frame was incomplete
+		if cs.hasStarted && cs.waitSeq < cs.pktTotal {
+			fmt.Printf("[DROP] ch=0x%02x #%d INCOMPLETE: got %d/%d pkts\n",
+				channel, cs.frameNo, cs.waitSeq, cs.pktTotal)
+		}
+		cs.reset()
+		cs.frameNo = hdr.FrameNo
+		cs.pktTotal = hdr.PktTotal
+	}
+
+	// If packet index doesn't match expected, reset (data loss)
+	if hdr.PktIdx != cs.waitSeq {
+		fmt.Printf("[OOO] ch=0x%02x #%d frameType=0x%02x pktTotal=%d expected pkt %d, got %d - reset\n",
+			channel, hdr.FrameNo, hdr.FrameType, hdr.PktTotal, cs.waitSeq, hdr.PktIdx)
+		cs.reset()
+		return
+	}
+
+	// First packet - mark as started
+	if cs.waitSeq == 0 {
+		cs.hasStarted = true
+	}
+
+	cs.waitData = append(cs.waitData, payload...)
+	cs.waitSeq++
+
+	// Store frame info if present
+	if fi != nil {
+		cs.frameInfo = fi
+	}
+
+	// Check if frame is complete
+	if cs.waitSeq != cs.pktTotal || cs.frameInfo == nil {
+		return
+	}
+
+	fi = cs.frameInfo
+	defer cs.reset()
+
+	if fi.PayloadSize > 0 && uint32(len(cs.waitData)) != fi.PayloadSize {
+		fmt.Printf("[SIZE] ch=0x%02x #%d mismatch: expected %d, got %d\n",
+			channel, cs.frameNo, fi.PayloadSize, len(cs.waitData))
+		return
+	}
+
+	if len(cs.waitData) == 0 {
+		return
+	}
+
+	accumUS := h.videoTS.update(fi.Timestamp)
+	rtpTS := uint32(accumUS * 90000 / 1000000)
+
+	pkt := &Packet{
+		Channel:    channel,
+		Payload:    append([]byte{}, cs.waitData...),
+		Codec:      fi.CodecID,
+		Timestamp:  rtpTS,
+		IsKeyframe: fi.IsKeyframe(),
+		FrameNo:    fi.FrameNo,
+	}
+
+	if h.verbose {
+		frameType := "P"
+		if fi.IsKeyframe() {
+			frameType = "KEY"
+		}
+		fmt.Printf("[OK] ch=0x%02x #%d codec=0x%02x %s size=%d\n",
+			channel, fi.FrameNo, fi.CodecID, frameType, len(pkt.Payload))
+		fmt.Printf("  [0-1]codec=0x%02x [2]flags=0x%x [3]=%d [4]=%d\n",
+			fi.CodecID, fi.Flags, fi.CamIndex, fi.OnlineNum)
+		fmt.Printf("  [5]=%d [6]=%d [7]=%d [8-11]ts=%d\n",
+			fi.FPS, fi.ResTier, fi.Bitrate, fi.Timestamp)
+		fmt.Printf("  [12-15]=0x%x [16-19]payload=%d [20-23]frameNo=%d\n",
+			fi.SessionID, fi.PayloadSize, fi.FrameNo)
+		fmt.Printf("  rtp_ts=%d accum_us=%d\n", rtpTS, accumUS)
+		fmt.Printf("  hex: %s\n", dumpHex(fi))
+	}
+
+	h.queue(pkt)
+}
+
+func (h *FrameHandler) handleAudio(payload []byte, fi *FrameInfo) {
+	if len(payload) == 0 || fi == nil {
+		return
+	}
+
+	var sampleRate uint32
+	var channels uint8
+
+	switch fi.CodecID {
+	case CodecAACRaw, CodecAACADTS, CodecAACLATM, CodecAACAlt:
+		sampleRate, channels = parseAudioParams(payload, fi)
+	default:
+		sampleRate = fi.SampleRate()
+		channels = fi.Channels()
+	}
+
+	accumUS := h.audioTS.update(fi.Timestamp)
+	rtpTS := uint32(accumUS * uint64(sampleRate) / 1000000)
+
+	payloadCopy := make([]byte, len(payload))
+	copy(payloadCopy, payload)
+
+	pkt := &Packet{
+		Channel:    ChannelAudio,
+		Payload:    payloadCopy,
+		Codec:      fi.CodecID,
+		Timestamp:  rtpTS,
+		SampleRate: sampleRate,
+		Channels:   channels,
+		FrameNo:    fi.FrameNo,
+	}
+
+	if h.verbose {
+		bits := 8
+		if fi.Flags&0x02 != 0 {
+			bits = 16
+		}
+		fmt.Printf("[OK] Audio #%d codec=0x%02x size=%d\n",
+			fi.FrameNo, fi.CodecID, len(payload))
+		fmt.Printf("  [0-1]codec=0x%02x [2]flags=0x%x(%dHz/%dbit/%dch)\n",
+			fi.CodecID, fi.Flags, sampleRate, bits, channels)
+		fmt.Printf("  [8-11]ts=%d [12-15]=0x%x rtp_ts=%d\n",
+			fi.Timestamp, fi.SessionID, rtpTS)
+		fmt.Printf("  hex: %s\n", dumpHex(fi))
+	}
+
+	h.queue(pkt)
+}
+
+func (h *FrameHandler) queue(pkt *Packet) {
+	h.closeMu.Lock()
+	defer h.closeMu.Unlock()
+
+	if h.closed {
+		return
+	}
+
+	select {
+	case h.output <- pkt:
+	default:
+		// Queue full - drop oldest
+		select {
+		case <-h.output:
+		default:
+		}
+		select {
+		case h.output <- pkt:
+		default:
+			// Queue still full, drop this packet
+		}
+	}
+}
+
+func parseAudioParams(payload []byte, fi *FrameInfo) (sampleRate uint32, channels uint8) {
+	if aac.IsADTS(payload) {
+		codec := aac.ADTSToCodec(payload)
+		if codec != nil {
+			return codec.ClockRate, codec.Channels
+		}
+	}
+
+	if fi != nil {
+		return fi.SampleRate(), fi.Channels()
+	}
+
+	return 16000, 1
+}
+
+func dumpHex(fi *FrameInfo) string {
+	b := make([]byte, frameInfoSize)
+	b[0] = fi.CodecID
+	b[1] = 0 // High byte (unused)
+	b[2] = fi.Flags
+	b[3] = fi.CamIndex
+	b[4] = fi.OnlineNum
+	b[5] = fi.FPS
+	b[6] = fi.ResTier
+	b[7] = fi.Bitrate
+	binary.LittleEndian.PutUint32(b[8:], fi.Timestamp)
+	binary.LittleEndian.PutUint32(b[12:], fi.SessionID)
+	binary.LittleEndian.PutUint32(b[16:], fi.PayloadSize)
+	binary.LittleEndian.PutUint32(b[20:], fi.FrameNo)
+	// Bytes 24-39 are DeviceID and Padding (not stored in struct)
+
+	hexStr := hex.EncodeToString(b)
+	formatted := ""
+	for i := 0; i < len(hexStr); i += 2 {
+		if i > 0 {
+			formatted += " "
+		}
+		formatted += hexStr[i : i+2]
+	}
+	return formatted
+}
diff --git a/installs_on_host/go2rtc/pkg/tutk/helpers.go b/installs_on_host/go2rtc/pkg/tutk/helpers.go
new file mode 100644
index 0000000..93bf4b5
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tutk/helpers.go
@@ -0,0 +1,71 @@
+package tutk
+
+import (
+	"encoding/binary"
+	"time"
+)
+
+func GenSessionID() []byte {
+	b := make([]byte, 8)
+	binary.LittleEndian.PutUint64(b, uint64(time.Now().UnixNano()))
+	return b
+}
+
+func ICAM(cmd uint32, args ...byte) []byte {
+	// 0   4943414d  ICAM
+	// 4   d807ff00  command
+	// 8   00000000000000
+	// 15  02        args count
+	// 16  00000000000000
+	// 23  0101      args
+	n := byte(len(args))
+	b := make([]byte, 23+n)
+	copy(b, "ICAM")
+	binary.LittleEndian.PutUint32(b[4:], cmd)
+	b[15] = n
+	copy(b[23:], args)
+	return b
+}
+
+func HL(cmdID uint16, payload []byte) []byte {
+	// 0-1   "HL"       magic
+	// 2     version    (typically 5)
+	// 3     reserved
+	// 4-5   cmdID      command ID (uint16 LE)
+	// 6-7   payloadLen payload length (uint16 LE)
+	// 8-15  reserved
+	// 16+   payload
+	const headerSize = 16
+	const version = 5
+
+	b := make([]byte, headerSize+len(payload))
+	copy(b, "HL")
+	b[2] = version
+	binary.LittleEndian.PutUint16(b[4:], cmdID)
+	binary.LittleEndian.PutUint16(b[6:], uint16(len(payload)))
+	copy(b[headerSize:], payload)
+	return b
+}
+
+func ParseHL(data []byte) (cmdID uint16, payload []byte, ok bool) {
+	if len(data) < 16 || data[0] != 'H' || data[1] != 'L' {
+		return 0, nil, false
+	}
+	cmdID = binary.LittleEndian.Uint16(data[4:])
+	payloadLen := binary.LittleEndian.Uint16(data[6:])
+	if len(data) >= 16+int(payloadLen) {
+		payload = data[16 : 16+payloadLen]
+	} else if len(data) > 16 {
+		payload = data[16:]
+	}
+	return cmdID, payload, true
+}
+
+func FindHL(data []byte, offset int) []byte {
+	for i := offset; i+16 <= len(data); i++ {
+		if data[i] == 'H' && data[i+1] == 'L' {
+			return data[i:]
+		}
+	}
+	return nil
+}
diff --git a/installs_on_host/go2rtc/pkg/tutk/session0.go b/installs_on_host/go2rtc/pkg/tutk/session0.go
new file mode 100644
index 0000000..6a1b225
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tutk/session0.go
@@ -0,0 +1,157 @@
+package tutk
+
+import (
+	"bytes"
+	"encoding/binary"
+	"net"
+	"time"
+)
+
+func (c *Conn) connectDirect(uid string, sid []byte) error {
+	res, err := writeAndWait(
+		c, func(res []byte) bool { return bytes.Index(res, []byte("\x02\x06\x12\x00")) == 8 },
+		ConnectByUID(stageBroadcast, uid, sid),
+	)
+	if err != nil {
+		return err
+	}
+
+	n := len(res) // should be 200
+	c.ver = []byte{res[2], res[n-13], res[n-14], res[n-15], res[n-16]}
+
+	_, err = c.Write(ConnectByUID(stageDirect, uid, sid))
+	return err
+}
+
+func (c *Conn) connectRemote(uid string, sid []byte) error {
+	res, err := writeAndWait(
+		c, func(res []byte) bool { return bytes.Index(res, []byte("\x01\x03\x43")) == 8 },
+		ConnectByUID(stageGetRemoteIP, uid, sid),
+	)
+	if err != nil {
+		return err
+	}
+
+	// Read real IP from cloud server response.
+	// Important ot use net.IPv4 because slice will be 16 bytes.
+	c.addr.IP = net.IPv4(res[40], res[41], res[42], res[43])
+	c.addr.Port = int(binary.BigEndian.Uint16(res[38:]))
+
+	res, err = writeAndWait(
+		c, func(res []byte) bool { return bytes.Index(res, []byte("\x04\x04\x33")) == 8 },
+		ConnectByUID(stageRemoteAck, uid, sid),
+	)
+	if err != nil {
+		return err
+	}
+
+	if len(res) == 52 {
+		c.ver = []byte{res[2], res[51], res[50], res[49], res[48]}
+	} else {
+		c.ver = []byte{res[2]}
+	}
+
+	_, err = c.Write(ConnectByUID(stageRemoteOK, uid, sid))
+	return err
+}
+
+func (c *Conn) clientStart(username, password string) error {
+	_, err := writeAndWait(
+		c, func(res []byte) bool {
+			return len(res) >= 84 && res[28] == 0 && (res[29] == 0x14 || res[29] == 0x21)
+		},
+		c.session.ClientStart(0, username, password),
+		c.session.ClientStart(1, username, password),
+	)
+	return err
+}
+
+func writeAndWait(conn net.Conn, ok func(res []byte) bool, req ...[]byte) ([]byte, error) {
+	var t *time.Timer
+	t = time.AfterFunc(1, func() {
+		for _, b := range req {
+			if _, err := conn.Write(b); err != nil {
+				return
+			}
+		}
+		if t != nil {
+			t.Reset(time.Second)
+		}
+	})
+	defer t.Stop()
+
+	buf := make([]byte, 1200)
+
+	for {
+		n, err := conn.Read(buf)
+		if err != nil {
+			return nil, err
+		}
+
+		if ok(buf[:n]) {
+			return buf[:n], nil
+		}
+	}
+}
+
+const (
+	magic      = "\x04\x02\x19"     // include version 0x19
+	sdkVersion = "\x06\x00\x03\x03" // 3.3.0.6
+)
+
+const (
+	stageBroadcast = iota + 1
+	stageDirect
+	stageGetPublicIP
+	stageGetRemoteIP
+	stageRemoteReq
+	stageRemoteAck
+	stageRemoteOK
+)
+
+func ConnectByUID(stage byte, uid string, sid8 []byte) []byte {
+	var b []byte
+
+	switch stage {
+	case stageBroadcast, stageDirect:
+		b = make([]byte, 68)
+		copy(b[8:], "\x01\x06\x21")
+		copy(b[52:], sdkVersion)
+		copy(b[56:], sid8)
+		b[64] = stage // 1 or 2
+
+	case stageGetPublicIP:
+		b = make([]byte, 54)
+		copy(b[8:], "\x07\x10\x18")
+
+	case stageGetRemoteIP:
+		b = make([]byte, 112)
+		copy(b[8:], "\x03\x02\x34")
+		copy(b[100:], sid8)
+		b[108] = stageDirect
+
+	case stageRemoteReq:
+		b = make([]byte, 52)
+		copy(b[8:], "\x01\x04\x33")
+		copy(b[36:], sid8)
+		copy(b[48:], sdkVersion)
+
+	case stageRemoteAck:
+		b = make([]byte, 44)
+		copy(b[8:], "\x02\x04\x33")
+		copy(b[36:], sid8)
+
+	case stageRemoteOK:
+		b = make([]byte, 52)
+		copy(b[8:], "\x04\x04\x33")
+		copy(b[36:], sid8)
+		copy(b[48:], sdkVersion)
+	}
+
+	copy(b, magic)
+	b[3] = 0x02 // connection stage
+	binary.LittleEndian.PutUint16(b[4:], uint16(len(b))-16)
+	copy(b[16:], uid)
+
+	return b
+}
diff --git a/installs_on_host/go2rtc/pkg/tutk/session16.go b/installs_on_host/go2rtc/pkg/tutk/session16.go
new file mode 100644
index 0000000..5344bdb
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tutk/session16.go
@@ -0,0 +1,381 @@
+package tutk
+
+import (
+	"bytes"
+	"encoding/binary"
+	"io"
+	"net"
+	"time"
+)
+
+type Session interface {
+	Close() error
+
+	ClientStart(i byte, username, password string) []byte
+
+	SendIOCtrl(ctrlType uint32, ctrlData []byte) []byte
+	SendFrameData(frameInfo, frameData []byte) []byte
+
+	RecvIOCtrl() (ctrlType uint32, ctrlData []byte, err error)
+	RecvFrameData() (frameInfo, frameData []byte, err error)
+
+	SessionRead(chID byte, buf []byte) int
+	SessionWrite(chID byte, buf []byte) error
+}
+
+func NewSession16(conn net.Conn, sid8 []byte) *Session16 {
+	sid16 := make([]byte, 16)
+	copy(sid16[8:], sid8)
+	copy(sid16, sid8[:2])
+	sid16[4] = 0x0c
+
+	return &Session16{
+		conn:   conn,
+		sid16:  sid16,
+		rawCmd: make(chan []byte, 10),
+		rawPkt: make(chan [2][]byte, 100),
+	}
+}
+
+type Session16 struct {
+	conn  net.Conn
+	sid16 []byte
+
+	rawCmd chan []byte
+	rawPkt chan [2][]byte
+
+	seqSendCh0 uint16
+	seqSendCh1 uint16
+
+	seqSendCmd1 uint16
+	seqSendAud  uint16
+
+	waitFSeq uint16
+	waitCSeq uint16
+	waitSize int
+	waitData []byte
+}
+
+func (s *Session16) Close() error {
+	close(s.rawCmd)
+	close(s.rawPkt)
+	return nil
+}
+
+func (s *Session16) Msg(size uint16) []byte {
+	b := make([]byte, size)
+	copy(b, magic)
+	b[3] = 0x0a // connected stage
+	binary.LittleEndian.PutUint16(b[4:], size-16)
+	copy(b[8:], "\x07\x04\x21") // client request
+	copy(b[12:], s.sid16)
+	return b
+}
+
+const (
+	msgHhrSize = 28
+	cmdHdrSize = 24
+)
+
+func (s *Session16) ClientStart(i byte, username, password string) []byte {
+	const size = 566 + 32
+	msg := s.Msg(size)
+
+	// 0    00000b0000000000000000000000000022020000fcfc7284
+	// 24   4d69737300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+	// 281  636c69656e740000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+	// 538  0100000004000000fb071f000000000000000000000003000000000001000000
+	cmd := msg[msgHhrSize:]
+	copy(cmd, "\x00\x00\x0b\x00")
+	binary.LittleEndian.PutUint16(cmd[16:], size-52)
+	if i == 0 {
+		cmd[18] = 1
+	} else {
+		cmd[1] = 0x20
+	}
+	binary.LittleEndian.PutUint32(cmd[20:], uint32(time.Now().UnixMilli()))
+
+	// important values for some cameras (not for df3)
+	data := cmd[cmdHdrSize:]
+	copy(data, username)
+	copy(data[257:], password)
+
+	// 0100000004000000fb071f000000000000000000000003000000000001000000
+	cfg := data[257+257:]
+	//cfg[0] = 1 // 0 - simple proto, 1 - complex proto with "0Cxx" commands
+	cfg[4] = 4
+	copy(cfg[8:], "\xfb\x07\x1f\x00")
+	cfg[22] = 3
+	//cfg[28] = 1 // unknown
+	return msg
+}
+
+func (s *Session16) SendIOCtrl(ctrlType uint32, ctrlData []byte) []byte {
+	dataSize := 4 + uint16(len(ctrlData))
+	msg := s.Msg(msgHhrSize + cmdHdrSize + dataSize)
+
+	cmd := msg[msgHhrSize:]
+	copy(cmd, "\x00\x70\x0b\x00")
+
+	s.seqSendCmd1++ // start from 1, important!
+	binary.LittleEndian.PutUint16(cmd[4:], s.seqSendCmd1)
+
+	binary.LittleEndian.PutUint16(cmd[16:], dataSize)
+	binary.LittleEndian.PutUint32(cmd[20:], uint32(time.Now().UnixMilli()))
+
+	data := cmd[cmdHdrSize:]
+	binary.LittleEndian.PutUint32(data, ctrlType)
+	copy(data[4:], ctrlData)
+	return msg
+}
+
+func (s *Session16) SendFrameData(frameInfo, frameData []byte) []byte {
+	// -> 01030b001d0000008802000000002800b0020bf501000000 ... 4f4455412000000088020000030400001d000000000000000bf51f7a9b0100000000000000000000
+
+	n := uint16(len(frameData))
+	dataSize := n + 8 + 32
+	msg := s.Msg(msgHhrSize + cmdHdrSize + dataSize)
+
+	// 0   01030b00  command + version
+	// 4   1d000000  seq
+	// 8   8802      media size (648)
+	// 10  00000000
+	// 14  2800      tail (pkt header) size?
+	// 16  b002      size (648 + 8 + 32)
+	// 18  0bf5      random msg id (unixms)
+	// 20  01000000  fixed
+	cmd := msg[msgHhrSize:]
+	copy(cmd, "\x01\x03\x0b\x00")
+	binary.LittleEndian.PutUint16(cmd[4:], s.seqSendAud)
+	s.seqSendAud++
+	binary.LittleEndian.PutUint16(cmd[8:], n)
+	cmd[14] = 0x28 // important!
+	binary.LittleEndian.PutUint16(cmd[16:], dataSize)
+	binary.LittleEndian.PutUint16(cmd[18:], uint16(time.Now().UnixMilli()))
+	cmd[20] = 1
+
+	data := cmd[cmdHdrSize:]
+	copy(data, frameData)
+	copy(data[n:], "ODUA\x20\x00\x00\x00")
+	copy(data[n+8:], frameInfo)
+
+	return msg
+}
+
+func (s *Session16) RecvIOCtrl() (ctrlType uint32, ctrlData []byte, err error) {
+	buf, ok := <-s.rawCmd
+	if !ok {
+		return 0, nil, io.EOF
+	}
+	return binary.LittleEndian.Uint32(buf), buf[4:], nil
+}
+
+func (s *Session16) RecvFrameData() (frameInfo, frameData []byte, err error) {
+	buf, ok := <-s.rawPkt
+	if !ok {
+		return nil, nil, io.EOF
+	}
+	return buf[0], buf[1], nil
+}
+
+func (s *Session16) SessionRead(chID byte, cmd []byte) int {
+	if chID != 0 {
+		return s.handleCh1(cmd)
+	}
+
+	// 0  01030800  command + version
+	// 4  00000000  frame seq
+	// 8  ac880100  total size
+	// 12 6200      chunk seq
+	// 14 2000      tail (pkt header) size
+	// 16 cc00      size
+	// 18 0000
+	// 20 01000000  fixed
+
+	switch cmd[0] {
+	case 0x01:
+		var packetData [2][]byte
+
+		switch cmd[1] {
+		case 0x03:
+			frameSeq := binary.LittleEndian.Uint16(cmd[4:])
+			chunkSeq := binary.LittleEndian.Uint16(cmd[12:])
+			if chunkSeq == 0 {
+				s.waitFSeq = frameSeq
+				s.waitCSeq = 0
+				s.waitData = s.waitData[:0]
+				payloadSize := binary.LittleEndian.Uint32(cmd[8:])
+				hdrSize := binary.LittleEndian.Uint16(cmd[14:])
+				s.waitSize = int(hdrSize) + int(payloadSize)
+			} else if frameSeq != s.waitFSeq || chunkSeq != s.waitCSeq {
+				s.waitCSeq = 0
+				return msgMediaLost
+			}
+
+			s.waitData = append(s.waitData, cmd[24:]...)
+			if n := len(s.waitData); n < s.waitSize {
+				s.waitCSeq++
+				return msgMediaChunk
+			}
+
+			s.waitCSeq = 0
+
+			payloadSize := binary.LittleEndian.Uint32(cmd[8:])
+			packetData[0] = bytes.Clone(s.waitData[payloadSize:])
+			packetData[1] = bytes.Clone(s.waitData[:payloadSize])
+
+		case 0x04:
+			data := cmd[24:]
+			hdrSize := binary.LittleEndian.Uint16(cmd[14:])
+			packetData[0] = bytes.Clone(data[:hdrSize])
+			packetData[1] = bytes.Clone(data[hdrSize:])
+
+		default:
+			return msgUnknown
+		}
+
+		select {
+		case s.rawPkt <- packetData:
+		default:
+			return msgError
+		}
+		return msgMediaFrame
+
+	case 0x00:
+		switch cmd[1] {
+		case 0x70:
+			_ = s.SessionWrite(0, s.msgAck0070(cmd))
+			select {
+			case s.rawCmd <- append([]byte{}, cmd[24:]...):
+			default:
+			}
+
+			return msgCommand
+		case 0x12:
+			_ = s.SessionWrite(0, s.msgAck0012(cmd))
+			return msgDafang0012
+		case 0x71:
+			return msgCommandAck
+		}
+	}
+
+	return msgUnknown
+}
+
+func (s *Session16) msgAck0070(msg28 []byte) []byte {
+	// <- 00700800010000000000000000000000340000007625a02f ...
+	// -> 00710800010000000000000000000000000000007625a02f
+	msg := s.Msg(msgHhrSize + cmdHdrSize)
+
+	cmd := msg[msgHhrSize:]
+	copy(cmd, "\x00\x71")
+	copy(cmd[2:], msg28[2:6])    // same version and seq
+	copy(cmd[20:], msg28[20:24]) // same msg random
+
+	return msg
+}
+
+func (s *Session16) msgAck0012(msg28 []byte) []byte {
+	// <- 001208000000000000000000000000000c00000000000000 020000000100000001000000
+	// -> 00130b000000000000000000000000001400000000000000 0200000001000000010000000000000000000000
+	const dataSize = 20
+	msg := s.Msg(msgHhrSize + cmdHdrSize + dataSize)
+
+	cmd := msg[msgHhrSize:]
+	copy(cmd, "\x00\x13\x0b\x00")
+	cmd[16] = dataSize
+
+	data := cmd[cmdHdrSize:]
+	copy(data, msg28[cmdHdrSize:])
+
+	return msg
+}
+
+func (s *Session16) handleCh1(cmd []byte) int {
+	// Channel 1 used for two-way audio. It's important:
+	// - answer on 0000 command with exact config response (can't set simple proto)
+	// - send 0012 command at start
+	// - respond on every 0008 command for smooth playback
+	switch cid := string(cmd[:2]); cid {
+	case "\x00\x00": // client start
+		_ = s.SessionWrite(1, s.msgAck0000(cmd))
+		_ = s.SessionWrite(1, s.msg0012())
+		return msgClientStart
+	case "\x00\x07": // time sync without data
+		_ = s.SessionWrite(1, s.msgAck0007(cmd))
+		return msgUnknown0007
+	case "\x00\x08": // time sync with data
+		_ = s.SessionWrite(1, s.msgAck0008(cmd))
+		return msgUnknown0008
+	case "\x00\x13": // ack for 0012
+		return msgUnknown0013
+	}
+	return msgUnknown
+}
+
+func (s *Session16) msgAck0000(msg28 []byte) []byte {
+	// <- 000008000000000000000000000000001a0200004f47c714 ... 00000000000000000100000004000000fb071f00000000000000000000000300
+	// -> 00140b00000000000000000000000000200000004f47c714     00000000000000000100000004000000fb071f00000000000000000000000300
+	const cmdDataSize = 32
+	msg := s.Msg(msgHhrSize + cmdHdrSize + cmdDataSize)
+
+	cmd := msg[msgHhrSize:]
+	copy(cmd, "\x00\x14\x0b\x00")
+	cmd[16] = cmdDataSize
+	copy(cmd[20:], msg28[20:24]) // request id (random)
+
+	// Important to answer with same data.
+	data := cmd[cmdHdrSize:]
+	copy(data, msg28[len(msg28)-32:])
+	return msg
+}
+
+func (s *Session16) msg0012() []byte {
+	// -> 00120b000000000000000000000000000c00000000000000020000000100000001000000
+	const dataSize = 12
+	msg := s.Msg(msgHhrSize + cmdHdrSize + dataSize)
+	cmd := msg[msgHhrSize:]
+
+	copy(cmd, "\x00\x12\x0b\x00")
+	cmd[16] = dataSize
+	data := cmd[cmdHdrSize:]
+
+	data[0] = 2
+	data[4] = 1
+	data[9] = 1
+	return msg
+}
+
+func (s *Session16) msgAck0007(msg28 []byte) []byte {
+	// <- 000708000000000000000000000000000c00000001000000000000001c551f7a00000000
+	// -> 010a0b00000000000000000000000000000000000100000000000000
+	msg := s.Msg(msgHhrSize + 28)
+	cmd := msg[msgHhrSize:]
+	copy(cmd, "\x01\x0a\x0b\x00")
+	cmd[20] = 1
+	return msg
+}
+
+func (s *Session16) msgAck0008(msg28 []byte) []byte {
+	// <- 000808000000000000000000000000000000f9f0010000000200000050f31f7a
+	// -> 01090b0000000000000000000000000000000000010000000200000050f31f7a
+	msg := s.Msg(msgHhrSize + 28)
+	cmd := msg[msgHhrSize:]
+	copy(cmd, "\x01\x09\x0b\x00")
+	copy(cmd[20:], msg28[20:])
+	return msg
+}
+
+func (s *Session16) SessionWrite(chID byte, buf []byte) error {
+	switch chID {
+	case 0:
+		binary.LittleEndian.PutUint16(buf[6:], s.seqSendCh0)
+		s.seqSendCh0++
+	case 1:
+		binary.LittleEndian.PutUint16(buf[6:], s.seqSendCh1)
+		s.seqSendCh1++
+		buf[14] = 1 // channel
+	}
+	_, err := s.conn.Write(buf)
+	return err
+}
diff --git a/installs_on_host/go2rtc/pkg/tutk/session25.go b/installs_on_host/go2rtc/pkg/tutk/session25.go
new file mode 100644
index 0000000..dc79d3a
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tutk/session25.go
@@ -0,0 +1,337 @@
+package tutk
+
+import (
+	"bytes"
+	"encoding/binary"
+	"net"
+	"time"
+)
+
+func NewSession25(conn net.Conn, sid []byte) *Session25 {
+	return &Session25{
+		Session16: NewSession16(conn, sid),
+		rb:        NewReorderBuffer(5),
+	}
+}
+
+type Session25 struct {
+	*Session16
+
+	rb *ReorderBuffer
+
+	seqSendCmd2 uint16
+	seqSendCnt  uint16
+
+	seqRecvPkt0 uint16
+	seqRecvPkt1 uint16
+	seqRecvCmd2 uint16
+}
+
+const cmdHdrSize25 = 28
+
+func (s *Session25) SendIOCtrl(ctrlType uint32, ctrlData []byte) []byte {
+	size := msgHhrSize + cmdHdrSize25 + 4 + uint16(len(ctrlData))
+	msg := s.Msg(size)
+
+	// 0  0070      command
+	// 2  0b00      version
+	// 4  1000      seq
+	// 6  0076      ???
+	cmd := msg[msgHhrSize:]
+	copy(cmd, "\x00\x70\x0b\x00")
+	binary.LittleEndian.PutUint16(cmd[4:], s.seqSendCmd1)
+	s.seqSendCmd1++
+
+	// 8  0070      command (second time)
+	// 10 0300      seq
+	// 12 0100      chunks count
+	// 14 0000      chunk seq (starts from 0)
+	// 16 5500      size
+	// 18 0000      random msg id (always 0)
+	// 20 03000000  seq (second time)
+	// 24 00000000
+	// 28 01010000  ctrlType
+	cmd[9] = 0x70
+	cmd[12] = 1
+	binary.LittleEndian.PutUint16(cmd[16:], size-52)
+
+	binary.LittleEndian.PutUint16(cmd[10:], s.seqSendCmd2)
+	binary.LittleEndian.PutUint16(cmd[20:], s.seqSendCmd2)
+	s.seqSendCmd2++
+
+	data := cmd[28:]
+	binary.LittleEndian.PutUint32(data, ctrlType)
+	copy(data[4:], ctrlData)
+	return msg
+}
+
+func (s *Session25) SendFrameData(frameInfo, frameData []byte) []byte {
+	return nil
+}
+
+func (s *Session25) SessionRead(chID byte, cmd []byte) (res int) {
+	if chID != 0 {
+		return s.handleCh1(cmd)
+	}
+
+	switch cmd[0] {
+	case 0x03, 0x05, 0x07:
+		for i := 0; cmd != nil; i++ {
+			res = s.handleChunk(cmd, i == 0)
+			cmd = s.rb.Pop()
+		}
+		return
+
+	case 0x00:
+		_ = s.SessionWrite(0, s.msgAckCounters())
+		s.seqRecvCmd2 = binary.LittleEndian.Uint16(cmd[2:])
+
+		switch cmd[1] {
+		case 0x10:
+			return msgUnknown0010 // unknown
+		case 0x21:
+			return msgClientStartAck2
+		case 0x70:
+			select {
+			case s.rawCmd <- cmd[28:]:
+			default:
+			}
+			return msgCommand // cmd from camera
+		case 0x71:
+			return msgCommandAck
+		}
+
+	case 0x09:
+		// off  sample
+		// 0    09000b00  cmd1
+		// 4    0d000000  seqCmd1
+		// 12   0000      seqRecvCmd2
+		seq := binary.LittleEndian.Uint16(cmd[12:])
+		if s.seqSendCmd1 > seq {
+			return msgCommandAck
+		}
+		return msgCounters
+
+	case 0x0a:
+		// seq sample
+		// 0   0a080b00
+		// 4   03000000
+		// 8   e2043200
+		// 12  01000000
+		_ = s.SessionWrite(0, s.msgAck0A08(cmd))
+		return msgUnknown0a08
+	}
+
+	return msgUnknown
+}
+
+func (s *Session25) handleChunk(cmd []byte, checkSeq bool) int {
+	var cmd2 []byte
+
+	flags := cmd[1]
+	if flags&0b1000 == 0 {
+		// off sample
+		// 0   0700      command
+		// 2   0b00      version
+		// 4   2700      seq
+		// 6   0000      ???
+		// 8   0700      command (second time)
+		// 10  1400      seq
+		// 12  1300      chunks count per this frame
+		// 14  1100      chunk seq, starts from 0 (0x20 for last chunk)
+		// 16  0004      frame data size
+		// 18  0000      random msg id (always 0)
+		// 20  02000000  previous frame seq, starts from 0
+		// 24  03000000  current frame seq, starts from 1
+		cmd2 = cmd[8:]
+	} else {
+		// off sample
+		// 0   070d0b00
+		// 4   30000000
+		// 8   5c965500  ???
+		// 12  ffff0000  ???
+		// 16  0701      fixed command
+		// 18  190001002000a802000006000000070000000
+		cmd2 = cmd[16:]
+	}
+
+	seq := binary.LittleEndian.Uint16(cmd2[2:])
+
+	if checkSeq {
+		if s.rb.Check(seq) {
+			s.rb.Next()
+		} else {
+			s.rb.Push(seq, cmd)
+			return msgMediaReorder
+		}
+	}
+
+	// Check if this is first chunk for frame.
+	// Handle protocol bug "0x20 chunk seq for last chunk" and sometimes
+	// "0x20 chunk seq for first chunk if only one chunk".
+	if binary.LittleEndian.Uint16(cmd2[6:]) == 0 || binary.LittleEndian.Uint16(cmd2[4:]) == 1 {
+		s.waitData = s.waitData[:0]
+		s.waitCSeq = seq
+	} else if seq != s.waitCSeq {
+		return msgMediaLost
+	}
+
+	s.waitData = append(s.waitData, cmd2[20:]...)
+
+	if flags&0b0001 == 0 {
+		s.waitCSeq++
+		return msgMediaChunk
+	}
+
+	s.seqRecvPkt1 = seq
+	_ = s.SessionWrite(0, s.msgAckCounters())
+
+	n := len(s.waitData) - 32
+	packetData := [2][]byte{bytes.Clone(s.waitData[n:]), bytes.Clone(s.waitData[:n])}
+
+	select {
+	case s.rawPkt <- packetData:
+	default:
+		return msgError
+	}
+	return msgMediaFrame
+}
+
+func (s *Session25) msgAckCounters() []byte {
+	msg := s.Msg(msgHhrSize + cmdHdrSize)
+
+	// off  sample
+	// 0    09000b00  cmd1
+	// 4    2700      seqCmd1
+	// 6    0000
+	// 8    1300      seqRecvPkt0
+	// 10   2600      seqRecvPkt1
+	// 12   0400      seqRecvCmd2
+	// 14   00000000
+	// 18   1400      seqSendCnt
+	// 20   d91a      random
+	// 22   0000
+	cmd := msg[msgHhrSize:]
+	copy(cmd, "\x09\x00\x0b\x00")
+
+	binary.LittleEndian.PutUint16(cmd[4:], s.seqSendCmd1)
+	s.seqSendCmd1++
+
+	// seqRecvPkt0 stores previous value of seqRecvPkt1
+	// don't understand why this needs
+	binary.LittleEndian.PutUint16(cmd[8:], s.seqRecvPkt0)
+	s.seqRecvPkt0 = s.seqRecvPkt1
+	binary.LittleEndian.PutUint16(cmd[10:], s.seqRecvPkt1)
+	binary.LittleEndian.PutUint16(cmd[12:], s.seqRecvCmd2)
+
+	binary.LittleEndian.PutUint16(cmd[18:], s.seqSendCnt)
+	s.seqSendCnt++
+	binary.LittleEndian.PutUint16(cmd[20:], uint16(time.Now().UnixMilli()))
+	return msg
+}
+
+func (s *Session25) handleCh1(cmd []byte) int {
+	switch cid := string(cmd[:2]); cid {
+	case "\x00\x00": // client start
+		return msgClientStart
+	case "\x00\x07": // time sync without data
+		_ = s.SessionWrite(1, s.msgAck0007(cmd))
+		return msgUnknown0007
+	case "\x00\x20": // client start2
+		_ = s.SessionWrite(1, s.msgAck0020(cmd))
+		return msgClientStart2
+	case "\x09\x00":
+		return msgUnknown0900
+	case "\x0a\x08":
+		return msgUnknown0a08
+	}
+	return msgUnknown
+}
+
+func (s *Session25) msgAck0020(msg28 []byte) []byte {
+	const cmdDataSize = 36
+
+	msg := s.Msg(msgHhrSize + cmdHdrSize25 + cmdDataSize)
+
+	cmd := msg[msgHhrSize:]
+	copy(cmd, "\x00\x21\x0b\x00")
+	cmd[16] = cmdDataSize
+	copy(cmd[20:], msg28[20:24]) // request id (random)
+
+	// 0  00000000
+	// 4  00010001
+	// 8  01000000
+	// 12 04000000
+	// 16 fb071f00
+	// 20 00000000
+	// 24 00000000
+	// 28 00000300
+	// 32 01000000
+	data := cmd[cmdHdrSize25:]
+	data[5] = 1
+	data[7] = 1
+	data[8] = 1
+	data[12] = 4
+	copy(data[16:], "\xfb\x07\x1f\x00")
+	data[30] = 3
+	data[32] = 1
+	return msg
+}
+
+func (s *Session25) msgAck0A08(msg28 []byte) []byte {
+	// <- 0a080b005b0000000b51590002000000
+	// -> 0b000b00000001000b5103000300000000000000
+	msg := s.Msg(msgHhrSize + 20)
+	cmd := msg[msgHhrSize:]
+	copy(cmd, "\x0b\x00\x0b\x00")
+	copy(cmd[8:], msg28[8:10])
+	return msg
+}
+
+// ReorderBuffer used for UDP incoming data. Because the order of the packets may be mixed up.
+type ReorderBuffer struct {
+	buf  map[uint16][]byte
+	seq  uint16
+	size int
+}
+
+func NewReorderBuffer(size int) *ReorderBuffer {
+	return &ReorderBuffer{buf: make(map[uint16][]byte), size: size}
+}
+
+// Check return OK if this is the seq we are waiting for.
+func (r *ReorderBuffer) Check(seq uint16) (ok bool) {
+	return seq == r.seq
+}
+
+func (r *ReorderBuffer) Next() {
+	r.seq++
+}
+
+// Available return how much free slots is in the buffer.
+func (r *ReorderBuffer) Available() int {
+	return r.size - len(r.buf)
+}
+
+// Push new item to buffer. Important! There is no buffer full check here.
+func (r *ReorderBuffer) Push(seq uint16, data []byte) {
+	//log.Printf("push seq=%d wait=%d", seq, r.seq)
+	r.buf[seq] = bytes.Clone(data)
+}
+
+// Pop latest item from buffer. OK - if items wasn't dropped.
+func (r *ReorderBuffer) Pop() []byte {
+	for {
+		if data := r.buf[r.seq]; data != nil {
+			delete(r.buf, r.seq)
+			r.Next()
+			//log.Printf("pop seq=%d", r.seq)
+			return data
+		}
+		if r.Available() > 0 {
+			return nil
+		}
+		//log.Printf("drop seq=%d", r.seq)
+		r.Next() // drop item
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/tuya/README.md b/installs_on_host/go2rtc/pkg/tuya/README.md
new file mode 100644
index 0000000..f193640
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tuya/README.md
@@ -0,0 +1,9 @@
+## Useful links
+
+- https://developer.tuya.com/en/docs/iot/webrtc?id=Kacsd4x2hl0se
+- https://github.com/tuya/webrtc-demo-go
+- https://github.com/bacco007/HomeAssistantConfig/blob/master/custom_components/xtend_tuya/multi_manager/tuya_iot/ipc/webrtc/xt_tuya_iot_webrtc_manager.py
+- https://github.com/tuya/tuya-device-sharing-sdk
+- https://github.com/make-all/tuya-local/blob/main/custom_components/tuya_local/cloud.py
+- https://ipc-us.ismartlife.me/
+- https://protect-us.ismartlife.me/
\ No newline at end of file
diff --git a/installs_on_host/go2rtc/pkg/tuya/client.go b/installs_on_host/go2rtc/pkg/tuya/client.go
new file mode 100644
index 0000000..3043a8d
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tuya/client.go
@@ -0,0 +1,555 @@
+package tuya
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/url"
+	"regexp"
+	"strings"
+	"sync"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/webrtc"
+	"github.com/pion/rtp"
+	pion "github.com/pion/webrtc/v4"
+)
+
+type Client struct {
+	api       TuyaAPI
+	conn      *webrtc.Conn
+	pc        *pion.PeerConnection
+	connected core.Waiter
+	closed    bool
+
+	// HEVC only:
+	dc         *pion.DataChannel
+	videoSSRC  *uint32
+	audioSSRC  *uint32
+	streamType int
+	isHEVC     bool
+	handlersMu sync.RWMutex
+	handlers   map[uint32]func(*rtp.Packet)
+}
+
+type DataChannelMessage struct {
+	Type string `json:"type"` // "codec", "start", "recv", "complete"
+	Msg  string `json:"msg"`
+}
+
+// RecvMessage contains SSRC values for video/audio streams
+type RecvMessage struct {
+	Video struct {
+		SSRC uint32 `json:"ssrc"`
+	} `json:"video"`
+	Audio struct {
+		SSRC uint32 `json:"ssrc"`
+	} `json:"audio"`
+}
+
+func Dial(rawURL string) (core.Producer, error) {
+	escapedURL := strings.ReplaceAll(rawURL, "#", "%23")
+	u, err := url.Parse(escapedURL)
+	if err != nil {
+		return nil, err
+	}
+
+	query := u.Query()
+
+	// Tuya Smart API
+	email := query.Get("email")
+	password := query.Get("password")
+
+	// Tuya Cloud API
+	uid := query.Get("uid")
+	clientId := query.Get("client_id")
+	clientSecret := query.Get("client_secret")
+
+	// Shared params
+	deviceId := query.Get("device_id")
+
+	// Stream params
+	streamResolution := query.Get("resolution")
+
+	useSmartApi := deviceId != "" && email != "" && password != ""
+	useCloudApi := deviceId != "" && uid != "" && clientId != "" && clientSecret != ""
+
+	if streamResolution == "" || (streamResolution != "hd" && streamResolution != "sd") {
+		streamResolution = "hd"
+	}
+
+	if !useSmartApi && !useCloudApi {
+		return nil, errors.New("tuya: wrong query params")
+	}
+
+	client := &Client{
+		handlers: make(map[uint32]func(*rtp.Packet)),
+	}
+
+	if useSmartApi {
+		if client.api, err = NewTuyaSmartApiClient(nil, u.Hostname(), email, password, deviceId); err != nil {
+			return nil, fmt.Errorf("tuya: %w", err)
+		}
+	} else {
+		if client.api, err = NewTuyaCloudApiClient(u.Hostname(), uid, deviceId, clientId, clientSecret); err != nil {
+			return nil, fmt.Errorf("tuya: %w", err)
+		}
+	}
+
+	if err := client.api.Init(); err != nil {
+		return nil, fmt.Errorf("tuya: %w", err)
+	}
+
+	client.streamType = client.api.GetStreamType(streamResolution)
+	client.isHEVC = client.api.IsHEVC(client.streamType)
+
+	// Create a new PeerConnection
+	conf := pion.Configuration{
+		ICEServers:         client.api.GetICEServers(),
+		ICETransportPolicy: pion.ICETransportPolicyAll,
+		BundlePolicy:       pion.BundlePolicyMaxBundle,
+	}
+
+	api, err := webrtc.NewAPI()
+	if err != nil {
+		client.Close(err)
+		return nil, err
+	}
+
+	client.pc, err = api.NewPeerConnection(conf)
+	if err != nil {
+		client.Close(err)
+		return nil, err
+	}
+
+	// protect from sending ICE candidate before Offer
+	var sendOffer core.Waiter
+
+	// protect from blocking on errors
+	defer sendOffer.Done(nil)
+
+	// Create new WebRTC connection
+	client.conn = webrtc.NewConn(client.pc)
+	client.conn.FormatName = "tuya/webrtc"
+	client.conn.Mode = core.ModeActiveProducer
+	client.conn.Protocol = "mqtt"
+
+	mqttClient := client.api.GetMqtt()
+	if mqttClient == nil {
+		err = errors.New("tuya: no mqtt client")
+		client.Close(err)
+		return nil, err
+	}
+
+	// Set up MQTT handlers
+	mqttClient.handleAnswer = func(answer AnswerFrame) {
+		// fmt.Printf("tuya: answer: %s\n", answer.Sdp)
+
+		desc := pion.SessionDescription{
+			Type: pion.SDPTypePranswer,
+			SDP:  answer.Sdp,
+		}
+
+		if err = client.pc.SetRemoteDescription(desc); err != nil {
+			client.Close(err)
+			return
+		}
+
+		if err = client.conn.SetAnswer(answer.Sdp); err != nil {
+			client.Close(err)
+			return
+		}
+
+		if client.isHEVC {
+			// Tuya responds with H264/90000 even for HEVC streams
+			// So we need to replace video codecs with HEVC ones from API
+			for _, media := range client.conn.Medias {
+				if media.Kind == core.KindVideo {
+					codecs := client.api.GetVideoCodecs()
+					if codecs != nil {
+						media.Codecs = codecs
+					}
+				}
+			}
+
+			// Audio codecs from API as well
+			// Tuya responds with multiple audio codecs (PCMU, PCMA)
+			// But the quality is bad if we use PCMU and skill only has PCMA
+			for _, media := range client.conn.Medias {
+				if media.Kind == core.KindAudio {
+					codecs := client.api.GetAudioCodecs()
+					if codecs != nil {
+						media.Codecs = codecs
+					}
+				}
+			}
+		}
+	}
+
+	mqttClient.handleCandidate = func(candidate CandidateFrame) {
+		// fmt.Printf("tuya: candidate: %s\n", candidate.Candidate)
+
+		if candidate.Candidate != "" {
+			client.conn.AddCandidate(candidate.Candidate)
+			if err != nil {
+				client.Close(err)
+			}
+		}
+	}
+
+	mqttClient.handleDisconnect = func() {
+		// fmt.Println("tuya: disconnect")
+		client.Close(errors.New("mqtt: disconnect"))
+	}
+
+	mqttClient.handleError = func(err error) {
+		// fmt.Printf("tuya: error: %s\n", err.Error())
+		client.Close(err)
+	}
+
+	if client.isHEVC {
+		maxRetransmits := uint16(5)
+		ordered := true
+		client.dc, err = client.pc.CreateDataChannel("fmp4Stream", &pion.DataChannelInit{
+			MaxRetransmits: &maxRetransmits,
+			Ordered:        &ordered,
+		})
+
+		// DataChannel receives two types of messages:
+		// 1. String messages: Control messages (codec, recv)
+		// 2. Binary messages: RTP packets with video/audio
+		client.dc.OnMessage(func(msg pion.DataChannelMessage) {
+			if msg.IsString {
+				// Handle control messages (codec, recv, etc.)
+				if connected, err := client.probe(msg); err != nil {
+					client.Close(err)
+				} else if connected {
+					client.connected.Done(nil)
+				}
+			} else {
+				// Handle RTP packets - Route by SSRC retrieved from "recv" message
+				packet := &rtp.Packet{}
+				if err := packet.Unmarshal(msg.Data); err != nil {
+					// Skip invalid packets
+					return
+				}
+
+				if handler, ok := client.getHandler(packet.SSRC); ok {
+					handler(packet)
+				}
+			}
+		})
+
+		client.dc.OnError(func(err error) {
+			// fmt.Printf("tuya: datachannel error: %s\n", err.Error())
+			client.Close(err)
+		})
+
+		client.dc.OnClose(func() {
+			// fmt.Println("tuya: datachannel closed")
+			client.Close(errors.New("datachannel: closed"))
+		})
+
+		client.dc.OnOpen(func() {
+			// fmt.Println("tuya: datachannel opened")
+
+			codecRequest, _ := json.Marshal(DataChannelMessage{
+				Type: "codec",
+				Msg:  "",
+			})
+
+			if err := client.sendMessageToDataChannel(codecRequest); err != nil {
+				client.Close(fmt.Errorf("failed to send codec request: %w", err))
+			}
+		})
+	}
+
+	// Set up pc handler
+	client.conn.Listen(func(msg any) {
+		switch msg := msg.(type) {
+		case *pion.ICECandidate:
+			_ = sendOffer.Wait()
+			if err := mqttClient.SendCandidate("a=" + msg.ToJSON().Candidate); err != nil {
+				client.Close(err)
+			}
+
+		case pion.PeerConnectionState:
+			switch msg {
+			case pion.PeerConnectionStateNew:
+				break
+			case pion.PeerConnectionStateConnecting:
+				break
+			case pion.PeerConnectionStateConnected:
+				// On HEVC, wait for DataChannel to be opened and camera to send codec info
+				if !client.isHEVC {
+					if streamResolution == "hd" {
+						_ = mqttClient.SendResolution(0)
+					}
+					client.connected.Done(nil)
+				}
+			case pion.PeerConnectionStateClosed:
+				client.Close(errors.New("webrtc: " + msg.String()))
+			default:
+				// client.Close(errors.New("webrtc: " + msg.String()))
+			}
+		}
+	})
+
+	// Audio first, otherwise tuya will send corrupt sdp
+	medias := []*core.Media{
+		{Kind: core.KindAudio, Direction: core.DirectionSendRecv},
+		{Kind: core.KindVideo, Direction: core.DirectionRecvonly},
+	}
+
+	// Create offer
+	offer, err := client.conn.CreateOffer(medias)
+	if err != nil {
+		client.Close(err)
+		return nil, err
+	}
+
+	// horter sdp, remove a=extmap... line, device ONLY allow 8KB json payload
+	// https://github.com/tuya/webrtc-demo-go/blob/04575054f18ccccb6bc9d82939dd46d449544e20/static/js/main.js#L224
+	re := regexp.MustCompile(`\r\na=extmap[^\r\n]*`)
+	offer = re.ReplaceAllString(offer, "")
+
+	// Send offer
+	if err := mqttClient.SendOffer(offer, streamResolution, client.streamType, client.isHEVC); err != nil {
+		err = fmt.Errorf("tuya: %w", err)
+		client.Close(err)
+		return nil, err
+	}
+
+	sendOffer.Done(nil)
+
+	// Wait for connection
+	if err = client.connected.Wait(); err != nil {
+		err = fmt.Errorf("tuya: %w", err)
+		client.Close(err)
+		return nil, err
+	}
+
+	return client, nil
+}
+
+func (c *Client) GetMedias() []*core.Media {
+	return c.conn.GetMedias()
+}
+
+func (c *Client) GetTrack(media *core.Media, codec *core.Codec) (*core.Receiver, error) {
+	return c.conn.GetTrack(media, codec)
+}
+
+func (c *Client) AddTrack(media *core.Media, codec *core.Codec, track *core.Receiver) error {
+	localTrack := c.conn.GetSenderTrack(media.ID)
+	if localTrack == nil {
+		return errors.New("webrtc: can't get track")
+	}
+
+	// DISABLED: Speaker Protocol 312 command
+	// JavaScript client doesn't send this on first call either
+	// Only subsequent calls (when speakerChloron is set) send Protocol 312
+	// mqttClient := c.api.GetMqtt()
+	// if mqttClient != nil {
+	// 	_ = mqttClient.SendSpeaker(1)
+	// }
+
+	payloadType := codec.PayloadType
+
+	sender := core.NewSender(media, codec)
+
+	switch track.Codec.Name {
+	case core.CodecPCMA, core.CodecPCMU, core.CodecPCM, core.CodecPCML:
+		// Frame size affects audio delay with Tuya cameras:
+		// Browser sends standard 20ms frames (160 bytes for G.711), but this causes
+		// up to 4s delay on some Tuya cameras. Increasing to 240 bytes (30ms) reduces
+		// delay to ~2s. Higher values (320+ bytes) don't work and cause issues.
+		// Using 240 bytes (30ms) as optimal balance between latency and stability.
+		frameSize := 240
+
+		var buf []byte
+		var seq uint16
+		var ts uint32
+
+		sender.Handler = func(packet *rtp.Packet) {
+			buf = append(buf, packet.Payload...)
+
+			for len(buf) >= frameSize {
+				payload := buf[:frameSize]
+
+				pkt := &rtp.Packet{
+					Header: rtp.Header{
+						Version:        2,
+						Marker:         true,
+						PayloadType:    payloadType,
+						SequenceNumber: seq,
+						Timestamp:      ts,
+						SSRC:           packet.SSRC,
+					},
+					Payload: payload,
+				}
+
+				seq++
+				ts += uint32(frameSize)
+				buf = buf[frameSize:]
+
+				c.conn.Send += pkt.MarshalSize()
+				_ = localTrack.WriteRTP(payloadType, pkt)
+			}
+		}
+
+	default:
+		sender.Handler = func(packet *rtp.Packet) {
+			c.conn.Send += packet.MarshalSize()
+			_ = localTrack.WriteRTP(payloadType, packet)
+		}
+	}
+
+	sender.HandleRTP(track)
+	c.conn.Senders = append(c.conn.Senders, sender)
+
+	return nil
+}
+
+func (c *Client) Start() error {
+	if len(c.conn.Receivers) == 0 {
+		return errors.New("tuya: no receivers")
+	}
+
+	var video, audio *core.Receiver
+	for _, receiver := range c.conn.Receivers {
+		if receiver.Codec.IsVideo() {
+			video = receiver
+		} else if receiver.Codec.IsAudio() {
+			audio = receiver
+		}
+	}
+
+	if c.videoSSRC != nil {
+		c.setHandler(*c.videoSSRC, func(packet *rtp.Packet) {
+			if video != nil {
+				video.WriteRTP(packet)
+			}
+		})
+	}
+
+	if c.audioSSRC != nil {
+		c.setHandler(*c.audioSSRC, func(packet *rtp.Packet) {
+			if audio != nil {
+				audio.WriteRTP(packet)
+			}
+		})
+	}
+
+	return c.conn.Start()
+}
+
+func (c *Client) Stop() error {
+	if c.closed {
+		return nil
+	}
+
+	c.closed = true
+
+	c.clearHandlers()
+
+	if c.conn != nil {
+		_ = c.conn.Stop()
+	}
+
+	if c.api != nil {
+		c.api.Close()
+	}
+
+	return nil
+}
+
+func (c *Client) Close(err error) error {
+	c.connected.Done(err)
+	return c.Stop()
+}
+
+func (c *Client) MarshalJSON() ([]byte, error) {
+	return c.conn.MarshalJSON()
+}
+
+func (c *Client) setHandler(ssrc uint32, handler func(*rtp.Packet)) {
+	c.handlersMu.Lock()
+	defer c.handlersMu.Unlock()
+	c.handlers[ssrc] = handler
+}
+
+func (c *Client) getHandler(ssrc uint32) (func(*rtp.Packet), bool) {
+	c.handlersMu.RLock()
+	defer c.handlersMu.RUnlock()
+	handler, ok := c.handlers[ssrc]
+	return handler, ok
+}
+
+func (c *Client) clearHandlers() {
+	c.handlersMu.Lock()
+	defer c.handlersMu.Unlock()
+	for ssrc := range c.handlers {
+		delete(c.handlers, ssrc)
+	}
+}
+
+func (c *Client) probe(msg pion.DataChannelMessage) (bool, error) {
+	// fmt.Printf("[tuya] Received string message: %s\n", string(msg.Data))
+
+	var message DataChannelMessage
+	if err := json.Unmarshal([]byte(msg.Data), &message); err != nil {
+		return false, err
+	}
+
+	switch message.Type {
+	case "codec":
+		// Camera responded to our codec request - now request frame start
+		frameRequest, _ := json.Marshal(DataChannelMessage{
+			Type: "start",
+			Msg:  "frame",
+		})
+
+		err := c.sendMessageToDataChannel(frameRequest)
+		if err != nil {
+			return false, err
+		}
+
+	case "recv":
+		// Camera sends SSRC values for video/audio streams
+		// We need these to route incoming RTP packets correctly
+		var recvMessage RecvMessage
+		if err := json.Unmarshal([]byte(message.Msg), &recvMessage); err != nil {
+			return false, err
+		}
+
+		videoSSRC := recvMessage.Video.SSRC
+		audioSSRC := recvMessage.Audio.SSRC
+		c.videoSSRC = &videoSSRC
+		c.audioSSRC = &audioSSRC
+
+		// Send "complete" to tell camera we're ready to receive RTP packets
+		completeMsg, _ := json.Marshal(DataChannelMessage{
+			Type: "complete",
+			Msg:  "",
+		})
+
+		err := c.sendMessageToDataChannel(completeMsg)
+		if err != nil {
+			return false, err
+		}
+
+		return true, nil
+	}
+
+	return false, nil
+}
+
+func (c *Client) sendMessageToDataChannel(message []byte) error {
+	if c.dc != nil {
+		// fmt.Printf("[tuya] sending message to data channel: %s\n", message)
+		return c.dc.Send(message)
+	}
+
+	return nil
+}
diff --git a/installs_on_host/go2rtc/pkg/tuya/cloud_api.go b/installs_on_host/go2rtc/pkg/tuya/cloud_api.go
new file mode 100644
index 0000000..c34d0fe
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tuya/cloud_api.go
@@ -0,0 +1,322 @@
+package tuya
+
+import (
+	"bytes"
+	"crypto/md5"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/webrtc"
+	"github.com/google/uuid"
+)
+
+type Token struct {
+	UID          string `json:"uid"`
+	AccessToken  string `json:"access_token"`
+	RefreshToken string `json:"refresh_token"`
+	ExpireTime   int64  `json:"expire_time"`
+}
+
+type WebRTCConfigResponse struct {
+	Timestamp int64        `json:"t"`
+	Success   bool         `json:"success"`
+	Result    WebRTCConfig `json:"result"`
+	Msg       string       `json:"msg,omitempty"`
+	Code      int          `json:"code,omitempty"`
+}
+
+type TokenResponse struct {
+	Timestamp int64  `json:"t"`
+	Success   bool   `json:"success"`
+	Result    Token  `json:"result"`
+	Msg       string `json:"msg,omitempty"`
+	Code      int    `json:"code,omitempty"`
+}
+
+type OpenIoTHubConfigRequest struct {
+	UID      string `json:"uid"`
+	UniqueID string `json:"unique_id"`
+	LinkType string `json:"link_type"`
+	Topics   string `json:"topics"`
+}
+
+type OpenIoTHubConfig struct {
+	Url       string `json:"url"`
+	ClientID  string `json:"client_id"`
+	Username  string `json:"username"`
+	Password  string `json:"password"`
+	SinkTopic struct {
+		IPC string `json:"ipc"`
+	} `json:"sink_topic"`
+	SourceSink struct {
+		IPC string `json:"ipc"`
+	} `json:"source_topic"`
+	ExpireTime int `json:"expire_time"`
+}
+
+type OpenIoTHubConfigResponse struct {
+	Timestamp int              `json:"t"`
+	Success   bool             `json:"success"`
+	Result    OpenIoTHubConfig `json:"result"`
+	Msg       string           `json:"msg,omitempty"`
+	Code      int              `json:"code,omitempty"`
+}
+
+type TuyaCloudApiClient struct {
+	TuyaClient
+	uid             string
+	clientId        string
+	clientSecret    string
+	accessToken     string
+	refreshToken    string
+	refreshingToken bool
+}
+
+func NewTuyaCloudApiClient(baseUrl, uid, deviceId, clientId, clientSecret string) (*TuyaCloudApiClient, error) {
+	mqttClient := NewTuyaMqttClient(deviceId)
+
+	client := &TuyaCloudApiClient{
+		TuyaClient: TuyaClient{
+			httpClient: &http.Client{Timeout: 15 * time.Second},
+			mqtt:       mqttClient,
+			deviceId:   deviceId,
+			expireTime: 0,
+			baseUrl:    baseUrl,
+		},
+		uid:             uid,
+		clientId:        clientId,
+		clientSecret:    clientSecret,
+		refreshingToken: false,
+	}
+
+	return client, nil
+}
+
+// WebRTC Flow
+func (c *TuyaCloudApiClient) Init() error {
+	if err := c.initToken(); err != nil {
+		return fmt.Errorf("failed to initialize token: %w", err)
+	}
+
+	webrtcConfig, err := c.loadWebrtcConfig()
+	if err != nil {
+		return fmt.Errorf("failed to load webrtc config: %w", err)
+	}
+
+	hubConfig, err := c.loadHubConfig()
+	if err != nil {
+		return fmt.Errorf("failed to load hub config: %w", err)
+	}
+
+	if err := c.mqtt.Start(hubConfig, webrtcConfig, c.skill.WebRTC); err != nil {
+		return fmt.Errorf("failed to start MQTT: %w", err)
+	}
+
+	if c.skill.LowPower > 0 {
+		_ = c.mqtt.WakeUp(c.localKey)
+	}
+
+	return nil
+}
+
+func (c *TuyaCloudApiClient) GetStreamUrl(streamType string) (streamUrl string, err error) {
+	if err := c.initToken(); err != nil {
+		return "", fmt.Errorf("failed to initialize token: %w", err)
+	}
+
+	url := fmt.Sprintf("https://%s/v1.0/devices/%s/stream/actions/allocate", c.baseUrl, c.deviceId)
+
+	request := &AllocateRequest{
+		Type: streamType,
+	}
+
+	body, err := c.request("POST", url, request)
+	if err != nil {
+		return "", err
+	}
+
+	var allocResponse AllocateResponse
+	err = json.Unmarshal(body, &allocResponse)
+	if err != nil {
+		return "", err
+	}
+
+	if !allocResponse.Success {
+		return "", errors.New(allocResponse.Msg)
+	}
+
+	return allocResponse.Result.URL, nil
+}
+
+func (c *TuyaCloudApiClient) initToken() (err error) {
+	if c.refreshingToken {
+		return nil
+	}
+
+	now := time.Now().Unix()
+	if (c.expireTime - 60) > now {
+		return nil
+	}
+
+	c.refreshingToken = true
+
+	url := fmt.Sprintf("https://%s/v1.0/token?grant_type=1", c.baseUrl)
+
+	c.accessToken = ""
+	c.refreshToken = ""
+
+	body, err := c.request("GET", url, nil)
+	if err != nil {
+		return err
+	}
+
+	var tokenResponse TokenResponse
+	err = json.Unmarshal(body, &tokenResponse)
+	if err != nil {
+		return err
+	}
+
+	if !tokenResponse.Success {
+		return errors.New(tokenResponse.Msg)
+	}
+
+	c.accessToken = tokenResponse.Result.AccessToken
+	c.refreshToken = tokenResponse.Result.RefreshToken
+	c.expireTime = tokenResponse.Timestamp + tokenResponse.Result.ExpireTime
+	c.refreshingToken = false
+
+	return nil
+}
+
+func (c *TuyaCloudApiClient) loadWebrtcConfig() (*WebRTCConfig, error) {
+	url := fmt.Sprintf("https://%s/v1.0/users/%s/devices/%s/webrtc-configs", c.baseUrl, c.uid, c.deviceId)
+
+	body, err := c.request("GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	var webRTCConfigResponse WebRTCConfigResponse
+	err = json.Unmarshal(body, &webRTCConfigResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	if !webRTCConfigResponse.Success {
+		return nil, fmt.Errorf(webRTCConfigResponse.Msg)
+	}
+
+	err = json.Unmarshal([]byte(webRTCConfigResponse.Result.Skill), &c.skill)
+	if err != nil {
+		return nil, err
+	}
+
+	// Store LocalKey (not sure if cloud api provides this, but we need it for low power cameras)
+	c.localKey = webRTCConfigResponse.Result.LocalKey
+
+	iceServers, err := json.Marshal(&webRTCConfigResponse.Result.P2PConfig.Ices)
+	if err != nil {
+		return nil, err
+	}
+
+	c.iceServers, err = webrtc.UnmarshalICEServers(iceServers)
+	if err != nil {
+		return nil, err
+	}
+
+	return &webRTCConfigResponse.Result, nil
+}
+
+func (c *TuyaCloudApiClient) loadHubConfig() (config *MQTTConfig, err error) {
+	url := fmt.Sprintf("https://%s/v2.0/open-iot-hub/access/config", c.baseUrl)
+
+	request := &OpenIoTHubConfigRequest{
+		UID:      c.uid,
+		UniqueID: uuid.New().String(),
+		LinkType: "mqtt",
+		Topics:   "ipc",
+	}
+
+	body, err := c.request("POST", url, request)
+	if err != nil {
+		return nil, err
+	}
+
+	var openIoTHubConfigResponse OpenIoTHubConfigResponse
+	err = json.Unmarshal(body, &openIoTHubConfigResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	if !openIoTHubConfigResponse.Success {
+		return nil, fmt.Errorf(openIoTHubConfigResponse.Msg)
+	}
+
+	return &MQTTConfig{
+		Url:            openIoTHubConfigResponse.Result.Url,
+		Username:       openIoTHubConfigResponse.Result.Username,
+		Password:       openIoTHubConfigResponse.Result.Password,
+		ClientID:       openIoTHubConfigResponse.Result.ClientID,
+		PublishTopic:   openIoTHubConfigResponse.Result.SinkTopic.IPC,
+		SubscribeTopic: openIoTHubConfigResponse.Result.SourceSink.IPC,
+	}, nil
+}
+
+func (c *TuyaCloudApiClient) request(method string, url string, body any) ([]byte, error) {
+	var bodyReader io.Reader
+	if body != nil {
+		jsonBody, err := json.Marshal(body)
+		if err != nil {
+			return nil, err
+		}
+		bodyReader = bytes.NewReader(jsonBody)
+	}
+
+	req, err := http.NewRequest(method, url, bodyReader)
+	if err != nil {
+		return nil, err
+	}
+
+	ts := time.Now().UnixNano() / 1000000
+	sign := c.calBusinessSign(ts)
+
+	req.Header.Set("Accept", "*")
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Access-Control-Allow-Origin", "*")
+	req.Header.Set("Access-Control-Allow-Methods", "*")
+	req.Header.Set("Access-Control-Allow-Headers", "*")
+	req.Header.Set("mode", "no-cors")
+	req.Header.Set("client_id", c.clientId)
+	req.Header.Set("access_token", c.accessToken)
+	req.Header.Set("sign", sign)
+	req.Header.Set("t", strconv.FormatInt(ts, 10))
+
+	response, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer response.Body.Close()
+
+	res, err := io.ReadAll(response.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	if response.StatusCode != http.StatusOK {
+		return nil, err
+	}
+
+	return res, nil
+}
+
+func (c *TuyaCloudApiClient) calBusinessSign(ts int64) string {
+	data := fmt.Sprintf("%s%s%s%d", c.clientId, c.accessToken, c.clientSecret, ts)
+	val := md5.Sum([]byte(data))
+	res := fmt.Sprintf("%X", val)
+	return res
+}
diff --git a/installs_on_host/go2rtc/pkg/tuya/helper.go b/installs_on_host/go2rtc/pkg/tuya/helper.go
new file mode 100644
index 0000000..7c9eb41
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tuya/helper.go
@@ -0,0 +1,69 @@
+package tuya
+
+import (
+	"crypto/md5"
+	cryptoRand "crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"encoding/hex"
+	"encoding/pem"
+	"errors"
+	"net/http"
+	"net/http/cookiejar"
+	"regexp"
+	"time"
+
+	"golang.org/x/net/publicsuffix"
+)
+
+func EncryptPassword(password, pbKey string) (string, error) {
+	// Hash password with MD5
+	hasher := md5.New()
+	hasher.Write([]byte(password))
+	hashedPassword := hex.EncodeToString(hasher.Sum(nil))
+
+	// Decode PEM public key
+	block, _ := pem.Decode([]byte("-----BEGIN PUBLIC KEY-----\n" + pbKey + "\n-----END PUBLIC KEY-----"))
+	if block == nil {
+		return "", errors.New("failed to decode PEM block")
+	}
+
+	pubKey, err := x509.ParsePKIXPublicKey(block.Bytes)
+	if err != nil {
+		return "", err
+	}
+
+	rsaPubKey, ok := pubKey.(*rsa.PublicKey)
+	if !ok {
+		return "", errors.New("not an RSA public key")
+	}
+
+	// Encrypt with RSA
+	encrypted, err := rsa.EncryptPKCS1v15(cryptoRand.Reader, rsaPubKey, []byte(hashedPassword))
+	if err != nil {
+		return "", err
+	}
+
+	// Convert to hex string
+	return hex.EncodeToString(encrypted), nil
+}
+
+func IsEmailAddress(input string) bool {
+	emailRegex := regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)
+	return emailRegex.MatchString(input)
+}
+
+func CreateHTTPClientWithSession() *http.Client {
+	jar, err := cookiejar.New(&cookiejar.Options{
+		PublicSuffixList: publicsuffix.List,
+	})
+
+	if err != nil {
+		return nil
+	}
+
+	return &http.Client{
+		Timeout: 30 * time.Second,
+		Jar:     jar,
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/tuya/interface.go b/installs_on_host/go2rtc/pkg/tuya/interface.go
new file mode 100644
index 0000000..25ba0dd
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tuya/interface.go
@@ -0,0 +1,270 @@
+package tuya
+
+import (
+	"net/http"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	pionWebrtc "github.com/pion/webrtc/v4"
+)
+
+type TuyaAPI interface {
+	GetMqtt() *TuyaMqttClient
+
+	GetStreamType(streamResolution string) int
+	IsHEVC(streamType int) bool
+
+	GetVideoCodecs() []*core.Codec
+	GetAudioCodecs() []*core.Codec
+
+	GetStreamUrl(streamUrl string) (string, error)
+	GetICEServers() []pionWebrtc.ICEServer
+
+	Init() error
+	Close()
+}
+
+type TuyaClient struct {
+	TuyaAPI
+
+	httpClient *http.Client
+	mqtt       *TuyaMqttClient
+	baseUrl    string
+	expireTime int64
+	deviceId   string
+	localKey   string
+	skill      *Skill
+	iceServers []pionWebrtc.ICEServer
+}
+
+type AudioAttributes struct {
+	CallMode           []int `json:"call_mode"`           // 1 = one way, 2 = two way
+	HardwareCapability []int `json:"hardware_capability"` // 1 = mic, 2 = speaker
+}
+
+type ICEServer struct {
+	Urls       string `json:"urls"`
+	Username   string `json:"username,omitempty"`
+	Credential string `json:"credential,omitempty"`
+	TTL        int    `json:"ttl,omitempty"`
+}
+
+type WebICE struct {
+	Urls       string `json:"urls"`
+	Username   string `json:"username,omitempty"`
+	Credential string `json:"credential,omitempty"`
+}
+
+type P2PConfig struct {
+	Ices []ICEServer `json:"ices"`
+}
+
+type AudioSkill struct {
+	Channels   int `json:"channels"`
+	DataBit    int `json:"dataBit"`
+	CodecType  int `json:"codecType"`
+	SampleRate int `json:"sampleRate"`
+}
+
+type VideoSkill struct {
+	StreamType int    `json:"streamType"` // 2 = main stream (HD), 4 = sub stream (SD)
+	CodecType  int    `json:"codecType"`  // 2 = H264, 4 = H265 (HEVC)
+	Width      int    `json:"width"`
+	Height     int    `json:"height"`
+	SampleRate int    `json:"sampleRate"`
+	ProfileId  string `json:"profileId,omitempty"`
+}
+
+type Skill struct {
+	WebRTC   int          `json:"webrtc"`             // Bit flags: bit 4=speaker, bit 5=clarity, bit 6=record
+	LowPower int          `json:"lowPower,omitempty"` // 1 = battery-powered camera
+	Audios   []AudioSkill `json:"audios"`
+	Videos   []VideoSkill `json:"videos"`
+}
+
+type WebRTCConfig struct {
+	AudioAttributes      AudioAttributes `json:"audio_attributes"`
+	Auth                 string          `json:"auth"`
+	ID                   string          `json:"id"`
+	LocalKey             string          `json:"local_key,omitempty"`
+	MotoID               string          `json:"moto_id"`
+	P2PConfig            P2PConfig       `json:"p2p_config"`
+	ProtocolVersion      string          `json:"protocol_version"`
+	Skill                string          `json:"skill"`
+	SupportsWebRTCRecord bool            `json:"supports_webrtc_record"`
+	SupportsWebRTC       bool            `json:"supports_webrtc"`
+	VedioClaritiy        int             `json:"vedio_clarity"`
+	VideoClaritiy        int             `json:"video_clarity"`
+	VideoClarities       []int           `json:"video_clarities"`
+}
+
+type MQTTConfig struct {
+	Url            string `json:"url"`
+	PublishTopic   string `json:"publish_topic"`
+	SubscribeTopic string `json:"subscribe_topic"`
+	ClientID       string `json:"client_id"`
+	Username       string `json:"username"`
+	Password       string `json:"password"`
+}
+
+type Allocate struct {
+	URL string `json:"url"`
+}
+
+type AllocateRequest struct {
+	Type string `json:"type"`
+}
+
+type AllocateResponse struct {
+	Success bool     `json:"success"`
+	Result  Allocate `json:"result"`
+	Msg     string   `json:"msg,omitempty"`
+}
+
+func (c *TuyaClient) GetICEServers() []pionWebrtc.ICEServer {
+	return c.iceServers
+}
+
+func (c *TuyaClient) GetMqtt() *TuyaMqttClient {
+	return c.mqtt
+}
+
+// GetStreamType returns the Skill StreamType for the requested resolution
+// Returns Skill values (2 or 4), not MQTT values (0 or 1)
+// - "hd" → highest resolution streamType (usually 2 = mainStream)
+// - "sd" → lowest resolution streamType (usually 4 = substream)
+//
+// These values must be mapped before sending to MQTT:
+// - streamType 2 → MQTT stream_type 0
+// - streamType 4 → MQTT stream_type 1
+func (c *TuyaClient) GetStreamType(streamResolution string) int {
+	// Default streamType if nothing is found
+	defaultStreamType := 1
+
+	if c.skill == nil || len(c.skill.Videos) == 0 {
+		return defaultStreamType
+	}
+
+	// Find the highest and lowest resolution based on pixel count
+	var highestResType = defaultStreamType
+	var highestRes = 0
+	var lowestResType = defaultStreamType
+	var lowestRes = 0
+
+	for _, video := range c.skill.Videos {
+		res := video.Width * video.Height
+
+		// Highest Resolution
+		if res > highestRes {
+			highestRes = res
+			highestResType = video.StreamType
+		}
+
+		// Lower Resolution (or first if not set yet)
+		if lowestRes == 0 || res < lowestRes {
+			lowestRes = res
+			lowestResType = video.StreamType
+		}
+	}
+
+	// Return the streamType based on the selection
+	switch streamResolution {
+	case "hd":
+		return highestResType
+	case "sd":
+		return lowestResType
+	default:
+		return defaultStreamType
+	}
+}
+
+// IsHEVC checks if the given streamType uses H265 (HEVC) codec
+// HEVC cameras use DataChannel, H264 cameras use RTP tracks
+// - codecType 4 = H265 (HEVC) → DataChannel mode
+// - codecType 2 = H264 → Normal RTP mode
+func (c *TuyaClient) IsHEVC(streamType int) bool {
+	for _, video := range c.skill.Videos {
+		if video.StreamType == streamType {
+			return video.CodecType == 4 // 4 = H265/HEVC
+		}
+	}
+
+	return false
+}
+
+func (c *TuyaClient) GetVideoCodecs() []*core.Codec {
+	if len(c.skill.Videos) > 0 {
+		codecs := make([]*core.Codec, 0)
+
+		for _, video := range c.skill.Videos {
+			name := core.CodecH264
+			if c.IsHEVC(video.StreamType) {
+				name = core.CodecH265
+			}
+
+			codec := &core.Codec{
+				Name:      name,
+				ClockRate: uint32(video.SampleRate),
+			}
+
+			codecs = append(codecs, codec)
+		}
+
+		if len(codecs) > 0 {
+			return codecs
+		}
+	}
+
+	return nil
+}
+
+func (c *TuyaClient) GetAudioCodecs() []*core.Codec {
+	if len(c.skill.Audios) > 0 {
+		codecs := make([]*core.Codec, 0)
+
+		for _, audio := range c.skill.Audios {
+			name := getAudioCodecName(&audio)
+
+			codec := &core.Codec{
+				Name:      name,
+				ClockRate: uint32(audio.SampleRate),
+				Channels:  uint8(audio.Channels),
+			}
+			codecs = append(codecs, codec)
+		}
+
+		if len(codecs) > 0 {
+			return codecs
+		}
+	}
+
+	return nil
+}
+
+func (c *TuyaClient) Close() {
+	c.mqtt.Stop()
+	c.httpClient.CloseIdleConnections()
+}
+
+// https://protect-us.ismartlife.me/
+func getAudioCodecName(audioSkill *AudioSkill) string {
+	switch audioSkill.CodecType {
+	// case 100:
+	// 	return "ADPCM"
+	case 101:
+		return core.CodecPCML
+	case 102, 103, 104:
+		return core.CodecAAC
+	case 105:
+		return core.CodecPCMU
+	case 106:
+		return core.CodecPCMA
+	// case 107:
+	// 	return "G726-32"
+	// case 108:
+	// 	return "SPEEX"
+	case 109:
+		return core.CodecMP3
+	default:
+		return core.CodecPCML
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/tuya/mqtt.go b/installs_on_host/go2rtc/pkg/tuya/mqtt.go
new file mode 100644
index 0000000..5f64ef4
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tuya/mqtt.go
@@ -0,0 +1,436 @@
+package tuya
+
+import (
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"hash/crc32"
+	"strings"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	mqtt "github.com/eclipse/paho.mqtt.golang"
+)
+
+type TuyaMqttClient struct {
+	client           mqtt.Client
+	waiter           core.Waiter
+	wakeupWaiter     core.Waiter
+	speakerWaiter    core.Waiter
+	publishTopic     string
+	subscribeTopic   string
+	auth             string
+	iceServers       []ICEServer
+	uid              string
+	motoId           string
+	deviceId         string
+	sessionId        string
+	closed           bool
+	webrtcVersion    int
+	handleAnswer     func(answer AnswerFrame)
+	handleCandidate  func(candidate CandidateFrame)
+	handleDisconnect func()
+	handleError      func(err error)
+}
+
+type MqttFrameHeader struct {
+	Type          string `json:"type"`
+	From          string `json:"from"`
+	To            string `json:"to"`
+	SubDevID      string `json:"sub_dev_id"`
+	SessionID     string `json:"sessionid"`
+	MotoID        string `json:"moto_id"`
+	TransactionID string `json:"tid"`
+}
+
+type MqttFrame struct {
+	Header  MqttFrameHeader `json:"header"`
+	Message json.RawMessage `json:"msg"`
+}
+
+type OfferFrame struct {
+	Mode              string      `json:"mode"`
+	Sdp               string      `json:"sdp"`
+	StreamType        int         `json:"stream_type"` // 0: mainStream(HD), 1: substream(SD)
+	Auth              string      `json:"auth"`
+	DatachannelEnable bool        `json:"datachannel_enable"` // true for HEVC, false for H264
+	Token             []ICEServer `json:"token"`
+}
+
+type AnswerFrame struct {
+	Mode string `json:"mode"`
+	Sdp  string `json:"sdp"`
+}
+
+type CandidateFrame struct {
+	Mode      string `json:"mode"`
+	Candidate string `json:"candidate"`
+}
+
+type ResolutionFrame struct {
+	Mode  string `json:"mode"`
+	Value int    `json:"cmdValue"` // 0: HD, 1: SD
+}
+
+type SpeakerFrame struct {
+	Mode  string `json:"mode"`
+	Value int    `json:"cmdValue"` // 0: off, 1: on
+}
+
+type DisconnectFrame struct {
+	Mode string `json:"mode"`
+}
+
+type MqttLowPowerMessage struct {
+	Protocol int    `json:"protocol"`
+	T        int    `json:"t"`
+	S        int    `json:"s,omitempty"`
+	Type     string `json:"type,omitempty"`
+	Data     struct {
+		DevID                string                 `json:"devId,omitempty"`
+		Online               bool                   `json:"online,omitempty"`
+		LastOnlineChangeTime int64                  `json:"lastOnlineChangeTime,omitempty"`
+		GwID                 string                 `json:"gwId,omitempty"`
+		Cmd                  string                 `json:"cmd,omitempty"`
+		Dps                  map[string]interface{} `json:"dps,omitempty"`
+	} `json:"data"`
+}
+
+type MqttMessage struct {
+	Protocol int       `json:"protocol"`
+	Pv       string    `json:"pv"`
+	T        int64     `json:"t"`
+	Data     MqttFrame `json:"data"`
+}
+
+func NewTuyaMqttClient(deviceId string) *TuyaMqttClient {
+	return &TuyaMqttClient{
+		deviceId:     deviceId,
+		sessionId:    core.RandString(6, 62),
+		waiter:       core.Waiter{},
+		wakeupWaiter: core.Waiter{},
+	}
+}
+
+func (c *TuyaMqttClient) Start(hubConfig *MQTTConfig, webrtcConfig *WebRTCConfig, webrtcVersion int) error {
+	c.webrtcVersion = webrtcVersion
+	c.motoId = webrtcConfig.MotoID
+	c.auth = webrtcConfig.Auth
+	c.iceServers = webrtcConfig.P2PConfig.Ices
+
+	c.publishTopic = hubConfig.PublishTopic
+	c.subscribeTopic = hubConfig.SubscribeTopic
+
+	c.publishTopic = strings.Replace(c.publishTopic, "moto_id", c.motoId, 1)
+	c.publishTopic = strings.Replace(c.publishTopic, "{device_id}", c.deviceId, 1)
+
+	parts := strings.Split(c.subscribeTopic, "/")
+	c.uid = parts[3]
+
+	opts := mqtt.NewClientOptions().AddBroker(hubConfig.Url).
+		SetClientID(hubConfig.ClientID).
+		SetUsername(hubConfig.Username).
+		SetPassword(hubConfig.Password).
+		SetOnConnectHandler(c.onConnect).
+		SetAutoReconnect(true).
+		SetMaxReconnectInterval(30 * time.Second).
+		SetConnectTimeout(30 * time.Second).
+		SetKeepAlive(60 * time.Second).
+		SetPingTimeout(20 * time.Second)
+
+	c.client = mqtt.NewClient(opts)
+
+	if token := c.client.Connect(); token.Wait() && token.Error() != nil {
+		return token.Error()
+	}
+
+	if err := c.waiter.Wait(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c *TuyaMqttClient) Stop() {
+	c.waiter.Done(errors.New("mqtt: stopped"))
+	c.wakeupWaiter.Done(errors.New("mqtt: stopped"))
+	c.speakerWaiter.Done(errors.New("mqtt: stopped"))
+
+	if c.client != nil {
+		_ = c.SendDisconnect()
+		c.client.Disconnect(100)
+	}
+
+	c.closed = true
+}
+
+// WakeUp sends a wake-up signal to battery-powered cameras (LowPower mode).
+// The camera wakes up and starts responding immediately - we don't wait for dps[149].
+// Note: LowPower cameras sleep after ~3 minutes of inactivity.
+func (c *TuyaMqttClient) WakeUp(localKey string) error {
+	// Calculate CRC32 of localKey as wake-up payload
+	crc := crc32.ChecksumIEEE([]byte(localKey))
+
+	// Convert to hex string
+	hexStr := fmt.Sprintf("%08x", crc)
+
+	// Convert hex string to byte array (2 chars at a time)
+	payload := make([]byte, len(hexStr)/2)
+	for i := 0; i < len(hexStr); i += 2 {
+		b, err := hex.DecodeString(hexStr[i : i+2])
+		if err != nil {
+			return fmt.Errorf("failed to decode hex: %w", err)
+		}
+		payload[i/2] = b[0]
+	}
+
+	// Publish to wake-up topic: m/w/{deviceId}
+	wakeUpTopic := fmt.Sprintf("m/w/%s", c.deviceId)
+	token := c.client.Publish(wakeUpTopic, 1, false, payload)
+	if token.Wait() && token.Error() != nil {
+		return fmt.Errorf("failed to publish wake-up message: %w", token.Error())
+	}
+
+	// Subscribe to lowPower topic to receive dps[149] status updates
+	// (we don't wait for this signal - camera responds immediately)
+	lowPowerTopic := fmt.Sprintf("smart/decrypt/in/%s", c.deviceId)
+	if token := c.client.Subscribe(lowPowerTopic, 1, c.onLowPowerMessage); token.Wait() && token.Error() != nil {
+		return fmt.Errorf("failed to subscribe to lowPower topic: %w", token.Error())
+	}
+
+	return nil
+}
+
+func (c *TuyaMqttClient) SendOffer(sdp string, streamResolution string, streamType int, isHEVC bool) error {
+	// Map Skill StreamType to MQTT stream_type values
+	// streamType comes from GetStreamType() and uses Skill StreamType values:
+	// - mainStream = 2 (HD)
+	// - substream = 4 (SD)
+	//
+	// But MQTT expects mapped stream_type values:
+	// - mainStream (2) → stream_type: 0
+	// - substream (4) → stream_type: 1
+
+	mqttStreamType := streamType
+	switch streamType {
+	case 2:
+		mqttStreamType = 0 // mainStream (HD)
+	case 4:
+		mqttStreamType = 1 // substream (SD)
+	}
+
+	return c.sendMqttMessage("offer", 302, "", OfferFrame{
+		Mode:              "webrtc",
+		Sdp:               sdp,
+		StreamType:        mqttStreamType,
+		Auth:              c.auth,
+		DatachannelEnable: isHEVC, // must be true for HEVC
+		Token:             c.iceServers,
+	})
+}
+
+func (c *TuyaMqttClient) SendCandidate(candidate string) error {
+	return c.sendMqttMessage("candidate", 302, "", CandidateFrame{
+		Mode:      "webrtc",
+		Candidate: candidate,
+	})
+}
+
+func (c *TuyaMqttClient) SendResolution(resolution int) error {
+	// Check if camera supports clarity switching
+	isClaritySupported := (c.webrtcVersion & (1 << 5)) != 0
+	if !isClaritySupported {
+		return nil
+	}
+
+	return c.sendMqttMessage("resolution", 312, "", ResolutionFrame{
+		Mode:  "webrtc",
+		Value: resolution, // 0: HD, 1: SD
+	})
+}
+
+func (c *TuyaMqttClient) SendSpeaker(speaker int) error {
+	if err := c.sendMqttMessage("speaker", 312, "", SpeakerFrame{
+		Mode:  "webrtc",
+		Value: speaker, // 0: off, 1: on
+	}); err != nil {
+		return err
+	}
+
+	// Wait for camera response
+	if err := c.speakerWaiter.Wait(); err != nil {
+		return fmt.Errorf("speaker wait failed: %w", err)
+	}
+
+	return nil
+}
+
+func (c *TuyaMqttClient) SendDisconnect() error {
+	return c.sendMqttMessage("disconnect", 302, "", DisconnectFrame{
+		Mode: "webrtc",
+	})
+}
+
+func (c *TuyaMqttClient) onConnect(client mqtt.Client) {
+	if token := client.Subscribe(c.subscribeTopic, 1, c.onMessage); token.Wait() && token.Error() != nil {
+		c.waiter.Done(token.Error())
+		return
+	}
+
+	c.waiter.Done(nil)
+}
+
+func (c *TuyaMqttClient) onMessage(client mqtt.Client, msg mqtt.Message) {
+	var rmqtt MqttMessage
+	if err := json.Unmarshal(msg.Payload(), &rmqtt); err != nil {
+		c.onError(err)
+		return
+	}
+
+	// Filter by session ID to prevent processing messages from other sessions
+	if rmqtt.Data.Header.SessionID != c.sessionId {
+		return
+	}
+
+	switch rmqtt.Data.Header.Type {
+	case "answer":
+		c.onMqttAnswer(&rmqtt)
+	case "candidate":
+		c.onMqttCandidate(&rmqtt)
+	case "disconnect":
+		c.onMqttDisconnect()
+	case "speaker":
+		c.onMqttSpeaker(&rmqtt)
+	}
+}
+
+func (c *TuyaMqttClient) onLowPowerMessage(client mqtt.Client, msg mqtt.Message) {
+	var message MqttLowPowerMessage
+	if err := json.Unmarshal(msg.Payload(), &message); err != nil {
+		return
+	}
+
+	// Check if protocol is 4 and dps[149] is true
+	// https://developer.tuya.com/en/docs/iot-device-dev/doorbell_solution?id=Kayamyivh15ox#title-2-Battery
+	if message.Protocol == 4 {
+		if val, ok := message.Data.Dps["149"]; ok {
+			if ready, ok := val.(bool); ok && ready {
+				// Camera is now ready after wake-up (dps[149]:true received).
+				// However, we don't wait for this signal (like ismartlife.me doesn't either).
+				// The camera starts responding immediately after WakeUp() is called,
+				// so we proceed with the connection without blocking.
+				// This waiter is kept for potential future use.
+				c.wakeupWaiter.Done(nil)
+			}
+		}
+	}
+}
+
+func (c *TuyaMqttClient) onMqttAnswer(msg *MqttMessage) {
+	var answerFrame AnswerFrame
+	if err := json.Unmarshal(msg.Data.Message, &answerFrame); err != nil {
+		c.onError(err)
+		return
+	}
+
+	c.onAnswer(answerFrame)
+}
+
+func (c *TuyaMqttClient) onMqttCandidate(msg *MqttMessage) {
+	var candidateFrame CandidateFrame
+	if err := json.Unmarshal(msg.Data.Message, &candidateFrame); err != nil {
+		c.onError(err)
+		return
+	}
+
+	// fix candidates
+	candidateFrame.Candidate = strings.TrimPrefix(candidateFrame.Candidate, "a=")
+	candidateFrame.Candidate = strings.TrimSuffix(candidateFrame.Candidate, "\r\n")
+
+	c.onCandidate(candidateFrame)
+}
+
+func (c *TuyaMqttClient) onMqttDisconnect() {
+	c.closed = true
+	c.onDisconnect()
+}
+
+func (c *TuyaMqttClient) onMqttSpeaker(msg *MqttMessage) {
+	var speakerResponse struct {
+		ResCode int `json:"resCode"`
+	}
+
+	if err := json.Unmarshal(msg.Data.Message, &speakerResponse); err == nil {
+		if speakerResponse.ResCode != 0 {
+			c.speakerWaiter.Done(fmt.Errorf("speaker failed with resCode: %d", speakerResponse.ResCode))
+			return
+		}
+	}
+
+	c.speakerWaiter.Done(nil)
+}
+
+func (c *TuyaMqttClient) onAnswer(answer AnswerFrame) {
+	if c.handleAnswer != nil {
+		c.handleAnswer(answer)
+	}
+}
+
+func (c *TuyaMqttClient) onCandidate(candidate CandidateFrame) {
+	if c.handleCandidate != nil {
+		c.handleCandidate(candidate)
+	}
+}
+
+func (c *TuyaMqttClient) onDisconnect() {
+	if c.handleDisconnect != nil {
+		c.handleDisconnect()
+	}
+}
+
+func (c *TuyaMqttClient) onError(err error) {
+	if c.handleError != nil {
+		c.handleError(err)
+	}
+}
+
+func (c *TuyaMqttClient) sendMqttMessage(messageType string, protocol int, transactionID string, data interface{}) error {
+	if c.closed {
+		return fmt.Errorf("mqtt client is closed, send mqtt message fail")
+	}
+
+	jsonMessage, err := json.Marshal(data)
+	if err != nil {
+		return err
+	}
+
+	msg := &MqttMessage{
+		Protocol: protocol,
+		Pv:       "2.2",
+		T:        time.Now().Unix(),
+		Data: MqttFrame{
+			Header: MqttFrameHeader{
+				Type:          messageType,
+				From:          c.uid,
+				To:            c.deviceId,
+				SessionID:     c.sessionId,
+				MotoID:        c.motoId,
+				TransactionID: transactionID,
+			},
+			Message: jsonMessage,
+		},
+	}
+
+	payload, err := json.Marshal(msg)
+	if err != nil {
+		return err
+	}
+
+	token := c.client.Publish(c.publishTopic, 1, false, payload)
+	if token.Wait() && token.Error() != nil {
+		return token.Error()
+	}
+
+	return nil
+}
diff --git a/installs_on_host/go2rtc/pkg/tuya/smart_api.go b/installs_on_host/go2rtc/pkg/tuya/smart_api.go
new file mode 100644
index 0000000..09615db
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/tuya/smart_api.go
@@ -0,0 +1,597 @@
+package tuya
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"math/rand"
+	"net/http"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/webrtc"
+)
+
+type LoginTokenRequest struct {
+	CountryCode string `json:"countryCode"`
+	Username    string `json:"username"`
+	IsUid       bool   `json:"isUid"`
+}
+
+type LoginTokenResponse struct {
+	Result  LoginToken `json:"result"`
+	Success bool       `json:"success"`
+	Msg     string     `json:"errorMsg,omitempty"`
+}
+
+type LoginToken struct {
+	Token     string `json:"token"`
+	Exponent  string `json:"exponent"`
+	PublicKey string `json:"publicKey"`
+	PbKey     string `json:"pbKey"`
+}
+
+type PasswordLoginRequest struct {
+	CountryCode string `json:"countryCode"`
+	Email       string `json:"email,omitempty"`
+	Mobile      string `json:"mobile,omitempty"`
+	Passwd      string `json:"passwd"`
+	Token       string `json:"token"`
+	IfEncrypt   int    `json:"ifencrypt"`
+	Options     string `json:"options"`
+}
+
+type PasswordLoginResponse struct {
+	Result   LoginResult `json:"result"`
+	Success  bool        `json:"success"`
+	Status   string      `json:"status"`
+	ErrorMsg string      `json:"errorMsg,omitempty"`
+}
+
+type LoginResult struct {
+	Attribute          int    `json:"attribute"`
+	ClientId           string `json:"clientId"`
+	DataVersion        int    `json:"dataVersion"`
+	Domain             Domain `json:"domain"`
+	Ecode              string `json:"ecode"`
+	Email              string `json:"email"`
+	Extras             Extras `json:"extras"`
+	HeadPic            string `json:"headPic"`
+	ImproveCompanyInfo bool   `json:"improveCompanyInfo"`
+	Nickname           string `json:"nickname"`
+	PartnerIdentity    string `json:"partnerIdentity"`
+	PhoneCode          string `json:"phoneCode"`
+	Receiver           string `json:"receiver"`
+	RegFrom            int    `json:"regFrom"`
+	Sid                string `json:"sid"`
+	SnsNickname        string `json:"snsNickname"`
+	TempUnit           int    `json:"tempUnit"`
+	Timezone           string `json:"timezone"`
+	TimezoneId         string `json:"timezoneId"`
+	Uid                string `json:"uid"`
+	UserType           int    `json:"userType"`
+	Username           string `json:"username"`
+}
+
+type Domain struct {
+	AispeechHttpsUrl    string `json:"aispeechHttpsUrl"`
+	AispeechQuicUrl     string `json:"aispeechQuicUrl"`
+	DeviceHttpUrl       string `json:"deviceHttpUrl"`
+	DeviceHttpsPskUrl   string `json:"deviceHttpsPskUrl"`
+	DeviceHttpsUrl      string `json:"deviceHttpsUrl"`
+	DeviceMediaMqttUrl  string `json:"deviceMediaMqttUrl"`
+	DeviceMediaMqttsUrl string `json:"deviceMediaMqttsUrl"`
+	DeviceMqttsPskUrl   string `json:"deviceMqttsPskUrl"`
+	DeviceMqttsUrl      string `json:"deviceMqttsUrl"`
+	GwApiUrl            string `json:"gwApiUrl"`
+	GwMqttUrl           string `json:"gwMqttUrl"`
+	HttpPort            int    `json:"httpPort"`
+	HttpsPort           int    `json:"httpsPort"`
+	HttpsPskPort        int    `json:"httpsPskPort"`
+	MobileApiUrl        string `json:"mobileApiUrl"`
+	MobileMediaMqttUrl  string `json:"mobileMediaMqttUrl"`
+	MobileMqttUrl       string `json:"mobileMqttUrl"`
+	MobileMqttsUrl      string `json:"mobileMqttsUrl"`
+	MobileQuicUrl       string `json:"mobileQuicUrl"`
+	MqttPort            int    `json:"mqttPort"`
+	MqttQuicUrl         string `json:"mqttQuicUrl"`
+	MqttsPort           int    `json:"mqttsPort"`
+	MqttsPskPort        int    `json:"mqttsPskPort"`
+	RegionCode          string `json:"regionCode"`
+}
+
+type Extras struct {
+	HomeId    string `json:"homeId"`
+	SceneType string `json:"sceneType"`
+}
+
+type AppInfoResponse struct {
+	Result  AppInfo `json:"result"`
+	T       int64   `json:"t"`
+	Success bool    `json:"success"`
+	Msg     string  `json:"errorMsg,omitempty"`
+}
+
+type AppInfo struct {
+	AppId    int    `json:"appId"`
+	AppName  string `json:"appName"`
+	ClientId string `json:"clientId"`
+	Icon     string `json:"icon"`
+}
+
+type MQTTConfigResponse struct {
+	Result  SmartApiMQTTConfig `json:"result"`
+	Success bool               `json:"success"`
+	Msg     string             `json:"errorMsg,omitempty"`
+}
+
+type SmartApiMQTTConfig struct {
+	Msid     string `json:"msid"`
+	Password string `json:"password"`
+}
+
+type HomeListResponse struct {
+	Result  []Home `json:"result"`
+	T       int64  `json:"t"`
+	Success bool   `json:"success"`
+	Msg     string `json:"errorMsg,omitempty"`
+}
+
+type SharedHomeListResponse struct {
+	Result  SharedHome `json:"result"`
+	T       int64      `json:"t"`
+	Success bool       `json:"success"`
+	Msg     string     `json:"errorMsg,omitempty"`
+}
+
+type SharedHome struct {
+	SecurityWebCShareInfoList []struct {
+		DeviceInfoList []Device `json:"deviceInfoList"`
+		Nickname       string   `json:"nickname"`
+		Username       string   `json:"username"`
+	} `json:"securityWebCShareInfoList"`
+}
+
+type Home struct {
+	Admin            bool    `json:"admin"`
+	Background       string  `json:"background"`
+	DealStatus       int     `json:"dealStatus"`
+	DisplayOrder     int     `json:"displayOrder"`
+	GeoName          string  `json:"geoName"`
+	Gid              int     `json:"gid"`
+	GmtCreate        int64   `json:"gmtCreate"`
+	GmtModified      int64   `json:"gmtModified"`
+	GroupId          int     `json:"groupId"`
+	GroupUserId      int     `json:"groupUserId"`
+	Id               int     `json:"id"`
+	Lat              float64 `json:"lat"`
+	Lon              float64 `json:"lon"`
+	ManagementStatus bool    `json:"managementStatus"`
+	Name             string  `json:"name"`
+	OwnerId          string  `json:"ownerId"`
+	Role             int     `json:"role"`
+	Status           bool    `json:"status"`
+	Uid              string  `json:"uid"`
+}
+
+type RoomListRequest struct {
+	HomeId string `json:"homeId"`
+}
+
+type RoomListResponse struct {
+	Result  []Room `json:"result"`
+	T       int64  `json:"t"`
+	Success bool   `json:"success"`
+	Msg     string `json:"errorMsg,omitempty"`
+}
+
+type Room struct {
+	DeviceCount int      `json:"deviceCount"`
+	DeviceList  []Device `json:"deviceList"`
+	RoomId      string   `json:"roomId"`
+	RoomName    string   `json:"roomName"`
+}
+
+type Device struct {
+	Category            string `json:"category"`
+	DeviceId            string `json:"deviceId"`
+	DeviceName          string `json:"deviceName"`
+	P2pType             int    `json:"p2pType"`
+	ProductId           string `json:"productId"`
+	SupportCloudStorage bool   `json:"supportCloudStorage"`
+	Uuid                string `json:"uuid"`
+}
+
+type SmartApiWebRTCConfigRequest struct {
+	DevId         string `json:"devId"`
+	ClientTraceId string `json:"clientTraceId"`
+}
+
+type SmartApiWebRTCConfigResponse struct {
+	Result  SmartApiWebRTCConfig `json:"result"`
+	Success bool                 `json:"success"`
+	Msg     string               `json:"errorMsg,omitempty"`
+}
+
+type SmartApiWebRTCConfig struct {
+	AudioAttributes     AudioAttributes `json:"audioAttributes"`
+	Auth                string          `json:"auth"`
+	GatewayId           string          `json:"gatewayId"`
+	Id                  string          `json:"id"`
+	LocalKey            string          `json:"localKey"`
+	MotoId              string          `json:"motoId"`
+	NodeId              string          `json:"nodeId"`
+	P2PConfig           P2PConfig       `json:"p2pConfig"`
+	ProtocolVersion     string          `json:"protocolVersion"`
+	Skill               string          `json:"skill"`
+	Sub                 bool            `json:"sub"`
+	SupportWebrtcRecord bool            `json:"supportWebrtcRecord"`
+	SupportsPtz         bool            `json:"supportsPtz"`
+	SupportsWebrtc      bool            `json:"supportsWebrtc"`
+	VedioClarity        int             `json:"vedioClarity"`
+	VedioClaritys       []int           `json:"vedioClaritys"`
+	VideoClarity        int             `json:"videoClarity"`
+}
+
+type TuyaSmartApiClient struct {
+	TuyaClient
+
+	email       string
+	password    string
+	countryCode string
+	mqttsUrl    string
+}
+
+type Region struct {
+	Name        string `json:"name"`
+	Host        string `json:"host"`
+	Description string `json:"description"`
+	Continent   string `json:"continent"`
+}
+
+var AvailableRegions = []Region{
+	{"eu-central", "protect-eu.ismartlife.me", "Central Europe", "EU"},
+	{"eu-east", "protect-we.ismartlife.me", "East Europe", "EU"},
+	{"us-west", "protect-us.ismartlife.me", "West America", "AZ"},
+	{"us-east", "protect-ue.ismartlife.me", "East America", "AZ"},
+	{"china", "protect.ismartlife.me", "China", "AY"},
+	{"india", "protect-in.ismartlife.me", "India", "IN"},
+}
+
+func NewTuyaSmartApiClient(httpClient *http.Client, baseUrl, email, password, deviceId string) (*TuyaSmartApiClient, error) {
+	var region *Region
+	for _, r := range AvailableRegions {
+		if r.Host == baseUrl {
+			region = &r
+			break
+		}
+	}
+
+	if region == nil {
+		return nil, fmt.Errorf("invalid region: %s", baseUrl)
+	}
+
+	if httpClient == nil {
+		httpClient = CreateHTTPClientWithSession()
+	}
+
+	mqttClient := NewTuyaMqttClient(deviceId)
+
+	client := &TuyaSmartApiClient{
+		TuyaClient: TuyaClient{
+			httpClient: httpClient,
+			mqtt:       mqttClient,
+			deviceId:   deviceId,
+			expireTime: 0,
+			baseUrl:    baseUrl,
+		},
+		email:       email,
+		password:    password,
+		countryCode: region.Continent,
+	}
+
+	return client, nil
+}
+
+// WebRTC Flow
+func (c *TuyaSmartApiClient) Init() error {
+	if err := c.initToken(); err != nil {
+		return fmt.Errorf("failed to initialize token: %w", err)
+	}
+
+	webrtcConfig, err := c.loadWebrtcConfig()
+	if err != nil {
+		return fmt.Errorf("failed to load webrtc config: %w", err)
+	}
+
+	hubConfig, err := c.loadHubConfig()
+	if err != nil {
+		return fmt.Errorf("failed to load hub config: %w", err)
+	}
+
+	if err := c.mqtt.Start(hubConfig, webrtcConfig, c.skill.WebRTC); err != nil {
+		return fmt.Errorf("failed to start MQTT: %w", err)
+	}
+
+	if c.skill.LowPower > 0 {
+		_ = c.mqtt.WakeUp(c.localKey)
+	}
+
+	return nil
+}
+
+func (c *TuyaSmartApiClient) GetStreamUrl(streamType string) (streamUrl string, err error) {
+	return "", errors.New("not supported")
+}
+
+func (c *TuyaSmartApiClient) GetAppInfo() (*AppInfoResponse, error) {
+	url := fmt.Sprintf("https://%s/api/customized/web/app/info", c.baseUrl)
+
+	body, err := c.request("POST", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	var appInfoResponse AppInfoResponse
+	if err := json.Unmarshal(body, &appInfoResponse); err != nil {
+		return nil, err
+	}
+
+	if !appInfoResponse.Success {
+		return nil, errors.New(appInfoResponse.Msg)
+	}
+
+	return &appInfoResponse, nil
+}
+
+func (c *TuyaSmartApiClient) GetHomeList() (*HomeListResponse, error) {
+	url := fmt.Sprintf("https://%s/api/new/common/homeList", c.baseUrl)
+
+	body, err := c.request("POST", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	var homeListResponse HomeListResponse
+	if err := json.Unmarshal(body, &homeListResponse); err != nil {
+		return nil, err
+	}
+
+	if !homeListResponse.Success {
+		return nil, errors.New(homeListResponse.Msg)
+	}
+
+	return &homeListResponse, nil
+}
+
+func (c *TuyaSmartApiClient) GetSharedHomeList() (*SharedHomeListResponse, error) {
+	url := fmt.Sprintf("https://%s/api/new/playback/shareList", c.baseUrl)
+
+	body, err := c.request("POST", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	var sharedHomeListResponse SharedHomeListResponse
+	if err := json.Unmarshal(body, &sharedHomeListResponse); err != nil {
+		return nil, err
+	}
+
+	if !sharedHomeListResponse.Success {
+		return nil, errors.New(sharedHomeListResponse.Msg)
+	}
+
+	return &sharedHomeListResponse, nil
+}
+
+func (c *TuyaSmartApiClient) GetRoomList(homeId string) (*RoomListResponse, error) {
+	url := fmt.Sprintf("https://%s/api/new/common/roomList", c.baseUrl)
+
+	data := RoomListRequest{
+		HomeId: homeId,
+	}
+
+	body, err := c.request("POST", url, data)
+	if err != nil {
+		return nil, err
+	}
+
+	var roomListResponse RoomListResponse
+	if err := json.Unmarshal(body, &roomListResponse); err != nil {
+		return nil, err
+	}
+
+	if !roomListResponse.Success {
+		return nil, errors.New(roomListResponse.Msg)
+	}
+
+	return &roomListResponse, nil
+}
+
+func (c *TuyaSmartApiClient) initToken() error {
+	tokenUrl := fmt.Sprintf("https://%s/api/login/token", c.baseUrl)
+
+	tokenReq := LoginTokenRequest{
+		CountryCode: c.countryCode,
+		Username:    c.email,
+		IsUid:       false,
+	}
+
+	body, err := c.request("POST", tokenUrl, tokenReq)
+	if err != nil {
+		return err
+	}
+
+	var tokenResp LoginTokenResponse
+	if err := json.Unmarshal(body, &tokenResp); err != nil {
+		return err
+	}
+
+	if !tokenResp.Success {
+		return errors.New(tokenResp.Msg)
+	}
+
+	encryptedPassword, err := EncryptPassword(c.password, tokenResp.Result.PbKey)
+	if err != nil {
+		return fmt.Errorf("failed to encrypt password: %v", err)
+	}
+	var loginUrl string
+
+	loginReq := PasswordLoginRequest{
+		CountryCode: c.countryCode,
+		Passwd:      encryptedPassword,
+		Token:       tokenResp.Result.Token,
+		IfEncrypt:   1,
+		Options:     `{"group":1}`,
+	}
+
+	if IsEmailAddress(c.email) {
+		loginUrl = fmt.Sprintf("https://%s/api/private/email/login", c.baseUrl)
+		loginReq.Email = c.email
+	} else {
+		loginUrl = fmt.Sprintf("https://%s/api/private/phone/login", c.baseUrl)
+		loginReq.Mobile = c.email
+	}
+
+	body, err = c.request("POST", loginUrl, loginReq)
+	if err != nil {
+		return err
+	}
+
+	var loginResp *PasswordLoginResponse
+	if err := json.Unmarshal(body, &loginResp); err != nil {
+		return err
+	}
+
+	if !loginResp.Success {
+		return errors.New(loginResp.ErrorMsg)
+	}
+
+	c.mqttsUrl = fmt.Sprintf("ssl://%s:%d", loginResp.Result.Domain.MobileMqttsUrl, loginResp.Result.Domain.MqttsPort)
+	c.expireTime = time.Now().Unix() + 2*24*60*60 // 2 days in seconds
+
+	return nil
+}
+
+func (c *TuyaSmartApiClient) loadWebrtcConfig() (*WebRTCConfig, error) {
+	url := fmt.Sprintf("https://%s/api/jarvis/config", c.baseUrl)
+
+	data := SmartApiWebRTCConfigRequest{
+		DevId:         c.deviceId,
+		ClientTraceId: fmt.Sprintf("%x", rand.Int63()),
+	}
+
+	body, err := c.request("POST", url, data)
+	if err != nil {
+		return nil, err
+	}
+
+	var webRTCConfigResponse SmartApiWebRTCConfigResponse
+	err = json.Unmarshal(body, &webRTCConfigResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	if !webRTCConfigResponse.Success {
+		return nil, errors.New(webRTCConfigResponse.Msg)
+	}
+
+	err = json.Unmarshal([]byte(webRTCConfigResponse.Result.Skill), &c.skill)
+	if err != nil {
+		return nil, err
+	}
+
+	// Store LocalKey
+	c.localKey = webRTCConfigResponse.Result.LocalKey
+
+	iceServers, err := json.Marshal(&webRTCConfigResponse.Result.P2PConfig.Ices)
+	if err != nil {
+		return nil, err
+	}
+
+	c.iceServers, err = webrtc.UnmarshalICEServers(iceServers)
+	if err != nil {
+		return nil, err
+	}
+
+	return &WebRTCConfig{
+		AudioAttributes:      webRTCConfigResponse.Result.AudioAttributes,
+		Auth:                 webRTCConfigResponse.Result.Auth,
+		ID:                   webRTCConfigResponse.Result.Id,
+		MotoID:               webRTCConfigResponse.Result.MotoId,
+		P2PConfig:            webRTCConfigResponse.Result.P2PConfig,
+		ProtocolVersion:      webRTCConfigResponse.Result.ProtocolVersion,
+		Skill:                webRTCConfigResponse.Result.Skill,
+		SupportsWebRTCRecord: webRTCConfigResponse.Result.SupportWebrtcRecord,
+		SupportsWebRTC:       webRTCConfigResponse.Result.SupportsWebrtc,
+		VedioClaritiy:        webRTCConfigResponse.Result.VedioClarity,
+		VideoClaritiy:        webRTCConfigResponse.Result.VideoClarity,
+		VideoClarities:       webRTCConfigResponse.Result.VedioClaritys,
+	}, nil
+}
+
+func (c *TuyaSmartApiClient) loadHubConfig() (config *MQTTConfig, err error) {
+	mqttUrl := fmt.Sprintf("https://%s/api/jarvis/mqtt", c.baseUrl)
+
+	mqttBody, err := c.request("POST", mqttUrl, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	var mqttConfigResponse MQTTConfigResponse
+	err = json.Unmarshal(mqttBody, &mqttConfigResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	if !mqttConfigResponse.Success {
+		return nil, errors.New(mqttConfigResponse.Msg)
+	}
+
+	return &MQTTConfig{
+		Url:            c.mqttsUrl,
+		ClientID:       fmt.Sprintf("web_%s", mqttConfigResponse.Result.Msid),
+		Username:       fmt.Sprintf("web_%s", mqttConfigResponse.Result.Msid),
+		Password:       mqttConfigResponse.Result.Password,
+		PublishTopic:   "/av/moto/moto_id/u/{device_id}",
+		SubscribeTopic: fmt.Sprintf("/av/u/%s", mqttConfigResponse.Result.Msid),
+	}, nil
+}
+
+func (c *TuyaSmartApiClient) request(method string, url string, body any) ([]byte, error) {
+	var bodyReader io.Reader
+	if body != nil {
+		jsonBody, err := json.Marshal(body)
+		if err != nil {
+			return nil, err
+		}
+		bodyReader = bytes.NewReader(jsonBody)
+	}
+
+	req, err := http.NewRequest(method, url, bodyReader)
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Set("Content-Type", "application/json; charset=utf-8")
+	req.Header.Set("Accept", "*/*")
+	req.Header.Set("Origin", fmt.Sprintf("https://%s", c.baseUrl))
+
+	response, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer response.Body.Close()
+
+	res, err := io.ReadAll(response.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	if response.StatusCode != http.StatusOK {
+		return nil, err
+	}
+
+	return res, nil
+}
diff --git a/installs_on_host/go2rtc/pkg/v4l2/device/README.md b/installs_on_host/go2rtc/pkg/v4l2/device/README.md
new file mode 100644
index 0000000..de686ea
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/v4l2/device/README.md
@@ -0,0 +1,21 @@
+# Video For Linux Two
+
+Build on Ubuntu
+
+```bash
+sudo apt install gcc-x86-64-linux-gnu
+sudo apt install gcc-i686-linux-gnu
+sudo apt install gcc-aarch64-linux-gnu binutils
+sudo apt install gcc-arm-linux-gnueabihf
+sudo apt install gcc-mipsel-linux-gnu
+
+x86_64-linux-gnu-gcc -w -static videodev2_arch.c -o videodev2_x86_64
+i686-linux-gnu-gcc -w -static videodev2_arch.c -o videodev2_i686
+aarch64-linux-gnu-gcc -w -static videodev2_arch.c -o videodev2_aarch64
+arm-linux-gnueabihf-gcc -w -static videodev2_arch.c -o videodev2_armhf
+mipsel-linux-gnu-gcc -w -static videodev2_arch.c -o videodev2_mipsel -D_TIME_BITS=32
+```
+
+## Useful links
+
+- https://github.com/torvalds/linux/blob/master/include/uapi/linux/videodev2.h
diff --git a/installs_on_host/go2rtc/pkg/v4l2/device/device.go b/installs_on_host/go2rtc/pkg/v4l2/device/device.go
new file mode 100644
index 0000000..c77d60f
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/v4l2/device/device.go
@@ -0,0 +1,252 @@
+//go:build linux
+
+package device
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"syscall"
+	"unsafe"
+)
+
+type Device struct {
+	fd     int
+	bufs   [][]byte
+	pixFmt uint32
+}
+
+func Open(path string) (*Device, error) {
+	fd, err := syscall.Open(path, syscall.O_RDWR|syscall.O_CLOEXEC, 0)
+	if err != nil {
+		return nil, err
+	}
+	return &Device{fd: fd}, nil
+}
+
+const buffersCount = 2
+
+type Capability struct {
+	Driver  string
+	Card    string
+	BusInfo string
+	Version string
+}
+
+func (d *Device) Capability() (*Capability, error) {
+	c := v4l2_capability{}
+	if err := ioctl(d.fd, VIDIOC_QUERYCAP, unsafe.Pointer(&c)); err != nil {
+		return nil, err
+	}
+	return &Capability{
+		Driver:  str(c.driver[:]),
+		Card:    str(c.card[:]),
+		BusInfo: str(c.bus_info[:]),
+		Version: fmt.Sprintf("%d.%d.%d", byte(c.version>>16), byte(c.version>>8), byte(c.version)),
+	}, nil
+}
+
+func (d *Device) ListFormats() ([]uint32, error) {
+	var items []uint32
+
+	for i := uint32(0); ; i++ {
+		fd := v4l2_fmtdesc{
+			index: i,
+			typ:   V4L2_BUF_TYPE_VIDEO_CAPTURE,
+		}
+		if err := ioctl(d.fd, VIDIOC_ENUM_FMT, unsafe.Pointer(&fd)); err != nil {
+			if !errors.Is(err, syscall.EINVAL) {
+				return nil, err
+			}
+			break
+		}
+
+		items = append(items, fd.pixelformat)
+	}
+
+	return items, nil
+}
+
+func (d *Device) ListSizes(pixFmt uint32) ([][2]uint32, error) {
+	var items [][2]uint32
+
+	for i := uint32(0); ; i++ {
+		fs := v4l2_frmsizeenum{
+			index:        i,
+			pixel_format: pixFmt,
+		}
+		if err := ioctl(d.fd, VIDIOC_ENUM_FRAMESIZES, unsafe.Pointer(&fs)); err != nil {
+			if !errors.Is(err, syscall.EINVAL) {
+				return nil, err
+			}
+			break
+		}
+
+		if fs.typ != V4L2_FRMSIZE_TYPE_DISCRETE {
+			continue
+		}
+
+		items = append(items, [2]uint32{fs.discrete.width, fs.discrete.height})
+	}
+
+	return items, nil
+}
+
+func (d *Device) ListFrameRates(pixFmt, width, height uint32) ([]uint32, error) {
+	var items []uint32
+
+	for i := uint32(0); ; i++ {
+		fi := v4l2_frmivalenum{
+			index:        i,
+			pixel_format: pixFmt,
+			width:        width,
+			height:       height,
+		}
+		if err := ioctl(d.fd, VIDIOC_ENUM_FRAMEINTERVALS, unsafe.Pointer(&fi)); err != nil {
+			if !errors.Is(err, syscall.EINVAL) {
+				return nil, err
+			}
+			break
+		}
+
+		if fi.typ != V4L2_FRMIVAL_TYPE_DISCRETE || fi.discrete.numerator != 1 {
+			continue
+		}
+
+		items = append(items, fi.discrete.denominator)
+	}
+
+	return items, nil
+}
+
+func (d *Device) SetFormat(width, height, pixFmt uint32) error {
+	d.pixFmt = pixFmt
+
+	f := v4l2_format{
+		typ: V4L2_BUF_TYPE_VIDEO_CAPTURE,
+		pix: v4l2_pix_format{
+			width:       width,
+			height:      height,
+			pixelformat: pixFmt,
+			field:       V4L2_FIELD_NONE,
+			colorspace:  V4L2_COLORSPACE_DEFAULT,
+		},
+	}
+	return ioctl(d.fd, VIDIOC_S_FMT, unsafe.Pointer(&f))
+}
+
+func (d *Device) SetParam(fps uint32) error {
+	p := v4l2_streamparm{
+		typ: V4L2_BUF_TYPE_VIDEO_CAPTURE,
+		capture: v4l2_captureparm{
+			timeperframe: v4l2_fract{numerator: 1, denominator: fps},
+		},
+	}
+	return ioctl(d.fd, VIDIOC_S_PARM, unsafe.Pointer(&p))
+}
+
+func (d *Device) StreamOn() (err error) {
+	rb := v4l2_requestbuffers{
+		count:  buffersCount,
+		typ:    V4L2_BUF_TYPE_VIDEO_CAPTURE,
+		memory: V4L2_MEMORY_MMAP,
+	}
+	if err = ioctl(d.fd, VIDIOC_REQBUFS, unsafe.Pointer(&rb)); err != nil {
+		return err
+	}
+
+	d.bufs = make([][]byte, buffersCount)
+	for i := uint32(0); i < buffersCount; i++ {
+		qb := v4l2_buffer{
+			index:  i,
+			typ:    V4L2_BUF_TYPE_VIDEO_CAPTURE,
+			memory: V4L2_MEMORY_MMAP,
+		}
+		if err = ioctl(d.fd, VIDIOC_QUERYBUF, unsafe.Pointer(&qb)); err != nil {
+			return err
+		}
+
+		if d.bufs[i], err = syscall.Mmap(
+			d.fd, int64(qb.offset), int(qb.length), syscall.PROT_READ, syscall.MAP_SHARED,
+		); nil != err {
+			return err
+		}
+
+		if err = ioctl(d.fd, VIDIOC_QBUF, unsafe.Pointer(&qb)); err != nil {
+			return err
+		}
+	}
+
+	typ := uint32(V4L2_BUF_TYPE_VIDEO_CAPTURE)
+	return ioctl(d.fd, VIDIOC_STREAMON, unsafe.Pointer(&typ))
+}
+
+func (d *Device) StreamOff() (err error) {
+	typ := uint32(V4L2_BUF_TYPE_VIDEO_CAPTURE)
+	if err = ioctl(d.fd, VIDIOC_STREAMOFF, unsafe.Pointer(&typ)); err != nil {
+		return err
+	}
+
+	for i := range d.bufs {
+		_ = syscall.Munmap(d.bufs[i])
+	}
+
+	rb := v4l2_requestbuffers{
+		count:  0,
+		typ:    V4L2_BUF_TYPE_VIDEO_CAPTURE,
+		memory: V4L2_MEMORY_MMAP,
+	}
+	return ioctl(d.fd, VIDIOC_REQBUFS, unsafe.Pointer(&rb))
+}
+
+func (d *Device) Capture() ([]byte, error) {
+	dec := v4l2_buffer{
+		typ:    V4L2_BUF_TYPE_VIDEO_CAPTURE,
+		memory: V4L2_MEMORY_MMAP,
+	}
+	if err := ioctl(d.fd, VIDIOC_DQBUF, unsafe.Pointer(&dec)); err != nil {
+		return nil, err
+	}
+
+	src := d.bufs[dec.index][:dec.bytesused]
+	dst := make([]byte, dec.bytesused)
+
+	switch d.pixFmt {
+	case V4L2_PIX_FMT_YUYV:
+		YUYVtoYUV(dst, src)
+	case V4L2_PIX_FMT_NV12:
+		NV12toYUV(dst, src)
+	default:
+		copy(dst, d.bufs[dec.index][:dec.bytesused])
+	}
+
+	enc := v4l2_buffer{
+		typ:    V4L2_BUF_TYPE_VIDEO_CAPTURE,
+		memory: V4L2_MEMORY_MMAP,
+		index:  dec.index,
+	}
+	if err := ioctl(d.fd, VIDIOC_QBUF, unsafe.Pointer(&enc)); err != nil {
+		return nil, err
+	}
+
+	return dst, nil
+}
+
+func (d *Device) Close() error {
+	return syscall.Close(d.fd)
+}
+
+func ioctl(fd int, req uint, arg unsafe.Pointer) error {
+	_, _, err := syscall.Syscall(syscall.SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(arg))
+	if err != 0 {
+		return err
+	}
+	return nil
+}
+
+func str(b []byte) string {
+	if i := bytes.IndexByte(b, 0); i >= 0 {
+		return string(b[:i])
+	}
+	return string(b)
+}
diff --git a/installs_on_host/go2rtc/pkg/v4l2/device/formats.go b/installs_on_host/go2rtc/pkg/v4l2/device/formats.go
new file mode 100644
index 0000000..a0b4108
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/v4l2/device/formats.go
@@ -0,0 +1,62 @@
+package device
+
+const (
+	V4L2_PIX_FMT_YUYV  = 'Y' | 'U'<<8 | 'Y'<<16 | 'V'<<24
+	V4L2_PIX_FMT_NV12  = 'N' | 'V'<<8 | '1'<<16 | '2'<<24
+	V4L2_PIX_FMT_MJPEG = 'M' | 'J'<<8 | 'P'<<16 | 'G'<<24
+	V4L2_PIX_FMT_H264  = 'H' | '2'<<8 | '6'<<16 | '4'<<24
+	V4L2_PIX_FMT_HEVC  = 'H' | 'E'<<8 | 'V'<<16 | 'C'<<24
+)
+
+type Format struct {
+	FourCC uint32
+	Name   string
+	FFmpeg string
+}
+
+var Formats = []Format{
+	{V4L2_PIX_FMT_YUYV, "YUV 4:2:2", "yuyv422"},
+	{V4L2_PIX_FMT_NV12, "Y/UV 4:2:0", "nv12"},
+	{V4L2_PIX_FMT_MJPEG, "Motion-JPEG", "mjpeg"},
+	{V4L2_PIX_FMT_H264, "H.264", "h264"},
+	{V4L2_PIX_FMT_HEVC, "HEVC", "hevc"},
+}
+
+func YUYVtoYUV(dst, src []byte) {
+	n := len(src)
+	i0 := 0
+	iy := 0
+	iu := n / 2
+	iv := n / 4 * 3
+	for i0 < n {
+		dst[iy] = src[i0]
+		i0++
+		iy++
+		dst[iu] = src[i0]
+		i0++
+		iu++
+		dst[iy] = src[i0]
+		i0++
+		iy++
+		dst[iv] = src[i0]
+		i0++
+		iv++
+	}
+}
+
+func NV12toYUV(dst, src []byte) {
+	n := len(src)
+	k := n / 6
+	i0 := k * 4
+	iu := i0
+	iv := i0 + k
+	copy(dst, src[:i0]) // copy Y
+	for i0 < n {
+		dst[iu] = src[i0]
+		i0++
+		iu++
+		dst[iv] = src[i0]
+		i0++
+		iv++
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/v4l2/device/videodev2_386.go b/installs_on_host/go2rtc/pkg/v4l2/device/videodev2_386.go
new file mode 100644
index 0000000..8737ca9
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/v4l2/device/videodev2_386.go
@@ -0,0 +1,149 @@
+package device
+
+const (
+	VIDIOC_QUERYCAP = 0x80685600
+	VIDIOC_ENUM_FMT = 0xc0405602
+	VIDIOC_G_FMT    = 0xc0cc5604
+	VIDIOC_S_FMT    = 0xc0cc5605
+	VIDIOC_REQBUFS  = 0xc0145608
+	VIDIOC_QUERYBUF = 0xc0445609
+
+	VIDIOC_QBUF      = 0xc044560f
+	VIDIOC_DQBUF     = 0xc0445611
+	VIDIOC_STREAMON  = 0x40045612
+	VIDIOC_STREAMOFF = 0x40045613
+	VIDIOC_G_PARM    = 0xc0cc5615
+	VIDIOC_S_PARM    = 0xc0cc5616
+
+	VIDIOC_ENUM_FRAMESIZES     = 0xc02c564a
+	VIDIOC_ENUM_FRAMEINTERVALS = 0xc034564b
+)
+
+const (
+	V4L2_BUF_TYPE_VIDEO_CAPTURE = 1
+	V4L2_COLORSPACE_DEFAULT     = 0
+	V4L2_FIELD_NONE             = 1
+	V4L2_FRMIVAL_TYPE_DISCRETE  = 1
+	V4L2_FRMSIZE_TYPE_DISCRETE  = 1
+	V4L2_MEMORY_MMAP            = 1
+)
+
+type v4l2_capability struct { // size 104
+	driver       [16]byte  // offset 0, size 16
+	card         [32]byte  // offset 16, size 32
+	bus_info     [32]byte  // offset 48, size 32
+	version      uint32    // offset 80, size 4
+	capabilities uint32    // offset 84, size 4
+	device_caps  uint32    // offset 88, size 4
+	reserved     [3]uint32 // offset 92, size 12
+}
+
+type v4l2_format struct { // size 204
+	typ uint32          // offset 0, size 4
+	_   [0]byte         // align
+	pix v4l2_pix_format // offset 4, size 48
+	_   [152]byte       // filler
+}
+
+type v4l2_pix_format struct { // size 48
+	width        uint32 // offset 0, size 4
+	height       uint32 // offset 4, size 4
+	pixelformat  uint32 // offset 8, size 4
+	field        uint32 // offset 12, size 4
+	bytesperline uint32 // offset 16, size 4
+	sizeimage    uint32 // offset 20, size 4
+	colorspace   uint32 // offset 24, size 4
+	priv         uint32 // offset 28, size 4
+	flags        uint32 // offset 32, size 4
+	ycbcr_enc    uint32 // offset 36, size 4
+	quantization uint32 // offset 40, size 4
+	xfer_func    uint32 // offset 44, size 4
+}
+
+type v4l2_streamparm struct { // size 204
+	typ     uint32           // offset 0, size 4
+	capture v4l2_captureparm // offset 4, size 40
+	_       [160]byte        // filler
+}
+
+type v4l2_captureparm struct { // size 40
+	capability   uint32     // offset 0, size 4
+	capturemode  uint32     // offset 4, size 4
+	timeperframe v4l2_fract // offset 8, size 8
+	extendedmode uint32     // offset 16, size 4
+	readbuffers  uint32     // offset 20, size 4
+	reserved     [4]uint32  // offset 24, size 16
+}
+
+type v4l2_fract struct { // size 8
+	numerator   uint32 // offset 0, size 4
+	denominator uint32 // offset 4, size 4
+}
+
+type v4l2_requestbuffers struct { // size 20
+	count        uint32   // offset 0, size 4
+	typ          uint32   // offset 4, size 4
+	memory       uint32   // offset 8, size 4
+	capabilities uint32   // offset 12, size 4
+	flags        uint8    // offset 16, size 1
+	reserved     [3]uint8 // offset 17, size 3
+}
+
+type v4l2_buffer struct { // size 68
+	index     uint32        // offset 0, size 4
+	typ       uint32        // offset 4, size 4
+	bytesused uint32        // offset 8, size 4
+	flags     uint32        // offset 12, size 4
+	field     uint32        // offset 16, size 4
+	_         [8]byte       // align
+	timecode  v4l2_timecode // offset 28, size 16
+	sequence  uint32        // offset 44, size 4
+	memory    uint32        // offset 48, size 4
+	offset    uint32        // offset 52, size 4
+	_         [0]byte       // align
+	length    uint32        // offset 56, size 4
+	_         [8]byte       // filler
+}
+
+type v4l2_timecode struct { // size 16
+	typ      uint32   // offset 0, size 4
+	flags    uint32   // offset 4, size 4
+	frames   uint8    // offset 8, size 1
+	seconds  uint8    // offset 9, size 1
+	minutes  uint8    // offset 10, size 1
+	hours    uint8    // offset 11, size 1
+	userbits [4]uint8 // offset 12, size 4
+}
+
+type v4l2_fmtdesc struct { // size 64
+	index       uint32    // offset 0, size 4
+	typ         uint32    // offset 4, size 4
+	flags       uint32    // offset 8, size 4
+	description [32]byte  // offset 12, size 32
+	pixelformat uint32    // offset 44, size 4
+	mbus_code   uint32    // offset 48, size 4
+	reserved    [3]uint32 // offset 52, size 12
+}
+
+type v4l2_frmsizeenum struct { // size 44
+	index        uint32                // offset 0, size 4
+	pixel_format uint32                // offset 4, size 4
+	typ          uint32                // offset 8, size 4
+	discrete     v4l2_frmsize_discrete // offset 12, size 8
+	_            [24]byte              // filler
+}
+
+type v4l2_frmsize_discrete struct { // size 8
+	width  uint32 // offset 0, size 4
+	height uint32 // offset 4, size 4
+}
+
+type v4l2_frmivalenum struct { // size 52
+	index        uint32     // offset 0, size 4
+	pixel_format uint32     // offset 4, size 4
+	width        uint32     // offset 8, size 4
+	height       uint32     // offset 12, size 4
+	typ          uint32     // offset 16, size 4
+	discrete     v4l2_fract // offset 20, size 8
+	_            [24]byte   // filler
+}
diff --git a/installs_on_host/go2rtc/pkg/v4l2/device/videodev2_arch.c b/installs_on_host/go2rtc/pkg/v4l2/device/videodev2_arch.c
new file mode 100644
index 0000000..19ac6a6
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/v4l2/device/videodev2_arch.c
@@ -0,0 +1,164 @@
+//go:build ignore
+#include <stdio.h>
+#include <stddef.h>
+#include <linux/videodev2.h>
+
+#define printconst1(con) printf("\t%s = 0x%08lx\n", #con, con)
+#define printconst2(con) printf("\t%s = %d\n", #con, con)
+#define printstruct(str) printf("type %s struct { // size %lu\n", #str, sizeof(struct str))
+#define printmember(str, mem, typ) printf("\t%s %s // offset %lu, size %lu\n", #mem == "type" ? "typ" : #mem, typ, offsetof(struct str, mem), sizeof((struct str){0}.mem))
+#define printunimem(str, uni, mem, typ) printf("\t%s %s // offset %lu, size %lu\n", #mem, typ, offsetof(struct str, uni.mem), sizeof((struct str){0}.uni.mem))
+#define printalign1(str, mem2, mem1) printf("\t_ [%lu]byte // align\n", offsetof(struct str, mem2) - offsetof(struct str, mem1) - sizeof((struct str){0}.mem1))
+#define printfiller(str, mem) printf("\t_ [%lu]byte // filler\n", sizeof(struct str) - offsetof(struct str, mem) - sizeof((struct str){0}.mem))
+
+int main() {
+	printf("const (\n");
+	printconst1(VIDIOC_QUERYCAP);
+	printconst1(VIDIOC_ENUM_FMT);
+	printconst1(VIDIOC_G_FMT);
+	printconst1(VIDIOC_S_FMT);
+	printconst1(VIDIOC_REQBUFS);
+	printconst1(VIDIOC_QUERYBUF);
+	printf("\n");
+	printconst1(VIDIOC_QBUF);
+	printconst1(VIDIOC_DQBUF);
+	printconst1(VIDIOC_STREAMON);
+	printconst1(VIDIOC_STREAMOFF);
+	printconst1(VIDIOC_G_PARM);
+	printconst1(VIDIOC_S_PARM);
+	printf("\n");
+	printconst1(VIDIOC_ENUM_FRAMESIZES);
+	printconst1(VIDIOC_ENUM_FRAMEINTERVALS);
+	printf(")\n\n");
+
+	printf("const (\n");
+	printconst2(V4L2_BUF_TYPE_VIDEO_CAPTURE);
+	printconst2(V4L2_COLORSPACE_DEFAULT);
+	printconst2(V4L2_FIELD_NONE);
+	printconst2(V4L2_FRMIVAL_TYPE_DISCRETE);
+	printconst2(V4L2_FRMSIZE_TYPE_DISCRETE);
+	printconst2(V4L2_MEMORY_MMAP);
+	printf(")\n\n");
+
+	printstruct(v4l2_capability);
+	printmember(v4l2_capability, driver, "[16]byte");
+	printmember(v4l2_capability, card, "[32]byte");
+	printmember(v4l2_capability, bus_info, "[32]byte");
+	printmember(v4l2_capability, version, "uint32");
+	printmember(v4l2_capability, capabilities, "uint32");
+	printmember(v4l2_capability, device_caps, "uint32");
+	printmember(v4l2_capability, reserved, "[3]uint32");
+	printf("}\n\n");
+
+	printstruct(v4l2_format);
+	printmember(v4l2_format, type, "uint32");
+	printalign1(v4l2_format, fmt, type);
+	printunimem(v4l2_format, fmt, pix, "v4l2_pix_format");
+	printfiller(v4l2_format, fmt.pix);
+	printf("}\n\n");
+
+	printstruct(v4l2_pix_format);
+	printmember(v4l2_pix_format, width, "uint32");
+	printmember(v4l2_pix_format, height, "uint32");
+	printmember(v4l2_pix_format, pixelformat, "uint32");
+	printmember(v4l2_pix_format, field, "uint32");
+	printmember(v4l2_pix_format, bytesperline, "uint32");
+	printmember(v4l2_pix_format, sizeimage, "uint32");
+	printmember(v4l2_pix_format, colorspace, "uint32");
+	printmember(v4l2_pix_format, priv, "uint32");
+	printmember(v4l2_pix_format, flags, "uint32");
+	printmember(v4l2_pix_format, ycbcr_enc, "uint32");
+	printmember(v4l2_pix_format, quantization, "uint32");
+	printmember(v4l2_pix_format, xfer_func, "uint32");
+	printf("}\n\n");
+
+	printstruct(v4l2_streamparm);
+	printmember(v4l2_streamparm, type, "uint32");
+	printunimem(v4l2_streamparm, parm, capture, "v4l2_captureparm");
+	printfiller(v4l2_streamparm, parm.capture);
+	printf("}\n\n");
+
+	printstruct(v4l2_captureparm);
+	printmember(v4l2_captureparm, capability, "uint32");
+	printmember(v4l2_captureparm, capturemode, "uint32");
+	printmember(v4l2_captureparm, timeperframe, "v4l2_fract");
+	printmember(v4l2_captureparm, extendedmode, "uint32");
+	printmember(v4l2_captureparm, readbuffers, "uint32");
+	printmember(v4l2_captureparm, reserved, "[4]uint32");
+	printf("}\n\n");
+
+	printstruct(v4l2_fract);
+	printmember(v4l2_fract, numerator, "uint32");
+	printmember(v4l2_fract, denominator, "uint32");
+	printf("}\n\n");
+
+	printstruct(v4l2_requestbuffers);
+	printmember(v4l2_requestbuffers, count, "uint32");
+	printmember(v4l2_requestbuffers, type, "uint32");
+	printmember(v4l2_requestbuffers, memory, "uint32");
+	printmember(v4l2_requestbuffers, capabilities, "uint32");
+	printmember(v4l2_requestbuffers, flags, "uint8");
+	printmember(v4l2_requestbuffers, reserved, "[3]uint8");
+	printf("}\n\n");
+
+	printstruct(v4l2_buffer);
+	printmember(v4l2_buffer, index, "uint32");
+	printmember(v4l2_buffer, type, "uint32");
+	printmember(v4l2_buffer, bytesused, "uint32");
+	printmember(v4l2_buffer, flags, "uint32");
+	printmember(v4l2_buffer, field, "uint32");
+	printalign1(v4l2_buffer, timecode, field);
+	printmember(v4l2_buffer, timecode, "v4l2_timecode");
+	printmember(v4l2_buffer, sequence, "uint32");
+	printmember(v4l2_buffer, memory, "uint32");
+	printunimem(v4l2_buffer, m, offset, "uint32");
+	printalign1(v4l2_buffer, length, m.offset);
+	printmember(v4l2_buffer, length, "uint32");
+	printfiller(v4l2_buffer, length);
+	printf("}\n\n");
+
+	printstruct(v4l2_timecode);
+	printmember(v4l2_timecode, type, "uint32");
+	printmember(v4l2_timecode, flags, "uint32");
+	printmember(v4l2_timecode, frames, "uint8");
+	printmember(v4l2_timecode, seconds, "uint8");
+	printmember(v4l2_timecode, minutes, "uint8");
+	printmember(v4l2_timecode, hours, "uint8");
+	printmember(v4l2_timecode, userbits, "[4]uint8");
+	printf("}\n\n");
+
+	printstruct(v4l2_fmtdesc);
+	printmember(v4l2_fmtdesc, index, "uint32");
+	printmember(v4l2_fmtdesc, type, "uint32");
+	printmember(v4l2_fmtdesc, flags, "uint32");
+	printmember(v4l2_fmtdesc, description, "[32]byte");
+	printmember(v4l2_fmtdesc, pixelformat, "uint32");
+	printmember(v4l2_fmtdesc, mbus_code, "uint32");
+	printmember(v4l2_fmtdesc, reserved, "[3]uint32");
+	printf("}\n\n");
+
+	printstruct(v4l2_frmsizeenum);
+	printmember(v4l2_frmsizeenum, index, "uint32");
+	printmember(v4l2_frmsizeenum, pixel_format, "uint32");
+	printmember(v4l2_frmsizeenum, type, "uint32");
+	printmember(v4l2_frmsizeenum, discrete, "v4l2_frmsize_discrete");
+	printfiller(v4l2_frmsizeenum, discrete);
+	printf("}\n\n");
+
+	printstruct(v4l2_frmsize_discrete);
+	printmember(v4l2_frmsize_discrete, width, "uint32");
+	printmember(v4l2_frmsize_discrete, height, "uint32");
+	printf("}\n\n");
+
+	printstruct(v4l2_frmivalenum);
+	printmember(v4l2_frmivalenum, index, "uint32");
+	printmember(v4l2_frmivalenum, pixel_format, "uint32");
+	printmember(v4l2_frmivalenum, width, "uint32");
+	printmember(v4l2_frmivalenum, height, "uint32");
+	printmember(v4l2_frmivalenum, type, "uint32");
+	printmember(v4l2_frmivalenum, discrete, "v4l2_fract");
+	printfiller(v4l2_frmivalenum, discrete);
+	printf("}\n\n");
+
+	return 0;
+}
\ No newline at end of file
diff --git a/installs_on_host/go2rtc/pkg/v4l2/device/videodev2_arm.go b/installs_on_host/go2rtc/pkg/v4l2/device/videodev2_arm.go
new file mode 100644
index 0000000..098ca5a
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/v4l2/device/videodev2_arm.go
@@ -0,0 +1,149 @@
+package device
+
+const (
+	VIDIOC_QUERYCAP = 0x80685600
+	VIDIOC_ENUM_FMT = 0xc0405602
+	VIDIOC_G_FMT    = 0xc0cc5604
+	VIDIOC_S_FMT    = 0xc0cc5605
+	VIDIOC_REQBUFS  = 0xc0145608
+	VIDIOC_QUERYBUF = 0xc0505609
+
+	VIDIOC_QBUF      = 0xc050560f
+	VIDIOC_DQBUF     = 0xc0505611
+	VIDIOC_STREAMON  = 0x40045612
+	VIDIOC_STREAMOFF = 0x40045613
+	VIDIOC_G_PARM    = 0xc0cc5615
+	VIDIOC_S_PARM    = 0xc0cc5616
+
+	VIDIOC_ENUM_FRAMESIZES     = 0xc02c564a
+	VIDIOC_ENUM_FRAMEINTERVALS = 0xc034564b
+)
+
+const (
+	V4L2_BUF_TYPE_VIDEO_CAPTURE = 1
+	V4L2_COLORSPACE_DEFAULT     = 0
+	V4L2_FIELD_NONE             = 1
+	V4L2_FRMIVAL_TYPE_DISCRETE  = 1
+	V4L2_FRMSIZE_TYPE_DISCRETE  = 1
+	V4L2_MEMORY_MMAP            = 1
+)
+
+type v4l2_capability struct { // size 104
+	driver       [16]byte  // offset 0, size 16
+	card         [32]byte  // offset 16, size 32
+	bus_info     [32]byte  // offset 48, size 32
+	version      uint32    // offset 80, size 4
+	capabilities uint32    // offset 84, size 4
+	device_caps  uint32    // offset 88, size 4
+	reserved     [3]uint32 // offset 92, size 12
+}
+
+type v4l2_format struct { // size 204
+	typ uint32          // offset 0, size 4
+	_   [0]byte         // align
+	pix v4l2_pix_format // offset 4, size 48
+	_   [152]byte       // filler
+}
+
+type v4l2_pix_format struct { // size 48
+	width        uint32 // offset 0, size 4
+	height       uint32 // offset 4, size 4
+	pixelformat  uint32 // offset 8, size 4
+	field        uint32 // offset 12, size 4
+	bytesperline uint32 // offset 16, size 4
+	sizeimage    uint32 // offset 20, size 4
+	colorspace   uint32 // offset 24, size 4
+	priv         uint32 // offset 28, size 4
+	flags        uint32 // offset 32, size 4
+	ycbcr_enc    uint32 // offset 36, size 4
+	quantization uint32 // offset 40, size 4
+	xfer_func    uint32 // offset 44, size 4
+}
+
+type v4l2_streamparm struct { // size 204
+	typ     uint32           // offset 0, size 4
+	capture v4l2_captureparm // offset 4, size 40
+	_       [160]byte        // filler
+}
+
+type v4l2_captureparm struct { // size 40
+	capability   uint32     // offset 0, size 4
+	capturemode  uint32     // offset 4, size 4
+	timeperframe v4l2_fract // offset 8, size 8
+	extendedmode uint32     // offset 16, size 4
+	readbuffers  uint32     // offset 20, size 4
+	reserved     [4]uint32  // offset 24, size 16
+}
+
+type v4l2_fract struct { // size 8
+	numerator   uint32 // offset 0, size 4
+	denominator uint32 // offset 4, size 4
+}
+
+type v4l2_requestbuffers struct { // size 20
+	count        uint32   // offset 0, size 4
+	typ          uint32   // offset 4, size 4
+	memory       uint32   // offset 8, size 4
+	capabilities uint32   // offset 12, size 4
+	flags        uint8    // offset 16, size 1
+	reserved     [3]uint8 // offset 17, size 3
+}
+
+type v4l2_buffer struct { // size 80
+	index     uint32        // offset 0, size 4
+	typ       uint32        // offset 4, size 4
+	bytesused uint32        // offset 8, size 4
+	flags     uint32        // offset 12, size 4
+	field     uint32        // offset 16, size 4
+	_         [20]byte      // align
+	timecode  v4l2_timecode // offset 40, size 16
+	sequence  uint32        // offset 56, size 4
+	memory    uint32        // offset 60, size 4
+	offset    uint32        // offset 64, size 4
+	_         [0]byte       // align
+	length    uint32        // offset 68, size 4
+	_         [8]byte       // filler
+}
+
+type v4l2_timecode struct { // size 16
+	typ      uint32   // offset 0, size 4
+	flags    uint32   // offset 4, size 4
+	frames   uint8    // offset 8, size 1
+	seconds  uint8    // offset 9, size 1
+	minutes  uint8    // offset 10, size 1
+	hours    uint8    // offset 11, size 1
+	userbits [4]uint8 // offset 12, size 4
+}
+
+type v4l2_fmtdesc struct { // size 64
+	index       uint32    // offset 0, size 4
+	typ         uint32    // offset 4, size 4
+	flags       uint32    // offset 8, size 4
+	description [32]byte  // offset 12, size 32
+	pixelformat uint32    // offset 44, size 4
+	mbus_code   uint32    // offset 48, size 4
+	reserved    [3]uint32 // offset 52, size 12
+}
+
+type v4l2_frmsizeenum struct { // size 44
+	index        uint32                // offset 0, size 4
+	pixel_format uint32                // offset 4, size 4
+	typ          uint32                // offset 8, size 4
+	discrete     v4l2_frmsize_discrete // offset 12, size 8
+	_            [24]byte              // filler
+}
+
+type v4l2_frmsize_discrete struct { // size 8
+	width  uint32 // offset 0, size 4
+	height uint32 // offset 4, size 4
+}
+
+type v4l2_frmivalenum struct { // size 52
+	index        uint32     // offset 0, size 4
+	pixel_format uint32     // offset 4, size 4
+	width        uint32     // offset 8, size 4
+	height       uint32     // offset 12, size 4
+	typ          uint32     // offset 16, size 4
+	discrete     v4l2_fract // offset 20, size 8
+	_            [24]byte   // filler
+}
diff --git a/installs_on_host/go2rtc/pkg/v4l2/device/videodev2_mipsle.go b/installs_on_host/go2rtc/pkg/v4l2/device/videodev2_mipsle.go
new file mode 100644
index 0000000..cecc54c
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/v4l2/device/videodev2_mipsle.go
@@ -0,0 +1,149 @@
+package device
+
+const (
+	VIDIOC_QUERYCAP = 0x40685600
+	VIDIOC_ENUM_FMT = 0xc0405602
+	VIDIOC_G_FMT    = 0xc0cc5604
+	VIDIOC_S_FMT    = 0xc0cc5605
+	VIDIOC_REQBUFS  = 0xc0145608
+	VIDIOC_QUERYBUF = 0xc0445609
+
+	VIDIOC_QBUF      = 0xc044560f
+	VIDIOC_DQBUF     = 0xc0445611
+	VIDIOC_STREAMON  = 0x80045612
+	VIDIOC_STREAMOFF = 0x80045613
+	VIDIOC_G_PARM    = 0xc0cc5615
+	VIDIOC_S_PARM    = 0xc0cc5616
+
+	VIDIOC_ENUM_FRAMESIZES     = 0xc02c564a
+	VIDIOC_ENUM_FRAMEINTERVALS = 0xc034564b
+)
+
+const (
+	V4L2_BUF_TYPE_VIDEO_CAPTURE = 1
+	V4L2_COLORSPACE_DEFAULT     = 0
+	V4L2_FIELD_NONE             = 1
+	V4L2_FRMIVAL_TYPE_DISCRETE  = 1
+	V4L2_FRMSIZE_TYPE_DISCRETE  = 1
+	V4L2_MEMORY_MMAP            = 1
+)
+
+type v4l2_capability struct { // size 104
+	driver       [16]byte  // offset 0, size 16
+	card         [32]byte  // offset 16, size 32
+	bus_info     [32]byte  // offset 48, size 32
+	version      uint32    // offset 80, size 4
+	capabilities uint32    // offset 84, size 4
+	device_caps  uint32    // offset 88, size 4
+	reserved     [3]uint32 // offset 92, size 12
+}
+
+type v4l2_format struct { // size 204
+	typ uint32          // offset 0, size 4
+	_   [0]byte         // align
+	pix v4l2_pix_format // offset 4, size 48
+	_   [152]byte       // filler
+}
+
+type v4l2_pix_format struct { // size 48
+	width        uint32 // offset 0, size 4
+	height       uint32 // offset 4, size 4
+	pixelformat  uint32 // offset 8, size 4
+	field        uint32 // offset 12, size 4
+	bytesperline uint32 // offset 16, size 4
+	sizeimage    uint32 // offset 20, size 4
+	colorspace   uint32 // offset 24, size 4
+	priv         uint32 // offset 28, size 4
+	flags        uint32 // offset 32, size 4
+	ycbcr_enc    uint32 // offset 36, size 4
+	quantization uint32 // offset 40, size 4
+	xfer_func    uint32 // offset 44, size 4
+}
+
+type v4l2_streamparm struct { // size 204
+	typ     uint32           // offset 0, size 4
+	capture v4l2_captureparm // offset 4, size 40
+	_       [160]byte        // filler
+}
+
+type v4l2_captureparm struct { // size 40
+	capability   uint32     // offset 0, size 4
+	capturemode  uint32     // offset 4, size 4
+	timeperframe v4l2_fract // offset 8, size 8
+	extendedmode uint32     // offset 16, size 4
+	readbuffers  uint32     // offset 20, size 4
+	reserved     [4]uint32  // offset 24, size 16
+}
+
+type v4l2_fract struct { // size 8
+	numerator   uint32 // offset 0, size 4
+	denominator uint32 // offset 4, size 4
+}
+
+type v4l2_requestbuffers struct { // size 20
+	count        uint32   // offset 0, size 4
+	typ          uint32   // offset 4, size 4
+	memory       uint32   // offset 8, size 4
+	capabilities uint32   // offset 12, size 4
+	flags        uint8    // offset 16, size 1
+	reserved     [3]uint8 // offset 17, size 3
+}
+
+type v4l2_buffer struct { // size 68
+	index     uint32        // offset 0, size 4
+	typ       uint32        // offset 4, size 4
+	bytesused uint32        // offset 8, size 4
+	flags     uint32        // offset 12, size 4
+	field     uint32        // offset 16, size 4
+	_         [8]byte       // align
+	timecode  v4l2_timecode // offset 28, size 16
+	sequence  uint32        // offset 44, size 4
+	memory    uint32        // offset 48, size 4
+	offset    uint32        // offset 52, size 4
+	_         [0]byte       // align
+	length    uint32        // offset 56, size 4
+	_         [8]byte       // filler
+}
+
+type v4l2_timecode struct { // size 16
+	typ      uint32   // offset 0, size 4
+	flags    uint32   // offset 4, size 4
+	frames   uint8    // offset 8, size 1
+	seconds  uint8    // offset 9, size 1
+	minutes  uint8    // offset 10, size 1
+	hours    uint8    // offset 11, size 1
+	userbits [4]uint8 // offset 12, size 4
+}
+
+type v4l2_fmtdesc struct { // size 64
+	index       uint32    // offset 0, size 4
+	typ         uint32    // offset 4, size 4
+	flags       uint32    // offset 8, size 4
+	description [32]byte  // offset 12, size 32
+	pixelformat uint32    // offset 44, size 4
+	mbus_code   uint32    // offset 48, size 4
+	reserved    [3]uint32 // offset 52, size 12
+}
+
+type v4l2_frmsizeenum struct { // size 44
+	index        uint32                // offset 0, size 4
+	pixel_format uint32                // offset 4, size 4
+	typ          uint32                // offset 8, size 4
+	discrete     v4l2_frmsize_discrete // offset 12, size 8
+	_            [24]byte              // filler
+}
+
+type v4l2_frmsize_discrete struct { // size 8
+	width  uint32 // offset 0, size 4
+	height uint32 // offset 4, size 4
+}
+
+type v4l2_frmivalenum struct { // size 52
+	index        uint32     // offset 0, size 4
+	pixel_format uint32     // offset 4, size 4
+	width        uint32     // offset 8, size 4
+	height       uint32     // offset 12, size 4
+	typ          uint32     // offset 16, size 4
+	discrete     v4l2_fract // offset 20, size 8
+	_            [24]byte   // filler
+}
diff --git a/installs_on_host/go2rtc/pkg/v4l2/device/videodev2_x64.go b/installs_on_host/go2rtc/pkg/v4l2/device/videodev2_x64.go
new file mode 100644
index 0000000..6e1018e
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/v4l2/device/videodev2_x64.go
@@ -0,0 +1,151 @@
+//go:build amd64 || arm64
+
+package device
+
+const (
+	VIDIOC_QUERYCAP = 0x80685600
+	VIDIOC_ENUM_FMT = 0xc0405602
+	VIDIOC_G_FMT    = 0xc0d05604
+	VIDIOC_S_FMT    = 0xc0d05605
+	VIDIOC_REQBUFS  = 0xc0145608
+	VIDIOC_QUERYBUF = 0xc0585609
+
+	VIDIOC_QBUF      = 0xc058560f
+	VIDIOC_DQBUF     = 0xc0585611
+	VIDIOC_STREAMON  = 0x40045612
+	VIDIOC_STREAMOFF = 0x40045613
+	VIDIOC_G_PARM    = 0xc0cc5615
+	VIDIOC_S_PARM    = 0xc0cc5616
+
+	VIDIOC_ENUM_FRAMESIZES     = 0xc02c564a
+	VIDIOC_ENUM_FRAMEINTERVALS = 0xc034564b
+)
+
+const (
+	V4L2_BUF_TYPE_VIDEO_CAPTURE = 1
+	V4L2_COLORSPACE_DEFAULT     = 0
+	V4L2_FIELD_NONE             = 1
+	V4L2_FRMIVAL_TYPE_DISCRETE  = 1
+	V4L2_FRMSIZE_TYPE_DISCRETE  = 1
+	V4L2_MEMORY_MMAP            = 1
+)
+
+type v4l2_capability struct { // size 104
+	driver       [16]byte  // offset 0, size 16
+	card         [32]byte  // offset 16, size 32
+	bus_info     [32]byte  // offset 48, size 32
+	version      uint32    // offset 80, size 4
+	capabilities uint32    // offset 84, size 4
+	device_caps  uint32    // offset 88, size 4
+	reserved     [3]uint32 // offset 92, size 12
+}
+
+type v4l2_format struct { // size 208
+	typ uint32          // offset 0, size 4
+	_   [4]byte         // align
+	pix v4l2_pix_format // offset 8, size 48
+	_   [152]byte       // filler
+}
+
+type v4l2_pix_format struct { // size 48
+	width        uint32 // offset 0, size 4
+	height       uint32 // offset 4, size 4
+	pixelformat  uint32 // offset 8, size 4
+	field        uint32 // offset 12, size 4
+	bytesperline uint32 // offset 16, size 4
+	sizeimage    uint32 // offset 20, size 4
+	colorspace   uint32 // offset 24, size 4
+	priv         uint32 // offset 28, size 4
+	flags        uint32 // offset 32, size 4
+	ycbcr_enc    uint32 // offset 36, size 4
+	quantization uint32 // offset 40, size 4
+	xfer_func    uint32 // offset 44, size 4
+}
+
+type v4l2_streamparm struct { // size 204
+	typ     uint32           // offset 0, size 4
+	capture v4l2_captureparm // offset 4, size 40
+	_       [160]byte        // filler
+}
+
+type v4l2_captureparm struct { // size 40
+	capability   uint32     // offset 0, size 4
+	capturemode  uint32     // offset 4, size 4
+	timeperframe v4l2_fract // offset 8, size 8
+	extendedmode uint32     // offset 16, size 4
+	readbuffers  uint32     // offset 20, size 4
+	reserved     [4]uint32  // offset 24, size 16
+}
+
+type v4l2_fract struct { // size 8
+	numerator   uint32 // offset 0, size 4
+	denominator uint32 // offset 4, size 4
+}
+
+type v4l2_requestbuffers struct { // size 20
+	count        uint32   // offset 0, size 4
+	typ          uint32   // offset 4, size 4
+	memory       uint32   // offset 8, size 4
+	capabilities uint32   // offset 12, size 4
+	flags        uint8    // offset 16, size 1
+	reserved     [3]uint8 // offset 17, size 3
+}
+
+type v4l2_buffer struct { // size 88
+	index     uint32        // offset 0, size 4
+	typ       uint32        // offset 4, size 4
+	bytesused uint32        // offset 8, size 4
+	flags     uint32        // offset 12, size 4
+	field     uint32        // offset 16, size 4
+	_         [20]byte      // align
+	timecode  v4l2_timecode // offset 40, size 16
+	sequence  uint32        // offset 56, size 4
+	memory    uint32        // offset 60, size 4
+	offset    uint32        // offset 64, size 4
+	_         [4]byte       // align
+	length    uint32        // offset 72, size 4
+	_         [12]byte      // filler
+}
+
+type v4l2_timecode struct { // size 16
+	typ      uint32   // offset 0, size 4
+	flags    uint32   // offset 4, size 4
+	frames   uint8    // offset 8, size 1
+	seconds  uint8    // offset 9, size 1
+	minutes  uint8    // offset 10, size 1
+	hours    uint8    // offset 11, size 1
+	userbits [4]uint8 // offset 12, size 4
+}
+
+type v4l2_fmtdesc struct { // size 64
+	index       uint32    // offset 0, size 4
+	typ         uint32    // offset 4, size 4
+	flags       uint32    // offset 8, size 4
+	description [32]byte  // offset 12, size 32
+	pixelformat uint32    // offset 44, size 4
+	mbus_code   uint32    // offset 48, size 4
+	reserved    [3]uint32 // offset 52, size 12
+}
+
+type v4l2_frmsizeenum struct { // size 44
+	index        uint32                // offset 0, size 4
+	pixel_format uint32                // offset 4, size 4
+	typ          uint32                // offset 8, size 4
+	discrete     v4l2_frmsize_discrete // offset 12, size 8
+	_            [24]byte              // filler
+}
+
+type v4l2_frmsize_discrete struct { // size 8
+	width  uint32 // offset 0, size 4
+	height uint32 // offset 4, size 4
+}
+
+type v4l2_frmivalenum struct { // size 52
+	index        uint32     // offset 0, size 4
+	pixel_format uint32     // offset 4, size 4
+	width        uint32     // offset 8, size 4
+	height       uint32     // offset 12, size 4
+	typ          uint32     // offset 16, size 4
+	discrete     v4l2_fract // offset 20, size 8
+	_            [24]byte   // filler
+}
diff --git a/installs_on_host/go2rtc/pkg/v4l2/producer.go b/installs_on_host/go2rtc/pkg/v4l2/producer.go
new file mode 100644
index 0000000..663d0a9
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/v4l2/producer.go
@@ -0,0 +1,142 @@
+//go:build linux
+
+package v4l2
+
+import (
+	"errors"
+	"net/url"
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264/annexb"
+	"github.com/AlexxIT/go2rtc/pkg/v4l2/device"
+	"github.com/pion/rtp"
+)
+
+type Producer struct {
+	core.Connection
+	dev *device.Device
+}
+
+func Open(rawURL string) (*Producer, error) {
+	// Example (ffmpeg source compatible):
+	// v4l2:device?video=/dev/video0&input_format=mjpeg&video_size=1280x720
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	query := u.Query()
+
+	dev, err := device.Open(query.Get("video"))
+	if err != nil {
+		return nil, err
+	}
+
+	codec := &core.Codec{
+		ClockRate:   90000,
+		PayloadType: core.PayloadTypeRAW,
+	}
+
+	var width, height, pixFmt uint32
+
+	if wh := strings.Split(query.Get("video_size"), "x"); len(wh) == 2 {
+		codec.FmtpLine = "width=" + wh[0] + ";height=" + wh[1]
+		width = uint32(core.Atoi(wh[0]))
+		height = uint32(core.Atoi(wh[1]))
+	}
+
+	switch query.Get("input_format") {
+	case "yuyv422":
+		if codec.FmtpLine == "" {
+			return nil, errors.New("v4l2: invalid video_size")
+		}
+		codec.Name = core.CodecRAW
+		codec.FmtpLine += ";colorspace=422"
+		pixFmt = device.V4L2_PIX_FMT_YUYV
+	case "nv12":
+		if codec.FmtpLine == "" {
+			return nil, errors.New("v4l2: invalid video_size")
+		}
+		codec.Name = core.CodecRAW
+		codec.FmtpLine += ";colorspace=420mpeg2" // maybe 420jpeg
+		pixFmt = device.V4L2_PIX_FMT_NV12
+	case "mjpeg":
+		codec.Name = core.CodecJPEG
+		pixFmt = device.V4L2_PIX_FMT_MJPEG
+	case "h264":
+		codec.Name = core.CodecH264
+		pixFmt = device.V4L2_PIX_FMT_H264
+	case "hevc":
+		codec.Name = core.CodecH265
+		pixFmt = device.V4L2_PIX_FMT_HEVC
+	default:
+		return nil, errors.New("v4l2: invalid input_format")
+	}
+
+	if err = dev.SetFormat(width, height, pixFmt); err != nil {
+		return nil, err
+	}
+
+	if fps := core.Atoi(query.Get("framerate")); fps > 0 {
+		if err = dev.SetParam(uint32(fps)); err != nil {
+			return nil, err
+		}
+	}
+
+	medias := []*core.Media{
+		{
+			Kind:      core.KindVideo,
+			Direction: core.DirectionRecvonly,
+			Codecs:    []*core.Codec{codec},
+		},
+	}
+	return &Producer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "v4l2",
+			Medias:     medias,
+		},
+		dev: dev,
+	}, nil
+}
+
+func (c *Producer) Start() error {
+	if err := c.dev.StreamOn(); err != nil {
+		return err
+	}
+
+	var bitstream bool
+	switch c.Medias[0].Codecs[0].Name {
+	case core.CodecH264, core.CodecH265:
+		bitstream = true
+	}
+
+	for {
+		buf, err := c.dev.Capture()
+		if err != nil {
+			return err
+		}
+
+		c.Recv += len(buf)
+
+		if len(c.Receivers) == 0 {
+			continue
+		}
+
+		if bitstream {
+			buf = annexb.EncodeToAVCC(buf)
+		}
+
+		pkt := &rtp.Packet{
+			Header:  rtp.Header{Timestamp: core.Now90000()},
+			Payload: buf,
+		}
+		c.Receivers[0].WriteRTP(pkt)
+	}
+}
+
+func (c *Producer) Stop() error {
+	_ = c.Connection.Stop()
+	return errors.Join(c.dev.StreamOff(), c.dev.Close())
+}
diff --git a/installs_on_host/go2rtc/pkg/wav/backchannel.go b/installs_on_host/go2rtc/pkg/wav/backchannel.go
new file mode 100644
index 0000000..f9697ee
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/wav/backchannel.go
@@ -0,0 +1,67 @@
+package wav
+
+import (
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/shell"
+	"github.com/pion/rtp"
+)
+
+type Backchannel struct {
+	core.Connection
+	cmd *shell.Command
+}
+
+func NewBackchannel(cmd *shell.Command) (core.Producer, error) {
+	medias := []*core.Media{
+		{
+			Kind:      core.KindAudio,
+			Direction: core.DirectionSendonly,
+			Codecs: []*core.Codec{
+				//{Name: core.CodecPCML},
+				{Name: core.CodecPCMA},
+				{Name: core.CodecPCMU},
+			},
+		},
+	}
+
+	return &Backchannel{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "wav",
+			Protocol:   "pipe",
+			Medias:     medias,
+			Transport:  cmd,
+		},
+		cmd: cmd,
+	}, nil
+}
+
+func (c *Backchannel) GetTrack(media *core.Media, codec *core.Codec) (*core.Receiver, error) {
+	return nil, core.ErrCantGetTrack
+}
+
+func (c *Backchannel) AddTrack(media *core.Media, codec *core.Codec, track *core.Receiver) error {
+	wr, err := c.cmd.StdinPipe()
+	if err != nil {
+		return err
+	}
+
+	b := Header(track.Codec)
+	if _, err = wr.Write(b); err != nil {
+		return err
+	}
+
+	sender := core.NewSender(media, track.Codec)
+	sender.Handler = func(packet *rtp.Packet) {
+		if n, err := wr.Write(packet.Payload); err != nil {
+			c.Send += n
+		}
+	}
+	sender.HandleRTP(track)
+	c.Senders = append(c.Senders, sender)
+	return nil
+}
+
+func (c *Backchannel) Start() error {
+	return c.cmd.Run()
+}
diff --git a/installs_on_host/go2rtc/pkg/wav/producer.go b/installs_on_host/go2rtc/pkg/wav/producer.go
new file mode 100644
index 0000000..60bdeaa
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/wav/producer.go
@@ -0,0 +1,83 @@
+package wav
+
+import (
+	"bufio"
+	"errors"
+	"io"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+)
+
+const FourCC = "RIFF"
+
+func Open(r io.Reader) (*Producer, error) {
+	// https://en.wikipedia.org/wiki/WAV
+	// https://www.mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html
+	rd := bufio.NewReaderSize(r, core.BufferSize)
+
+	codec, err := ReadHeader(r)
+	if err != nil {
+		return nil, err
+	}
+
+	if codec.Name == "" {
+		return nil, errors.New("waw: unsupported codec")
+	}
+
+	medias := []*core.Media{
+		{
+			Kind:      core.KindAudio,
+			Direction: core.DirectionRecvonly,
+			Codecs:    []*core.Codec{codec},
+		},
+	}
+	return &Producer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "wav",
+			Medias:     medias,
+			Transport:  r,
+		},
+		rd: rd,
+	}, nil
+}
+
+type Producer struct {
+	core.Connection
+	rd *bufio.Reader
+}
+
+func (c *Producer) Start() error {
+	var seq uint16
+	var ts uint32
+
+	const PacketSize = 0.040 * 8000 // 40ms
+
+	for {
+		payload := make([]byte, PacketSize)
+		if _, err := io.ReadFull(c.rd, payload); err != nil {
+			return err
+		}
+
+		c.Recv += PacketSize
+
+		if len(c.Receivers) == 0 {
+			continue
+		}
+
+		pkt := &rtp.Packet{
+			Header: rtp.Header{
+				Version:        2,
+				Marker:         true,
+				SequenceNumber: seq,
+				Timestamp:      ts,
+			},
+			Payload: payload,
+		}
+		c.Receivers[0].WriteRTP(pkt)
+
+		seq++
+		ts += PacketSize
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/wav/wav.go b/installs_on_host/go2rtc/pkg/wav/wav.go
new file mode 100644
index 0000000..9fe857d
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/wav/wav.go
@@ -0,0 +1,103 @@
+package wav
+
+import (
+	"encoding/binary"
+	"io"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func Header(codec *core.Codec) []byte {
+	var fmt, size, extra byte
+
+	switch codec.Name {
+	case core.CodecPCML:
+		fmt = 1
+		size = 2
+	case core.CodecPCMA:
+		fmt = 6
+		size = 1
+		extra = 2
+	case core.CodecPCMU:
+		fmt = 7
+		size = 1
+		extra = 2
+	default:
+		return nil
+	}
+
+	channels := byte(codec.Channels)
+	if channels == 0 {
+		channels = 1
+	}
+
+	b := make([]byte, 0, 46) // cap with extra
+	b = append(b, "RIFF\xFF\xFF\xFF\xFFWAVEfmt "...)
+
+	b = append(b, 0x10+extra, 0, 0, 0)
+	b = append(b, fmt, 0)
+	b = append(b, channels, 0)
+	b = binary.LittleEndian.AppendUint32(b, codec.ClockRate)
+	b = binary.LittleEndian.AppendUint32(b, uint32(size*channels)*codec.ClockRate)
+	b = append(b, size*channels, 0)
+	b = append(b, size*8, 0)
+	if extra > 0 {
+		b = append(b, 0, 0) // ExtraParamSize (if PCM, then doesn't exist)
+	}
+
+	b = append(b, "data\xFF\xFF\xFF\xFF"...)
+
+	return b
+}
+
+func ReadHeader(r io.Reader) (*core.Codec, error) {
+	// skip Master RIFF chunk
+	if _, err := io.ReadFull(r, make([]byte, 12)); err != nil {
+		return nil, err
+	}
+
+	var codec core.Codec
+
+	for {
+		chunkID, data, err := readChunk(r)
+		if err != nil {
+			return nil, err
+		}
+
+		if chunkID == "data" {
+			break
+		}
+
+		if chunkID == "fmt " {
+			// https://audiocoding.cc/articles/2008-05-22-wav-file-structure/wav_formats.txt
+			switch data[0] {
+			case 1:
+				codec.Name = core.CodecPCML
+			case 6:
+				codec.Name = core.CodecPCMA
+			case 7:
+				codec.Name = core.CodecPCMU
+			}
+
+			codec.Channels = data[2]
+			codec.ClockRate = binary.LittleEndian.Uint32(data[4:])
+		}
+	}
+
+	return &codec, nil
+}
+
+func readChunk(r io.Reader) (chunkID string, data []byte, err error) {
+	b := make([]byte, 8)
+	if _, err = io.ReadFull(r, b); err != nil {
+		return
+	}
+
+	if chunkID = string(b[:4]); chunkID != "data" {
+		size := binary.LittleEndian.Uint32(b[4:])
+		data = make([]byte, size)
+		_, err = io.ReadFull(r, data)
+	}
+
+	return
+}
diff --git a/installs_on_host/go2rtc/pkg/webrtc/README.md b/installs_on_host/go2rtc/pkg/webrtc/README.md
new file mode 100644
index 0000000..24282e0
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/webrtc/README.md
@@ -0,0 +1,11 @@
+## StateChange
+
+1. offer = pc.CreateOffer()
+2. pc.SetLocalDescription(offer)
+3. OnICEGatheringStateChange: gathering
+4. OnSignalingStateChange: have-local-offer
+*. OnICEGatheringStateChange: complete
+5. pc.SetRemoteDescription(answer)
+6. OnSignalingStateChange: stable
+7. OnICEConnectionStateChange: checking
+8. OnICEConnectionStateChange: connected
diff --git a/installs_on_host/go2rtc/pkg/webrtc/api.go b/installs_on_host/go2rtc/pkg/webrtc/api.go
new file mode 100644
index 0000000..5551d65
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/webrtc/api.go
@@ -0,0 +1,316 @@
+package webrtc
+
+import (
+	"fmt"
+	"net"
+	"slices"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/xnet"
+	"github.com/pion/ice/v4"
+	"github.com/pion/interceptor"
+	"github.com/pion/webrtc/v4"
+)
+
+// ReceiveMTU = Ethernet MTU (1500) - IP Header (20) - UDP Header (8)
+// https://ffmpeg.org/ffmpeg-all.html#Muxer
+const ReceiveMTU = 1472
+
+func NewAPI() (*webrtc.API, error) {
+	return NewServerAPI("", "", nil)
+}
+
+type Filters struct {
+	Candidates []string `yaml:"candidates"`
+	Loopback   bool     `yaml:"loopback"`
+	Interfaces []string `yaml:"interfaces"`
+	IPs        []string `yaml:"ips"`
+	Networks   []string `yaml:"networks"`
+	UDPPorts   []uint16 `yaml:"udp_ports"`
+}
+
+func (f *Filters) Network(protocol string) string {
+	if f == nil || f.Networks == nil {
+		return protocol
+	}
+	v4 := slices.Contains(f.Networks, protocol+"4")
+	v6 := slices.Contains(f.Networks, protocol+"6")
+	if v4 && v6 {
+		return protocol
+	} else if v4 {
+		return protocol + "4"
+	} else if v6 {
+		return protocol + "6"
+	}
+	return ""
+}
+
+func (f *Filters) NetIPs() (ips []net.IP) {
+	itfs, _ := net.Interfaces()
+	for _, itf := range itfs {
+		if itf.Flags&net.FlagUp == 0 {
+			continue
+		}
+		if !f.IncludeLoopback() && itf.Flags&net.FlagLoopback != 0 {
+			continue
+		}
+		if !f.InterfaceFilter(itf.Name) {
+			continue
+		}
+
+		addrs, _ := itf.Addrs()
+		for _, addr := range addrs {
+			ip := parseNetAddr(addr)
+			if ip == nil || !f.IPFilter(ip) {
+				continue
+			}
+			ips = append(ips, ip)
+		}
+	}
+	return
+}
+
+func parseNetAddr(addr net.Addr) net.IP {
+	switch addr := addr.(type) {
+	case *net.IPNet:
+		return addr.IP
+	case *net.IPAddr:
+		return addr.IP
+	}
+	return nil
+}
+
+func (f *Filters) IncludeLoopback() bool {
+	return f != nil && f.Loopback
+}
+
+func (f *Filters) InterfaceFilter(name string) bool {
+	return f == nil || f.Interfaces == nil || slices.Contains(f.Interfaces, name)
+}
+
+func (f *Filters) IPFilter(ip net.IP) bool {
+	return f == nil || f.IPs == nil || core.Contains(f.IPs, ip.String())
+}
+
+func NewServerAPI(network, address string, filters *Filters) (*webrtc.API, error) {
+	// for debug logs add to env: `PION_LOG_DEBUG=all`
+	m := &webrtc.MediaEngine{}
+	//if err := m.RegisterDefaultCodecs(); err != nil {
+	//	return nil, err
+	//}
+	if err := RegisterDefaultCodecs(m); err != nil {
+		return nil, err
+	}
+
+	i := &interceptor.Registry{}
+	if err := webrtc.RegisterDefaultInterceptors(m, i); err != nil {
+		return nil, err
+	}
+
+	s := webrtc.SettingEngine{}
+
+	// fix https://github.com/pion/webrtc/pull/2407
+	s.SetDTLSInsecureSkipHelloVerify(true)
+
+	if filters != nil && filters.Loopback {
+		s.SetIncludeLoopbackCandidate(true)
+	}
+
+	var interfaceFilter func(name string) bool
+	if filters != nil && filters.Interfaces != nil {
+		interfaceFilter = func(name string) bool {
+			return core.Contains(filters.Interfaces, name)
+		}
+	} else {
+		// default interfaces - all, except loopback
+	}
+	s.SetInterfaceFilter(interfaceFilter)
+
+	var ipFilter func(ip net.IP) bool
+	if filters != nil && filters.IPs != nil {
+		ipFilter = func(ip net.IP) bool {
+			return core.Contains(filters.IPs, ip.String())
+		}
+	} else {
+		// try filter all Docker-like interfaces
+		ipFilter = func(ip net.IP) bool {
+			return !xnet.Docker.Contains(ip)
+		}
+		// if there are no such interfaces - disable the filter
+		// the user will need to enable port forwarding
+		if nets, _ := xnet.IPNets(ipFilter); len(nets) == 0 {
+			ipFilter = nil
+		}
+	}
+	s.SetIPFilter(ipFilter)
+
+	var networkTypes []webrtc.NetworkType
+	if filters != nil && filters.Networks != nil {
+		for _, s := range filters.Networks {
+			if networkType, err := webrtc.NewNetworkType(s); err == nil {
+				networkTypes = append(networkTypes, networkType)
+			}
+		}
+	} else {
+		// default network types - all
+		networkTypes = []webrtc.NetworkType{
+			webrtc.NetworkTypeUDP4, webrtc.NetworkTypeUDP6,
+			webrtc.NetworkTypeTCP4, webrtc.NetworkTypeTCP6,
+		}
+	}
+	s.SetNetworkTypes(networkTypes)
+
+	if filters != nil && len(filters.UDPPorts) == 2 {
+		_ = s.SetEphemeralUDPPortRange(filters.UDPPorts[0], filters.UDPPorts[1])
+	}
+
+	// If you don't specify an address, this won't cause an error.
+	// Connections can still be established using random UDP addresses.
+	if address != "" {
+		// Both newMux functions respect filters and do not raise an error
+		// if the port cannot be listened on.
+		if network == "" || network == "tcp" {
+			tcpMux := newTCPMux(address, filters)
+			s.SetICETCPMux(tcpMux)
+		}
+		if network == "" || network == "udp" {
+			udpMux := newUDPMux(address, filters)
+			s.SetICEUDPMux(udpMux)
+		}
+	}
+
+	return webrtc.NewAPI(
+		webrtc.WithMediaEngine(m),
+		webrtc.WithInterceptorRegistry(i),
+		webrtc.WithSettingEngine(s),
+	), nil
+}
+
+// OnNewListener temporary ugly solution for log
+var OnNewListener = func(ln any) {}
+
+func newTCPMux(address string, filters *Filters) ice.TCPMux {
+	networkTCP := filters.Network("tcp") // tcp or tcp4 or tcp6
+	if ln, _ := net.Listen(networkTCP, address); ln != nil {
+		OnNewListener(ln)
+		return webrtc.NewICETCPMux(nil, ln, 8)
+	}
+	return nil
+}
+
+func newUDPMux(address string, filters *Filters) ice.UDPMux {
+	host, port, err := net.SplitHostPort(address)
+	if err != nil {
+		return nil
+	}
+
+	// UDPMux should not listening on unspecified address.
+	// So we will create a listener on all available interfaces.
+	// We can't use ice.NewMultiUDPMuxFromPort, because it sometimes crashes with an error:
+	//     listen udp [***]:8555: bind: cannot assign requested address
+	var addrs []string
+	if host == "" {
+		for _, ip := range filters.NetIPs() {
+			addrs = append(addrs, fmt.Sprintf("%s:%s", ip, port))
+		}
+	} else {
+		addrs = []string{address}
+	}
+
+	networkUDP := filters.Network("udp") // udp or udp4 or udp6
+
+	var muxes []ice.UDPMux
+	for _, addr := range addrs {
+		if ln, _ := net.ListenPacket(networkUDP, addr); ln != nil {
+			OnNewListener(ln)
+			mux := ice.NewUDPMuxDefault(ice.UDPMuxParams{UDPConn: ln})
+			muxes = append(muxes, mux)
+		}
+	}
+
+	switch len(muxes) {
+	case 0:
+		return nil
+	case 1:
+		return muxes[0]
+	}
+	return ice.NewMultiUDPMuxDefault(muxes...)
+}
+
+func RegisterDefaultCodecs(m *webrtc.MediaEngine) error {
+	for _, codec := range []webrtc.RTPCodecParameters{
+		{
+			RTPCodecCapability: webrtc.RTPCodecCapability{
+				MimeType: webrtc.MimeTypeOpus, ClockRate: 48000, Channels: 2, SDPFmtpLine: "minptime=10;useinbandfec=1",
+			},
+			PayloadType: 101, //111,
+		},
+		{
+			RTPCodecCapability: webrtc.RTPCodecCapability{
+				MimeType: webrtc.MimeTypePCMU, ClockRate: 8000,
+			},
+			PayloadType: 0,
+		},
+		{
+			RTPCodecCapability: webrtc.RTPCodecCapability{
+				MimeType: webrtc.MimeTypePCMA, ClockRate: 8000,
+			},
+			PayloadType: 8,
+		},
+	} {
+		if err := m.RegisterCodec(codec, webrtc.RTPCodecTypeAudio); err != nil {
+			return err
+		}
+	}
+
+	videoRTCPFeedback := []webrtc.RTCPFeedback{
+		{"goog-remb", ""},
+		{"ccm", "fir"},
+		{"nack", ""},
+		{"nack", "pli"},
+	}
+	for _, codec := range []webrtc.RTPCodecParameters{
+		{
+			RTPCodecCapability: webrtc.RTPCodecCapability{
+				MimeType:     webrtc.MimeTypeH264,
+				ClockRate:    90000,
+				SDPFmtpLine:  "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42001f",
+				RTCPFeedback: videoRTCPFeedback,
+			},
+			PayloadType: 96, // Chrome v110 - PayloadType: 102
+		},
+		{
+			RTPCodecCapability: webrtc.RTPCodecCapability{
+				MimeType:     webrtc.MimeTypeH264,
+				ClockRate:    90000,
+				SDPFmtpLine:  "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f",
+				RTCPFeedback: videoRTCPFeedback,
+			},
+			PayloadType: 97, // Chrome v110 - PayloadType: 106
+		},
+		{
+			RTPCodecCapability: webrtc.RTPCodecCapability{
+				MimeType:     webrtc.MimeTypeH264,
+				ClockRate:    90000,
+				SDPFmtpLine:  "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=640032",
+				RTCPFeedback: videoRTCPFeedback,
+			},
+			PayloadType: 98, // Chrome v110 - PayloadType: 112
+		},
+		// macOS Safari 15.1
+		{
+			RTPCodecCapability: webrtc.RTPCodecCapability{
+				MimeType:     webrtc.MimeTypeH265,
+				ClockRate:    90000,
+				RTCPFeedback: videoRTCPFeedback,
+			},
+			PayloadType: 100,
+		},
+	} {
+		if err := m.RegisterCodec(codec, webrtc.RTPCodecTypeVideo); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
diff --git a/installs_on_host/go2rtc/pkg/webrtc/client.go b/installs_on_host/go2rtc/pkg/webrtc/client.go
new file mode 100644
index 0000000..bc2c4f8
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/webrtc/client.go
@@ -0,0 +1,145 @@
+package webrtc
+
+import (
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/sdp/v3"
+	"github.com/pion/webrtc/v4"
+)
+
+func (c *Conn) CreateOffer(medias []*core.Media) (string, error) {
+	// 1. Create transeivers with proper kind and direction
+	for _, media := range medias {
+		var err error
+		switch media.Direction {
+		case core.DirectionRecvonly:
+			_, err = c.pc.AddTransceiverFromKind(
+				webrtc.NewRTPCodecType(media.Kind),
+				webrtc.RTPTransceiverInit{Direction: webrtc.RTPTransceiverDirectionRecvonly},
+			)
+		case core.DirectionSendonly:
+			_, err = c.pc.AddTransceiverFromTrack(
+				NewTrack(media.Kind),
+				webrtc.RTPTransceiverInit{Direction: webrtc.RTPTransceiverDirectionSendonly},
+			)
+		case core.DirectionSendRecv:
+			// default transceiver is sendrecv
+			_, err = c.pc.AddTransceiverFromTrack(NewTrack(media.Kind))
+		default:
+			// Nest cameras require data channel
+			_, err = c.pc.CreateDataChannel(media.Kind, nil)
+		}
+
+		if err != nil {
+			return "", err
+		}
+	}
+
+	// 2. Create local offer
+	desc, err := c.pc.CreateOffer(nil)
+	if err != nil {
+		return "", err
+	}
+
+	// 3. Start gathering phase
+	if err = c.pc.SetLocalDescription(desc); err != nil {
+		return "", err
+	}
+
+	return c.pc.LocalDescription().SDP, nil
+}
+
+func (c *Conn) CreateCompleteOffer(medias []*core.Media) (string, error) {
+	if _, err := c.CreateOffer(medias); err != nil {
+		return "", err
+	}
+
+	<-webrtc.GatheringCompletePromise(c.pc)
+	return c.pc.LocalDescription().SDP, nil
+}
+
+func (c *Conn) SetAnswer(answer string) (err error) {
+	desc := webrtc.SessionDescription{
+		Type: webrtc.SDPTypeAnswer,
+		SDP:  fakeFormatsInAnswer(c.pc.LocalDescription().SDP, answer),
+	}
+	if err = c.pc.SetRemoteDescription(desc); err != nil {
+		return err
+	}
+
+	sd := &sdp.SessionDescription{}
+	if err = sd.Unmarshal([]byte(answer)); err != nil {
+		return err
+	}
+
+	c.Medias = UnmarshalMedias(sd.MediaDescriptions)
+
+	return nil
+}
+
+// fakeFormatsInAnswer - fix pion bug with remote SDP parsing:
+// pion will process formats only from first media of each kind
+// so we add all formats from first offer media to the first answer media
+func fakeFormatsInAnswer(offer, answer string) string {
+	sd2 := &sdp.SessionDescription{}
+	if err := sd2.Unmarshal([]byte(answer)); err != nil {
+		return answer
+	}
+
+	// check if answer has recvonly audio
+	var ok bool
+	for _, md2 := range sd2.MediaDescriptions {
+		if md2.MediaName.Media == "audio" {
+			if _, ok = md2.Attribute("recvonly"); ok {
+				break
+			}
+		}
+	}
+	if !ok {
+		return answer
+	}
+
+	sd1 := &sdp.SessionDescription{}
+	if err := sd1.Unmarshal([]byte(offer)); err != nil {
+		return answer
+	}
+
+	var formats []string
+	var attrs []sdp.Attribute
+
+	for _, md1 := range sd1.MediaDescriptions {
+		if md1.MediaName.Media == "audio" {
+			for _, attr := range md1.Attributes {
+				switch attr.Key {
+				case "rtpmap", "fmtp", "rtcp-fb", "extmap":
+					attrs = append(attrs, attr)
+				}
+			}
+
+			formats = md1.MediaName.Formats
+			break
+		}
+	}
+
+	for _, md2 := range sd2.MediaDescriptions {
+		if md2.MediaName.Media == "audio" {
+			for _, attr := range md2.Attributes {
+				switch attr.Key {
+				case "rtpmap", "fmtp", "rtcp-fb", "extmap":
+				default:
+					attrs = append(attrs, attr)
+				}
+			}
+
+			md2.MediaName.Formats = formats
+			md2.Attributes = attrs
+			break
+		}
+	}
+
+	b, err := sd2.Marshal()
+	if err != nil {
+		return answer
+	}
+
+	return string(b)
+}
diff --git a/installs_on_host/go2rtc/pkg/webrtc/client_test.go b/installs_on_host/go2rtc/pkg/webrtc/client_test.go
new file mode 100644
index 0000000..5d195a2
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/webrtc/client_test.go
@@ -0,0 +1,118 @@
+package webrtc
+
+import (
+	"testing"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/webrtc/v4"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestClient(t *testing.T) {
+	api, err := NewAPI()
+	require.Nil(t, err)
+
+	pc, err := api.NewPeerConnection(webrtc.Configuration{})
+	require.Nil(t, err)
+
+	prod := NewConn(pc)
+
+	medias := []*core.Media{
+		{Kind: core.KindVideo, Direction: core.DirectionRecvonly},
+		{Kind: core.KindAudio, Direction: core.DirectionRecvonly},
+		{Kind: core.KindAudio, Direction: core.DirectionSendonly},
+	}
+
+	offer, err := prod.CreateOffer(medias)
+	require.Nil(t, err)
+	assert.NotEmpty(t, offer)
+
+	require.Len(t, prod.pc.GetReceivers(), 2)
+	require.Len(t, prod.pc.GetSenders(), 1)
+
+	answer := `v=0
+o=- 1934370540648269799 1678277622 IN IP4 0.0.0.0
+s=-
+t=0 0
+a=fingerprint:sha-256 77:8C:9A:62:51:81:69:EA:4E:BE:93:6B:4E:DF:51:D2:2F:E3:DF:E7:F4:8A:18:1A:C0:74:FA:AE:B8:98:29:9B
+a=extmap-allow-mixed
+a=group:BUNDLE 0 1 2
+m=video 9 UDP/TLS/RTP/SAVPF 97
+c=IN IP4 0.0.0.0
+a=setup:active
+a=mid:0
+a=ice-ufrag:xxx
+a=ice-pwd:xxx
+a=rtcp-mux
+a=rtcp-rsize
+a=rtpmap:97 H264/90000
+a=fmtp:97 packetization-mode=1;profile-level-id=42e01f
+a=extmap:1 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01
+a=ssrc:2815449682 cname:go2rtc
+a=ssrc:2815449682 msid:go2rtc video
+a=ssrc:2815449682 mslabel:go2rtc
+a=ssrc:2815449682 label:video
+a=msid:go2rtc video
+a=sendonly
+m=audio 9 UDP/TLS/RTP/SAVPF 8
+c=IN IP4 0.0.0.0
+a=setup:active
+a=mid:1
+a=ice-ufrag:xxx
+a=ice-pwd:xxx
+a=rtcp-mux
+a=rtcp-rsize
+a=rtpmap:8 PCMA/8000
+a=extmap:1 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01
+a=ssrc:1392166302 cname:go2rtc
+a=ssrc:1392166302 msid:go2rtc audio
+a=ssrc:1392166302 mslabel:go2rtc
+a=ssrc:1392166302 label:audio
+a=msid:go2rtc audio
+a=sendonly
+m=audio 9 UDP/TLS/RTP/SAVPF 0
+c=IN IP4 0.0.0.0
+a=setup:active
+a=mid:2
+a=ice-ufrag:xxx
+a=ice-pwd:xxx
+a=rtcp-mux
+a=rtcp-rsize
+a=rtpmap:0 PCMU/8000
+a=extmap:1 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01
+a=recvonly
+`
+
+	err = prod.SetAnswer(answer)
+	require.Nil(t, err)
+
+	sender := prod.pc.GetSenders()[0]
+
+	caps := webrtc.RTPCodecCapability{
+		MimeType:  webrtc.MimeTypePCMU,
+		ClockRate: 8000,
+		Channels:  0,
+	}
+	track := sender.Track()
+	track, err = webrtc.NewTrackLocalStaticRTP(caps, track.ID(), track.StreamID())
+	require.Nil(t, err)
+
+	err = sender.ReplaceTrack(track)
+	require.Nil(t, err)
+}
+
+func TestUnmarshalICEServers(t *testing.T) {
+	s := `[{"credential":"xxx","urls":"xxx","username":"xxx"},{"credential":null,"urls":"xxx","username":null}]`
+	servers, err := UnmarshalICEServers([]byte(s))
+	require.Nil(t, err)
+	require.Len(t, servers, 2)
+	require.Equal(t, []string{"xxx"}, servers[0].URLs)
+
+	s = `[{"urls":"xxx"},{"urls":["yyy","zzz"]}]`
+	servers, err = UnmarshalICEServers([]byte(s))
+	require.Nil(t, err)
+	require.Len(t, servers, 2)
+	require.Equal(t, []string{"xxx"}, servers[0].URLs)
+	require.Equal(t, []string{"yyy", "zzz"}, servers[1].URLs)
+}
diff --git a/installs_on_host/go2rtc/pkg/webrtc/conn.go b/installs_on_host/go2rtc/pkg/webrtc/conn.go
new file mode 100644
index 0000000..924fd55
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/webrtc/conn.go
@@ -0,0 +1,220 @@
+package webrtc
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtcp"
+	"github.com/pion/rtp"
+	"github.com/pion/webrtc/v4"
+)
+
+type Conn struct {
+	core.Connection
+	core.Listener
+
+	Mode core.Mode `json:"mode"`
+
+	pc *webrtc.PeerConnection
+
+	offer  string
+	closed core.Waiter
+}
+
+func NewConn(pc *webrtc.PeerConnection) *Conn {
+	c := &Conn{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "webrtc",
+			Transport:  pc,
+		},
+		pc: pc,
+	}
+
+	pc.OnICECandidate(func(candidate *webrtc.ICECandidate) {
+		// last candidate will be empty
+		if candidate != nil {
+			c.Fire(candidate)
+		}
+	})
+
+	pc.OnDataChannel(func(channel *webrtc.DataChannel) {
+		c.Fire(channel)
+	})
+
+	pc.OnICEConnectionStateChange(func(state webrtc.ICEConnectionState) {
+		if state != webrtc.ICEConnectionStateChecking {
+			return
+		}
+		pc.SCTP().Transport().ICETransport().OnSelectedCandidatePairChange(
+			func(pair *webrtc.ICECandidatePair) {
+				// fix situation when candidate pair changes multiple times
+				if i := strings.IndexByte(c.Protocol, '+'); i > 0 {
+					c.Protocol = c.Protocol[:i]
+				}
+				c.Protocol += "+" + pair.Remote.Protocol.String()
+				c.RemoteAddr = fmt.Sprintf(
+					"%s:%d %s", sanitizeIP6(pair.Remote.Address), pair.Remote.Port, pair.Remote.Typ,
+				)
+				if pair.Remote.RelatedAddress != "" {
+					c.RemoteAddr += fmt.Sprintf(
+						" %s:%d", sanitizeIP6(pair.Remote.RelatedAddress), pair.Remote.RelatedPort,
+					)
+				}
+			},
+		)
+	})
+
+	pc.OnTrack(func(remote *webrtc.TrackRemote, receiver *webrtc.RTPReceiver) {
+		media, codec := c.getMediaCodec(remote)
+		if media == nil {
+			return
+		}
+
+		track, err := c.GetTrack(media, codec)
+		if err != nil {
+			return
+		}
+
+		switch c.Mode {
+		case core.ModePassiveProducer, core.ModeActiveProducer:
+			// replace the theoretical list of codecs with the actual list of codecs
+			if len(media.Codecs) > 1 {
+				media.Codecs = []*core.Codec{codec}
+			}
+		}
+
+		if c.Mode == core.ModePassiveProducer && remote.Kind() == webrtc.RTPCodecTypeVideo {
+			go func() {
+				pkts := []rtcp.Packet{&rtcp.PictureLossIndication{MediaSSRC: uint32(remote.SSRC())}}
+				for range time.NewTicker(time.Second * 2).C {
+					if err := pc.WriteRTCP(pkts); err != nil {
+						return
+					}
+				}
+			}()
+		}
+
+		for {
+			b := make([]byte, ReceiveMTU)
+			n, _, err := remote.Read(b)
+			if err != nil {
+				return
+			}
+
+			c.Recv += n
+
+			packet := &rtp.Packet{}
+			if err := packet.Unmarshal(b[:n]); err != nil {
+				return
+			}
+
+			if len(packet.Payload) == 0 {
+				continue
+			}
+
+			track.WriteRTP(packet)
+		}
+	})
+
+	// OK connection:
+	// 15:01:46 ICE connection state changed: checking
+	// 15:01:46 peer connection state changed: connected
+	// 15:01:54 peer connection state changed: disconnected
+	// 15:02:20 peer connection state changed: failed
+	//
+	// Fail connection:
+	// 14:53:08 ICE connection state changed: checking
+	// 14:53:39 peer connection state changed: failed
+	pc.OnConnectionStateChange(func(state webrtc.PeerConnectionState) {
+		c.Fire(state)
+
+		switch state {
+		case webrtc.PeerConnectionStateConnected:
+			for _, sender := range c.Senders {
+				sender.Start()
+			}
+		case webrtc.PeerConnectionStateDisconnected, webrtc.PeerConnectionStateFailed, webrtc.PeerConnectionStateClosed:
+			// disconnect event comes earlier, than failed
+			// but it comes only for success connections
+			_ = c.Close()
+		}
+	})
+
+	return c
+}
+
+func (c *Conn) MarshalJSON() ([]byte, error) {
+	return json.Marshal(c.Connection)
+}
+
+func (c *Conn) Close() error {
+	c.closed.Done(nil)
+	return c.pc.Close()
+}
+
+func (c *Conn) AddCandidate(candidate string) error {
+	// pion uses only candidate value from json/object candidate struct
+	return c.pc.AddICECandidate(webrtc.ICECandidateInit{Candidate: candidate})
+}
+
+func (c *Conn) GetSenderTrack(mid string) *Track {
+	if tr := c.getTranseiver(mid); tr != nil {
+		if s := tr.Sender(); s != nil {
+			if t := s.Track().(*Track); t != nil {
+				return t
+			}
+		}
+	}
+	return nil
+}
+
+func (c *Conn) getTranseiver(mid string) *webrtc.RTPTransceiver {
+	for _, tr := range c.pc.GetTransceivers() {
+		if tr.Mid() == mid {
+			return tr
+		}
+	}
+	return nil
+}
+
+func (c *Conn) getMediaCodec(remote *webrtc.TrackRemote) (*core.Media, *core.Codec) {
+	for _, tr := range c.pc.GetTransceivers() {
+		// search Transeiver for this TrackRemote
+		if tr.Receiver() == nil || tr.Receiver().Track() != remote {
+			continue
+		}
+
+		// search Media for this MID
+		for _, media := range c.Medias {
+			if media.ID != tr.Mid() || media.Direction != core.DirectionRecvonly {
+				continue
+			}
+
+			// search codec for this PayloadType
+			for _, codec := range media.Codecs {
+				if codec.PayloadType != uint8(remote.PayloadType()) {
+					continue
+				}
+				return media, codec
+			}
+		}
+	}
+
+	// fix moment when core.ModePassiveProducer or core.ModeActiveProducer
+	// sends new codec with new payload type to same media
+	// check GetTrack
+	panic(core.Caller())
+
+	return nil, nil
+}
+
+func sanitizeIP6(host string) string {
+	if strings.IndexByte(host, ':') > 0 {
+		return "[" + host + "]"
+	}
+	return host
+}
diff --git a/installs_on_host/go2rtc/pkg/webrtc/consumer.go b/installs_on_host/go2rtc/pkg/webrtc/consumer.go
new file mode 100644
index 0000000..767394d
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/webrtc/consumer.go
@@ -0,0 +1,90 @@
+package webrtc
+
+import (
+	"errors"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/h265"
+	"github.com/AlexxIT/go2rtc/pkg/pcm"
+	"github.com/pion/rtp"
+)
+
+func (c *Conn) GetMedias() []*core.Media {
+	return WithResampling(c.Medias)
+}
+
+func (c *Conn) AddTrack(media *core.Media, codec *core.Codec, track *core.Receiver) error {
+	core.Assert(media.Direction == core.DirectionSendonly)
+
+	for _, sender := range c.Senders {
+		if sender.Codec == codec {
+			sender.Bind(track)
+			return nil
+		}
+	}
+
+	switch c.Mode {
+	case core.ModePassiveConsumer: // video/audio for browser
+	case core.ModeActiveProducer: // go2rtc as WebRTC client (backchannel)
+	case core.ModePassiveProducer: // WebRTC/WHIP
+	default:
+		panic(core.Caller())
+	}
+
+	localTrack := c.GetSenderTrack(media.ID)
+	if localTrack == nil {
+		return errors.New("webrtc: can't get track")
+	}
+
+	payloadType := codec.PayloadType
+
+	sender := core.NewSender(media, codec)
+	sender.Handler = func(packet *rtp.Packet) {
+		c.Send += packet.MarshalSize()
+		//important to send with remote PayloadType
+		_ = localTrack.WriteRTP(payloadType, packet)
+	}
+
+	switch track.Codec.Name {
+	case core.CodecH264:
+		sender.Handler = h264.RTPPay(1200, sender.Handler)
+		if track.Codec.IsRTP() {
+			sender.Handler = h264.RTPDepay(track.Codec, sender.Handler)
+		} else {
+			sender.Handler = h264.RepairAVCC(track.Codec, sender.Handler)
+		}
+
+	case core.CodecH265:
+		sender.Handler = h265.RTPPay(1200, sender.Handler)
+		if track.Codec.IsRTP() {
+			sender.Handler = h265.RTPDepay(track.Codec, sender.Handler)
+		} else {
+			sender.Handler = h265.RepairAVCC(track.Codec, sender.Handler)
+		}
+
+	case core.CodecPCMA, core.CodecPCMU, core.CodecPCM, core.CodecPCML:
+		// Fix audio quality https://github.com/AlexxIT/WebRTC/issues/500
+		// should be before ResampleToG711, because it will be called last
+		sender.Handler = pcm.RepackG711(false, sender.Handler)
+
+		if codec.ClockRate == 0 {
+			if codec.Name == core.CodecPCM || codec.Name == core.CodecPCML {
+				codec.Name = core.CodecPCMA
+			}
+			codec.ClockRate = 8000
+			sender.Handler = pcm.TranscodeHandler(codec, track.Codec, sender.Handler)
+		}
+	}
+
+	// TODO: rewrite this dirty logic
+	// maybe not best solution, but ActiveProducer connected before AddTrack
+	if c.Mode != core.ModeActiveProducer {
+		sender.Bind(track)
+	} else {
+		sender.HandleRTP(track)
+	}
+
+	c.Senders = append(c.Senders, sender)
+	return nil
+}
diff --git a/installs_on_host/go2rtc/pkg/webrtc/helpers.go b/installs_on_host/go2rtc/pkg/webrtc/helpers.go
new file mode 100644
index 0000000..167697f
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/webrtc/helpers.go
@@ -0,0 +1,348 @@
+package webrtc
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"hash/crc32"
+	"net"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/ice/v4"
+	"github.com/pion/sdp/v3"
+	"github.com/pion/stun/v3"
+	"github.com/pion/webrtc/v4"
+)
+
+func UnmarshalMedias(descriptions []*sdp.MediaDescription) (medias []*core.Media) {
+	// 1. Sort medias, so video will always be before audio
+	// 2. Ignore application media from Hass default lovelace card
+	// 3. Ignore media without direction (inactive media)
+	// 4. Inverse media direction (because it is remote peer medias list)
+	for _, kind := range []string{core.KindVideo, core.KindAudio} {
+		for _, md := range descriptions {
+			if md.MediaName.Media != kind {
+				continue
+			}
+
+			media := core.UnmarshalMedia(md)
+			switch media.Direction {
+			case core.DirectionSendRecv:
+				media.Direction = core.DirectionRecvonly
+				medias = append(medias, media)
+
+				media = media.Clone()
+				media.Direction = core.DirectionSendonly
+
+			case core.DirectionRecvonly:
+				media.Direction = core.DirectionSendonly
+
+			case core.DirectionSendonly:
+				media.Direction = core.DirectionRecvonly
+
+			case "":
+				continue
+			}
+
+			// skip non-media codecs to avoid confusing users in info and logs
+			media.Codecs = SkipNonMediaCodecs(media.Codecs)
+
+			medias = append(medias, media)
+		}
+	}
+
+	return
+}
+
+func SkipNonMediaCodecs(input []*core.Codec) (output []*core.Codec) {
+	for _, codec := range input {
+		switch codec.Name {
+		case "RTX", "RED", "ULPFEC", "FLEXFEC-03":
+			continue
+		case "CN", "TELEPHONE-EVENT":
+			continue // https://datatracker.ietf.org/doc/html/rfc7874
+		}
+		// VP8, VP9, H264, H265, AV1
+		// OPUS, G722, PCMU, PCMA
+		output = append(output, codec)
+	}
+	return
+}
+
+// WithResampling - will add for consumer: PCMA/0, PCMU/0, PCM/0, PCML/0
+// so it can add resampling for PCMA/PCMU and repack for PCM/PCML
+func WithResampling(medias []*core.Media) []*core.Media {
+	for _, media := range medias {
+		if media.Kind != core.KindAudio || media.Direction != core.DirectionSendonly {
+			continue
+		}
+
+		var pcma, pcmu, pcm, pcml *core.Codec
+
+		for _, codec := range media.Codecs {
+			switch codec.Name {
+			case core.CodecPCMA:
+				if codec.ClockRate != 0 {
+					pcma = codec
+				} else {
+					pcma = nil
+				}
+			case core.CodecPCMU:
+				if codec.ClockRate != 0 {
+					pcmu = codec
+				} else {
+					pcmu = nil
+				}
+			case core.CodecPCM:
+				pcm = codec
+			case core.CodecPCML:
+				pcml = codec
+			}
+		}
+
+		if pcma != nil {
+			pcma = pcma.Clone()
+			pcma.ClockRate = 0 // reset clock rate so will match any
+			media.Codecs = append(media.Codecs, pcma)
+		}
+		if pcmu != nil {
+			pcmu = pcmu.Clone()
+			pcmu.ClockRate = 0
+			media.Codecs = append(media.Codecs, pcmu)
+		}
+		if pcma != nil && pcm == nil {
+			pcm = pcma.Clone()
+			pcm.Name = core.CodecPCM
+			media.Codecs = append(media.Codecs, pcm)
+		}
+		if pcma != nil && pcml == nil {
+			pcml = pcma.Clone()
+			pcml.Name = core.CodecPCML
+			media.Codecs = append(media.Codecs, pcml)
+		}
+	}
+
+	return medias
+}
+
+func NewCandidate(network, address string) (string, error) {
+	i := strings.LastIndexByte(address, ':')
+	if i < 0 {
+		return "", errors.New("wrong candidate: " + address)
+	}
+	host, port := address[:i], address[i+1:]
+
+	i, err := strconv.Atoi(port)
+	if err != nil {
+		return "", err
+	}
+
+	config := &ice.CandidateHostConfig{
+		Network:   network,
+		Address:   host,
+		Port:      i,
+		Component: ice.ComponentRTP,
+	}
+
+	if network == "tcp" {
+		config.TCPType = ice.TCPTypePassive
+	}
+
+	cand, err := ice.NewCandidateHost(config)
+	if err != nil {
+		return "", err
+	}
+
+	return "candidate:" + cand.Marshal(), nil
+}
+
+func LookupIP(address string) (string, error) {
+	if strings.HasPrefix(address, "stun:") {
+		ip, err := GetCachedPublicIP()
+		if err != nil {
+			return "", err
+		}
+		return ip.String() + address[4:], nil
+	}
+
+	if IsIP(address) {
+		return address, nil
+	}
+
+	i := strings.IndexByte(address, ':')
+	ips, err := net.LookupIP(address[:i])
+	if err != nil {
+		return "", err
+	}
+	if len(ips) == 0 {
+		return "", fmt.Errorf("can't resolve: %s", address)
+	}
+
+	return ips[0].String() + address[i:], nil
+}
+
+// GetPublicIP example from https://github.com/pion/stun
+func GetPublicIP(address string) (net.IP, error) {
+	conn, err := net.Dial("udp", address)
+	if err != nil {
+		return nil, err
+	}
+
+	c, err := stun.NewClient(conn)
+	if err != nil {
+		return nil, err
+	}
+
+	if err = conn.SetDeadline(time.Now().Add(time.Second * 3)); err != nil {
+		return nil, err
+	}
+
+	var res stun.Event
+
+	message := stun.MustBuild(stun.TransactionID, stun.BindingRequest)
+	if err = c.Do(message, func(e stun.Event) { res = e }); err != nil {
+		return nil, err
+	}
+	if err = c.Close(); err != nil {
+		return nil, err
+	}
+
+	if res.Error != nil {
+		return nil, res.Error
+	}
+
+	var xorAddr stun.XORMappedAddress
+	if err = xorAddr.GetFrom(res.Message); err != nil {
+		return nil, err
+	}
+
+	return xorAddr.IP, nil
+}
+
+var cachedIP net.IP
+var cachedTS time.Time
+
+func GetCachedPublicIP(stuns ...string) (net.IP, error) {
+	if now := time.Now(); now.After(cachedTS) {
+		for _, addr := range stuns {
+			if ip, _ := GetPublicIP(addr); ip != nil {
+				cachedIP = ip
+				cachedTS = now.Add(time.Minute * 5)
+				return ip, nil
+			}
+		}
+	}
+	if cachedIP == nil {
+		return nil, errors.New("webrtc: can't get public IP")
+	}
+	return cachedIP, nil
+}
+
+func IsIP(host string) bool {
+	for _, i := range host {
+		if i >= 'A' {
+			return false
+		}
+	}
+	return true
+}
+
+func MimeType(codec *core.Codec) string {
+	switch codec.Name {
+	case core.CodecH264:
+		return webrtc.MimeTypeH264
+	case core.CodecH265:
+		return webrtc.MimeTypeH265
+	case core.CodecVP8:
+		return webrtc.MimeTypeVP8
+	case core.CodecVP9:
+		return webrtc.MimeTypeVP9
+	case core.CodecAV1:
+		return webrtc.MimeTypeAV1
+	case core.CodecPCMU:
+		return webrtc.MimeTypePCMU
+	case core.CodecPCMA:
+		return webrtc.MimeTypePCMA
+	case core.CodecOpus:
+		return webrtc.MimeTypeOpus
+	case core.CodecG722:
+		return webrtc.MimeTypeG722
+	}
+	panic("not implemented")
+}
+
+func CandidateICE(network, host, port string, priority uint32) string {
+	// 1. Foundation
+	// 2. Component, always 1 because RTP
+	// 3. "udp" or "tcp"
+	// 4. Priority
+	// 5. Host - IP4 or IP6 or domain name
+	// 6. Port
+	// 7. "typ host"
+	foundation := crc32.ChecksumIEEE([]byte("host" + host + network + "4"))
+	s := fmt.Sprintf("candidate:%d 1 %s %d %s %s typ host", foundation, network, priority, host, port)
+	if network == "tcp" {
+		return s + " tcptype passive"
+	}
+	return s
+}
+
+// Priority = type << 24 + local << 8 + component
+// https://www.rfc-editor.org/rfc/rfc8445#section-5.1.2.1
+
+const PriorityHostUDP uint32 = 0x001F_FFFF |
+	126<<24 | // udp host
+	7<<21 // udp
+const PriorityHostTCPPassive uint32 = 0x001F_FFFF |
+	99<<24 | // tcp host
+	4<<21 // tcp passive
+
+// CandidateHostPriority (lower indexes has a higher priority)
+func CandidateHostPriority(network string, index int) uint32 {
+	switch network {
+	case "udp":
+		return PriorityHostUDP - uint32(index)
+	case "tcp":
+		return PriorityHostTCPPassive - uint32(index)
+	}
+	return 0
+}
+
+func UnmarshalICEServers(b []byte) ([]webrtc.ICEServer, error) {
+	type ICEServer struct {
+		URLs       any    `json:"urls"`
+		Username   string `json:"username,omitempty"`
+		Credential string `json:"credential,omitempty"`
+	}
+
+	var src []ICEServer
+	if err := json.Unmarshal(b, &src); err != nil {
+		return nil, err
+	}
+
+	var dst []webrtc.ICEServer
+	for i := range src {
+		srv := webrtc.ICEServer{
+			Username:   src[i].Username,
+			Credential: src[i].Credential,
+		}
+
+		switch v := src[i].URLs.(type) {
+		case []any:
+			for _, u := range v {
+				if s, ok := u.(string); ok {
+					srv.URLs = append(srv.URLs, s)
+				}
+			}
+		case string:
+			srv.URLs = []string{v}
+		}
+
+		dst = append(dst, srv)
+	}
+
+	return dst, nil
+}
diff --git a/installs_on_host/go2rtc/pkg/webrtc/producer.go b/installs_on_host/go2rtc/pkg/webrtc/producer.go
new file mode 100644
index 0000000..32e958e
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/webrtc/producer.go
@@ -0,0 +1,49 @@
+package webrtc
+
+import (
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/webrtc/v4"
+)
+
+func (c *Conn) GetTrack(media *core.Media, codec *core.Codec) (*core.Receiver, error) {
+	core.Assert(media.Direction == core.DirectionRecvonly)
+
+	for _, track := range c.Receivers {
+		if track.Codec == codec {
+			return track, nil
+		}
+	}
+
+	switch c.Mode {
+	case core.ModePassiveConsumer: // backchannel from browser
+		// set codec for consumer recv track so remote peer should send media with this codec
+		params := webrtc.RTPCodecParameters{
+			RTPCodecCapability: webrtc.RTPCodecCapability{
+				MimeType:  MimeType(codec),
+				ClockRate: codec.ClockRate,
+				Channels:  uint16(codec.Channels),
+			},
+			PayloadType: 0, // don't know if this necessary
+		}
+
+		tr := c.getTranseiver(media.ID)
+
+		_ = tr.SetCodecPreferences([]webrtc.RTPCodecParameters{params})
+
+	case core.ModePassiveProducer, core.ModeActiveProducer:
+		// Passive producers: OBS Studio via WHIP or Browser
+		// Active producers: go2rtc as WebRTC client or WebTorrent
+
+	default:
+		panic(core.Caller())
+	}
+
+	track := core.NewReceiver(media, codec)
+	c.Receivers = append(c.Receivers, track)
+	return track, nil
+}
+
+func (c *Conn) Start() error {
+	c.closed.Wait()
+	return nil
+}
diff --git a/installs_on_host/go2rtc/pkg/webrtc/server.go b/installs_on_host/go2rtc/pkg/webrtc/server.go
new file mode 100644
index 0000000..4714a6a
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/webrtc/server.go
@@ -0,0 +1,123 @@
+package webrtc
+
+import (
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/sdp/v3"
+	"github.com/pion/webrtc/v4"
+)
+
+func (c *Conn) SetOffer(offer string) (err error) {
+	c.offer = offer
+
+	sd := &sdp.SessionDescription{}
+	if err = sd.Unmarshal([]byte(offer)); err != nil {
+		return
+	}
+
+	// create transceivers with opposite direction
+	for _, md := range sd.MediaDescriptions {
+		var mid string
+		var tr *webrtc.RTPTransceiver
+		for _, attr := range md.Attributes {
+			switch attr.Key {
+			case core.DirectionSendRecv:
+				tr, _ = c.pc.AddTransceiverFromTrack(NewTrack(md.MediaName.Media))
+			case core.DirectionSendonly:
+				tr, _ = c.pc.AddTransceiverFromKind(
+					webrtc.NewRTPCodecType(md.MediaName.Media),
+					webrtc.RTPTransceiverInit{Direction: webrtc.RTPTransceiverDirectionRecvonly},
+				)
+			case core.DirectionRecvonly:
+				tr, _ = c.pc.AddTransceiverFromTrack(
+					NewTrack(md.MediaName.Media),
+					webrtc.RTPTransceiverInit{Direction: webrtc.RTPTransceiverDirectionSendonly},
+				)
+			case "mid":
+				mid = attr.Value
+			}
+		}
+
+		if mid != "" && tr != nil {
+			_ = tr.SetMid(mid)
+		}
+	}
+
+	c.Medias = UnmarshalMedias(sd.MediaDescriptions)
+
+	return
+}
+
+func (c *Conn) GetAnswer() (answer string, err error) {
+	// we need to process remote offer after we create transeivers
+	desc := webrtc.SessionDescription{Type: webrtc.SDPTypeOffer, SDP: c.offer}
+	if err = c.pc.SetRemoteDescription(desc); err != nil {
+		return "", err
+	}
+
+	// disable transceivers if we don't have track, make direction=inactive
+transeivers:
+	for _, tr := range c.pc.GetTransceivers() {
+		for _, sender := range c.Senders {
+			if sender.Media.ID == tr.Mid() {
+				continue transeivers
+			}
+		}
+
+		switch tr.Direction() {
+		case webrtc.RTPTransceiverDirectionSendrecv:
+			_ = tr.Sender().Stop()             // don't know if necessary
+			_ = tr.SetSender(tr.Sender(), nil) // set direction to recvonly
+		case webrtc.RTPTransceiverDirectionSendonly:
+			_ = tr.Stop()
+		}
+	}
+
+	if desc, err = c.pc.CreateAnswer(nil); err != nil {
+		return
+	}
+	if err = c.pc.SetLocalDescription(desc); err != nil {
+		return
+	}
+
+	return c.pc.LocalDescription().SDP, nil
+}
+
+// GetCompleteAnswer - get SDP answer with candidates inside
+func (c *Conn) GetCompleteAnswer(candidates []string, filter func(*webrtc.ICECandidate) bool) (string, error) {
+	var done = make(chan struct{})
+
+	c.pc.OnICECandidate(func(candidate *webrtc.ICECandidate) {
+		if candidate != nil {
+			if filter == nil || filter(candidate) {
+				candidates = append(candidates, candidate.ToJSON().Candidate)
+			}
+		} else {
+			done <- struct{}{}
+		}
+	})
+
+	answer, err := c.GetAnswer()
+	if err != nil {
+		return "", err
+	}
+
+	<-done
+
+	sd := &sdp.SessionDescription{}
+	if err = sd.Unmarshal([]byte(answer)); err != nil {
+		return "", err
+	}
+
+	md := sd.MediaDescriptions[0]
+
+	for _, candidate := range candidates {
+		md.WithPropertyAttribute(candidate)
+	}
+
+	b, err := sd.Marshal()
+	if err != nil {
+		return "", err
+	}
+
+	return string(b), nil
+}
diff --git a/installs_on_host/go2rtc/pkg/webrtc/track.go b/installs_on_host/go2rtc/pkg/webrtc/track.go
new file mode 100644
index 0000000..657eee1
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/webrtc/track.go
@@ -0,0 +1,83 @@
+package webrtc
+
+import (
+	"sync"
+
+	"github.com/pion/rtp"
+	"github.com/pion/webrtc/v4"
+)
+
+type Track struct {
+	kind     string
+	id       string
+	streamID string
+	sequence uint16
+	ssrc     uint32
+	writer   webrtc.TrackLocalWriter
+	mu       sync.Mutex
+}
+
+func NewTrack(kind string) *Track {
+	return &Track{
+		kind:     kind,
+		id:       "go2rtc-" + kind,
+		streamID: "go2rtc",
+	}
+}
+
+func (t *Track) Bind(context webrtc.TrackLocalContext) (webrtc.RTPCodecParameters, error) {
+	t.mu.Lock()
+	t.ssrc = uint32(context.SSRC())
+	t.writer = context.WriteStream()
+	t.mu.Unlock()
+
+	for _, parameters := range context.CodecParameters() {
+		// return first parameters
+		return parameters, nil
+	}
+
+	return webrtc.RTPCodecParameters{}, nil
+}
+
+func (t *Track) Unbind(context webrtc.TrackLocalContext) error {
+	t.mu.Lock()
+	t.writer = nil
+	t.mu.Unlock()
+	return nil
+}
+
+func (t *Track) ID() string {
+	return t.id
+}
+
+func (t *Track) RID() string {
+	return "" // don't know what it is
+}
+
+func (t *Track) StreamID() string {
+	return t.streamID
+}
+
+func (t *Track) Kind() webrtc.RTPCodecType {
+	return webrtc.NewRTPCodecType(t.kind)
+}
+
+func (t *Track) WriteRTP(payloadType uint8, packet *rtp.Packet) (err error) {
+	// using mutex because Unbind https://github.com/AlexxIT/go2rtc/issues/994
+	t.mu.Lock()
+
+	// in case when we start WriteRTP before Track.Bind
+	if t.writer != nil {
+		// important to have internal counter if input packets from different sources
+		t.sequence++
+
+		header := packet.Header
+		header.SSRC = t.ssrc
+		header.PayloadType = payloadType
+		header.SequenceNumber = t.sequence
+		_, err = t.writer.WriteRTP(&header, packet.Payload)
+	}
+
+	t.mu.Unlock()
+	return
+}
diff --git a/installs_on_host/go2rtc/pkg/webrtc/webrtc_test.go b/installs_on_host/go2rtc/pkg/webrtc/webrtc_test.go
new file mode 100644
index 0000000..6b20b08
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/webrtc/webrtc_test.go
@@ -0,0 +1,71 @@
+package webrtc
+
+import (
+	"testing"
+
+	"github.com/pion/webrtc/v4"
+	"github.com/stretchr/testify/require"
+)
+
+func TestAlexa(t *testing.T) {
+	// from https://github.com/AlexxIT/go2rtc/issues/825
+	offer := `v=0
+o=- 3911343731 3911343731 IN IP4 0.0.0.0
+s=a 2 z
+c=IN IP4 0.0.0.0
+t=0 0
+a=group:BUNDLE audio0 video0
+m=audio 1 UDP/TLS/RTP/SAVPF 96 0 8
+a=candidate:1 1 UDP 2013266431 52.90.193.210 60128 typ host
+a=candidate:2 1 TCP 1015021823 52.90.193.210 9 typ host tcptype active
+a=candidate:3 1 TCP 1010827519 52.90.193.210 45962 typ host tcptype passive
+a=candidate:1 2 UDP 2013266430 52.90.193.210 46109 typ host
+a=candidate:2 2 TCP 1015021822 52.90.193.210 9 typ host tcptype active
+a=candidate:3 2 TCP 1010827518 52.90.193.210 53795 typ host tcptype passive
+a=setup:actpass
+a=extmap:3 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time
+a=rtpmap:96 opus/48000/2
+a=rtpmap:0 PCMU/8000
+a=rtpmap:8 PCMA/8000
+a=rtcp:9 IN IP4 0.0.0.0
+a=rtcp-mux
+a=sendrecv
+a=mid:audio0
+a=ssrc:3573704076 cname:user3856789923@host-9dd1dd33
+a=ice-ufrag:gxfV
+a=ice-pwd:KepKrlQ1+LD+RGTAFaqVck
+a=fingerprint:sha-256 A2:93:53:50:E4:2F:C5:4E:DF:7C:70:99:5A:A7:39:50:1A:63:E5:B2:CA:73:70:7A:C5:F4:01:BF:BD:99:57:FC
+m=video 1 UDP/TLS/RTP/SAVPF 99
+a=candidate:1 1 UDP 2013266431 52.90.193.210 60128 typ host
+a=candidate:1 2 UDP 2013266430 52.90.193.210 46109 typ host
+a=candidate:2 1 TCP 1015021823 52.90.193.210 9 typ host tcptype active
+a=candidate:3 1 TCP 1010827519 52.90.193.210 45962 typ host tcptype passive
+a=candidate:3 2 TCP 1010827518 52.90.193.210 53795 typ host tcptype passive
+a=candidate:2 2 TCP 1015021822 52.90.193.210 9 typ host tcptype active
+b=AS:2500
+a=setup:actpass
+a=extmap:3 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time
+a=rtpmap:99 H264/90000
+a=rtcp:9 IN IP4 0.0.0.0
+a=rtcp-mux
+a=sendrecv
+a=mid:video0
+a=rtcp-fb:99 nack
+a=rtcp-fb:99 nack pli
+a=rtcp-fb:99 ccm fir
+a=ssrc:3778078295 cname:user3856789923@host-9dd1dd33
+a=ice-ufrag:gxfV
+a=ice-pwd:KepKrlQ1+LD+RGTAFaqVck
+a=fingerprint:sha-256 A2:93:53:50:E4:2F:C5:4E:DF:7C:70:99:5A:A7:39:50:1A:63:E5:B2:CA:73:70:7A:C5:F4:01:BF:BD:99:57:FC
+`
+
+	pc, err := webrtc.NewPeerConnection(webrtc.Configuration{})
+	require.Nil(t, err)
+
+	conn := NewConn(pc)
+	err = conn.SetOffer(offer)
+	require.Nil(t, err)
+
+	_, err = conn.GetAnswer()
+	require.Nil(t, err)
+}
diff --git a/installs_on_host/go2rtc/pkg/webtorrent/client.go b/installs_on_host/go2rtc/pkg/webtorrent/client.go
new file mode 100644
index 0000000..04eeccd
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/webtorrent/client.go
@@ -0,0 +1,94 @@
+package webtorrent
+
+import (
+	"encoding/base64"
+	"fmt"
+	"strconv"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/webrtc"
+	"github.com/gorilla/websocket"
+	pion "github.com/pion/webrtc/v4"
+)
+
+func NewClient(tracker, share, pwd string, pc *pion.PeerConnection) (*webrtc.Conn, error) {
+	// 1. Create WebRTC producer
+	prod := webrtc.NewConn(pc)
+	prod.FormatName = "webtorrent"
+	prod.Mode = core.ModeActiveProducer
+	prod.Protocol = "ws"
+
+	medias := []*core.Media{
+		{Kind: core.KindVideo, Direction: core.DirectionRecvonly},
+		{Kind: core.KindAudio, Direction: core.DirectionRecvonly},
+	}
+
+	// 2. Create offer
+	offer, err := prod.CreateCompleteOffer(medias)
+	if err != nil {
+		return nil, err
+	}
+
+	// 3. Encrypt offer
+	nonce := strconv.FormatInt(time.Now().UnixNano(), 36)
+
+	cipher, err := NewCipher(share, pwd, nonce)
+	if err != nil {
+		return nil, err
+	}
+
+	enc := cipher.Encrypt([]byte(offer))
+
+	// 4. Connect to Tracker
+	ws, _, err := websocket.DefaultDialer.Dial(tracker, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	defer ws.Close()
+
+	// 5. Send offer
+	msg := fmt.Sprintf(
+		`{"action":"announce","info_hash":"%s","peer_id":"%s","offers":[{"offer_id":"%s","offer":{"type":"offer","sdp":"%s"}}],"numwant":1}`,
+		InfoHash(share), core.RandString(16, 36), nonce, base64.StdEncoding.EncodeToString(enc),
+	)
+	if err = ws.WriteMessage(websocket.TextMessage, []byte(msg)); err != nil {
+		return nil, err
+	}
+
+	// wait 30 seconds until full answer
+	if err = ws.SetReadDeadline(time.Now().Add(time.Second * 30)); err != nil {
+		return nil, err
+	}
+
+	for {
+		// 6. Read answer
+		var v Message
+		if err = ws.ReadJSON(&v); err != nil {
+			return nil, err
+		}
+
+		if v.Answer == nil {
+			continue
+		}
+
+		// 7. Decrypt answer
+		enc, err = base64.StdEncoding.DecodeString(v.Answer.SDP)
+		if err != nil {
+			return nil, err
+		}
+
+		answer, err := cipher.Decrypt(enc)
+		if err != nil {
+			return nil, err
+		}
+
+		// 8. Set answer
+		if err = prod.SetAnswer(string(answer)); err != nil {
+			return nil, err
+		}
+
+		return prod, nil
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/webtorrent/crypto.go b/installs_on_host/go2rtc/pkg/webtorrent/crypto.go
new file mode 100644
index 0000000..3e90fd6
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/webtorrent/crypto.go
@@ -0,0 +1,72 @@
+package webtorrent
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/sha256"
+	"encoding/base64"
+	"fmt"
+	"strconv"
+	"time"
+)
+
+type Cipher struct {
+	gcm   cipher.AEAD
+	iv    []byte
+	nonce []byte
+}
+
+func NewCipher(share, pwd, nonce string) (*Cipher, error) {
+	timestamp, err := strconv.ParseInt(nonce, 36, 64)
+	if err != nil {
+		return nil, err
+	}
+
+	delta := time.Duration(time.Now().UnixNano() - timestamp)
+	if delta < 0 {
+		delta = -delta
+	}
+
+	// protect from replay attack, but respect wrong timezone on server
+	if delta > 12*time.Hour {
+		return nil, fmt.Errorf("wrong timedelta %s", delta)
+	}
+
+	c := &Cipher{}
+
+	hash := sha256.New()
+	hash.Write([]byte(nonce + ":" + pwd))
+	key := hash.Sum(nil)
+
+	hash.Reset()
+	hash.Write([]byte(share + ":" + nonce))
+	c.iv = hash.Sum(nil)[:12]
+
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+	c.gcm, err = cipher.NewGCM(block)
+	if err != nil {
+		return nil, err
+	}
+
+	c.nonce = []byte(nonce)
+
+	return c, nil
+}
+
+func (c *Cipher) Decrypt(ciphertext []byte) ([]byte, error) {
+	return c.gcm.Open(nil, c.iv, ciphertext, c.nonce)
+}
+
+func (c *Cipher) Encrypt(plaintext []byte) []byte {
+	return c.gcm.Seal(nil, c.iv, plaintext, c.nonce)
+}
+
+func InfoHash(share string) string {
+	hash := sha256.New()
+	hash.Write([]byte(share))
+	sum := hash.Sum(nil)
+	return base64.StdEncoding.EncodeToString(sum)
+}
diff --git a/installs_on_host/go2rtc/pkg/webtorrent/server.go b/installs_on_host/go2rtc/pkg/webtorrent/server.go
new file mode 100644
index 0000000..86b2be5
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/webtorrent/server.go
@@ -0,0 +1,228 @@
+package webtorrent
+
+import (
+	"encoding/base64"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/gorilla/websocket"
+)
+
+type Server struct {
+	core.Listener
+
+	URL      string
+	Exchange func(src, offer string) (answer string, err error)
+
+	shares   map[string]*Share
+	mu       sync.Mutex
+	announce *core.Worker
+}
+
+type Share struct {
+	name string
+	pwd  string
+	src  string
+}
+
+func (s *Server) AddShare(name, pwd, src string) {
+	s.mu.Lock()
+
+	if s.shares == nil {
+		s.shares = map[string]*Share{}
+	}
+
+	if len(s.shares) == 0 {
+		go s.Serve()
+	}
+
+	hash := InfoHash(name)
+	s.shares[hash] = &Share{
+		name: name,
+		pwd:  pwd,
+		src:  src,
+	}
+
+	s.announce.Do()
+
+	s.mu.Unlock()
+}
+
+func (s *Server) GetSharePwd(name string) (pwd string) {
+	hash := InfoHash(name)
+	s.mu.Lock()
+	if share, ok := s.shares[hash]; ok {
+		pwd = share.pwd
+	}
+	s.mu.Unlock()
+	return
+}
+
+func (s *Server) RemoveShare(name string) {
+	hash := InfoHash(name)
+	s.mu.Lock()
+	if _, ok := s.shares[hash]; ok {
+		delete(s.shares, hash)
+	}
+	s.mu.Unlock()
+}
+
+// Serve - run reconnection loop, will exit on??
+func (s *Server) Serve() error {
+	for s.HasShares() {
+		s.Fire("connect to tracker: " + s.URL)
+
+		ws, _, err := websocket.DefaultDialer.Dial(s.URL, nil)
+		if err != nil {
+			s.Fire(err)
+			time.Sleep(time.Minute)
+			continue
+		}
+
+		peerID := core.RandString(16, 36)
+
+		// instant run announce worker
+		s.announce = core.NewWorker(0, func() time.Duration {
+			if err = s.writer(ws, peerID); err != nil {
+				return 0
+			}
+			return time.Minute
+		})
+
+		// run reader forewer
+		for {
+			if err = s.reader(ws, peerID); err != nil {
+				break
+			}
+		}
+
+		// stop announcing worker
+		s.announce.Stop()
+
+		// ensure ws is stopped
+		_ = ws.Close()
+
+		time.Sleep(time.Minute)
+	}
+
+	s.Fire("disconnect")
+
+	return nil
+}
+
+// reader - receive offers in the loop, will exit on ws.Close
+func (s *Server) reader(ws *websocket.Conn, peerID string) error {
+	var v Message
+	if err := ws.ReadJSON(&v); err != nil {
+		return err
+	}
+
+	s.Fire(&v)
+
+	s.mu.Lock()
+	share, ok := s.shares[v.InfoHash]
+	s.mu.Unlock()
+
+	// skip any unknown shares
+	if !ok || v.OfferId == "" || v.Offer == nil {
+		return nil
+	}
+
+	s.Fire("new offer: " + v.OfferId)
+
+	cipher, err := NewCipher(share.name, share.pwd, v.OfferId)
+	if err != nil {
+		s.Fire(err)
+		return nil
+	}
+
+	enc, err := base64.StdEncoding.DecodeString(v.Offer.SDP)
+	if err != nil {
+		s.Fire(err)
+		return nil
+	}
+
+	offer, err := cipher.Decrypt(enc)
+	if err != nil {
+		s.Fire(err)
+		return nil
+	}
+
+	answer, err := s.Exchange(share.src, string(offer))
+	if err != nil {
+		s.Fire(err)
+		return nil
+	}
+
+	enc = cipher.Encrypt([]byte(answer))
+
+	raw := fmt.Sprintf(
+		`{"action":"announce","info_hash":"%s","peer_id":"%s","offer_id":"%s","answer":{"type":"answer","sdp":"%s"},"to_peer_id":"%s"}`,
+		v.InfoHash, peerID, v.OfferId, base64.StdEncoding.EncodeToString(enc), v.PeerId,
+	)
+	return ws.WriteMessage(websocket.TextMessage, []byte(raw))
+}
+
+func (s *Server) writer(ws *websocket.Conn, peerID string) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if len(s.shares) == 0 {
+		return ws.Close()
+	}
+
+	for hash := range s.shares {
+		msg := fmt.Sprintf(
+			`{"action":"announce","info_hash":"%s","peer_id":"%s","offers":[],"numwant":10}`,
+			hash, peerID,
+		)
+		if err := ws.WriteMessage(websocket.TextMessage, []byte(msg)); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (s *Server) HasShares() bool {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return len(s.shares) > 0
+}
+
+type Message struct {
+	Action   string `json:"action"`
+	InfoHash string `json:"info_hash"`
+
+	// Announce msg
+	Numwant int    `json:"numwant,omitempty"`
+	PeerId  string `json:"peer_id,omitempty"`
+	Offers  []struct {
+		OfferId string `json:"offer_id"`
+		Offer   struct {
+			Type string `json:"type"`
+			SDP  string `json:"sdp"`
+		} `json:"offer"`
+	} `json:"offers,omitempty"`
+
+	// Interval msg
+	Interval   int `json:"interval,omitempty"`
+	Complete   int `json:"complete,omitempty"`
+	Incomplete int `json:"incomplete,omitempty"`
+
+	// Offer msg
+	OfferId string `json:"offer_id,omitempty"`
+	Offer   *struct {
+		Type string `json:"type"`
+		SDP  string `json:"sdp"`
+	} `json:"offer,omitempty"`
+
+	// Answer msg
+	ToPeerId string `json:"to_peer_id,omitempty"`
+	Answer   *struct {
+		Type string `json:"type"`
+		SDP  string `json:"sdp"`
+	} `json:"answer,omitempty"`
+}
diff --git a/installs_on_host/go2rtc/pkg/wyoming/README.md b/installs_on_host/go2rtc/pkg/wyoming/README.md
new file mode 100644
index 0000000..ff17d07
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/wyoming/README.md
@@ -0,0 +1,14 @@
+##  Default wake words
+
+- alexa_v0.1
+- hey_jarvis_v0.1
+- hey_mycroft_v0.1
+- hey_rhasspy_v0.1
+- ok_nabu_v0.1
+
+## Useful Links
+
+- https://github.com/rhasspy/wyoming-satellite
+- https://github.com/rhasspy/wyoming-openwakeword
+- https://github.com/fwartner/home-assistant-wakewords-collection
+- https://github.com/esphome/micro-wake-word-models/tree/main?tab=readme-ov-file
diff --git a/installs_on_host/go2rtc/pkg/wyoming/api.go b/installs_on_host/go2rtc/pkg/wyoming/api.go
new file mode 100644
index 0000000..ce297a2
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/wyoming/api.go
@@ -0,0 +1,99 @@
+package wyoming
+
+import (
+	"bufio"
+	"encoding/json"
+	"io"
+	"net"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+type API struct {
+	conn net.Conn
+	rd   *bufio.Reader
+}
+
+func DialAPI(address string) (*API, error) {
+	conn, err := net.DialTimeout("tcp", address, core.ConnDialTimeout)
+	if err != nil {
+		return nil, err
+	}
+
+	return NewAPI(conn), nil
+}
+
+const Version = "1.5.4"
+
+func NewAPI(conn net.Conn) *API {
+	return &API{conn: conn, rd: bufio.NewReader(conn)}
+}
+
+func (w *API) WriteEvent(evt *Event) (err error) {
+	hdr := EventHeader{
+		Type:          evt.Type,
+		Version:       Version,
+		DataLength:    len(evt.Data),
+		PayloadLength: len(evt.Payload),
+	}
+
+	buf, err := json.Marshal(hdr)
+	if err != nil {
+		return err
+	}
+
+	buf = append(buf, '\n')
+	buf = append(buf, evt.Data...)
+	buf = append(buf, evt.Payload...)
+
+	_, err = w.conn.Write(buf)
+	return err
+}
+
+func (w *API) ReadEvent() (*Event, error) {
+	data, err := w.rd.ReadBytes('\n')
+	if err != nil {
+		return nil, err
+	}
+
+	var hdr EventHeader
+	if err = json.Unmarshal(data, &hdr); err != nil {
+		return nil, err
+	}
+
+	evt := Event{Type: hdr.Type}
+
+	if hdr.DataLength > 0 {
+		data = make([]byte, hdr.DataLength)
+		if _, err = io.ReadFull(w.rd, data); err != nil {
+			return nil, err
+		}
+		evt.Data = string(data)
+	}
+
+	if hdr.PayloadLength > 0 {
+		evt.Payload = make([]byte, hdr.PayloadLength)
+		if _, err = io.ReadFull(w.rd, evt.Payload); err != nil {
+			return nil, err
+		}
+	}
+
+	return &evt, nil
+}
+
+func (w *API) Close() error {
+	return w.conn.Close()
+}
+
+type Event struct {
+	Type    string
+	Data    string
+	Payload []byte
+}
+
+type EventHeader struct {
+	Type          string `json:"type"`
+	Version       string `json:"version"`
+	DataLength    int    `json:"data_length,omitempty"`
+	PayloadLength int    `json:"payload_length,omitempty"`
+}
diff --git a/installs_on_host/go2rtc/pkg/wyoming/backchannel.go b/installs_on_host/go2rtc/pkg/wyoming/backchannel.go
new file mode 100644
index 0000000..e0569fe
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/wyoming/backchannel.go
@@ -0,0 +1,63 @@
+package wyoming
+
+import (
+	"fmt"
+	"net"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+)
+
+type Backchannel struct {
+	core.Connection
+	api *API
+}
+
+func newBackchannel(conn net.Conn) *Backchannel {
+	return &Backchannel{
+		core.Connection{
+			ID:         core.NewID(),
+			FormatName: "wyoming",
+			Medias: []*core.Media{
+				{
+					Kind:      core.KindAudio,
+					Direction: core.DirectionSendonly,
+					Codecs: []*core.Codec{
+						{Name: core.CodecPCML, ClockRate: 22050},
+					},
+				},
+			},
+			Transport: conn,
+		},
+		NewAPI(conn),
+	}
+}
+
+func (b *Backchannel) GetTrack(media *core.Media, codec *core.Codec) (*core.Receiver, error) {
+	return nil, core.ErrCantGetTrack
+}
+
+func (b *Backchannel) AddTrack(media *core.Media, codec *core.Codec, track *core.Receiver) error {
+	sender := core.NewSender(media, codec)
+	sender.Handler = func(pkt *rtp.Packet) {
+		ts := time.Now().Nanosecond()
+		evt := &Event{
+			Type:    "audio-chunk",
+			Data:    fmt.Sprintf(`{"rate":22050,"width":2,"channels":1,"timestamp":%d}`, ts),
+			Payload: pkt.Payload,
+		}
+		_ = b.api.WriteEvent(evt)
+	}
+	sender.HandleRTP(track)
+	b.Senders = append(b.Senders, sender)
+	return nil
+}
+
+func (b *Backchannel) Start() error {
+	for {
+		if _, err := b.api.ReadEvent(); err != nil {
+			return err
+		}
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/wyoming/expr.go b/installs_on_host/go2rtc/pkg/wyoming/expr.go
new file mode 100644
index 0000000..f2f5893
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/wyoming/expr.go
@@ -0,0 +1,138 @@
+package wyoming
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/expr"
+	"github.com/AlexxIT/go2rtc/pkg/wav"
+)
+
+type env struct {
+	*satellite
+	Type string
+	Data string
+}
+
+func (s *satellite) handleEvent(evt *Event) {
+	switch evt.Type {
+	case "describe":
+		// {"asr": [], "tts": [], "handle": [], "intent": [], "wake": [], "satellite": {"name": "my satellite", "attribution": {"name": "", "url": ""}, "installed": true, "description": "my satellite", "version": "1.4.1", "area": null, "snd_format": null}}
+		data := fmt.Sprintf(`{"satellite":{"name":%q,"attribution":{"name":"go2rtc","url":"https://github.com/AlexxIT/go2rtc"},"installed":true}}`, s.srv.Name)
+		s.WriteEvent("info", data)
+	case "run-satellite":
+		s.Detect()
+	case "pause-satellite":
+		s.Stop()
+	case "detect": // WAKE_WORD_START {"names": null}
+	case "detection": // WAKE_WORD_END {"name": "ok_nabu_v0.1", "timestamp": 17580, "speaker": null}
+	case "transcribe": // STT_START {"language": "en"}
+	case "voice-started": // STT_VAD_START {"timestamp": 1160}
+	case "voice-stopped": // STT_VAD_END {"timestamp": 2470}
+		s.Pause()
+	case "transcript": // STT_END {"text": "how are you"}
+	case "synthesize": // TTS_START {"text": "Sorry, I couldn't understand that", "voice": {"language": "en"}}
+	case "audio-start": // TTS_END {"rate": 22050, "width": 2, "channels": 1, "timestamp": 0}
+	case "audio-chunk": // {"rate": 22050, "width": 2, "channels": 1, "timestamp": 0}
+	case "audio-stop": // {"timestamp": 2.880000000000002}
+		// run async because PlayAudio takes some time
+		go func() {
+			s.PlayAudio()
+			s.WriteEvent("played")
+			s.Detect()
+		}()
+	case "error":
+		s.Detect()
+	case "internal-run":
+		s.WriteEvent("run-pipeline", `{"start_stage":"wake","end_stage":"tts"}`)
+		s.Stream()
+	case "internal-detection":
+		s.WriteEvent("run-pipeline", `{"start_stage":"asr","end_stage":"tts"}`)
+		s.Stream()
+	}
+}
+
+func (s *satellite) handleScript(evt *Event) {
+	var script string
+	if s.srv.Event != nil {
+		script = s.srv.Event[evt.Type]
+	}
+
+	s.srv.Trace("event=%s data=%s payload size=%d", evt.Type, evt.Data, len(evt.Payload))
+
+	if script == "" {
+		s.handleEvent(evt)
+		return
+	}
+
+	// run async because script can have sleeps
+	go func() {
+		e := &env{satellite: s, Type: evt.Type, Data: evt.Data}
+		if res, err := expr.Eval(script, e); err != nil {
+			s.srv.Trace("event=%s expr error=%s", evt.Type, err)
+			s.handleEvent(evt)
+		} else {
+			s.srv.Trace("event=%s expr result=%v", evt.Type, res)
+		}
+	}()
+}
+
+func (s *satellite) Detect() bool {
+	return s.setMicState(stateWaitVAD)
+}
+
+func (s *satellite) Stream() bool {
+	return s.setMicState(stateActive)
+}
+
+func (s *satellite) Pause() bool {
+	return s.setMicState(stateIdle)
+}
+
+func (s *satellite) Stop() bool {
+	s.micStop()
+	return true
+}
+
+func (s *satellite) WriteEvent(args ...string) bool {
+	if len(args) == 0 {
+		return false
+	}
+	evt := &Event{Type: args[0]}
+	if len(args) > 1 {
+		evt.Data = args[1]
+	}
+	if err := s.api.WriteEvent(evt); err != nil {
+		return false
+	}
+	return true
+}
+
+func (s *satellite) PlayAudio() bool {
+	return s.playAudio(sndCodec, bytes.NewReader(s.sndAudio))
+}
+
+func (s *satellite) PlayFile(path string) bool {
+	f, err := os.Open(path)
+	if err != nil {
+		return false
+	}
+
+	codec, err := wav.ReadHeader(f)
+	if err != nil {
+		return false
+	}
+
+	return s.playAudio(codec, f)
+}
+
+func (e *env) Sleep(s string) bool {
+	d, err := time.ParseDuration(s)
+	if err != nil {
+		return false
+	}
+	time.Sleep(d)
+	return true
+}
diff --git a/installs_on_host/go2rtc/pkg/wyoming/mic.go b/installs_on_host/go2rtc/pkg/wyoming/mic.go
new file mode 100644
index 0000000..4fb03b4
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/wyoming/mic.go
@@ -0,0 +1,35 @@
+package wyoming
+
+import (
+	"fmt"
+	"net"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func (s *Server) HandleMic(conn net.Conn) {
+	defer conn.Close()
+
+	var closed core.Waiter
+	var timestamp int
+
+	api := NewAPI(conn)
+	mic := newMicConsumer(func(chunk []byte) {
+		data := fmt.Sprintf(`{"rate":16000,"width":2,"channels":1,"timestamp":%d}`, timestamp)
+		evt := &Event{Type: "audio-chunk", Data: data, Payload: chunk}
+		if err := api.WriteEvent(evt); err != nil {
+			closed.Done(nil)
+		}
+
+		timestamp += len(chunk) / 2
+	})
+	mic.RemoteAddr = api.conn.RemoteAddr().String()
+
+	if err := s.MicHandler(mic); err != nil {
+		s.Error("mic error: %s", err)
+		return
+	}
+
+	_ = closed.Wait()
+	_ = mic.Stop()
+}
diff --git a/installs_on_host/go2rtc/pkg/wyoming/producer.go b/installs_on_host/go2rtc/pkg/wyoming/producer.go
new file mode 100644
index 0000000..0945133
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/wyoming/producer.go
@@ -0,0 +1,65 @@
+package wyoming
+
+import (
+	"net"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+)
+
+type Producer struct {
+	core.Connection
+	api *API
+}
+
+func newProducer(conn net.Conn) *Producer {
+	return &Producer{
+		core.Connection{
+			ID:         core.NewID(),
+			FormatName: "wyoming",
+			Medias: []*core.Media{
+				{
+					Kind:      core.KindAudio,
+					Direction: core.DirectionRecvonly,
+					Codecs: []*core.Codec{
+						{Name: core.CodecPCML, ClockRate: 16000},
+					},
+				},
+			},
+			Transport: conn,
+		},
+		NewAPI(conn),
+	}
+}
+
+func (p *Producer) Start() error {
+	var seq uint16
+	var ts uint32
+
+	for {
+		evt, err := p.api.ReadEvent()
+		if err != nil {
+			return err
+		}
+
+		if evt.Type != "audio-chunk" {
+			continue
+		}
+
+		p.Recv += len(evt.Payload)
+
+		pkt := &core.Packet{
+			Header: rtp.Header{
+				Version:        2,
+				Marker:         true,
+				SequenceNumber: seq,
+				Timestamp:      ts,
+			},
+			Payload: evt.Payload,
+		}
+		p.Receivers[0].WriteRTP(pkt)
+
+		seq++
+		ts += uint32(len(evt.Payload) / 2)
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/wyoming/satellite.go b/installs_on_host/go2rtc/pkg/wyoming/satellite.go
new file mode 100644
index 0000000..0c0e6f3
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/wyoming/satellite.go
@@ -0,0 +1,275 @@
+package wyoming
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net"
+	"sync"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/pcm"
+	"github.com/AlexxIT/go2rtc/pkg/pcm/s16le"
+	"github.com/pion/rtp"
+)
+
+type Server struct {
+	Name  string
+	Event map[string]string
+
+	VADThreshold int16
+	WakeURI      string
+
+	MicHandler func(cons core.Consumer) error
+	SndHandler func(prod core.Producer) error
+
+	Trace func(format string, v ...any)
+	Error func(format string, v ...any)
+}
+
+func (s *Server) Serve(l net.Listener) error {
+	for {
+		conn, err := l.Accept()
+		if err != nil {
+			return err
+		}
+
+		go s.Handle(conn)
+	}
+}
+
+func (s *Server) Handle(conn net.Conn) {
+	api := NewAPI(conn)
+	sat := newSatellite(api, s)
+	defer sat.Close()
+
+	for {
+		evt, err := api.ReadEvent()
+		if err != nil {
+			return
+		}
+
+		switch evt.Type {
+		case "ping": // {"text": null}
+			_ = api.WriteEvent(&Event{Type: "pong", Data: evt.Data})
+		case "audio-start": // TTS_END {"rate": 22050, "width": 2, "channels": 1, "timestamp": 0}
+			sat.sndAudio = sat.sndAudio[:0]
+		case "audio-chunk": // {"rate": 22050, "width": 2, "channels": 1, "timestamp": 0}
+			sat.sndAudio = append(sat.sndAudio, evt.Payload...)
+		default:
+			sat.handleScript(evt)
+		}
+	}
+}
+
+// states like http.ConnState
+const (
+	stateError        = -2
+	stateClosed       = -1
+	stateNew          = 0
+	stateIdle         = 1
+	stateWaitVAD      = 2 // aka wait VAD
+	stateWaitWakeWord = 3
+	stateActive       = 4
+)
+
+type satellite struct {
+	api *API
+	srv *Server
+
+	micState int8
+	micTS    int
+	micMu    sync.Mutex
+	sndAudio []byte
+
+	mic  *micConsumer
+	wake *WakeWord
+}
+
+func newSatellite(api *API, srv *Server) *satellite {
+	sat := &satellite{api: api, srv: srv}
+	return sat
+}
+
+func (s *satellite) Close() error {
+	s.Stop()
+	return s.api.Close()
+}
+
+const wakeTimeout = 5 * 2 * 16000 // 5 seconds
+
+func (s *satellite) setMicState(state int8) bool {
+	s.micMu.Lock()
+	defer s.micMu.Unlock()
+
+	if s.micState == stateNew {
+		s.mic = newMicConsumer(s.onMicChunk)
+		s.mic.RemoteAddr = s.api.conn.RemoteAddr().String()
+		if err := s.srv.MicHandler(s.mic); err != nil {
+			s.micState = stateError
+			s.srv.Error("can't get mic: %w", err)
+			_ = s.api.Close()
+		} else {
+			s.micState = stateIdle
+		}
+	}
+
+	if s.micState < stateIdle {
+		return false
+	}
+
+	s.micState = state
+	s.micTS = 0
+	return true
+}
+
+func (s *satellite) micStop() {
+	s.micMu.Lock()
+
+	s.micState = stateClosed
+	if s.mic != nil {
+		_ = s.mic.Stop()
+		s.mic = nil
+	}
+	if s.wake != nil {
+		_ = s.wake.Close()
+		s.wake = nil
+	}
+
+	s.micMu.Unlock()
+}
+
+func (s *satellite) onMicChunk(chunk []byte) {
+	s.micMu.Lock()
+	defer s.micMu.Unlock()
+
+	if s.micState == stateIdle {
+		return
+	}
+
+	if s.micState == stateWaitVAD {
+		// tests show that values over 1000 are most likely speech
+		if s.srv.VADThreshold == 0 || s16le.PeaksRMS(chunk) > s.srv.VADThreshold {
+			if s.wake == nil && s.srv.WakeURI != "" {
+				s.wake, _ = DialWakeWord(s.srv.WakeURI)
+			}
+			if s.wake == nil {
+				// some problems with wake word - redirect to HA
+				s.micState = stateIdle
+				go s.handleScript(&Event{Type: "internal-run"})
+			} else {
+				s.micState = stateWaitWakeWord
+			}
+			s.micTS = 0
+		}
+	}
+
+	if s.micState == stateWaitWakeWord {
+		if s.wake.Detection != "" {
+			// check if wake word detected
+			s.micState = stateIdle
+			go s.handleScript(&Event{Type: "internal-detection", Data: `{"name":"` + s.wake.Detection + `"}`})
+		} else if err := s.wake.WriteChunk(chunk); err != nil {
+			// wake word service failed
+			s.micState = stateWaitVAD
+			_ = s.wake.Close()
+			s.wake = nil
+		} else if s.micTS > wakeTimeout {
+			// wake word detection timeout
+			s.micState = stateWaitVAD
+		}
+	} else if s.wake != nil {
+		_ = s.wake.Close()
+		s.wake = nil
+	}
+
+	if s.micState == stateActive {
+		data := fmt.Sprintf(`{"rate":16000,"width":2,"channels":1,"timestamp":%d}`, s.micTS)
+		evt := &Event{Type: "audio-chunk", Data: data, Payload: chunk}
+		_ = s.api.WriteEvent(evt)
+	}
+
+	s.micTS += len(chunk) / 2
+}
+
+func (s *satellite) playAudio(codec *core.Codec, rd io.Reader) bool {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	prod := pcm.OpenSync(codec, rd)
+	prod.OnClose(cancel)
+
+	if err := s.srv.SndHandler(prod); err != nil {
+		return false
+	} else {
+		<-ctx.Done()
+		return true
+	}
+}
+
+type micConsumer struct {
+	core.Connection
+	onData  func(chunk []byte)
+	onClose func()
+}
+
+func newMicConsumer(onData func(chunk []byte)) *micConsumer {
+	medias := []*core.Media{
+		{
+			Kind:      core.KindAudio,
+			Direction: core.DirectionSendonly,
+			Codecs:    pcm.ConsumerCodecs(),
+		},
+	}
+
+	return &micConsumer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "wyoming",
+			Protocol:   "tcp",
+			Medias:     medias,
+		},
+		onData: onData,
+	}
+}
+
+func (c *micConsumer) AddTrack(media *core.Media, codec *core.Codec, track *core.Receiver) error {
+	src := track.Codec
+	dst := &core.Codec{
+		Name:      core.CodecPCML,
+		ClockRate: 16000,
+		Channels:  1,
+	}
+	sender := core.NewSender(media, dst)
+	sender.Handler = pcm.TranscodeHandler(dst, src,
+		repack(func(packet *core.Packet) {
+			c.onData(packet.Payload)
+		}),
+	)
+	sender.HandleRTP(track)
+	c.Senders = append(c.Senders, sender)
+	return nil
+}
+
+func (c *micConsumer) Stop() error {
+	if c.onClose != nil {
+		c.onClose()
+	}
+	return c.Connection.Stop()
+}
+
+func repack(handler core.HandlerFunc) core.HandlerFunc {
+	const PacketSize = 2 * 16000 / 50 // 20ms
+
+	var buf []byte
+
+	return func(pkt *rtp.Packet) {
+		buf = append(buf, pkt.Payload...)
+
+		for len(buf) >= PacketSize {
+			pkt = &core.Packet{Payload: buf[:PacketSize]}
+			buf = buf[PacketSize:]
+			handler(pkt)
+		}
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/wyoming/snd.go b/installs_on_host/go2rtc/pkg/wyoming/snd.go
new file mode 100644
index 0000000..e26ca7e
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/wyoming/snd.go
@@ -0,0 +1,40 @@
+package wyoming
+
+import (
+	"bytes"
+	"net"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/pcm"
+)
+
+func (s *Server) HandleSnd(conn net.Conn) {
+	defer conn.Close()
+
+	var snd []byte
+
+	api := NewAPI(conn)
+	for {
+		evt, err := api.ReadEvent()
+		if err != nil {
+			return
+		}
+
+		s.Trace("event: %s data: %s payload: %d", evt.Type, evt.Data, len(evt.Payload))
+
+		switch evt.Type {
+		case "audio-start":
+			snd = snd[:0]
+		case "audio-chunk":
+			snd = append(snd, evt.Payload...)
+		case "audio-stop":
+			prod := pcm.OpenSync(sndCodec, bytes.NewReader(snd))
+			if err = s.SndHandler(prod); err != nil {
+				s.Error("snd error: %s", err)
+				return
+			}
+		}
+	}
+}
+
+var sndCodec = &core.Codec{Name: core.CodecPCML, ClockRate: 22050}
diff --git a/installs_on_host/go2rtc/pkg/wyoming/wakeword.go b/installs_on_host/go2rtc/pkg/wyoming/wakeword.go
new file mode 100644
index 0000000..4c728f2
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/wyoming/wakeword.go
@@ -0,0 +1,120 @@
+package wyoming
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/url"
+)
+
+type WakeWord struct {
+	*API
+	names []string
+	send  int
+
+	Detection string
+}
+
+func DialWakeWord(rawURL string) (*WakeWord, error) {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	api, err := DialAPI(u.Host)
+	if err != nil {
+		return nil, err
+	}
+
+	names := u.Query()["name"]
+	if len(names) == 0 {
+		names = []string{"ok_nabu_v0.1"}
+	}
+
+	wake := &WakeWord{API: api, names: names}
+	if err = wake.Start(); err != nil {
+		_ = wake.Close()
+		return nil, err
+	}
+
+	go wake.handle()
+	return wake, nil
+}
+
+func (w *WakeWord) handle() {
+	defer w.Close()
+
+	for {
+		evt, err := w.ReadEvent()
+		if err != nil {
+			return
+		}
+
+		if evt.Type == "detection" {
+			var data struct {
+				Name string `json:"name"`
+			}
+			if err = json.Unmarshal([]byte(evt.Data), &data); err != nil {
+				return
+			}
+			w.Detection = data.Name
+		}
+	}
+}
+
+//func (w *WakeWord) Describe() error {
+//	if err := w.WriteEvent(&Event{Type: "describe"}); err != nil {
+//		return err
+//	}
+//
+//	evt, err := w.ReadEvent()
+//	if err != nil {
+//		return err
+//	}
+//
+//	var info struct {
+//		Wake []struct {
+//			Models []struct {
+//				Name string `json:"name"`
+//			} `json:"models"`
+//		} `json:"wake"`
+//	}
+//	if err = json.Unmarshal(evt.Data, &info); err != nil {
+//		return err
+//	}
+//
+//	return nil
+//}
+
+func (w *WakeWord) Start() error {
+	msg := struct {
+		Names []string `json:"names"`
+	}{
+		Names: w.names,
+	}
+	data, err := json.Marshal(msg)
+	if err != nil {
+		return err
+	}
+	evt := &Event{Type: "detect", Data: string(data)}
+	if err := w.WriteEvent(evt); err != nil {
+		return err
+	}
+
+	evt = &Event{Type: "audio-start", Data: audioData(0)}
+	return w.WriteEvent(evt)
+}
+
+func (w *WakeWord) Close() error {
+	return w.conn.Close()
+}
+
+func (w *WakeWord) WriteChunk(payload []byte) error {
+	evt := &Event{Type: "audio-chunk", Data: audioData(w.send), Payload: payload}
+	w.send += len(payload)
+	return w.WriteEvent(evt)
+}
+
+func audioData(send int) string {
+	// timestamp in ms = send / 2 * 1000 / 16000 = send / 32
+	return fmt.Sprintf(`{"rate":16000,"width":2,"channels":1,"timestamp":%d}`, send/32)
+}
diff --git a/installs_on_host/go2rtc/pkg/wyoming/wyoming.go b/installs_on_host/go2rtc/pkg/wyoming/wyoming.go
new file mode 100644
index 0000000..0c8eeba
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/wyoming/wyoming.go
@@ -0,0 +1,26 @@
+package wyoming
+
+import (
+	"net"
+	"net/url"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+func Dial(rawURL string) (core.Producer, error) {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	conn, err := net.DialTimeout("tcp", u.Host, core.ConnDialTimeout)
+	if err != nil {
+		return nil, err
+	}
+
+	if u.Query().Get("backchannel") != "1" {
+		return newProducer(conn), nil
+	} else {
+		return newBackchannel(conn), nil
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/wyze/backchannel.go b/installs_on_host/go2rtc/pkg/wyze/backchannel.go
new file mode 100644
index 0000000..37472c1
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/wyze/backchannel.go
@@ -0,0 +1,55 @@
+package wyze
+
+import (
+	"fmt"
+
+	"github.com/AlexxIT/go2rtc/pkg/aac"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/tutk"
+	"github.com/pion/rtp"
+)
+
+func (p *Producer) AddTrack(media *core.Media, codec *core.Codec, track *core.Receiver) error {
+	if err := p.client.StartIntercom(); err != nil {
+		return fmt.Errorf("wyze: failed to enable intercom: %w", err)
+	}
+
+	// Get the camera's audio codec info (what it sent us = what it accepts)
+	tutkCodec, sampleRate, channels := p.client.GetBackchannelCodec()
+	if tutkCodec == 0 {
+		return fmt.Errorf("wyze: no audio codec detected from camera")
+	}
+
+	if p.client.verbose {
+		fmt.Printf("[Wyze] Intercom enabled, using codec=0x%04x rate=%d ch=%d\n", tutkCodec, sampleRate, channels)
+	}
+
+	sender := core.NewSender(media, track.Codec)
+
+	// Track our own timestamp - camera expects timestamps starting from 0
+	// and incrementing by frame duration in microseconds
+	var timestamp uint32 = 0
+	samplesPerFrame := tutk.GetSamplesPerFrame(tutkCodec)
+	frameDurationUS := samplesPerFrame * 1000000 / sampleRate
+
+	sender.Handler = func(pkt *rtp.Packet) {
+		if err := p.client.WriteAudio(tutkCodec, pkt.Payload, timestamp, sampleRate, channels); err == nil {
+			p.Send += len(pkt.Payload)
+		}
+		timestamp += frameDurationUS
+	}
+
+	switch track.Codec.Name {
+	case core.CodecAAC:
+		if track.Codec.IsRTP() {
+			sender.Handler = aac.RTPToADTS(codec, sender.Handler)
+		} else {
+			sender.Handler = aac.EncodeToADTS(codec, sender.Handler)
+		}
+	}
+
+	sender.HandleRTP(track)
+	p.Senders = append(p.Senders, sender)
+
+	return nil
+}
diff --git a/installs_on_host/go2rtc/pkg/wyze/client.go b/installs_on_host/go2rtc/pkg/wyze/client.go
new file mode 100644
index 0000000..0fe878e
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/wyze/client.go
@@ -0,0 +1,618 @@
+package wyze
+
+import (
+	"crypto/rand"
+	"encoding/binary"
+	"encoding/json"
+	"fmt"
+	"net"
+	"net/url"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/tutk"
+	"github.com/AlexxIT/go2rtc/pkg/tutk/dtls"
+)
+
+const (
+	FrameSize1080P      = 0
+	FrameSize360P       = 1
+	FrameSize720P       = 2
+	FrameSize2K         = 3
+	FrameSizeFloodlight = 4
+)
+
+const (
+	BitrateMax uint16 = 0xF0
+	BitrateSD  uint16 = 0x3C
+)
+
+const (
+	MediaTypeVideo       = 1
+	MediaTypeAudio       = 2
+	MediaTypeReturnAudio = 3
+	MediaTypeRDT         = 4
+)
+
+const (
+	KCmdAuth               = 10000
+	KCmdChallenge          = 10001
+	KCmdChallengeResp      = 10002
+	KCmdAuthResult         = 10003
+	KCmdControlChannel     = 10010
+	KCmdControlChannelResp = 10011
+	KCmdSetResolutionDB    = 10052
+	KCmdSetResolutionDBRes = 10053
+	KCmdSetResolution      = 10056
+	KCmdSetResolutionResp  = 10057
+)
+
+type Client struct {
+	conn *dtls.DTLSConn
+
+	host  string
+	uid   string
+	enr   string
+	mac   string
+	model string
+
+	authKey string
+	verbose bool
+
+	closed  bool
+	closeMu sync.Mutex
+
+	hasAudio    bool
+	hasIntercom bool
+
+	audioCodecID    byte
+	audioSampleRate uint32
+	audioChannels   uint8
+}
+
+type AuthResponse struct {
+	ConnectionRes string         `json:"connectionRes"`
+	CameraInfo    map[string]any `json:"cameraInfo"`
+}
+
+func Dial(rawURL string) (*Client, error) {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, fmt.Errorf("wyze: invalid URL: %w", err)
+	}
+
+	query := u.Query()
+
+	if query.Get("dtls") != "true" {
+		return nil, fmt.Errorf("wyze: only DTLS cameras are supported")
+	}
+
+	c := &Client{
+		host:    u.Host,
+		uid:     query.Get("uid"),
+		enr:     query.Get("enr"),
+		mac:     query.Get("mac"),
+		model:   query.Get("model"),
+		verbose: query.Get("verbose") == "true",
+	}
+
+	c.authKey = string(dtls.CalculateAuthKey(c.enr, c.mac))
+
+	if c.verbose {
+		fmt.Printf("[Wyze] Connecting to %s (UID: %s)\n", c.host, c.uid)
+	}
+
+	if err := c.connect(); err != nil {
+		c.Close()
+		return nil, err
+	}
+
+	if err := c.doAVLogin(); err != nil {
+		c.Close()
+		return nil, err
+	}
+
+	if err := c.doKAuth(); err != nil {
+		c.Close()
+		return nil, err
+	}
+
+	if c.verbose {
+		fmt.Printf("[Wyze] Connection established\n")
+	}
+
+	return c, nil
+}
+
+func (c *Client) SupportsAudio() bool {
+	return c.hasAudio
+}
+
+func (c *Client) SupportsIntercom() bool {
+	return c.hasIntercom
+}
+
+func (c *Client) SetBackchannelCodec(codecID byte, sampleRate uint32, channels uint8) {
+	c.audioCodecID = codecID
+	c.audioSampleRate = sampleRate
+	c.audioChannels = channels
+}
+
+func (c *Client) GetBackchannelCodec() (codecID byte, sampleRate uint32, channels uint8) {
+	return c.audioCodecID, c.audioSampleRate, c.audioChannels
+}
+
+func (c *Client) SetResolution(quality byte) error {
+	var frameSize uint8
+	var bitrate uint16
+
+	switch quality {
+	case 0: // Auto/HD - use model's best
+		frameSize = c.hdFrameSize()
+		bitrate = BitrateMax
+	case FrameSize360P: // 1 = SD/360P
+		frameSize = FrameSize360P
+		bitrate = BitrateSD
+	case FrameSize720P: // 2 = 720P
+		frameSize = FrameSize720P
+		bitrate = BitrateMax
+	case FrameSize2K: // 3 = 2K
+		if c.is2K() {
+			frameSize = FrameSize2K
+		} else {
+			frameSize = c.hdFrameSize()
+		}
+		bitrate = BitrateMax
+	case FrameSizeFloodlight: // 4 = Floodlight
+		frameSize = c.hdFrameSize()
+		bitrate = BitrateMax
+	default:
+		frameSize = quality
+		bitrate = BitrateMax
+	}
+
+	if c.verbose {
+		fmt.Printf("[Wyze] SetResolution: quality=%d frameSize=%d bitrate=%d model=%s\n", quality, frameSize, bitrate, c.model)
+	}
+
+	// Use K10052 (doorbell format) for certain models
+	if c.useDoorbellResolution() {
+		k10052 := c.buildK10052(frameSize, bitrate)
+		_, err := c.conn.WriteAndWaitIOCtrl(k10052, c.matchHL(KCmdSetResolutionDBRes), 5*time.Second)
+		return err
+	}
+
+	k10056 := c.buildK10056(frameSize, bitrate)
+	_, err := c.conn.WriteAndWaitIOCtrl(k10056, c.matchHL(KCmdSetResolutionResp), 5*time.Second)
+	return err
+}
+
+func (c *Client) StartVideo() error {
+	k10010 := c.buildK10010(MediaTypeVideo, true)
+	_, err := c.conn.WriteAndWaitIOCtrl(k10010, c.matchHL(KCmdControlChannelResp), 5*time.Second)
+	return err
+}
+
+func (c *Client) StartAudio() error {
+	k10010 := c.buildK10010(MediaTypeAudio, true)
+	_, err := c.conn.WriteAndWaitIOCtrl(k10010, c.matchHL(KCmdControlChannelResp), 5*time.Second)
+	return err
+}
+
+func (c *Client) StartIntercom() error {
+	if c.conn == nil {
+		return fmt.Errorf("connection is nil")
+	}
+
+	if c.conn.IsBackchannelReady() {
+		return nil
+	}
+
+	k10010 := c.buildK10010(MediaTypeReturnAudio, true)
+	if _, err := c.conn.WriteAndWaitIOCtrl(k10010, c.matchHL(KCmdControlChannelResp), 5*time.Second); err != nil {
+		return fmt.Errorf("enable return audio: %w", err)
+	}
+
+	if c.verbose {
+		fmt.Printf("[Wyze] Speaker channel enabled, waiting for readiness...\n")
+	}
+
+	return c.conn.AVServStart()
+}
+
+func (c *Client) StopIntercom() error {
+	if c.conn == nil || !c.conn.IsBackchannelReady() {
+		return nil
+	}
+
+	k10010 := c.buildK10010(MediaTypeReturnAudio, false)
+	c.conn.WriteIOCtrl(k10010)
+
+	return c.conn.AVServStop()
+}
+
+func (c *Client) ReadPacket() (*tutk.Packet, error) {
+	return c.conn.AVRecvFrameData()
+}
+
+func (c *Client) WriteAudio(codec byte, payload []byte, timestamp uint32, sampleRate uint32, channels uint8) error {
+	if !c.conn.IsBackchannelReady() {
+		return fmt.Errorf("speaker channel not connected")
+	}
+
+	if c.verbose {
+		fmt.Printf("[Wyze] WriteAudio: codec=0x%02x, payload=%d bytes, rate=%d, ch=%d\n", codec, len(payload), sampleRate, channels)
+	}
+
+	return c.conn.AVSendAudioData(codec, payload, timestamp, sampleRate, channels)
+}
+
+func (c *Client) SetDeadline(t time.Time) error {
+	if c.conn != nil {
+		return c.conn.SetDeadline(t)
+	}
+	return nil
+}
+
+func (c *Client) Protocol() string {
+	return "wyze/dtls"
+}
+
+func (c *Client) RemoteAddr() net.Addr {
+	if c.conn != nil {
+		return c.conn.RemoteAddr()
+	}
+	return nil
+}
+
+func (c *Client) Close() error {
+	c.closeMu.Lock()
+	if c.closed {
+		c.closeMu.Unlock()
+		return nil
+	}
+	c.closed = true
+	c.closeMu.Unlock()
+
+	if c.verbose {
+		fmt.Printf("[Wyze] Closing connection\n")
+	}
+
+	c.StopIntercom()
+
+	if c.conn != nil {
+		c.conn.Close()
+	}
+
+	if c.verbose {
+		fmt.Printf("[Wyze] Connection closed\n")
+	}
+
+	return nil
+}
+
+func (c *Client) connect() error {
+	host := c.host
+	port := 0
+
+	if idx := strings.Index(host, ":"); idx > 0 {
+		if p, err := strconv.Atoi(host[idx+1:]); err == nil {
+			port = p
+		}
+		host = host[:idx]
+	}
+
+	conn, err := dtls.DialDTLS(host, port, c.uid, c.authKey, c.enr, c.verbose)
+	if err != nil {
+		return fmt.Errorf("wyze: connect failed: %w", err)
+	}
+
+	c.conn = conn
+	if c.verbose {
+		fmt.Printf("[Wyze] Connected to %s (IOTC + DTLS)\n", conn.RemoteAddr())
+	}
+
+	return nil
+}
+
+func (c *Client) doAVLogin() error {
+	if c.verbose {
+		fmt.Printf("[Wyze] Sending AV Login\n")
+	}
+
+	if err := c.conn.AVClientStart(5 * time.Second); err != nil {
+		return fmt.Errorf("wyze: av login failed: %w", err)
+	}
+
+	if c.verbose {
+		fmt.Printf("[Wyze] AV Login response received\n")
+	}
+	return nil
+}
+
+func (c *Client) doKAuth() error {
+	// Step 1: K10000 -> K10001 (Challenge)
+	data, err := c.conn.WriteAndWaitIOCtrl(c.buildK10000(), c.matchHL(KCmdChallenge), 5*time.Second)
+	if err != nil {
+		return fmt.Errorf("wyze: K10001 failed: %w", err)
+	}
+
+	hlData := c.extractHL(data)
+	challenge, status, err := c.parseK10001(hlData)
+	if err != nil {
+		return fmt.Errorf("wyze: K10001 parse failed: %w", err)
+	}
+
+	if c.verbose {
+		fmt.Printf("[Wyze] K10001 challenge received, status=%d\n", status)
+	}
+
+	// Step 2: K10002 -> K10003 (Auth)
+	data, err = c.conn.WriteAndWaitIOCtrl(c.buildK10002(challenge, status), c.matchHL(KCmdAuthResult), 5*time.Second)
+	if err != nil {
+		return fmt.Errorf("wyze: K10002 failed: %w", err)
+	}
+	hlData = c.extractHL(data)
+
+	// Parse K10003 response
+	authResp, err := c.parseK10003(hlData)
+	if err != nil {
+		return fmt.Errorf("wyze: K10003 parse failed: %w", err)
+	}
+
+	if c.verbose && authResp != nil {
+		if jsonBytes, err := json.MarshalIndent(authResp, "", "  "); err == nil {
+			fmt.Printf("[Wyze] K10003 response:\n%s\n", jsonBytes)
+		}
+	}
+
+	// Extract audio capability from cameraInfo
+	if authResp != nil && authResp.CameraInfo != nil {
+		if channelResult, ok := authResp.CameraInfo["channelRequestResult"].(map[string]any); ok {
+			if audio, ok := channelResult["audio"].(string); ok {
+				c.hasAudio = audio == "1"
+			} else {
+				c.hasAudio = true
+			}
+		} else {
+			c.hasAudio = true
+		}
+	} else {
+		c.hasAudio = true
+	}
+
+	if c.verbose {
+		fmt.Printf("[Wyze] K10003 auth success\n")
+	}
+
+	c.hasIntercom = c.conn.HasTwoWayStreaming()
+
+	if c.verbose {
+		fmt.Printf("[Wyze] K-auth complete\n")
+	}
+
+	return nil
+}
+
+func (c *Client) buildK10000() []byte {
+	json := []byte(`{"cameraInfo":{"audioEncoderList":[137,138,140]}}`) // 137=PCMU, 138=PCMA, 140=PCM
+	b := make([]byte, 16+len(json))
+	copy(b, "HL")                                           // magic
+	b[2] = 5                                                // version
+	binary.LittleEndian.PutUint16(b[4:], KCmdAuth)          // 10000
+	binary.LittleEndian.PutUint16(b[6:], uint16(len(json))) // payload len
+	copy(b[16:], json)
+	return b
+}
+
+func (c *Client) buildK10002(challenge []byte, status byte) []byte {
+	resp := generateChallengeResponse(challenge, c.enr, status)
+	sessionID := make([]byte, 4)
+	rand.Read(sessionID)
+	b := make([]byte, 38)
+	copy(b, "HL")                                           // magic
+	b[2] = 5                                                // version
+	binary.LittleEndian.PutUint16(b[4:], KCmdChallengeResp) // 10002
+	b[6] = 22                                               // payload len
+	copy(b[16:], resp[:16])                                 // challenge response
+	copy(b[32:], sessionID)                                 // random session ID
+	b[36] = 1                                               // video enabled/disabled
+	b[37] = 1                                               // audio enabled/disabled
+	return b
+}
+
+func (c *Client) buildK10010(mediaType byte, enabled bool) []byte {
+	b := make([]byte, 18)
+	copy(b, "HL")                                            // magic
+	b[2] = 5                                                 // version
+	binary.LittleEndian.PutUint16(b[4:], KCmdControlChannel) // 10010
+	binary.LittleEndian.PutUint16(b[6:], 2)                  // payload len
+	b[16] = mediaType                                        // 1=video, 2=audio, 3=return audio
+	b[17] = 1                                                // 1=enable, 2=disable
+	if !enabled {
+		b[17] = 2
+	}
+	return b
+}
+
+func (c *Client) buildK10052(frameSize uint8, bitrate uint16) []byte {
+	b := make([]byte, 22)
+	copy(b, "HL")                                             // magic
+	b[2] = 5                                                  // version
+	binary.LittleEndian.PutUint16(b[4:], KCmdSetResolutionDB) // 10052
+	binary.LittleEndian.PutUint16(b[6:], 6)                   // payload len
+	binary.LittleEndian.PutUint16(b[16:], bitrate)            // bitrate (2 bytes)
+	b[18] = frameSize + 1                                     // frame size (1 byte)
+	// b[19] = fps, b[20:22] = zeros
+	return b
+}
+
+func (c *Client) buildK10056(frameSize uint8, bitrate uint16) []byte {
+	b := make([]byte, 21)
+	copy(b, "HL")                                           // magic
+	b[2] = 5                                                // version
+	binary.LittleEndian.PutUint16(b[4:], KCmdSetResolution) // 10056
+	binary.LittleEndian.PutUint16(b[6:], 5)                 // payload len
+	b[16] = frameSize + 1                                   // frame size
+	binary.LittleEndian.PutUint16(b[17:], bitrate)          // bitrate
+	// b[19:21] = FPS (0 = auto)
+	return b
+}
+
+func (c *Client) parseK10001(data []byte) (challenge []byte, status byte, err error) {
+	if c.verbose {
+		fmt.Printf("[Wyze] parseK10001: received %d bytes\n", len(data))
+	}
+
+	if len(data) < 33 {
+		return nil, 0, fmt.Errorf("data too short: %d bytes", len(data))
+	}
+
+	if data[0] != 'H' || data[1] != 'L' {
+		return nil, 0, fmt.Errorf("invalid HL magic: %x %x", data[0], data[1])
+	}
+
+	cmdID := binary.LittleEndian.Uint16(data[4:])
+	if cmdID != KCmdChallenge {
+		return nil, 0, fmt.Errorf("expected cmdID 10001, got %d", cmdID)
+	}
+
+	status = data[16]
+	challenge = make([]byte, 16)
+	copy(challenge, data[17:33])
+
+	return challenge, status, nil
+}
+
+func (c *Client) parseK10003(data []byte) (*AuthResponse, error) {
+	if c.verbose {
+		fmt.Printf("[Wyze] parseK10003: received %d bytes\n", len(data))
+	}
+
+	if len(data) < 16 {
+		return &AuthResponse{}, nil
+	}
+
+	if data[0] != 'H' || data[1] != 'L' {
+		return &AuthResponse{}, nil
+	}
+
+	cmdID := binary.LittleEndian.Uint16(data[4:])
+	textLen := binary.LittleEndian.Uint16(data[6:])
+
+	if cmdID != KCmdAuthResult {
+		return &AuthResponse{}, nil
+	}
+
+	if len(data) > 16 && textLen > 0 {
+		jsonData := data[16:]
+		for i := range jsonData {
+			if jsonData[i] == '{' {
+				var resp AuthResponse
+				if err := json.Unmarshal(jsonData[i:], &resp); err == nil {
+					if c.verbose {
+						fmt.Printf("[Wyze] parseK10003: parsed JSON\n")
+					}
+					return &resp, nil
+				}
+				break
+			}
+		}
+	}
+
+	return &AuthResponse{}, nil
+}
+
+func (c *Client) useDoorbellResolution() bool {
+	switch c.model {
+	case "WYZEDB3", "WVOD1", "HL_WCO2", "WYZEC1":
+		return true
+	}
+	return false
+}
+
+func (c *Client) hdFrameSize() uint8 {
+	if c.isFloodlight() {
+		return FrameSizeFloodlight
+	}
+	if c.is2K() {
+		return FrameSize2K
+	}
+	return FrameSize1080P
+}
+
+func (c *Client) is2K() bool {
+	switch c.model {
+	case "HL_CAM3P", "HL_PANP", "HL_CAM4", "HL_DB2", "HL_CFL2":
+		return true
+	}
+	return false
+}
+
+func (c *Client) isFloodlight() bool {
+	return c.model == "HL_CFL2"
+}
+
+func (c *Client) matchHL(expectCmd uint16) func([]byte) bool {
+	return func(data []byte) bool {
+		hlData := c.extractHL(data)
+		if hlData == nil {
+			return false
+		}
+		cmd, _, ok := tutk.ParseHL(hlData)
+		return ok && cmd == expectCmd
+	}
+}
+
+func (c *Client) extractHL(data []byte) []byte {
+	// Try offset 32 (magicIOCtrl, protoVersion)
+	if hlData := tutk.FindHL(data, 32); hlData != nil {
+		return hlData
+	}
+	// Try offset 36 (magicChannelMsg)
+	if len(data) >= 36 && data[16] == 0x00 {
+		return tutk.FindHL(data, 36)
+	}
+	return nil
+}
+
+const (
+	statusDefault byte = 1
+	statusENR16   byte = 3
+	statusENR32   byte = 6
+)
+
+func generateChallengeResponse(challengeBytes []byte, enr string, status byte) []byte {
+	var secretKey []byte
+
+	switch status {
+	case statusDefault:
+		secretKey = []byte("FFFFFFFFFFFFFFFF")
+	case statusENR16:
+		if len(enr) >= 16 {
+			secretKey = []byte(enr[:16])
+		} else {
+			secretKey = make([]byte, 16)
+			copy(secretKey, enr)
+		}
+	case statusENR32:
+		if len(enr) >= 16 {
+			firstKey := []byte(enr[:16])
+			challengeBytes = tutk.XXTEADecryptVar(challengeBytes, firstKey)
+		}
+		if len(enr) >= 32 {
+			secretKey = []byte(enr[16:32])
+		} else if len(enr) > 16 {
+			secretKey = make([]byte, 16)
+			copy(secretKey, []byte(enr[16:]))
+		} else {
+			secretKey = []byte("FFFFFFFFFFFFFFFF")
+		}
+	default:
+		secretKey = []byte("FFFFFFFFFFFFFFFF")
+	}
+
+	return tutk.XXTEADecryptVar(challengeBytes, secretKey)
+}
diff --git a/installs_on_host/go2rtc/pkg/wyze/cloud.go b/installs_on_host/go2rtc/pkg/wyze/cloud.go
new file mode 100644
index 0000000..17f914a
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/wyze/cloud.go
@@ -0,0 +1,337 @@
+package wyze
+
+import (
+	"crypto/md5"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+const (
+	baseURLAuth = "https://auth-prod.api.wyze.com"
+	baseURLAPI  = "https://api.wyzecam.com"
+	appName     = "com.hualai.WyzeCam"
+	appVersion  = "2.50.0"
+)
+
+type Cloud struct {
+	client      *http.Client
+	apiKey      string
+	keyID       string
+	accessToken string
+	phoneID     string
+	cameras     []*Camera
+}
+
+type Camera struct {
+	MAC          string `json:"mac"`
+	P2PID        string `json:"p2p_id"`
+	ENR          string `json:"enr"`
+	IP           string `json:"ip"`
+	Nickname     string `json:"nickname"`
+	ProductModel string `json:"product_model"`
+	ProductType  string `json:"product_type"`
+	DTLS         int    `json:"dtls"`
+	FirmwareVer  string `json:"firmware_ver"`
+	IsOnline     bool   `json:"is_online"`
+}
+
+type deviceListResponse struct {
+	Code string `json:"code"`
+	Msg  string `json:"msg"`
+	Data struct {
+		DeviceList []deviceInfo `json:"device_list"`
+	} `json:"data"`
+}
+
+type deviceInfo struct {
+	MAC          string       `json:"mac"`
+	ENR          string       `json:"enr"`
+	Nickname     string       `json:"nickname"`
+	ProductModel string       `json:"product_model"`
+	ProductType  string       `json:"product_type"`
+	FirmwareVer  string       `json:"firmware_ver"`
+	ConnState    int          `json:"conn_state"`
+	DeviceParams deviceParams `json:"device_params"`
+}
+
+type deviceParams struct {
+	P2PID   string `json:"p2p_id"`
+	P2PType int    `json:"p2p_type"`
+	IP      string `json:"ip"`
+	DTLS    int    `json:"dtls"`
+}
+
+type p2pInfoResponse struct {
+	Code string         `json:"code"`
+	Msg  string         `json:"msg"`
+	Data map[string]any `json:"data"`
+}
+
+type loginResponse struct {
+	AccessToken    string   `json:"access_token"`
+	RefreshToken   string   `json:"refresh_token"`
+	UserID         string   `json:"user_id"`
+	MFAOptions     []string `json:"mfa_options"`
+	SMSSessionID   string   `json:"sms_session_id"`
+	EmailSessionID string   `json:"email_session_id"`
+}
+
+func NewCloud(apiKey, keyID string) *Cloud {
+	return &Cloud{
+		client:  &http.Client{Timeout: 30 * time.Second},
+		phoneID: generatePhoneID(),
+		apiKey:  apiKey,
+		keyID:   keyID,
+	}
+}
+
+func (c *Cloud) Login(email, password string) error {
+	payload := map[string]string{
+		"email":    strings.TrimSpace(email),
+		"password": hashPassword(password),
+	}
+
+	jsonData, _ := json.Marshal(payload)
+
+	req, err := http.NewRequest("POST", baseURLAuth+"/api/user/login", strings.NewReader(string(jsonData)))
+	if err != nil {
+		return err
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Apikey", c.apiKey)
+	req.Header.Set("Keyid", c.keyID)
+	req.Header.Set("User-Agent", "go2rtc")
+
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	var errResp apiError
+	_ = json.Unmarshal(body, &errResp)
+	if errResp.hasError() {
+		return fmt.Errorf("wyze: login failed (code %s): %s", errResp.code(), errResp.message())
+	}
+
+	var result loginResponse
+	if err := json.Unmarshal(body, &result); err != nil {
+		return fmt.Errorf("wyze: failed to parse login response: %w", err)
+	}
+
+	if len(result.MFAOptions) > 0 {
+		return &AuthError{
+			Message:  "MFA required",
+			NeedsMFA: true,
+			MFAType:  strings.Join(result.MFAOptions, ","),
+		}
+	}
+
+	if result.AccessToken == "" {
+		return errors.New("wyze: no access token in response")
+	}
+
+	c.accessToken = result.AccessToken
+
+	return nil
+}
+
+func (c *Cloud) GetCameraList() ([]*Camera, error) {
+	payload := map[string]any{
+		"access_token":      c.accessToken,
+		"phone_id":          c.phoneID,
+		"app_name":          appName,
+		"app_ver":           appName + "___" + appVersion,
+		"app_version":       appVersion,
+		"phone_system_type": 1,
+		"sc":                "9f275790cab94a72bd206c8876429f3c",
+		"sv":                "9d74946e652647e9b6c9d59326aef104",
+		"ts":                time.Now().UnixMilli(),
+	}
+
+	jsonData, _ := json.Marshal(payload)
+
+	req, err := http.NewRequest("POST", baseURLAPI+"/app/v2/home_page/get_object_list", strings.NewReader(string(jsonData)))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	var result deviceListResponse
+	if err := json.Unmarshal(body, &result); err != nil {
+		return nil, fmt.Errorf("wyze: failed to parse device list: %w", err)
+	}
+
+	if result.Code != "1" {
+		return nil, fmt.Errorf("wyze: API error: %s - %s", result.Code, result.Msg)
+	}
+
+	c.cameras = nil
+	for _, dev := range result.Data.DeviceList {
+		if dev.ProductType != "Camera" {
+			continue
+		}
+		if dev.DeviceParams.IP == "" {
+			continue // skip cameras without IP (gwell protocol)
+		}
+
+		c.cameras = append(c.cameras, &Camera{
+			MAC:          dev.MAC,
+			P2PID:        dev.DeviceParams.P2PID,
+			ENR:          dev.ENR,
+			IP:           dev.DeviceParams.IP,
+			Nickname:     dev.Nickname,
+			ProductModel: dev.ProductModel,
+			ProductType:  dev.ProductType,
+			DTLS:         dev.DeviceParams.DTLS,
+			FirmwareVer:  dev.FirmwareVer,
+			IsOnline:     dev.ConnState == 1,
+		})
+	}
+
+	return c.cameras, nil
+}
+
+func (c *Cloud) GetCamera(id string) (*Camera, error) {
+	if c.cameras == nil {
+		if _, err := c.GetCameraList(); err != nil {
+			return nil, err
+		}
+	}
+
+	id = strings.ToUpper(id)
+	for _, cam := range c.cameras {
+		if strings.ToUpper(cam.MAC) == id || strings.EqualFold(cam.Nickname, id) {
+			return cam, nil
+		}
+	}
+
+	return nil, fmt.Errorf("wyze: camera not found: %s", id)
+}
+
+func (c *Cloud) GetP2PInfo(mac string) (map[string]any, error) {
+	payload := map[string]any{
+		"access_token":      c.accessToken,
+		"phone_id":          c.phoneID,
+		"device_mac":        mac,
+		"app_name":          appName,
+		"app_ver":           appName + "___" + appVersion,
+		"app_version":       appVersion,
+		"phone_system_type": 1,
+		"sc":                "9f275790cab94a72bd206c8876429f3c",
+		"sv":                "9d74946e652647e9b6c9d59326aef104",
+		"ts":                time.Now().UnixMilli(),
+	}
+
+	jsonData, _ := json.Marshal(payload)
+
+	req, err := http.NewRequest("POST", baseURLAPI+"/app/v2/device/get_iotc_info", strings.NewReader(string(jsonData)))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	var result p2pInfoResponse
+	if err := json.Unmarshal(body, &result); err != nil {
+		return nil, err
+	}
+
+	if result.Code != "1" {
+		return nil, fmt.Errorf("wyze: API error: %s - %s", result.Code, result.Msg)
+	}
+
+	return result.Data, nil
+}
+
+type apiError struct {
+	Code        string `json:"code"`
+	ErrorCode   int    `json:"errorCode"`
+	Msg         string `json:"msg"`
+	Description string `json:"description"`
+}
+
+func (e *apiError) hasError() bool {
+	if e.Code == "1" || e.Code == "0" {
+		return false
+	}
+	if e.Code == "" && e.ErrorCode == 0 {
+		return false
+	}
+	return e.Code != "" || e.ErrorCode != 0
+}
+
+func (e *apiError) message() string {
+	if e.Msg != "" {
+		return e.Msg
+	}
+	return e.Description
+}
+
+func (e *apiError) code() string {
+	if e.Code != "" {
+		return e.Code
+	}
+	return fmt.Sprintf("%d", e.ErrorCode)
+}
+
+type AuthError struct {
+	Message  string `json:"message"`
+	NeedsMFA bool   `json:"needs_mfa,omitempty"`
+	MFAType  string `json:"mfa_type,omitempty"`
+}
+
+func (e *AuthError) Error() string {
+	return e.Message
+}
+
+func generatePhoneID() string {
+	return core.RandString(16, 16) // 16 hex chars
+}
+
+func hashPassword(password string) string {
+	encoded := strings.TrimSpace(password)
+	if strings.HasPrefix(strings.ToLower(encoded), "md5:") {
+		return encoded[4:]
+	}
+	for range 3 {
+		hash := md5.Sum([]byte(encoded))
+		encoded = hex.EncodeToString(hash[:])
+	}
+	return encoded
+}
diff --git a/installs_on_host/go2rtc/pkg/wyze/producer.go b/installs_on_host/go2rtc/pkg/wyze/producer.go
new file mode 100644
index 0000000..16219c4
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/wyze/producer.go
@@ -0,0 +1,277 @@
+package wyze
+
+import (
+	"fmt"
+	"net/url"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/aac"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/h264/annexb"
+	"github.com/AlexxIT/go2rtc/pkg/h265"
+	"github.com/AlexxIT/go2rtc/pkg/tutk"
+	"github.com/pion/rtp"
+)
+
+type Producer struct {
+	core.Connection
+	client *Client
+	model  string
+}
+
+func NewProducer(rawURL string) (*Producer, error) {
+	client, err := Dial(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	u, _ := url.Parse(rawURL)
+	query := u.Query()
+
+	// 0 = HD (default), 1 = SD/360P, 2 = 720P, 3 = 2K, 4 = Floodlight
+	var quality byte
+	switch s := query.Get("subtype"); s {
+	case "", "hd":
+		quality = 0
+	case "sd":
+		quality = FrameSize360P
+	default:
+		quality = core.ParseByte(s)
+	}
+
+	medias, err := probe(client, quality)
+	if err != nil {
+		_ = client.Close()
+		return nil, err
+	}
+
+	prod := &Producer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "wyze",
+			Protocol:   client.Protocol(),
+			RemoteAddr: client.RemoteAddr().String(),
+			Source:     rawURL,
+			Medias:     medias,
+			Transport:  client,
+		},
+		client: client,
+		model:  query.Get("model"),
+	}
+
+	return prod, nil
+}
+
+func (p *Producer) Start() error {
+	for {
+		if p.client.verbose {
+			fmt.Println("[Wyze] Reading packet...")
+		}
+
+		_ = p.client.SetDeadline(time.Now().Add(core.ConnDeadline))
+		pkt, err := p.client.ReadPacket()
+		if err != nil {
+			return err
+		}
+		if pkt == nil {
+			continue
+		}
+
+		var name string
+		var pkt2 *core.Packet
+
+		switch codecID := pkt.Codec; codecID {
+		case tutk.CodecH264:
+			name = core.CodecH264
+			pkt2 = &core.Packet{
+				Header:  rtp.Header{SequenceNumber: uint16(pkt.FrameNo), Timestamp: pkt.Timestamp},
+				Payload: annexb.EncodeToAVCC(pkt.Payload),
+			}
+
+		case tutk.CodecH265:
+			name = core.CodecH265
+			pkt2 = &core.Packet{
+				Header:  rtp.Header{SequenceNumber: uint16(pkt.FrameNo), Timestamp: pkt.Timestamp},
+				Payload: annexb.EncodeToAVCC(pkt.Payload),
+			}
+
+		case tutk.CodecPCMU:
+			name = core.CodecPCMU
+			pkt2 = &core.Packet{
+				Header:  rtp.Header{Version: 2, Marker: true, SequenceNumber: uint16(pkt.FrameNo), Timestamp: pkt.Timestamp},
+				Payload: pkt.Payload,
+			}
+
+		case tutk.CodecPCMA:
+			name = core.CodecPCMA
+			pkt2 = &core.Packet{
+				Header:  rtp.Header{Version: 2, Marker: true, SequenceNumber: uint16(pkt.FrameNo), Timestamp: pkt.Timestamp},
+				Payload: pkt.Payload,
+			}
+
+		case tutk.CodecAACADTS, tutk.CodecAACAlt, tutk.CodecAACRaw, tutk.CodecAACLATM:
+			name = core.CodecAAC
+			payload := pkt.Payload
+			if aac.IsADTS(payload) {
+				payload = payload[aac.ADTSHeaderLen(payload):]
+			}
+			pkt2 = &core.Packet{
+				Header:  rtp.Header{Version: aac.RTPPacketVersionAAC, Marker: true, SequenceNumber: uint16(pkt.FrameNo), Timestamp: pkt.Timestamp},
+				Payload: payload,
+			}
+
+		case tutk.CodecOpus:
+			name = core.CodecOpus
+			pkt2 = &core.Packet{
+				Header:  rtp.Header{Version: 2, Marker: true, SequenceNumber: uint16(pkt.FrameNo), Timestamp: pkt.Timestamp},
+				Payload: pkt.Payload,
+			}
+
+		case tutk.CodecPCML:
+			name = core.CodecPCML
+			pkt2 = &core.Packet{
+				Header:  rtp.Header{Version: 2, Marker: true, SequenceNumber: uint16(pkt.FrameNo), Timestamp: pkt.Timestamp},
+				Payload: pkt.Payload,
+			}
+
+		case tutk.CodecMP3:
+			name = core.CodecMP3
+			pkt2 = &core.Packet{
+				Header:  rtp.Header{Version: 2, Marker: true, SequenceNumber: uint16(pkt.FrameNo), Timestamp: pkt.Timestamp},
+				Payload: pkt.Payload,
+			}
+
+		case tutk.CodecMJPEG:
+			name = core.CodecJPEG
+			pkt2 = &core.Packet{
+				Header:  rtp.Header{SequenceNumber: uint16(pkt.FrameNo), Timestamp: pkt.Timestamp},
+				Payload: pkt.Payload,
+			}
+
+		default:
+			continue
+		}
+
+		for _, recv := range p.Receivers {
+			if recv.Codec.Name == name {
+				recv.WriteRTP(pkt2)
+				break
+			}
+		}
+	}
+}
+
+func probe(client *Client, quality byte) ([]*core.Media, error) {
+	client.SetResolution(quality)
+	client.SetDeadline(time.Now().Add(core.ProbeTimeout))
+
+	var vcodec, acodec *core.Codec
+	var tutkAudioCodec byte
+
+	for {
+		if client.verbose {
+			fmt.Println("[Wyze] Probing for codecs...")
+		}
+
+		pkt, err := client.ReadPacket()
+		if err != nil {
+			return nil, fmt.Errorf("wyze: probe: %w", err)
+		}
+		if pkt == nil || len(pkt.Payload) < 5 {
+			continue
+		}
+
+		switch pkt.Codec {
+		case tutk.CodecH264:
+			if vcodec == nil {
+				buf := annexb.EncodeToAVCC(pkt.Payload)
+				if len(buf) >= 5 && h264.NALUType(buf) == h264.NALUTypeSPS {
+					vcodec = h264.AVCCToCodec(buf)
+				}
+			}
+		case tutk.CodecH265:
+			if vcodec == nil {
+				buf := annexb.EncodeToAVCC(pkt.Payload)
+				if len(buf) >= 5 && h265.NALUType(buf) == h265.NALUTypeVPS {
+					vcodec = h265.AVCCToCodec(buf)
+				}
+			}
+		case tutk.CodecPCMU:
+			if acodec == nil {
+				acodec = &core.Codec{Name: core.CodecPCMU, ClockRate: pkt.SampleRate, Channels: pkt.Channels}
+				tutkAudioCodec = pkt.Codec
+			}
+		case tutk.CodecPCMA:
+			if acodec == nil {
+				acodec = &core.Codec{Name: core.CodecPCMA, ClockRate: pkt.SampleRate, Channels: pkt.Channels}
+				tutkAudioCodec = pkt.Codec
+			}
+		case tutk.CodecAACAlt, tutk.CodecAACADTS, tutk.CodecAACRaw, tutk.CodecAACLATM:
+			if acodec == nil {
+				config := aac.EncodeConfig(aac.TypeAACLC, pkt.SampleRate, pkt.Channels, false)
+				acodec = aac.ConfigToCodec(config)
+				tutkAudioCodec = pkt.Codec
+			}
+		case tutk.CodecOpus:
+			if acodec == nil {
+				acodec = &core.Codec{Name: core.CodecOpus, ClockRate: 48000, Channels: 2}
+				tutkAudioCodec = pkt.Codec
+			}
+		case tutk.CodecPCML:
+			if acodec == nil {
+				acodec = &core.Codec{Name: core.CodecPCML, ClockRate: pkt.SampleRate, Channels: pkt.Channels}
+				tutkAudioCodec = pkt.Codec
+			}
+		case tutk.CodecMP3:
+			if acodec == nil {
+				acodec = &core.Codec{Name: core.CodecMP3, ClockRate: pkt.SampleRate, Channels: pkt.Channels}
+				tutkAudioCodec = pkt.Codec
+			}
+		case tutk.CodecMJPEG:
+			if vcodec == nil {
+				vcodec = &core.Codec{Name: core.CodecJPEG, ClockRate: 90000, PayloadType: core.PayloadTypeRAW}
+			}
+		}
+
+		if vcodec != nil && (acodec != nil || !client.SupportsAudio()) {
+			break
+		}
+	}
+
+	_ = client.SetDeadline(time.Time{})
+
+	medias := []*core.Media{
+		{
+			Kind:      core.KindVideo,
+			Direction: core.DirectionRecvonly,
+			Codecs:    []*core.Codec{vcodec},
+		},
+	}
+
+	if acodec != nil {
+		medias = append(medias, &core.Media{
+			Kind:      core.KindAudio,
+			Direction: core.DirectionRecvonly,
+			Codecs:    []*core.Codec{acodec},
+		})
+
+		if client.SupportsIntercom() {
+			client.SetBackchannelCodec(tutkAudioCodec, acodec.ClockRate, uint8(acodec.Channels))
+			medias = append(medias, &core.Media{
+				Kind:      core.KindAudio,
+				Direction: core.DirectionSendonly,
+				Codecs:    []*core.Codec{acodec.Clone()},
+			})
+		}
+	}
+
+	if client.verbose {
+		fmt.Printf("[Wyze] Probed codecs: video=%s audio=%s\n", vcodec.Name, acodec.Name)
+		if client.SupportsIntercom() {
+			fmt.Printf("[Wyze] Intercom supported, audio send codec=%s\n", acodec.Name)
+		}
+	}
+
+	return medias, nil
+}
diff --git a/installs_on_host/go2rtc/pkg/xiaomi/cloud.go b/installs_on_host/go2rtc/pkg/xiaomi/cloud.go
new file mode 100644
index 0000000..0dcfd24
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/xiaomi/cloud.go
@@ -0,0 +1,568 @@
+package xiaomi
+
+import (
+	"bytes"
+	"crypto/md5"
+	"crypto/rand"
+	"crypto/rc4"
+	"crypto/sha1"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+type Cloud struct {
+	client *http.Client
+
+	sid       string
+	cookies   string // for auth
+	ssecurity []byte // for encryption
+
+	userID    string
+	passToken string
+
+	auth map[string]string
+}
+
+func NewCloud(sid string) *Cloud {
+	return &Cloud{
+		client: &http.Client{Timeout: 15 * time.Second},
+		sid:    sid,
+	}
+}
+
+func (c *Cloud) Login(username, password string) error {
+	res, err := c.client.Get("https://account.xiaomi.com/pass/serviceLogin?_json=true&sid=" + c.sid)
+	if err != nil {
+		return err
+	}
+
+	var v1 struct {
+		Qs       string `json:"qs"`
+		Sign     string `json:"_sign"`
+		Sid      string `json:"sid"`
+		Callback string `json:"callback"`
+	}
+	if _, err = readLoginResponse(res.Body, &v1); err != nil {
+		return err
+	}
+
+	hash := fmt.Sprintf("%X", md5.Sum([]byte(password)))
+
+	form := url.Values{
+		"_json":    {"true"},
+		"hash":     {hash},
+		"sid":      {v1.Sid},
+		"callback": {v1.Callback},
+		"_sign":    {v1.Sign},
+		"qs":       {v1.Qs},
+		"user":     {username},
+	}
+	cookies := "deviceId=" + core.RandString(16, 62)
+
+	// login after captcha
+	if c.auth != nil && c.auth["captcha_code"] != "" {
+		form.Set("captCode", c.auth["captcha_code"])
+		cookies += "; ick=" + c.auth["ick"]
+	}
+
+	req := Request{
+		Method:     "POST",
+		URL:        "https://account.xiaomi.com/pass/serviceLoginAuth2",
+		Body:       form,
+		RawCookies: cookies,
+	}.Encode()
+
+	res, err = c.client.Do(req)
+	if err != nil {
+		return err
+	}
+
+	var v2 struct {
+		Ssecurity []byte `json:"ssecurity"`
+		PassToken string `json:"passToken"`
+		Location  string `json:"location"`
+
+		CaptchaURL      string `json:"captchaURL"`
+		NotificationURL string `json:"notificationUrl"`
+	}
+	body, err := readLoginResponse(res.Body, &v2)
+	if err != nil {
+		return err
+	}
+
+	// save auth for two-step verification
+	c.auth = map[string]string{
+		"username": username,
+		"password": password,
+	}
+
+	if v2.CaptchaURL != "" {
+		return c.getCaptcha(v2.CaptchaURL)
+	}
+
+	if v2.NotificationURL != "" {
+		return c.authStart(v2.NotificationURL)
+	}
+
+	if v2.Location == "" {
+		return fmt.Errorf("xiaomi: %s", body)
+	}
+
+	c.auth = nil
+	c.ssecurity = v2.Ssecurity
+	c.passToken = v2.PassToken
+
+	return c.finishAuth(v2.Location)
+}
+
+func (c *Cloud) LoginWithCaptcha(captcha string) error {
+	if c.auth == nil || c.auth["ick"] == "" {
+		panic("wrong login step")
+	}
+
+	c.auth["captcha_code"] = captcha
+
+	// check if captcha after verify
+	if c.auth["flag"] != "" {
+		return c.sendTicket()
+	}
+
+	return c.Login(c.auth["username"], c.auth["password"])
+}
+
+func (c *Cloud) LoginWithVerify(ticket string) error {
+	if c.auth == nil || c.auth["flag"] == "" {
+		panic("wrong login step")
+	}
+
+	req := Request{
+		Method:     "POST",
+		URL:        "https://account.xiaomi.com/identity/auth/verify" + c.verifyName(),
+		RawParams:  "_flag" + c.auth["flag"] + "&ticket=" + ticket + "&trust=false&_json=true",
+		RawCookies: "identity_session=" + c.auth["identity_session"],
+	}.Encode()
+
+	res, err := c.client.Do(req)
+	if err != nil {
+		return err
+	}
+
+	var v1 struct {
+		Location string `json:"location"`
+	}
+	body, err := readLoginResponse(res.Body, &v1)
+	if err != nil {
+		return err
+	}
+	if v1.Location == "" {
+		return fmt.Errorf("xiaomi: %s", body)
+	}
+
+	return c.finishAuth(v1.Location)
+}
+
+func (c *Cloud) getCaptcha(captchaURL string) error {
+	res, err := c.client.Get("https://account.xiaomi.com" + captchaURL)
+	if err != nil {
+		return err
+	}
+	defer res.Body.Close()
+
+	body, err := io.ReadAll(res.Body)
+	if err != nil {
+		return err
+	}
+
+	c.auth["ick"] = findCookie(res, "ick")
+
+	return &LoginError{
+		Captcha: body,
+	}
+}
+
+func (c *Cloud) authStart(notificationURL string) error {
+	rawURL := strings.Replace(notificationURL, "/fe/service/identity/authStart", "/identity/list", 1)
+	res, err := c.client.Get(rawURL)
+	if err != nil {
+		return err
+	}
+
+	var v1 struct {
+		Code int `json:"code"`
+		Flag int `json:"flag"`
+	}
+	if _, err = readLoginResponse(res.Body, &v1); err != nil {
+		return err
+	}
+
+	c.auth["flag"] = strconv.Itoa(v1.Flag)
+	c.auth["identity_session"] = findCookie(res, "identity_session")
+
+	return c.sendTicket()
+}
+
+func findCookie(res *http.Response, name string) string {
+	for _, cookie := range res.Cookies() {
+		if cookie.Name == name {
+			return cookie.Value
+		}
+	}
+	return ""
+}
+
+func (c *Cloud) verifyName() string {
+	switch c.auth["flag"] {
+	case "4":
+		return "Phone"
+	case "8":
+		return "Email"
+	}
+	return ""
+}
+
+func (c *Cloud) sendTicket() error {
+	name := c.verifyName()
+	cookies := "identity_session=" + c.auth["identity_session"]
+
+	req := Request{
+		URL:        "https://account.xiaomi.com/identity/auth/verify" + name,
+		RawParams:  "_flag=" + c.auth["flag"] + "&_json=true",
+		RawCookies: cookies,
+	}.Encode()
+
+	res, err := c.client.Do(req)
+	if err != nil {
+		return err
+	}
+
+	var v1 struct {
+		Code        int    `json:"code"`
+		MaskedPhone string `json:"maskedPhone"`
+		MaskedEmail string `json:"maskedEmail"`
+	}
+	if _, err = readLoginResponse(res.Body, &v1); err != nil {
+		return err
+	}
+
+	// verify after captcha
+	captCode := c.auth["captcha_code"]
+	if captCode != "" {
+		cookies += "; ick=" + c.auth["ick"]
+	}
+
+	form := url.Values{
+		"_json": {"true"},
+		"icode": {captCode},
+		"retry": {"0"},
+	}
+
+	req = Request{
+		Method:     "POST",
+		URL:        "https://account.xiaomi.com/identity/auth/send" + name + "Ticket",
+		Body:       form,
+		RawCookies: cookies,
+	}.Encode()
+
+	res, err = c.client.Do(req)
+	if err != nil {
+		return err
+	}
+
+	var v2 struct {
+		Code       int    `json:"code"`
+		CaptchaURL string `json:"captchaURL"`
+	}
+	body, err := readLoginResponse(res.Body, &v2)
+	if err != nil {
+		return err
+	}
+
+	if v2.CaptchaURL != "" {
+		return c.getCaptcha(v2.CaptchaURL)
+	}
+
+	if v2.Code != 0 {
+		return fmt.Errorf("xiaomi: %s", body)
+	}
+
+	return &LoginError{
+		VerifyPhone: v1.MaskedPhone,
+		VerifyEmail: v1.MaskedEmail,
+	}
+}
+
+type LoginError struct {
+	Captcha     []byte `json:"captcha,omitempty"`
+	VerifyPhone string `json:"verify_phone,omitempty"`
+	VerifyEmail string `json:"verify_email,omitempty"`
+}
+
+func (l *LoginError) Error() string {
+	return ""
+}
+
+func (c *Cloud) finishAuth(location string) error {
+	res, err := c.client.Get(location)
+	if err != nil {
+		return err
+	}
+	defer res.Body.Close()
+
+	// LoginWithVerify
+	//   - userId, cUserId, serviceToken from cookies
+	//   - passToken from redirect cookies
+	//   - ssecurity from extra header
+	// LoginWithToken
+	//   - userId, cUserId, serviceToken from cookies
+	var cUserId, serviceToken string
+
+	for res != nil {
+		for _, cookie := range res.Cookies() {
+			switch cookie.Name {
+			case "userId":
+				c.userID = cookie.Value
+			case "cUserId":
+				cUserId = cookie.Value
+			case "serviceToken":
+				serviceToken = cookie.Value
+			case "passToken":
+				c.passToken = cookie.Value
+			}
+		}
+
+		if s := res.Header.Get("Extension-Pragma"); s != "" {
+			var v1 struct {
+				Ssecurity []byte `json:"ssecurity"`
+			}
+			if err = json.Unmarshal([]byte(s), &v1); err != nil {
+				return err
+			}
+			c.ssecurity = v1.Ssecurity
+		}
+
+		res = res.Request.Response
+	}
+
+	c.cookies = fmt.Sprintf("userId=%s; cUserId=%s; serviceToken=%s", c.userID, cUserId, serviceToken)
+
+	return nil
+}
+
+func (c *Cloud) LoginWithToken(userID, passToken string) error {
+	req, err := http.NewRequest("GET", "https://account.xiaomi.com/pass/serviceLogin?_json=true&sid="+c.sid, nil)
+	if err != nil {
+		return err
+	}
+
+	req.Header.Set("Cookie", fmt.Sprintf("userId=%s; passToken=%s", userID, passToken))
+
+	res, err := c.client.Do(req)
+	if err != nil {
+		return err
+	}
+
+	var v1 struct {
+		Ssecurity []byte `json:"ssecurity"`
+		PassToken string `json:"passToken"`
+		Location  string `json:"location"`
+	}
+	if _, err = readLoginResponse(res.Body, &v1); err != nil {
+		return err
+	}
+
+	c.ssecurity = v1.Ssecurity
+	c.passToken = v1.PassToken
+
+	return c.finishAuth(v1.Location)
+}
+
+func (c *Cloud) UserToken() (string, string) {
+	return c.userID, c.passToken
+}
+
+func (c *Cloud) Request(baseURL, apiURL, params string, headers map[string]string) ([]byte, error) {
+	form := url.Values{"data": {params}}
+
+	nonce := genNonce()
+	signedNonce := genSignedNonce(c.ssecurity, nonce)
+
+	// 1. gen hash for data param
+	form.Set("rc4_hash__", genSignature64("POST", apiURL, form, signedNonce))
+
+	// 2. encrypt data and hash params
+	for _, v := range form {
+		ciphertext, err := crypt(signedNonce, []byte(v[0]))
+		if err != nil {
+			return nil, err
+		}
+		v[0] = base64.StdEncoding.EncodeToString(ciphertext)
+	}
+
+	// 3. add signature for encrypted data and hash params
+	form.Set("signature", genSignature64("POST", apiURL, form, signedNonce))
+
+	// 4. add nonce
+	form.Set("_nonce", base64.StdEncoding.EncodeToString(nonce))
+
+	req, err := http.NewRequest("POST", baseURL+apiURL, strings.NewReader(form.Encode()))
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Set("Cookie", c.cookies)
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+	for k, v := range headers {
+		req.Header.Set(k, v)
+	}
+
+	res, err := c.client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != http.StatusOK {
+		return nil, errors.New(res.Status)
+	}
+
+	body, err := io.ReadAll(res.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	ciphertext, err := base64.StdEncoding.DecodeString(string(body))
+	if err != nil {
+		return nil, err
+	}
+
+	plaintext, err := crypt(signedNonce, ciphertext)
+	if err != nil {
+		return nil, err
+	}
+
+	var res1 struct {
+		Code    int             `json:"code"`
+		Message string          `json:"message"`
+		Result  json.RawMessage `json:"result"`
+	}
+	if err = json.Unmarshal(plaintext, &res1); err != nil {
+		return nil, err
+	}
+
+	if res1.Code != 0 {
+		return nil, errors.New("xiaomi: " + res1.Message)
+	}
+
+	return res1.Result, nil
+}
+
+func readLoginResponse(rc io.ReadCloser, v any) ([]byte, error) {
+	defer rc.Close()
+
+	body, err := io.ReadAll(rc)
+	if err != nil {
+		return nil, err
+	}
+
+	body, ok := bytes.CutPrefix(body, []byte("&&&START&&&"))
+	if !ok {
+		return nil, fmt.Errorf("xiaomi: %s", body)
+	}
+
+	return body, json.Unmarshal(body, &v)
+}
+
+func genNonce() []byte {
+	ts := time.Now().Unix() / 60
+
+	nonce := make([]byte, 12)
+	_, _ = rand.Read(nonce[:8])
+	binary.BigEndian.PutUint32(nonce[8:], uint32(ts))
+	return nonce
+}
+
+func genSignedNonce(ssecurity, nonce []byte) []byte {
+	hasher := sha256.New()
+	hasher.Write(ssecurity)
+	hasher.Write(nonce)
+	return hasher.Sum(nil)
+}
+
+func crypt(key, plaintext []byte) ([]byte, error) {
+	cipher, err := rc4.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+
+	tmp := make([]byte, 1024)
+	cipher.XORKeyStream(tmp, tmp)
+
+	ciphertext := make([]byte, len(plaintext))
+	cipher.XORKeyStream(ciphertext, plaintext)
+
+	return ciphertext, nil
+}
+
+func genSignature64(method, path string, values url.Values, signedNonce []byte) string {
+	s := method + "&" + path + "&data=" + values.Get("data")
+	if values.Has("rc4_hash__") {
+		s += "&rc4_hash__=" + values.Get("rc4_hash__")
+	}
+	s += "&" + base64.StdEncoding.EncodeToString(signedNonce)
+
+	hasher := sha1.New()
+	hasher.Write([]byte(s))
+	signature := hasher.Sum(nil)
+
+	return base64.StdEncoding.EncodeToString(signature)
+}
+
+type Request struct {
+	Method     string
+	URL        string
+	RawParams  string
+	Body       url.Values
+	Headers    url.Values
+	RawCookies string
+}
+
+func (r Request) Encode() *http.Request {
+	if r.RawParams != "" {
+		r.URL += "?" + r.RawParams
+	}
+
+	var body io.Reader
+	if r.Body != nil {
+		body = strings.NewReader(r.Body.Encode())
+	}
+
+	req, err := http.NewRequest(r.Method, r.URL, body)
+	if err != nil {
+		return nil
+	}
+
+	if r.Headers != nil {
+		req.Header = http.Header(r.Headers)
+	}
+	if r.Body != nil {
+		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	}
+	if r.RawCookies != "" {
+		req.Header.Set("Cookie", r.RawCookies)
+	}
+
+	return req
+}
diff --git a/installs_on_host/go2rtc/pkg/xiaomi/crypto/crypto.go b/installs_on_host/go2rtc/pkg/xiaomi/crypto/crypto.go
new file mode 100644
index 0000000..16d6d1b
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/xiaomi/crypto/crypto.go
@@ -0,0 +1,68 @@
+package crypto
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+
+	"golang.org/x/crypto/chacha20"
+	"golang.org/x/crypto/nacl/box"
+)
+
+func GenerateKey() ([]byte, []byte, error) {
+	public, private, err := box.GenerateKey(rand.Reader)
+	if err != nil {
+		return nil, nil, err
+	}
+	return public[:], private[:], err
+}
+
+func CalcSharedKey(devicePublicB64, clientPrivateB64 string) ([]byte, error) {
+	var sharedKey, publicKey, privateKey [32]byte
+	if _, err := hex.Decode(publicKey[:], []byte(devicePublicB64)); err != nil {
+		return nil, err
+	}
+	if _, err := hex.Decode(privateKey[:], []byte(clientPrivateB64)); err != nil {
+		return nil, err
+	}
+	box.Precompute(&sharedKey, &publicKey, &privateKey)
+	return sharedKey[:], nil
+}
+
+func Encode(src, key32 []byte) ([]byte, error) {
+	dst := make([]byte, len(src)+8)
+
+	if _, err := rand.Read(dst[:8]); err != nil {
+		return nil, err
+	}
+
+	nonce12 := make([]byte, 12)
+	copy(nonce12[4:], dst[:8])
+
+	c, err := chacha20.NewUnauthenticatedCipher(key32, nonce12)
+	if err != nil {
+		return nil, err
+	}
+
+	c.XORKeyStream(dst[8:], src)
+
+	return dst, nil
+}
+
+func Decode(src, key32 []byte) ([]byte, error) {
+	return DecodeNonce(src[8:], src[:8], key32)
+}
+
+func DecodeNonce(src, nonce8, key32 []byte) ([]byte, error) {
+	nonce12 := make([]byte, 12)
+	copy(nonce12[4:], nonce8)
+
+	c, err := chacha20.NewUnauthenticatedCipher(key32, nonce12)
+	if err != nil {
+		return nil, err
+	}
+
+	dst := make([]byte, len(src))
+	c.XORKeyStream(dst, src)
+
+	return dst, nil
+}
diff --git a/installs_on_host/go2rtc/pkg/xiaomi/legacy/client.go b/installs_on_host/go2rtc/pkg/xiaomi/legacy/client.go
new file mode 100644
index 0000000..57bd0a0
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/xiaomi/legacy/client.go
@@ -0,0 +1,271 @@
+package legacy
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"net/url"
+
+	"github.com/AlexxIT/go2rtc/pkg/tutk"
+	"github.com/AlexxIT/go2rtc/pkg/xiaomi/crypto"
+)
+
+func NewClient(rawURL string) (*Client, error) {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	query := u.Query()
+	model := query.Get("model")
+
+	var username, password string
+	var key []byte
+
+	if query.Has("sign") {
+		// Legacy with encryption
+		key, err = crypto.CalcSharedKey(query.Get("device_public"), query.Get("client_private"))
+		if err != nil {
+			return nil, err
+		}
+
+		username = fmt.Sprintf(
+			`{"public_key":"%s","sign":"%s","account":"admin"}`,
+			query.Get("client_public"), query.Get("sign"),
+		)
+	} else if model == ModelMijia || model == ModelXiaobai {
+		username = "admin"
+		password = query.Get("password")
+	} else if model == ModelDafang || model == ModelXiaofang {
+		username = "admin"
+	} else {
+		return nil, fmt.Errorf("xiaomi: unsupported model: %s", model)
+	}
+
+	conn, err := tutk.Dial(u.Host, query.Get("uid"), username, password)
+	if err != nil {
+		return nil, err
+	}
+
+	if model == ModelDafang || model == ModelXiaofang {
+		err = xiaofangLogin(conn, query.Get("password"))
+		if err != nil {
+			_ = conn.Close()
+			return nil, err
+		}
+	}
+
+	c := &Client{
+		Conn:  conn,
+		key:   key,
+		model: model,
+	}
+
+	return c, nil
+}
+
+func xiaofangLogin(conn *tutk.Conn, password string) error {
+	data := tutk.ICAM(0x0400be) // ask login
+	if err := conn.WriteCommand(0x0100, data); err != nil {
+		return err
+	}
+
+	_, data, err := conn.ReadCommand() // login request
+	if err != nil {
+		return err
+	}
+
+	enc := data[24:] // data[23] == 3
+	tutk.XXTEADecrypt(enc, enc, []byte(password))
+
+	enc = append(enc, 0, 0, 0, 0, 1, 1, 1)
+	data = tutk.ICAM(0x0400c0, enc...) // login response
+	if err = conn.WriteCommand(0x0100, data); err != nil {
+		return err
+	}
+
+	_, data, err = conn.ReadCommand()
+	return err
+}
+
+type Client struct {
+	*tutk.Conn
+	key   []byte
+	model string
+}
+
+func (c *Client) Version() string {
+	return fmt.Sprintf("%s (%s)", c.Conn.Version(), c.model)
+}
+
+func (c *Client) ReadPacket() (hdr, payload []byte, err error) {
+	hdr, payload, err = c.Conn.ReadPacket()
+	if err != nil {
+		return
+	}
+	if c.key != nil {
+		if c.model == ModelAqaraG2 && hdr[0] == tutk.CodecH265 {
+			payload, err = DecodeVideo(payload, c.key)
+		} else {
+			// ModelAqaraG2: audio AAC
+			// ModelIMILABA1: video HEVC, audio PCMA
+			payload, err = crypto.Decode(payload, c.key)
+		}
+	}
+	return
+}
+
+const (
+	cmdVideoStart    = 0x01ff
+	cmdVideoStop     = 0x02ff
+	cmdAudioStart    = 0x0300
+	cmdAudioStop     = 0x0301
+	cmdStreamCtrlReq = 0x0320
+)
+
+func (c *Client) WriteCommandJSON(ctrlType uint32, format string, a ...any) error {
+	if len(a) > 0 {
+		format = fmt.Sprintf(format, a...)
+	}
+	return c.WriteCommand(ctrlType, []byte(format))
+}
+
+func (c *Client) StartMedia(video, audio string) error {
+	switch c.model {
+	case ModelAqaraG2:
+		// 0 - 1920x1080, 1 - 1280x720, 2 - ?
+		switch video {
+		case "", "fhd":
+			video = "0"
+		case "hd":
+			video = "1"
+		case "sd":
+			video = "2"
+		}
+
+		return errors.Join(
+			c.WriteCommandJSON(cmdVideoStart, `{}`),
+			c.WriteCommandJSON(0x0605, `{"channel":%s}`, video),
+			c.WriteCommandJSON(0x0704, `{}`), // don't know why
+		)
+
+	case ModelIMILABA1, ModelMijia:
+		// 0 - auto, 1 - low, 3 - hd
+		switch video {
+		case "", "hd":
+			video = "3"
+		case "sd":
+			video = "1" // 2 is also low quality
+		case "auto":
+			video = "0"
+		}
+
+		// quality after start
+		return errors.Join(
+			c.WriteCommandJSON(cmdAudioStart, `{}`),
+			c.WriteCommandJSON(cmdVideoStart, `{}`),
+			c.WriteCommandJSON(cmdStreamCtrlReq, `{"videoquality":%s}`, video),
+		)
+
+	case ModelXiaobai:
+		// 00030000 7b7d  audio on
+		// 01030000 7b7d  audio off
+		// 20030000 0000000001000000  fhd (1920x1080)
+		// 20030000 0000000002000000  hd (1280x720)
+		// 20030000 0000000004000000  low (640x360)
+		// 20030000 00000000ff000000  auto (1920x1080)
+		// ff010000 7b7d  video tart
+		// ff020000 7b7d  video stop
+
+		var b byte
+		switch video {
+		case "", "fhd":
+			b = 1
+		case "hd":
+			b = 2
+		case "sd":
+			b = 4
+		case "auto":
+			b = 0xff
+		}
+
+		// quality before start
+		return errors.Join(
+			c.WriteCommandJSON(cmdAudioStart, `{}`),
+			c.WriteCommand(cmdStreamCtrlReq, []byte{0, 0, 0, 0, b, 0, 0, 0}),
+			c.WriteCommandJSON(cmdVideoStart, `{}`),
+		)
+
+	case ModelDafang, ModelXiaofang:
+		// 00010000 4943414d 95010400000000000000000600000000000000d20400005a07 - 90k bitrate
+		// 00010000 4943414d 95010400000000000000000600000000000000d20400001e07 - 30k bitrate
+		//var b byte
+		//switch video {
+		//case "", "hd":
+		//	b = 0x5a // bitrate 90k
+		//case "sd":
+		//	b = 0x1e // bitrate 30k
+		//}
+		//data := tutk.ICAM(0x040195, 0xd2, 4, 0, 0, b, 7)
+		//if err := c.WriteCommand(0x100, data); err != nil {
+		//	return err
+		//}
+		return nil
+	}
+
+	return fmt.Errorf("xiaomi: unsupported model: %s", c.model)
+}
+
+func (c *Client) StopMedia() error {
+	return errors.Join(
+		c.WriteCommandJSON(cmdVideoStop, `{}`),
+		c.WriteCommand(cmdVideoStop, make([]byte, 8)),
+	)
+}
+
+func DecodeVideo(data, key []byte) ([]byte, error) {
+	if string(data[:4]) == "\x00\x00\x00\x01" || data[8] == 0 {
+		return data, nil
+	}
+
+	if data[8] != 1 {
+		// Support could be added, but I haven't seen such cameras.
+		return nil, fmt.Errorf("xiaomi: unsupported encryption")
+	}
+
+	nonce8 := data[:8]
+	i1 := binary.LittleEndian.Uint32(data[9:])
+	i2 := binary.LittleEndian.Uint32(data[13:])
+	data = data[17:]
+	src := data[i1 : i1+i2]
+
+	for i := 32; i+16 < len(src); i += 160 {
+		dst, err := crypto.DecodeNonce(src[i:i+16], nonce8, key)
+		if err != nil {
+			return nil, err
+		}
+		copy(src[i:], dst) // copy result in same place
+	}
+
+	return data, nil
+}
+
+const (
+	ModelAqaraG2  = "lumi.camera.gwagl01"
+	ModelIMILABA1 = "chuangmi.camera.ipc019e"
+	ModelLoockV1  = "loock.cateye.v01"
+	ModelXiaobai  = "chuangmi.camera.xiaobai"
+	ModelXiaofang = "isa.camera.isc5"
+	// ModelMijia support miss format for new fw and legacy format for old fw
+	ModelMijia = "chuangmi.camera.v2"
+	// ModelDafang support miss format for new fw and legacy format for old fw
+	ModelDafang = "isa.camera.df3"
+)
+
+func Supported(model string) bool {
+	switch model {
+	case ModelAqaraG2, ModelIMILABA1, ModelLoockV1, ModelXiaobai, ModelXiaofang:
+		return true
+	}
+	return false
+}
diff --git a/installs_on_host/go2rtc/pkg/xiaomi/legacy/producer.go b/installs_on_host/go2rtc/pkg/xiaomi/legacy/producer.go
new file mode 100644
index 0000000..92375fa
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/xiaomi/legacy/producer.go
@@ -0,0 +1,216 @@
+package legacy
+
+import (
+	"net/url"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/aac"
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/h264/annexb"
+	"github.com/AlexxIT/go2rtc/pkg/h265"
+	"github.com/AlexxIT/go2rtc/pkg/tutk"
+	"github.com/pion/rtp"
+)
+
+func Dial(rawURL string) (*Producer, error) {
+	client, err := NewClient(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	u, _ := url.Parse(rawURL)
+	query := u.Query()
+
+	err = client.StartMedia(query.Get("subtype"), "")
+	if err != nil {
+		_ = client.Close()
+		return nil, err
+	}
+
+	medias, err := probe(client)
+	if err != nil {
+		_ = client.Close()
+		return nil, err
+	}
+
+	c := &Producer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "xiaomi/legacy",
+			Protocol:   "tutk+udp",
+			RemoteAddr: client.RemoteAddr().String(),
+			UserAgent:  client.Version(),
+			Medias:     medias,
+			Transport:  client,
+		},
+		client: client,
+	}
+	return c, nil
+}
+
+type Producer struct {
+	core.Connection
+	client *Client
+}
+
+const codecXiaobaiPCMA = 1 // chuangmi.camera.xiaobai
+
+func probe(client *Client) ([]*core.Media, error) {
+	_ = client.SetDeadline(time.Now().Add(15 * time.Second))
+
+	var vcodec, acodec *core.Codec
+
+	for {
+		// 0   5000      codec
+		// 2   0000      codec params
+		// 4   01        active clients
+		// 5   34        unknown const
+		// 6   0600      unknown seq(s)
+		// 8   80026801  unknown fixed
+		// 12  ed8d5c69  time in sec
+		// 16  4c03      time in 1/1000
+		// 18  0000
+		hdr, payload, err := client.ReadPacket()
+		if err != nil {
+			return nil, err
+		}
+
+		switch codec := hdr[0]; codec {
+		case tutk.CodecH264, tutk.CodecH265:
+			if vcodec == nil {
+				avcc := annexb.EncodeToAVCC(payload)
+				if codec == tutk.CodecH264 {
+					if h264.NALUType(avcc) == h264.NALUTypeSPS {
+						vcodec = h264.AVCCToCodec(avcc)
+					}
+				} else {
+					if h265.NALUType(avcc) == h265.NALUTypeVPS {
+						vcodec = h265.AVCCToCodec(avcc)
+					}
+				}
+			}
+		case tutk.CodecPCMA, codecXiaobaiPCMA:
+			if acodec == nil {
+				acodec = &core.Codec{Name: core.CodecPCMA, ClockRate: 8000}
+			}
+		case tutk.CodecPCML:
+			if acodec == nil {
+				acodec = &core.Codec{Name: core.CodecPCML, ClockRate: 8000}
+			}
+		case tutk.CodecAACLATM:
+			if acodec == nil {
+				acodec = aac.ADTSToCodec(payload)
+				if acodec != nil {
+					acodec.PayloadType = core.PayloadTypeRAW
+				}
+			}
+		}
+
+		if vcodec != nil && acodec != nil {
+			break
+		}
+	}
+
+	medias := []*core.Media{
+		{
+			Kind:      core.KindVideo,
+			Direction: core.DirectionRecvonly,
+			Codecs:    []*core.Codec{vcodec},
+		},
+		{
+			Kind:      core.KindAudio,
+			Direction: core.DirectionRecvonly,
+			Codecs:    []*core.Codec{acodec},
+		},
+	}
+	return medias, nil
+}
+
+func (c *Producer) Protocol() string {
+	return "tutk+udp"
+}
+
+func (c *Producer) Start() error {
+	var audioTS uint32
+	var videoSeq, audioSeq uint16
+
+	for {
+		_ = c.client.SetDeadline(time.Now().Add(5 * time.Second))
+		hdr, payload, err := c.client.ReadPacket()
+		if err != nil {
+			return err
+		}
+
+		n := len(payload)
+		c.Recv += n
+
+		// TODO: rewrite this
+		var name string
+		var pkt *core.Packet
+
+		switch codec := hdr[0]; codec {
+		case tutk.CodecH264, tutk.CodecH265:
+			pkt = &core.Packet{
+				Header: rtp.Header{
+					SequenceNumber: videoSeq,
+					Timestamp:      core.Now90000(),
+				},
+				Payload: annexb.EncodeToAVCC(payload),
+			}
+			videoSeq++
+
+			if codec == tutk.CodecH264 {
+				name = core.CodecH264
+			} else {
+				name = core.CodecH265
+			}
+
+		case tutk.CodecPCMA, tutk.CodecPCML, codecXiaobaiPCMA:
+			pkt = &core.Packet{
+				Header: rtp.Header{
+					Version:        2,
+					Marker:         true,
+					SequenceNumber: audioSeq,
+					Timestamp:      audioTS,
+				},
+				Payload: payload,
+			}
+			audioSeq++
+
+			switch codec {
+			case tutk.CodecPCMA, codecXiaobaiPCMA:
+				name = core.CodecPCMA
+				audioTS += uint32(n)
+			case tutk.CodecPCML:
+				name = core.CodecPCML
+				audioTS += uint32(n / 2) // because 16bit
+			}
+
+		case tutk.CodecAACLATM:
+			pkt = &core.Packet{
+				Header: rtp.Header{
+					SequenceNumber: audioSeq,
+					Timestamp:      audioTS,
+				},
+				Payload: payload,
+			}
+			audioSeq++
+
+			name = core.CodecAAC
+			audioTS += 1024
+		}
+
+		for _, recv := range c.Receivers {
+			if recv.Codec.Name == name {
+				recv.WriteRTP(pkt)
+				break
+			}
+		}
+	}
+}
+
+func (c *Producer) Stop() error {
+	_ = c.client.StopMedia()
+	return c.Connection.Stop()
+}
diff --git a/installs_on_host/go2rtc/pkg/xiaomi/miss/backchannel.go b/installs_on_host/go2rtc/pkg/xiaomi/miss/backchannel.go
new file mode 100644
index 0000000..02ea3bb
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/xiaomi/miss/backchannel.go
@@ -0,0 +1,74 @@
+package miss
+
+import (
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/opus"
+	"github.com/AlexxIT/go2rtc/pkg/pcm"
+	"github.com/pion/rtp"
+)
+
+func (p *Producer) AddTrack(media *core.Media, _ *core.Codec, track *core.Receiver) error {
+	if err := p.client.StartSpeaker(); err != nil {
+		return err
+	}
+	// TODO: check this!!!
+	time.Sleep(time.Second)
+
+	sender := core.NewSender(media, track.Codec)
+
+	switch track.Codec.Name {
+	case core.CodecPCMA:
+		var buf []byte
+
+		if p.client.SpeakerCodec() == codecPCM {
+			dst := &core.Codec{Name: core.CodecPCML, ClockRate: 8000}
+			transcode := pcm.Transcode(dst, track.Codec)
+
+			sender.Handler = func(pkt *rtp.Packet) {
+				buf = append(buf, transcode(pkt.Payload)...)
+				const size = 2 * 8000 * 0.040 // 16bit 40ms
+				for len(buf) >= size {
+					p.Send += size
+					_ = p.client.WriteAudio(codecPCM, buf[:size])
+					buf = buf[size:]
+				}
+			}
+		} else {
+			sender.Handler = func(pkt *rtp.Packet) {
+				buf = append(buf, pkt.Payload...)
+				const size = 8000 * 0.040 // 8bit 40 ms
+				for len(buf) >= size {
+					p.Send += size
+					_ = p.client.WriteAudio(codecPCMA, buf[:size])
+					buf = buf[size:]
+				}
+			}
+		}
+	case core.CodecOpus:
+		if p.client.SpeakerCodec() == codecOPUS {
+			var buf []byte
+			sender.Handler = func(pkt *rtp.Packet) {
+				if buf == nil {
+					buf = pkt.Payload
+				} else {
+					// convert two 20ms to one 40ms
+					buf = opus.JoinFrames(buf, pkt.Payload)
+					p.Send += len(buf)
+					_ = p.client.WriteAudio(codecOPUS, buf)
+					buf = nil
+				}
+			}
+		} else {
+			sender.Handler = func(pkt *rtp.Packet) {
+				p.Send += len(pkt.Payload)
+				_ = p.client.WriteAudio(codecOPUS, pkt.Payload)
+			}
+		}
+	}
+
+	sender.HandleRTP(track)
+	p.Senders = append(p.Senders, sender)
+	return nil
+}
diff --git a/installs_on_host/go2rtc/pkg/xiaomi/miss/client.go b/installs_on_host/go2rtc/pkg/xiaomi/miss/client.go
new file mode 100644
index 0000000..3113632
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/xiaomi/miss/client.go
@@ -0,0 +1,338 @@
+package miss
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"net"
+	"net/url"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/tutk"
+	"github.com/AlexxIT/go2rtc/pkg/xiaomi/crypto"
+	"github.com/AlexxIT/go2rtc/pkg/xiaomi/miss/cs2"
+)
+
+const (
+	codecH264 = 4
+	codecH265 = 5
+	codecPCM  = 1024
+	codecPCMU = 1026
+	codecPCMA = 1027
+	codecOPUS = 1032
+)
+
+type Conn interface {
+	Protocol() string
+	Version() string
+	ReadCommand() (cmd uint32, data []byte, err error)
+	WriteCommand(cmd uint32, data []byte) error
+	ReadPacket() (hdr, payload []byte, err error)
+	WritePacket(hdr, payload []byte) error
+	RemoteAddr() net.Addr
+	SetDeadline(t time.Time) error
+	Close() error
+}
+
+func NewClient(rawURL string) (*Client, error) {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	// 1. Check if we can create shared key.
+	query := u.Query()
+	key, err := crypto.CalcSharedKey(query.Get("device_public"), query.Get("client_private"))
+	if err != nil {
+		return nil, err
+	}
+
+	model := query.Get("model")
+
+	// 2. Check if this vendor supported.
+	var conn Conn
+	switch s := query.Get("vendor"); s {
+	case "cs2":
+		conn, err = cs2.Dial(u.Host, query.Get("transport"))
+	case "tutk":
+		conn, err = tutk.Dial(u.Host, query.Get("uid"), "Miss", "client")
+	default:
+		err = fmt.Errorf("miss: unsupported vendor %s", s)
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	err = login(conn, query.Get("client_public"), query.Get("sign"))
+	if err != nil {
+		_ = conn.Close()
+		return nil, err
+	}
+
+	return &Client{Conn: conn, key: key, model: model}, nil
+}
+
+type Client struct {
+	Conn
+	key   []byte
+	model string
+}
+
+const (
+	cmdAuthReq           = 0x100
+	cmdAuthRes           = 0x101
+	cmdVideoStart        = 0x102
+	cmdVideoStop         = 0x103
+	cmdAudioStart        = 0x104
+	cmdAudioStop         = 0x105
+	cmdSpeakerStartReq   = 0x106
+	cmdSpeakerStartRes   = 0x107
+	cmdSpeakerStop       = 0x108
+	cmdStreamCtrlReq     = 0x109
+	cmdStreamCtrlRes     = 0x10A
+	cmdGetAudioFormatReq = 0x10B
+	cmdGetAudioFormatRes = 0x10C
+	cmdPlaybackReq       = 0x10D
+	cmdPlaybackRes       = 0x10E
+	cmdDevInfoReq        = 0x110
+	cmdDevInfoRes        = 0x111
+	cmdMotorReq          = 0x112
+	cmdMotorRes          = 0x113
+	cmdEncoded           = 0x1001
+)
+
+func login(conn Conn, clientPublic, sign string) error {
+	s := fmt.Sprintf(`{"public_key":"%s","sign":"%s","uuid":"","support_encrypt":0}`, clientPublic, sign)
+	if err := conn.WriteCommand(cmdAuthReq, []byte(s)); err != nil {
+		return err
+	}
+
+	_, data, err := conn.ReadCommand()
+	if err != nil {
+		return err
+	}
+
+	if !bytes.Contains(data, []byte(`"result":"success"`)) {
+		return fmt.Errorf("miss: auth: %s", data)
+	}
+
+	return nil
+}
+
+func (c *Client) Version() string {
+	return fmt.Sprintf("%s (%s)", c.Conn.Version(), c.model)
+}
+
+func (c *Client) WriteCommand(data []byte) error {
+	data, err := crypto.Encode(data, c.key)
+	if err != nil {
+		return err
+	}
+	return c.Conn.WriteCommand(cmdEncoded, data)
+}
+
+const (
+	ModelDafang  = "isa.camera.df3"
+	ModelLoockV2 = "loock.cateye.v02"
+	ModelC200    = "chuangmi.camera.046c04"
+	ModelC300    = "chuangmi.camera.72ac1"
+	// ModelXiaofang looks like it has the same firmware as the ModelDafang.
+	// There is also an older model "isa.camera.isc5" that only works with the legacy protocol.
+	ModelXiaofang = "isa.camera.isc5c1"
+)
+
+func (c *Client) StartMedia(channel, quality, audio string) error {
+	switch c.model {
+	case ModelDafang, ModelXiaofang:
+		var q, a byte
+		if quality == "sd" {
+			q = 1 // 0 - hd, 1 - sd, default - hd
+		}
+		if audio != "0" {
+			a = 1 // 0 - off, 1 - on, default - on
+		}
+
+		return errors.Join(
+			c.WriteCommand(dafangVideoQuality(q)),
+			c.WriteCommand(dafangVideoStart(1, a)),
+		)
+	}
+
+	// 0 - auto, 1 - sd, 2 - hd, default - hd
+	switch quality {
+	case "", "hd":
+		// Some models have broken codec settings in quality 3.
+		// Some models have low quality in quality 2.
+		// Different models require different default quality settings.
+		switch c.model {
+		case ModelC200, ModelC300:
+			quality = "3"
+		default:
+			quality = "2"
+		}
+	case "sd":
+		quality = "1"
+	case "auto":
+		quality = "0"
+	}
+
+	if audio == "" {
+		audio = "1"
+	}
+
+	data := binary.BigEndian.AppendUint32(nil, cmdVideoStart)
+	switch channel {
+	case "", "0":
+		data = fmt.Appendf(data, `{"videoquality":%s,"enableaudio":%s}`, quality, audio)
+	default:
+		data = fmt.Appendf(data, `{"videoquality":-1,"videoquality2":%s,"enableaudio":%s}`, quality, audio)
+	}
+	return c.WriteCommand(data)
+}
+
+func (c *Client) StopMedia() error {
+	data := binary.BigEndian.AppendUint32(nil, cmdVideoStop)
+	return c.WriteCommand(data)
+}
+
+func (c *Client) StartAudio() error {
+	data := binary.BigEndian.AppendUint32(nil, cmdAudioStart)
+	return c.WriteCommand(data)
+}
+
+func (c *Client) StartSpeaker() error {
+	data := binary.BigEndian.AppendUint32(nil, cmdSpeakerStartReq)
+	return c.WriteCommand(data)
+}
+
+// SpeakerCodec if the camera model has a non-standard two-way codec.
+func (c *Client) SpeakerCodec() uint32 {
+	switch c.model {
+	case ModelDafang, ModelXiaofang, "isa.camera.hlc6":
+		return codecPCM
+	case "chuangmi.camera.72ac1":
+		return codecOPUS
+	}
+	return 0
+}
+
+const hdrSize = 32
+
+func (c *Client) ReadPacket() (*Packet, error) {
+	hdr, payload, err := c.Conn.ReadPacket()
+	if err != nil {
+		return nil, fmt.Errorf("miss: read media: %w", err)
+	}
+
+	if len(hdr) < hdrSize {
+		return nil, fmt.Errorf("miss: packet header too small")
+	}
+
+	payload, err = crypto.Decode(payload, c.key)
+	if err != nil {
+		return nil, err
+	}
+
+	pkt := &Packet{
+		CodecID:  binary.LittleEndian.Uint32(hdr[4:]),
+		Sequence: binary.LittleEndian.Uint32(hdr[8:]),
+		Flags:    binary.LittleEndian.Uint32(hdr[12:]),
+		Payload:  payload,
+	}
+
+	switch c.model {
+	case ModelDafang, ModelXiaofang, ModelLoockV2:
+		// Dafang has ts in sec
+		// LoockV2 has ts in msec for video, but zero ts for audio
+		pkt.Timestamp = uint64(time.Now().UnixMilli())
+	default:
+		pkt.Timestamp = binary.LittleEndian.Uint64(hdr[16:])
+	}
+
+	return pkt, nil
+}
+
+func (c *Client) WriteAudio(codecID uint32, payload []byte) error {
+	payload, err := crypto.Encode(payload, c.key) // new payload will have new size!
+	if err != nil {
+		return err
+	}
+
+	n := uint32(len(payload))
+
+	header := make([]byte, hdrSize)
+	binary.LittleEndian.PutUint32(header, n)
+	binary.LittleEndian.PutUint32(header[4:], codecID)
+	binary.LittleEndian.PutUint64(header[16:], uint64(time.Now().UnixMilli())) // not really necessary
+	return c.Conn.WritePacket(header, payload)
+}
+
+type Packet struct {
+	//Length    uint32
+	CodecID   uint32
+	Sequence  uint32
+	Flags     uint32
+	Timestamp uint64 // msec
+	//TimestampS uint32
+	//Reserved uint32
+	Payload []byte
+}
+
+func (p *Packet) SampleRate() uint32 {
+	// flag:         1 0011 000 - sample rate 16000
+	// flag: 100 00 01 0000 000 - sample rate  8000
+	v := (p.Flags >> 3) & 0b1111
+	if v != 0 {
+		return 16000
+	}
+	return 8000
+}
+
+//func (p *Packet) AudioUnknown1() byte {
+//	return byte((p.Flags >> 7) & 0b11)
+//}
+//
+//func (p *Packet) AudioUnknown2() byte {
+//	return byte((p.Flags >> 9) & 0b11)
+//}
+
+func dafangRaw(cmd uint32, args ...byte) []byte {
+	payload := tutk.ICAM(cmd, args...)
+
+	data := make([]byte, 4+len(payload)*2)
+	copy(data, "\x7f\xff\xff\xff")
+	hex.Encode(data[4:], payload)
+	return data
+}
+
+// DafangVideoQuality 0 - hd, 1 - sd
+func dafangVideoQuality(quality uint8) []byte {
+	return dafangRaw(0xff07d5, quality)
+}
+
+func dafangVideoStart(video, audio uint8) []byte {
+	return dafangRaw(0xff07d8, video, audio)
+}
+
+//func dafangLeft() []byte {
+//	return dafangRaw(0xff2404, 2, 0, 5)
+//}
+//
+//func dafangRight() []byte {
+//	return dafangRaw(0xff2404, 1, 0, 5)
+//}
+//
+//func dafangUp() []byte {
+//	return dafangRaw(0xff2404, 0, 2, 5)
+//}
+//
+//func dafangDown() []byte {
+//	return dafangRaw(0xff2404, 0, 1, 5)
+//}
+//
+//func dafangStop() []byte {
+//	return dafangRaw(0xff2404, 0, 0, 5)
+//}
diff --git a/installs_on_host/go2rtc/pkg/xiaomi/miss/cs2/conn.go b/installs_on_host/go2rtc/pkg/xiaomi/miss/cs2/conn.go
new file mode 100644
index 0000000..2c1b395
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/xiaomi/miss/cs2/conn.go
@@ -0,0 +1,506 @@
+package cs2
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"net"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+func Dial(host, transport string) (*Conn, error) {
+	conn, err := handshake(host, transport)
+	if err != nil {
+		return nil, err
+	}
+
+	_, isTCP := conn.(*tcpConn)
+
+	c := &Conn{
+		Conn:  conn,
+		isTCP: isTCP,
+		channels: [4]*dataChannel{
+			newDataChannel(0, 10), nil, newDataChannel(250, 100), nil,
+		},
+	}
+	go c.worker()
+	return c, nil
+}
+
+type Conn struct {
+	net.Conn
+	isTCP bool
+
+	err    error
+	seqCh0 uint16
+	seqCh3 uint16
+
+	channels [4]*dataChannel
+
+	cmdMu  sync.Mutex
+	cmdAck func()
+}
+
+const (
+	magic        = 0xF1
+	magicDrw     = 0xD1
+	magicTCP     = 0x68
+	msgLanSearch = 0x30
+	msgPunchPkt  = 0x41
+	msgP2PRdyUDP = 0x42
+	msgP2PRdyTCP = 0x43
+	msgDrw       = 0xD0
+	msgDrwAck    = 0xD1
+	msgPing      = 0xE0
+	msgPong      = 0xE1
+	msgClose     = 0xF0
+	msgCloseAck  = 0xF1
+)
+
+func handshake(host, transport string) (net.Conn, error) {
+	conn, err := newUDPConn(host, 32108)
+	if err != nil {
+		return nil, err
+	}
+
+	_ = conn.SetDeadline(time.Now().Add(5 * time.Second))
+
+	req := []byte{magic, msgLanSearch, 0, 0}
+	res, err := conn.(*udpConn).WriteUntil(req, func(res []byte) bool {
+		return res[1] == msgPunchPkt
+	})
+	if err != nil {
+		_ = conn.Close()
+		return nil, err
+	}
+
+	var msgUDP, msgTCP byte
+
+	if transport == "" || transport == "udp" {
+		msgUDP = msgP2PRdyUDP
+	}
+	if transport == "" || transport == "tcp" {
+		msgTCP = msgP2PRdyTCP
+	}
+
+	res, err = conn.(*udpConn).WriteUntil(res, func(res []byte) bool {
+		return res[1] == msgUDP || res[1] == msgTCP
+	})
+	if err != nil {
+		_ = conn.Close()
+		return nil, err
+	}
+
+	_ = conn.SetDeadline(time.Time{})
+
+	if res[1] == msgTCP {
+		_ = conn.Close()
+		//host := fmt.Sprintf("%d.%d.%d.%d:%d", b[31], b[30], b[29], b[28], uint16(b[27])<<8|uint16(b[26]))
+		return newTCPConn(conn.RemoteAddr().String())
+	}
+
+	return conn, nil
+}
+
+func (c *Conn) worker() {
+	defer func() {
+		c.channels[0].Close()
+		c.channels[2].Close()
+	}()
+
+	var keepaliveTS time.Time // only for TCP
+
+	buf := make([]byte, 1200)
+
+	for {
+		n, err := c.Conn.Read(buf)
+		if err != nil {
+			c.err = fmt.Errorf("%s: %w", "cs2", err)
+			return
+		}
+
+		// 0  f1d0  magic
+		// 2  005d  size = total size + 4
+		// 4  d1    magic
+		// 5  00    channel
+		// 6  0000  seq
+		switch buf[1] {
+		case msgDrw:
+			ch := buf[5]
+			channel := c.channels[ch]
+
+			if c.isTCP {
+				// For TCP we should send ping every second to keep connection alive.
+				// Based on PCAP analysis: official Mi Home app sends PING every ~1s.
+				if now := time.Now(); now.After(keepaliveTS) {
+					_, _ = c.Conn.Write([]byte{magic, msgPing, 0, 0})
+					keepaliveTS = now.Add(time.Second)
+				}
+
+				err = channel.Push(buf[8:n])
+			} else {
+				var pushed int
+
+				seqHI, seqLO := buf[6], buf[7]
+				seq := uint16(seqHI)<<8 | uint16(seqLO)
+				pushed, err = channel.PushSeq(seq, buf[8:n])
+
+				if pushed >= 0 {
+					// For UDP we should send ACK.
+					ack := []byte{magic, msgDrwAck, 0, 6, magicDrw, ch, 0, 1, seqHI, seqLO}
+					_, _ = c.Conn.Write(ack)
+				}
+			}
+
+			if err != nil {
+				c.err = fmt.Errorf("%s: %w", "cs2", err)
+				return
+			}
+
+		case msgPing:
+			_, _ = c.Conn.Write([]byte{magic, msgPong, 0, 0})
+		case msgPong, msgP2PRdyUDP, msgP2PRdyTCP, msgClose, msgCloseAck: // skip it
+		case msgDrwAck: // only for UDP
+			if c.cmdAck != nil {
+				c.cmdAck()
+			}
+		default:
+			fmt.Printf("%s: unknown msg: %x\n", "cs2", buf[:n])
+		}
+	}
+}
+
+func (c *Conn) Protocol() string {
+	if c.isTCP {
+		return "cs2+tcp"
+	}
+	return "cs2+udp"
+}
+
+func (c *Conn) Version() string {
+	return "CS2"
+}
+
+func (c *Conn) Error() error {
+	if c.err != nil {
+		return c.err
+	}
+	return io.EOF
+}
+
+func (c *Conn) ReadCommand() (cmd uint32, data []byte, err error) {
+	buf, ok := c.channels[0].Pop()
+	if !ok {
+		return 0, nil, c.Error()
+	}
+	cmd = binary.LittleEndian.Uint32(buf)
+	data = buf[4:]
+	return
+}
+
+func (c *Conn) WriteCommand(cmd uint32, data []byte) error {
+	c.cmdMu.Lock()
+	defer c.cmdMu.Unlock()
+
+	req := marshalCmd(0, c.seqCh0, cmd, data)
+	c.seqCh0++
+
+	if c.isTCP {
+		_, err := c.Conn.Write(req)
+		return err
+	}
+
+	var repeat atomic.Int32
+	repeat.Store(5)
+
+	timeout := time.NewTicker(time.Second)
+	defer timeout.Stop()
+
+	c.cmdAck = func() {
+		repeat.Store(0)
+		timeout.Reset(1)
+	}
+
+	for {
+		if _, err := c.Conn.Write(req); err != nil {
+			return err
+		}
+		<-timeout.C
+		r := repeat.Add(-1)
+		if r < 0 {
+			return nil
+		}
+		if r == 0 {
+			return fmt.Errorf("%s: can't send command %d", "cs2", cmd)
+		}
+	}
+}
+
+const hdrSize = 32
+
+func (c *Conn) ReadPacket() (hdr, payload []byte, err error) {
+	data, ok := c.channels[2].Pop()
+	if !ok {
+		return nil, nil, c.Error()
+	}
+	return data[:hdrSize], data[hdrSize:], nil
+}
+
+func (c *Conn) WritePacket(hdr, payload []byte) error {
+	const offset = 12
+
+	n := hdrSize + uint32(len(payload))
+	req := make([]byte, n+offset)
+	req[0] = magic
+	req[1] = msgDrw
+	binary.BigEndian.PutUint16(req[2:], uint16(n+8))
+
+	req[4] = magicDrw
+	req[5] = 3 // channel
+	binary.BigEndian.PutUint16(req[6:], c.seqCh3)
+	c.seqCh3++
+	binary.BigEndian.PutUint32(req[8:], n)
+	copy(req[offset:], hdr)
+	copy(req[offset+hdrSize:], hdr)
+
+	_, err := c.Conn.Write(req)
+	return err
+}
+
+func marshalCmd(channel byte, seq uint16, cmd uint32, payload []byte) []byte {
+	size := len(payload)
+	req := make([]byte, 4+4+4+4+size)
+
+	// 1. message header (4 bytes)
+	req[0] = magic
+	req[1] = msgDrw
+	binary.BigEndian.PutUint16(req[2:], uint16(4+4+4+size))
+
+	// 2. drw? header (4 bytes)
+	req[4] = magicDrw
+	req[5] = channel
+	binary.BigEndian.PutUint16(req[6:], seq)
+
+	// 3. payload size (4 bytes)
+	binary.BigEndian.PutUint32(req[8:], uint32(4+size))
+
+	// 4. payload command (4 bytes)
+	binary.BigEndian.PutUint32(req[12:], cmd)
+
+	// 5. payload
+	copy(req[16:], payload)
+
+	return req
+}
+
+func newUDPConn(host string, port int) (net.Conn, error) {
+	// We using raw net.UDPConn, because RemoteAddr should be changed during handshake.
+	conn, err := net.ListenUDP("udp", nil)
+	if err != nil {
+		return nil, err
+	}
+
+	addr, err := net.ResolveUDPAddr("udp", host)
+	if err != nil {
+		addr = &net.UDPAddr{IP: net.ParseIP(host), Port: port}
+	}
+
+	return &udpConn{UDPConn: conn, addr: addr}, nil
+}
+
+type udpConn struct {
+	*net.UDPConn
+	addr *net.UDPAddr
+}
+
+func (c *udpConn) Read(b []byte) (n int, err error) {
+	var addr *net.UDPAddr
+	for {
+		n, addr, err = c.UDPConn.ReadFromUDP(b)
+		if err != nil {
+			return 0, err
+		}
+
+		if string(addr.IP) == string(c.addr.IP) || n >= 8 {
+			//log.Printf("<- %x", b[:n])
+			return
+		}
+	}
+}
+
+func (c *udpConn) Write(b []byte) (n int, err error) {
+	//log.Printf("-> %x", b)
+	return c.UDPConn.WriteToUDP(b, c.addr)
+}
+
+func (c *udpConn) RemoteAddr() net.Addr {
+	return c.addr
+}
+
+func (c *udpConn) WriteUntil(req []byte, ok func(res []byte) bool) ([]byte, error) {
+	var t *time.Timer
+	t = time.AfterFunc(1, func() {
+		if _, err := c.Write(req); err == nil && t != nil {
+			t.Reset(time.Second)
+		}
+	})
+	defer t.Stop()
+
+	buf := make([]byte, 1200)
+
+	for {
+		n, addr, err := c.UDPConn.ReadFromUDP(buf)
+		if err != nil {
+			return nil, err
+		}
+
+		if string(addr.IP) != string(c.addr.IP) || n < 16 {
+			continue // skip messages from another IP
+		}
+
+		if ok(buf[:n]) {
+			c.addr.Port = addr.Port
+			return buf[:n], nil
+		}
+	}
+}
+
+func newTCPConn(addr string) (net.Conn, error) {
+	conn, err := net.DialTimeout("tcp", addr, 3*time.Second)
+	if err != nil {
+		return nil, err
+	}
+	return &tcpConn{conn.(*net.TCPConn), bufio.NewReader(conn)}, nil
+}
+
+type tcpConn struct {
+	*net.TCPConn
+	rd *bufio.Reader
+}
+
+func (c *tcpConn) Read(p []byte) (n int, err error) {
+	tmp := make([]byte, 8)
+	if _, err = io.ReadFull(c.rd, tmp); err != nil {
+		return
+	}
+	n = int(binary.BigEndian.Uint16(tmp))
+	if len(p) < n {
+		return 0, fmt.Errorf("tcp: buffer too small")
+	}
+	_, err = io.ReadFull(c.rd, p[:n])
+	//log.Printf("<- %x%x", tmp, p[:n])
+	return
+}
+
+func (c *tcpConn) Write(req []byte) (n int, err error) {
+	n = len(req)
+	buf := make([]byte, 8+n)
+	binary.BigEndian.PutUint16(buf, uint16(n))
+	buf[2] = magicTCP
+	copy(buf[8:], req)
+	//log.Printf("-> %x", buf)
+	_, err = c.TCPConn.Write(buf)
+	return
+}
+
+func newDataChannel(pushSize, popSize int) *dataChannel {
+	c := &dataChannel{}
+	if pushSize > 0 {
+		c.pushBuf = make(map[uint16][]byte, pushSize)
+		c.pushSize = pushSize
+	}
+	if popSize >= 0 {
+		c.popBuf = make(chan []byte, popSize)
+	}
+	return c
+}
+
+type dataChannel struct {
+	waitSeq  uint16
+	pushBuf  map[uint16][]byte
+	pushSize int
+
+	waitData []byte
+	waitSize int
+	popBuf   chan []byte
+}
+
+func (c *dataChannel) Push(b []byte) error {
+	c.waitData = append(c.waitData, b...)
+
+	for len(c.waitData) > 4 {
+		// Every new data starts with size. There can be several data inside one packet.
+		if c.waitSize == 0 {
+			c.waitSize = int(binary.BigEndian.Uint32(c.waitData))
+			c.waitData = c.waitData[4:]
+		}
+		if c.waitSize > len(c.waitData) {
+			break
+		}
+
+		select {
+		case c.popBuf <- c.waitData[:c.waitSize]:
+		default:
+			return fmt.Errorf("pop buffer is full")
+		}
+
+		c.waitData = c.waitData[c.waitSize:]
+		c.waitSize = 0
+	}
+	return nil
+}
+
+func (c *dataChannel) Pop() ([]byte, bool) {
+	data, ok := <-c.popBuf
+	return data, ok
+}
+
+func (c *dataChannel) Close() {
+	close(c.popBuf)
+}
+
+// PushSeq returns how many seq were processed.
+// Returns 0 if seq was saved or processed earlier.
+// Returns -1 if seq could not be saved (buffer full or disabled).
+func (c *dataChannel) PushSeq(seq uint16, data []byte) (int, error) {
+	diff := int16(seq - c.waitSeq)
+	// Check if this is seq from the future.
+	if diff > 0 {
+		// Support disabled buffer.
+		if c.pushSize == 0 {
+			return -1, nil // couldn't save seq
+		}
+		// Check if we don't have this seq in the buffer.
+		if c.pushBuf[seq] == nil {
+			// Check if there is enough space in the buffer.
+			if len(c.pushBuf) == c.pushSize {
+				return -1, nil // couldn't save seq
+			}
+			c.pushBuf[seq] = bytes.Clone(data)
+			//log.Printf("push buf wait=%d seq=%d len=%d", c.waitSeq, seq, len(c.pushBuf))
+		}
+		return 0, nil
+	}
+
+	// Check if this is seq from the past.
+	if diff < 0 {
+		return 0, nil
+	}
+
+	for i := 1; ; i++ {
+		if err := c.Push(data); err != nil {
+			return i, err
+		}
+		c.waitSeq++
+		// Check if we have next seq in the buffer.
+		if data = c.pushBuf[c.waitSeq]; data != nil {
+			delete(c.pushBuf, c.waitSeq)
+		} else {
+			return i, nil
+		}
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/xiaomi/miss/producer.go b/installs_on_host/go2rtc/pkg/xiaomi/miss/producer.go
new file mode 100644
index 0000000..dcea284
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/xiaomi/miss/producer.go
@@ -0,0 +1,204 @@
+package miss
+
+import (
+	"fmt"
+	"net/url"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/h264/annexb"
+	"github.com/AlexxIT/go2rtc/pkg/h265"
+	"github.com/pion/rtp"
+)
+
+type Producer struct {
+	core.Connection
+	client *Client
+}
+
+func Dial(rawURL string) (core.Producer, error) {
+	client, err := NewClient(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	u, _ := url.Parse(rawURL)
+	query := u.Query()
+
+	err = client.StartMedia(query.Get("channel"), query.Get("subtype"), query.Get("audio"))
+	if err != nil {
+		_ = client.Close()
+		return nil, err
+	}
+
+	medias, err := probe(client, query.Get("audio") != "0")
+	if err != nil {
+		_ = client.Close()
+		return nil, err
+	}
+
+	return &Producer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "xiaomi/miss",
+			Protocol:   client.Protocol(),
+			RemoteAddr: client.RemoteAddr().String(),
+			UserAgent:  client.Version(),
+			Medias:     medias,
+			Transport:  client,
+		},
+		client: client,
+	}, nil
+}
+
+func probe(client *Client, audio bool) ([]*core.Media, error) {
+	_ = client.SetDeadline(time.Now().Add(15 * time.Second))
+
+	var vcodec, acodec *core.Codec
+
+	for {
+		pkt, err := client.ReadPacket()
+		if err != nil {
+			if vcodec != nil {
+				err = fmt.Errorf("no audio")
+			} else if acodec != nil {
+				err = fmt.Errorf("no video")
+			}
+			return nil, fmt.Errorf("xiaomi: probe: %w", err)
+		}
+
+		switch pkt.CodecID {
+		case codecH264:
+			if vcodec == nil {
+				buf := annexb.EncodeToAVCC(pkt.Payload)
+				if h264.NALUType(buf) == h264.NALUTypeSPS {
+					vcodec = h264.AVCCToCodec(buf)
+				}
+			}
+		case codecH265:
+			if vcodec == nil {
+				buf := annexb.EncodeToAVCC(pkt.Payload)
+				if h265.NALUType(buf) == h265.NALUTypeVPS {
+					vcodec = h265.AVCCToCodec(buf)
+				}
+			}
+		case codecPCMA:
+			if acodec == nil {
+				acodec = &core.Codec{Name: core.CodecPCMA, ClockRate: pkt.SampleRate()}
+			}
+		case codecOPUS:
+			if acodec == nil {
+				acodec = &core.Codec{Name: core.CodecOpus, ClockRate: 48000, Channels: 2}
+			}
+		}
+
+		if vcodec != nil && (acodec != nil || !audio) {
+			break
+		}
+	}
+
+	_ = client.SetDeadline(time.Time{})
+
+	medias := []*core.Media{
+		{
+			Kind:      core.KindVideo,
+			Direction: core.DirectionRecvonly,
+			Codecs:    []*core.Codec{vcodec},
+		},
+	}
+
+	if acodec != nil {
+		medias = append(medias, &core.Media{
+			Kind:      core.KindAudio,
+			Direction: core.DirectionRecvonly,
+			Codecs:    []*core.Codec{acodec},
+		})
+
+		medias = append(medias, &core.Media{
+			Kind:      core.KindAudio,
+			Direction: core.DirectionSendonly,
+			Codecs:    []*core.Codec{acodec.Clone()},
+		})
+	}
+
+	return medias, nil
+}
+
+const timestamp40ms = 48000 * 0.040
+
+func (p *Producer) Start() error {
+	var audioTS uint32
+
+	for {
+		_ = p.client.SetDeadline(time.Now().Add(10 * time.Second))
+		pkt, err := p.client.ReadPacket()
+		if err != nil {
+			return err
+		}
+
+		p.Recv += len(pkt.Payload)
+
+		// TODO: rewrite this
+		var name string
+		var pkt2 *core.Packet
+
+		switch pkt.CodecID {
+		case codecH264, codecH265:
+			pkt2 = &core.Packet{
+				Header: rtp.Header{
+					SequenceNumber: uint16(pkt.Sequence),
+					Timestamp:      TimeToRTP(pkt.Timestamp, 90000),
+				},
+				Payload: annexb.EncodeToAVCC(pkt.Payload),
+			}
+			if pkt.CodecID == codecH264 {
+				name = core.CodecH264
+			} else {
+				name = core.CodecH265
+			}
+		case codecPCMA:
+			name = core.CodecPCMA
+			pkt2 = &core.Packet{
+				Header: rtp.Header{
+					Version:        2,
+					Marker:         true,
+					SequenceNumber: uint16(pkt.Sequence),
+					Timestamp:      audioTS,
+				},
+				Payload: pkt.Payload,
+			}
+			audioTS += uint32(len(pkt.Payload))
+		case codecOPUS:
+			name = core.CodecOpus
+			pkt2 = &core.Packet{
+				Header: rtp.Header{
+					Version:        2,
+					Marker:         true,
+					SequenceNumber: uint16(pkt.Sequence),
+					Timestamp:      audioTS,
+				},
+				Payload: pkt.Payload,
+			}
+			// known cameras sends packets with 40ms long
+			audioTS += timestamp40ms
+		}
+
+		for _, recv := range p.Receivers {
+			if recv.Codec.Name == name {
+				recv.WriteRTP(pkt2)
+				break
+			}
+		}
+	}
+}
+
+func (p *Producer) Stop() error {
+	_ = p.client.StopMedia()
+	return p.Connection.Stop()
+}
+
+// TimeToRTP convert time in milliseconds to RTP time
+func TimeToRTP(timeMS, clockRate uint64) uint32 {
+	return uint32(timeMS * clockRate / 1000)
+}
diff --git a/installs_on_host/go2rtc/pkg/xiaomi/producer.go b/installs_on_host/go2rtc/pkg/xiaomi/producer.go
new file mode 100644
index 0000000..d0290f2
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/xiaomi/producer.go
@@ -0,0 +1,23 @@
+package xiaomi
+
+import (
+	"strings"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/AlexxIT/go2rtc/pkg/xiaomi/legacy"
+	"github.com/AlexxIT/go2rtc/pkg/xiaomi/miss"
+)
+
+func Dial(rawURL string) (core.Producer, error) {
+	// Format: xiaomi/miss
+	if strings.Contains(rawURL, "vendor") {
+		return miss.Dial(rawURL)
+	}
+
+	// Format: xiaomi/legacy
+	return legacy.Dial(rawURL)
+}
+
+func IsLegacy(model string) bool {
+	return legacy.Supported(model)
+}
diff --git a/installs_on_host/go2rtc/pkg/xnet/net.go b/installs_on_host/go2rtc/pkg/xnet/net.go
new file mode 100644
index 0000000..1636150
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/xnet/net.go
@@ -0,0 +1,64 @@
+package xnet
+
+import (
+	"net"
+	"strconv"
+)
+
+// Docker has common docker addresses (class B):
+// https://en.wikipedia.org/wiki/Private_network
+// - docker0 172.17.0.1/16
+// - br-xxxx 172.18.0.1/16
+// - hassio  172.30.32.1/23
+var Docker = net.IPNet{
+	IP:   []byte{172, 16, 0, 0},
+	Mask: []byte{255, 240, 0, 0},
+}
+
+// ParseUnspecifiedPort will return port if address is unspecified
+// ex. ":8555" or "0.0.0.0:8555"
+func ParseUnspecifiedPort(address string) int {
+	host, port, err := net.SplitHostPort(address)
+	if err != nil {
+		return 0
+	}
+
+	if host != "" && host != "0.0.0.0" && host != "[::]" {
+		return 0
+	}
+
+	i, _ := strconv.Atoi(port)
+	return i
+}
+
+func IPNets(ipFilter func(ip net.IP) bool) ([]*net.IPNet, error) {
+	ifaces, err := net.Interfaces()
+	if err != nil {
+		return nil, err
+	}
+
+	var nets []*net.IPNet
+
+	for _, iface := range ifaces {
+		if iface.Flags&net.FlagUp == 0 || iface.Flags&net.FlagLoopback != 0 {
+			continue
+		}
+
+		addrs, _ := iface.Addrs() // range on nil slice is OK
+		for _, addr := range addrs {
+			switch v := addr.(type) {
+			case *net.IPNet:
+				ip := v.IP.To4()
+				if ip == nil {
+					continue
+				}
+				if ipFilter != nil && !ipFilter(ip) {
+					continue
+				}
+				nets = append(nets, v)
+			}
+		}
+	}
+
+	return nets, nil
+}
diff --git a/installs_on_host/go2rtc/pkg/xnet/tls/tls.go b/installs_on_host/go2rtc/pkg/xnet/tls/tls.go
new file mode 100644
index 0000000..b4b6f60
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/xnet/tls/tls.go
@@ -0,0 +1,63 @@
+package tls
+
+import (
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/tls"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/pem"
+	"math/big"
+	"net"
+	"time"
+)
+
+func CreateCertificate() (*tls.Certificate, error) {
+	// 1. Generate an RSA private key
+	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
+	if err != nil {
+		return nil, err
+	}
+
+	// 2. Define the certificate template
+	serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
+	serialNumber, err := rand.Int(rand.Reader, serialNumberLimit)
+	if err != nil {
+		return nil, err
+	}
+
+	template := x509.Certificate{
+		SerialNumber: serialNumber,
+		Subject: pkix.Name{
+			Organization: []string{"home"},
+			CommonName:   "localhost",
+		},
+		NotBefore: time.Now(),
+		NotAfter:  time.Now().Add(365 * 24 * time.Hour), // Valid for 1 year
+
+		KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
+		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
+		BasicConstraintsValid: true,
+
+		// Add localhost as a valid IP and DNS name
+		IPAddresses: []net.IP{[]byte{127, 0, 0, 1}},
+		DNSNames:    []string{"localhost"},
+	}
+
+	// 3. Create a self-signed certificate
+	// The parent is the template itself, and we use the generated public and private keys.
+	derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, &privateKey.PublicKey, privateKey)
+	if err != nil {
+		return nil, err
+	}
+
+	derBytes = pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: derBytes})
+	keyBytes := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(privateKey)})
+
+	cert, err := tls.X509KeyPair(derBytes, keyBytes)
+	if err != nil {
+		return nil, err
+	}
+
+	return &cert, nil
+}
diff --git a/installs_on_host/go2rtc/pkg/y4m/README.md b/installs_on_host/go2rtc/pkg/y4m/README.md
new file mode 100644
index 0000000..ff97813
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/y4m/README.md
@@ -0,0 +1,19 @@
+## Planar YUV formats
+
+Packed YUV - yuyv422 - YUYV 4:2:2
+Semi-Planar - nv12 - Y/CbCr 4:2:0
+Planar YUV - yuv420p - Planar YUV 4:2:0 - aka. [cosited](https://manned.org/yuv4mpeg.5)
+
+```
+[video4linux2,v4l2 @ 0x55fddc42a940] Raw       :     yuyv422 :           YUYV 4:2:2 : 1920x1080
+[video4linux2,v4l2 @ 0x55fddc42a940] Raw       :        nv12 :         Y/CbCr 4:2:0 : 1920x1080
+[video4linux2,v4l2 @ 0x55fddc42a940] Raw       :     yuv420p :     Planar YUV 4:2:0 : 1920x1080
+```
+
+## Useful links
+
+- https://learn.microsoft.com/en-us/windows/win32/medfound/recommended-8-bit-yuv-formats-for-video-rendering
+- https://developer.mozilla.org/en-US/docs/Web/Media/Formats/Video_concepts
+- https://fourcc.org/yuv.php#YV12
+- https://docs.kernel.org/userspace-api/media/v4l/pixfmt-yuv-planar.html
+- https://gist.github.com/Jim-Bar/3cbba684a71d1a9d468a6711a6eddbeb
diff --git a/installs_on_host/go2rtc/pkg/y4m/consumer.go b/installs_on_host/go2rtc/pkg/y4m/consumer.go
new file mode 100644
index 0000000..dd9b46e
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/y4m/consumer.go
@@ -0,0 +1,65 @@
+package y4m
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+)
+
+type Consumer struct {
+	core.Connection
+	wr *core.WriteBuffer
+}
+
+func NewConsumer() *Consumer {
+	wr := core.NewWriteBuffer(nil)
+	return &Consumer{
+		core.Connection{
+			ID:         core.NewID(),
+			Transport:  wr,
+			FormatName: "yuv4mpegpipe",
+			Medias: []*core.Media{
+				{
+					Kind:      core.KindVideo,
+					Direction: core.DirectionSendonly,
+					Codecs: []*core.Codec{
+						{Name: core.CodecRAW},
+					},
+				},
+			},
+		},
+		wr,
+	}
+}
+
+func (c *Consumer) AddTrack(media *core.Media, _ *core.Codec, track *core.Receiver) error {
+	sender := core.NewSender(media, track.Codec)
+	sender.Handler = func(packet *rtp.Packet) {
+		if n, err := c.wr.Write([]byte(frameHdr)); err == nil {
+			c.Send += n
+		}
+		if n, err := c.wr.Write(packet.Payload); err == nil {
+			c.Send += n
+		}
+	}
+
+	hdr := fmt.Sprintf(
+		"YUV4MPEG2 W%s H%s C%s\n",
+		core.Between(track.Codec.FmtpLine, "width=", ";"),
+		core.Between(track.Codec.FmtpLine, "height=", ";"),
+		core.Between(track.Codec.FmtpLine, "colorspace=", ";"),
+	)
+	if _, err := c.wr.Write([]byte(hdr)); err != nil {
+		return err
+	}
+
+	sender.HandleRTP(track)
+	c.Senders = append(c.Senders, sender)
+	return nil
+}
+
+func (c *Consumer) WriteTo(wr io.Writer) (int64, error) {
+	return c.wr.WriteTo(wr)
+}
diff --git a/installs_on_host/go2rtc/pkg/y4m/producer.go b/installs_on_host/go2rtc/pkg/y4m/producer.go
new file mode 100644
index 0000000..ee2dd73
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/y4m/producer.go
@@ -0,0 +1,83 @@
+package y4m
+
+import (
+	"bufio"
+	"errors"
+	"io"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+	"github.com/pion/rtp"
+)
+
+func Open(r io.Reader) (*Producer, error) {
+	rd := bufio.NewReaderSize(r, core.BufferSize)
+	b, err := rd.ReadBytes('\n')
+	if err != nil {
+		return nil, err
+	}
+
+	b = b[:len(b)-1] // remove \n
+
+	fmtp := ParseHeader(b)
+
+	if GetSize(fmtp) == 0 {
+		return nil, errors.New("y4m: unsupported format: " + string(b))
+	}
+
+	medias := []*core.Media{
+		{
+			Kind:      core.KindVideo,
+			Direction: core.DirectionRecvonly,
+			Codecs: []*core.Codec{
+				{
+					Name:        core.CodecRAW,
+					ClockRate:   90000,
+					FmtpLine:    fmtp,
+					PayloadType: core.PayloadTypeRAW,
+				},
+			},
+		},
+	}
+	return &Producer{
+		Connection: core.Connection{
+			ID:         core.NewID(),
+			FormatName: "yuv4mpegpipe",
+			Medias:     medias,
+			SDP:        string(b),
+			Transport:  r,
+		},
+		rd: rd,
+	}, nil
+}
+
+type Producer struct {
+	core.Connection
+	rd *bufio.Reader
+}
+
+func (c *Producer) Start() error {
+	size := GetSize(c.Medias[0].Codecs[0].FmtpLine)
+
+	for {
+		if _, err := c.rd.Discard(len(frameHdr)); err != nil {
+			return err
+		}
+
+		frame := make([]byte, size)
+		if _, err := io.ReadFull(c.rd, frame); err != nil {
+			return err
+		}
+
+		c.Recv += size
+
+		if len(c.Receivers) == 0 {
+			continue
+		}
+
+		pkt := &rtp.Packet{
+			Header:  rtp.Header{Timestamp: core.Now90000()},
+			Payload: frame,
+		}
+		c.Receivers[0].WriteRTP(pkt)
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/y4m/y4m.go b/installs_on_host/go2rtc/pkg/y4m/y4m.go
new file mode 100644
index 0000000..24c4316
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/y4m/y4m.go
@@ -0,0 +1,149 @@
+package y4m
+
+import (
+	"bytes"
+	"image"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+const FourCC = "YUV4"
+
+const frameHdr = "FRAME\n"
+
+func ParseHeader(b []byte) (fmtp string) {
+	for b != nil {
+		// YUV4MPEG2 W1280 H720 F24:1 Ip A1:1 C420mpeg2 XYSCSS=420MPEG2
+		// https://manned.org/yuv4mpeg.5
+		// https://github.com/FFmpeg/FFmpeg/blob/master/libavformat/yuv4mpegenc.c
+		key := b[0]
+
+		var value string
+		if i := bytes.IndexByte(b, ' '); i > 0 {
+			value = string(b[1:i])
+			b = b[i+1:]
+		} else {
+			value = string(b[1:])
+			b = nil
+		}
+
+		switch key {
+		case 'W':
+			fmtp = "width=" + value
+		case 'H':
+			fmtp += ";height=" + value
+		case 'C':
+			fmtp += ";colorspace=" + value
+		}
+	}
+	return
+}
+
+func GetSize(fmtp string) int {
+	w := core.Atoi(core.Between(fmtp, "width=", ";"))
+	h := core.Atoi(core.Between(fmtp, "height=", ";"))
+
+	switch core.Between(fmtp, "colorspace=", ";") {
+	case "mono":
+		return w * h
+	case "420mpeg2", "420jpeg":
+		return w * h * 3 / 2
+	case "422":
+		return w * h * 2
+	case "444":
+		return w * h * 3
+	}
+
+	return 0
+}
+
+func NewImage(fmtp string) func(frame []byte) image.Image {
+	w := core.Atoi(core.Between(fmtp, "width=", ";"))
+	h := core.Atoi(core.Between(fmtp, "height=", ";"))
+	rect := image.Rect(0, 0, w, h)
+
+	switch core.Between(fmtp, "colorspace=", ";") {
+	case "mono":
+		return func(frame []byte) image.Image {
+			return &image.Gray{
+				Pix:    frame,
+				Stride: w,
+				Rect:   rect,
+			}
+		}
+	case "420mpeg2", "420jpeg":
+		i1 := w * h
+		i2 := i1 + i1/4
+		i3 := i2 + i1/4
+
+		return func(frame []byte) image.Image {
+			return &image.YCbCr{
+				Y:              frame[:i1],
+				Cb:             frame[i1:i2],
+				Cr:             frame[i2:i3],
+				YStride:        w,
+				CStride:        w / 2,
+				SubsampleRatio: image.YCbCrSubsampleRatio420,
+				Rect:           rect,
+			}
+		}
+	case "422":
+		i1 := w * h
+		i2 := i1 + i1/2
+		i3 := i2 + i1/2
+
+		return func(frame []byte) image.Image {
+			return &image.YCbCr{
+				Y:              frame[:i1],
+				Cb:             frame[i1:i2],
+				Cr:             frame[i2:i3],
+				YStride:        w,
+				CStride:        w / 2,
+				SubsampleRatio: image.YCbCrSubsampleRatio422,
+				Rect:           rect,
+			}
+		}
+	case "444":
+		i1 := w * h
+		i2 := i1 + i1
+		i3 := i2 + i1
+
+		return func(frame []byte) image.Image {
+			return &image.YCbCr{
+				Y:              frame[:i1],
+				Cb:             frame[i1:i2],
+				Cr:             frame[i2:i3],
+				YStride:        w,
+				CStride:        w,
+				SubsampleRatio: image.YCbCrSubsampleRatio444,
+				Rect:           rect,
+			}
+		}
+	}
+
+	return nil
+}
+
+// HasSameColor checks if all pixels has same color
+func HasSameColor(img image.Image) bool {
+	var pix []byte
+
+	switch img := img.(type) {
+	case *image.Gray:
+		pix = img.Pix
+	case *image.YCbCr:
+		pix = img.Y
+	}
+
+	if len(pix) == 0 {
+		return false
+	}
+
+	i0 := pix[0]
+	for _, i := range pix {
+		if i != i0 {
+			return false
+		}
+	}
+	return true
+}
diff --git a/installs_on_host/go2rtc/pkg/yaml/yaml.go b/installs_on_host/go2rtc/pkg/yaml/yaml.go
new file mode 100644
index 0000000..4672cb4
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/yaml/yaml.go
@@ -0,0 +1,230 @@
+package yaml
+
+import (
+	"bytes"
+	"errors"
+
+	"gopkg.in/yaml.v3"
+)
+
+func Unmarshal(in []byte, out interface{}) (err error) {
+	return yaml.Unmarshal(in, out)
+}
+
+func Encode(v any, indent int) ([]byte, error) {
+	b := bytes.NewBuffer(nil)
+	e := yaml.NewEncoder(b)
+	e.SetIndent(indent)
+
+	if err := e.Encode(v); err != nil {
+		return nil, err
+	}
+
+	return b.Bytes(), nil
+}
+
+func Patch(in []byte, path []string, value any) ([]byte, error) {
+	out, err := patch(in, path, value)
+	if err != nil {
+		return nil, err
+	}
+
+	// validate
+	if err = yaml.Unmarshal(out, map[string]any{}); err != nil {
+		return nil, err
+	}
+
+	return out, nil
+}
+
+func patch(in []byte, path []string, value any) ([]byte, error) {
+	var root yaml.Node
+	if err := yaml.Unmarshal(in, &root); err != nil {
+		// invalid yaml
+		return nil, err
+	}
+
+	// empty in
+	if len(root.Content) != 1 {
+		return addToEnd(in, path, value)
+	}
+
+	// yaml is not dict
+	if root.Content[0].Kind != yaml.MappingNode {
+		return nil, errors.New("yaml: can't patch")
+	}
+
+	// dict items list
+	nodes := root.Content[0].Content
+
+	n := len(path) - 1
+
+	// parent node key/value
+	pKey, pVal := findNode(nodes, path[:n])
+	if pKey == nil {
+		// no parent node
+		return addToEnd(in, path, value)
+	}
+
+	var paste []byte
+
+	if value != nil {
+		// nil value means delete key
+		var err error
+		v := map[string]any{path[n]: value}
+		if paste, err = Encode(v, 2); err != nil {
+			return nil, err
+		}
+	}
+
+	iKey, _ := findNode(pVal.Content, path[n:])
+	if iKey != nil {
+		// key item not nil (replace value)
+		paste = addIndent(paste, iKey.Column-1)
+
+		i0, i1 := nodeBounds(in, iKey)
+		return join(in[:i0], paste, in[i1:]), nil
+	}
+
+	if pVal.Content != nil {
+		// parent value not nil (use first child indent)
+		paste = addIndent(paste, pVal.Column-1)
+	} else {
+		// parent value is nil (use parent indent + 2)
+		paste = addIndent(paste, pKey.Column+1)
+	}
+
+	_, i1 := nodeBounds(in, pKey)
+	return join(in[:i1], paste, in[i1:]), nil
+}
+
+func findNode(nodes []*yaml.Node, keys []string) (key, value *yaml.Node) {
+	for i, name := range keys {
+		for j := 0; j < len(nodes); j += 2 {
+			if nodes[j].Value == name {
+				if i < len(keys)-1 {
+					nodes = nodes[j+1].Content
+					break
+				}
+				return nodes[j], nodes[j+1]
+			}
+		}
+	}
+	return nil, nil
+}
+
+func nodeBounds(in []byte, node *yaml.Node) (offset0, offset1 int) {
+	// start from next line after node
+	offset0 = lineOffset(in, node.Line)
+	offset1 = lineOffset(in, node.Line+1)
+
+	if offset1 < 0 {
+		return offset0, len(in)
+	}
+
+	for i := offset1; i < len(in); {
+		indent, length := parseLine(in[i:])
+		if indent+1 != length {
+			if node.Column < indent+1 {
+				offset1 = i + length
+			} else {
+				break
+			}
+		}
+		i += length
+	}
+
+	return
+}
+
+func addToEnd(in []byte, path []string, value any) ([]byte, error) {
+	if len(path) != 2 || value == nil {
+		return nil, errors.New("yaml: path not exist")
+	}
+
+	v := map[string]map[string]any{
+		path[0]: {path[1]: value},
+	}
+	paste, err := Encode(v, 2)
+	if err != nil {
+		return nil, err
+	}
+
+	return join(in, paste), nil
+}
+
+func join(items ...[]byte) []byte {
+	n := len(items) - 1
+	for _, b := range items {
+		n += len(b)
+	}
+
+	buf := make([]byte, 0, n)
+	for _, b := range items {
+		if len(b) == 0 {
+			continue
+		}
+		if n = len(buf); n > 0 && buf[n-1] != '\n' {
+			buf = append(buf, '\n')
+		}
+		buf = append(buf, b...)
+	}
+
+	return buf
+}
+
+func addPrefix(src, pre []byte) (dst []byte) {
+	for len(src) > 0 {
+		dst = append(dst, pre...)
+		i := bytes.IndexByte(src, '\n') + 1
+		if i == 0 {
+			dst = append(dst, src...)
+			break
+		}
+		dst = append(dst, src[:i]...)
+		src = src[i:]
+	}
+
+	return
+}
+
+func addIndent(in []byte, indent int) (dst []byte) {
+	pre := make([]byte, indent)
+	for i := 0; i < indent; i++ {
+		pre[i] = ' '
+	}
+	return addPrefix(in, pre)
+}
+
+func lineOffset(in []byte, line int) (offset int) {
+	for l := 1; ; l++ {
+		if l == line {
+			return offset
+		}
+
+		i := bytes.IndexByte(in[offset:], '\n') + 1
+		if i == 0 {
+			break
+		}
+		offset += i
+	}
+	return -1
+}
+
+func parseLine(b []byte) (indent int, length int) {
+	prefix := true
+	for ; length < len(b); length++ {
+		switch b[length] {
+		case ' ':
+			if prefix {
+				indent++
+			}
+		case '\n':
+			length++
+			return
+		default:
+			prefix = false
+		}
+	}
+	return
+}
diff --git a/installs_on_host/go2rtc/pkg/yaml/yaml_test.go b/installs_on_host/go2rtc/pkg/yaml/yaml_test.go
new file mode 100644
index 0000000..264546a
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/yaml/yaml_test.go
@@ -0,0 +1,109 @@
+package yaml
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestPatch(t *testing.T) {
+	tests := []struct {
+		name   string
+		src    string
+		path   []string
+		value  any
+		expect string
+	}{
+		{
+			name:   "empty config",
+			src:    "",
+			path:   []string{"streams", "camera1"},
+			value:  "val1",
+			expect: "streams:\n  camera1: val1\n",
+		},
+		{
+			name:   "empty main key",
+			src:    "#dummy",
+			path:   []string{"streams", "camera1"},
+			value:  "val1",
+			expect: "#dummy\nstreams:\n  camera1: val1\n",
+		},
+		{
+			name:   "single line value",
+			src:    "streams:\n  camera1: url1\n  camera2: url2",
+			path:   []string{"streams", "camera1"},
+			value:  "val1",
+			expect: "streams:\n  camera1: val1\n  camera2: url2",
+		},
+		{
+			name:   "next line value",
+			src:    "streams:\n  camera1:\n    url1\n  camera2: url2",
+			path:   []string{"streams", "camera1"},
+			value:  "val1",
+			expect: "streams:\n  camera1: val1\n  camera2: url2",
+		},
+		{
+			name:   "two lines value",
+			src:    "streams:\n  camera1: url1\n    url2\n  camera2: url2",
+			path:   []string{"streams", "camera1"},
+			value:  "val1",
+			expect: "streams:\n  camera1: val1\n  camera2: url2",
+		},
+		{
+			name:   "next two lines value",
+			src:    "streams:\n  camera1:\n    url1\n    url2\n  camera2: url2",
+			path:   []string{"streams", "camera1"},
+			value:  "val1",
+			expect: "streams:\n  camera1: val1\n  camera2: url2",
+		},
+		{
+			name:   "add array",
+			src:    "",
+			path:   []string{"streams", "camera1"},
+			value:  []string{"val1", "val2"},
+			expect: "streams:\n  camera1:\n    - val1\n    - val2\n",
+		},
+		{
+			name:   "remove value",
+			src:    "streams:\n  camera1: url1\n  camera2: url2",
+			path:   []string{"streams", "camera1"},
+			value:  nil,
+			expect: "streams:\n  camera2: url2",
+		},
+		{
+			name:   "add pairings",
+			src:    "homekit:\n  camera1:\nstreams:\n  camera1: url1",
+			path:   []string{"homekit", "camera1", "pairings"},
+			value:  []string{"val1"},
+			expect: "homekit:\n  camera1:\n    pairings:\n      - val1\nstreams:\n  camera1: url1",
+		},
+		{
+			name:   "remove pairings",
+			src:    "homekit:\n  camera1:\n    pairings:\n      - val1\nstreams:\n  camera1: url1",
+			path:   []string{"homekit", "camera1", "pairings"},
+			value:  nil,
+			expect: "homekit:\n  camera1:\nstreams:\n  camera1: url1",
+		},
+		{
+			name:   "no new line",
+			src:    "streams:\n  camera1: url1",
+			path:   []string{"streams", "camera1"},
+			value:  "val1",
+			expect: "streams:\n  camera1: val1\n",
+		},
+		{
+			name:   "no new line",
+			src:    "streams:\n  camera1: url1\nhomekit:\n  camera1:\n    name: dummy",
+			path:   []string{"homekit", "camera1", "pairings"},
+			value:  []string{"val1"},
+			expect: "streams:\n  camera1: url1\nhomekit:\n  camera1:\n    name: dummy\n    pairings:\n      - val1\n",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			b, err := Patch([]byte(tt.src), tt.path, tt.value)
+			require.NoError(t, err)
+			require.Equal(t, tt.expect, string(b))
+		})
+	}
+}
diff --git a/installs_on_host/go2rtc/pkg/yandex/session.go b/installs_on_host/go2rtc/pkg/yandex/session.go
new file mode 100644
index 0000000..bd0e3a2
--- /dev/null
+++ b/installs_on_host/go2rtc/pkg/yandex/session.go
@@ -0,0 +1,203 @@
+package yandex
+
+import (
+	"encoding/json"
+	"errors"
+	"io"
+	"net/http"
+	"net/http/cookiejar"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/AlexxIT/go2rtc/pkg/core"
+)
+
+type Session struct {
+	token  string
+	client *http.Client
+}
+
+var sessions = map[string]*Session{}
+var sessionsMu sync.Mutex
+
+func GetSession(token string) (*Session, error) {
+	sessionsMu.Lock()
+	defer sessionsMu.Unlock()
+
+	if session, ok := sessions[token]; ok {
+		return session, nil
+	}
+
+	session := &Session{token: token}
+	if err := session.Login(); err != nil {
+		return nil, err
+	}
+
+	sessions[token] = session
+
+	return session, nil
+}
+
+func (s *Session) Login() error {
+	req, err := http.NewRequest(
+		"POST", "https://mobileproxy.passport.yandex.net/1/bundle/auth/x_token/",
+		strings.NewReader("type=x-token&retpath=https%3A%2F%2Fwww.yandex.ru"),
+	)
+	if err != nil {
+		return err
+	}
+
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Set("Ya-Consumer-Authorization", "OAuth "+s.token)
+
+	res, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+
+	var auth struct {
+		PassportHost string `json:"passport_host"`
+		Status       string `json:"status"`
+		TrackId      string `json:"track_id"`
+	}
+	if err = json.NewDecoder(res.Body).Decode(&auth); err != nil {
+		return err
+	}
+
+	if auth.Status != "ok" {
+		return errors.New("yandex: login error: " + auth.Status)
+	}
+
+	s.client = &http.Client{Timeout: 15 * time.Second}
+	s.client.CheckRedirect = func(req *http.Request, via []*http.Request) error {
+		return http.ErrUseLastResponse
+	}
+	s.client.Jar, _ = cookiejar.New(nil)
+
+	res, err = s.client.Get(auth.PassportHost + "/auth/session/?track_id=" + auth.TrackId)
+	if err != nil {
+		return err
+	}
+
+	s.client.CheckRedirect = nil
+
+	return nil
+}
+
+func (s *Session) Get(url string) (*http.Response, error) {
+	return s.client.Get(url)
+}
+
+func (s *Session) GetCSRF() (string, error) {
+	res, err := s.Get("https://yandex.ru/quasar")
+	if err != nil {
+		return "", err
+	}
+
+	body, err := io.ReadAll(res.Body)
+	if err != nil {
+		return "", err
+	}
+
+	token := core.Between(string(body), `"csrfToken2":"`, `"`)
+	return token, nil
+}
+
+func (s *Session) GetCookieString(url string) string {
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return ""
+	}
+	for _, cookie := range s.client.Jar.Cookies(req.URL) {
+		req.AddCookie(cookie)
+	}
+	return req.Header.Get("Cookie")
+}
+
+func (s *Session) GetDevices() ([]Device, error) {
+	res, err := s.Get("https://iot.quasar.yandex.ru/m/v3/user/devices")
+	if err != nil {
+		return nil, err
+	}
+
+	var data struct {
+		Households []struct {
+			All []Device `json:"all"`
+		} `json:"households"`
+	}
+
+	if err = json.NewDecoder(res.Body).Decode(&data); err != nil {
+		return nil, err
+	}
+
+	var devices []Device
+	for _, household := range data.Households {
+		devices = append(devices, household.All...)
+	}
+	return devices, nil
+}
+
+func (s *Session) GetSnapshotURL(deviceID string) (string, error) {
+	devices, err := s.GetDevices()
+	if err != nil {
+		return "", err
+	}
+
+	for _, device := range devices {
+		if device.Id == deviceID {
+			return device.Parameters.SnapshotUrl, nil
+		}
+	}
+
+	return "", errors.New("yandex: can't get snapshot url for device: " + deviceID)
+}
+
+func (s *Session) WebrtcCreateRoom(deviceID string) (*Room, error) {
+	csrf, err := s.GetCSRF()
+	if err != nil {
+		return nil, err
+	}
+
+	req, err := http.NewRequest(
+		"POST", "https://iot.quasar.yandex.ru/m/v3/user/devices/"+deviceID+"/webrtc/create-room",
+		strings.NewReader(`{"protocol":"whip"}`),
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Add("Content-Type", "application/json")
+	req.Header.Add("X-CSRF-Token", csrf)
+
+	res, err := s.client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	var data struct {
+		Result Room `json:"result"`
+	}
+	if err = json.NewDecoder(res.Body).Decode(&data); err != nil {
+		return nil, err
+	}
+
+	return &data.Result, nil
+}
+
+type Device struct {
+	Id         string `json:"id"`
+	Name       string `json:"name"`
+	Type       string `json:"type"`
+	Parameters struct {
+		SnapshotUrl string `json:"snapshot_url,omitempty"`
+	} `json:"parameters"`
+}
+
+type Room struct {
+	ServiceUrl    string `json:"service_url"`
+	ServiceName   string `json:"service_name"`
+	RoomId        string `json:"room_id"`
+	ParticipantId string `json:"participant_id"`
+	Credentials   string `json:"jwt"`
+}
diff --git a/installs_on_host/go2rtc/scripts/README.md b/installs_on_host/go2rtc/scripts/README.md
new file mode 100644
index 0000000..8abb0c7
--- /dev/null
+++ b/installs_on_host/go2rtc/scripts/README.md
@@ -0,0 +1,104 @@
+# Scripts
+
+This folder contains a script for building binaries for all platforms.
+
+The project has no `CGO` dependencies, so building is as simple as possible using the `go build` command.
+
+The project has to use the latest versions of go due to dependencies on third-party go libraries. Such as `pion/webrtc` or `golang.org/x`. Unfortunately, this breaks compatibility with older versions of operating systems.
+
+The project uses [UPX](https://github.com/upx/upx) to compress binaries for Linux. The project does not use compression for Windows due to false antivirus alarms. The project does not use compression for macOS due to broken result.
+
+## Useful commands
+
+```
+go get -u
+go mod tidy
+go mod why github.com/pion/rtcp
+go list -deps .\cmd\go2rtc_rtsp\
+./goweight
+```
+
+## Dependencies
+
+```
+- gopkg.in/yaml.v3
+  - github.com/kr/pretty
+- github.com/AlexxIT/go2rtc/pkg/hap
+  - github.com/tadglines/go-pkgs
+  - golang.org/x/crypto
+- github.com/AlexxIT/go2rtc/pkg/mdns
+  - github.com/miekg/dns
+- github.com/AlexxIT/go2rtc/pkg/pcm
+  - github.com/sigurn/crc16
+  - github.com/sigurn/crc8
+- github.com/pion/ice/v2
+  - github.com/google/uuid
+  - github.com/wlynxg/anet
+- github.com/rs/zerolog
+  - github.com/mattn/go-colorable
+  - github.com/mattn/go-isatty
+- github.com/stretchr/testify
+  - github.com/davecgh/go-spew
+  - github.com/pmezard/go-difflib
+- ???
+  - golang.org/x/mod
+  - golang.org/x/net
+  - golang.org/x/sys
+  - golang.org/x/tools
+```
+
+## Licenses
+
+- github.com/asticode/go-astits - MIT
+- github.com/eclipse/paho.mqtt.golang - EPL-2.0
+- github.com/expr-lang/expr - MIT
+- github.com/gorilla/websocket - BSD-2
+- github.com/mattn/go-isatty - MIT
+- github.com/miekg/dns - BSD-3
+- github.com/pion/dtls - MIT
+- github.com/pion/ice - MIT
+- github.com/pion/interceptor - MIT
+- github.com/pion/rtcp - MIT
+- github.com/pion/rtp - MIT
+- github.com/pion/sdp - MIT
+- github.com/pion/srtp - MIT
+- github.com/pion/stun - MIT
+- github.com/pion/webrtc - MIT
+- github.com/rs/zerolog - MIT
+- github.com/sigurn/crc16 - MIT
+- github.com/sigurn/crc8 - MIT
+- github.com/stretchr/testify - MIT
+- github.com/tadglines/go-pkgs - Apache
+- golang.org/x/crypto - BSD-3
+- gopkg.in/yaml.v3 - MIT and Apache
+- github.com/asticode/go-astikit - MIT
+- github.com/davecgh/go-spew - ISC (BSD/MIT like)
+- github.com/google/uuid - BSD-3
+- github.com/kr/pretty - MIT
+- github.com/mattn/go-colorable - MIT
+- github.com/pion/datachannel - MIT
+- github.com/pion/logging - MIT
+- github.com/pion/mdns - MIT
+- github.com/pion/randutil - MIT
+- github.com/pion/sctp - MIT
+- github.com/pmezard/go-difflib - ???
+- github.com/wlynxg/anet - BSD-3
+- golang.org/x/mod - BSD-3
+- golang.org/x/net - BSD-3
+- golang.org/x/sync - BSD-3
+- golang.org/x/sys - BSD-3
+- golang.org/x/tools - BSD-3
+
+## Virus
+
+- https://go.dev/doc/faq#virus
+- https://groups.google.com/g/golang-nuts/c/lPwiWYaApSU
+
+## Useful links
+
+- https://github.com/golang-standards/project-layout
+- https://github.com/micro/micro
+- https://github.com/golang/go/wiki/GoArm
+- https://gist.github.com/asukakenji/f15ba7e588ac42795f421b48b8aede63
+- https://en.wikipedia.org/wiki/AArch64
+- https://stackoverflow.com/questions/22267189/what-does-the-w-flag-mean-when-passed-in-via-the-ldflags-option-to-the-go-comman
diff --git a/installs_on_host/go2rtc/scripts/build.cmd b/installs_on_host/go2rtc/scripts/build.cmd
new file mode 100644
index 0000000..37ccd44
--- /dev/null
+++ b/installs_on_host/go2rtc/scripts/build.cmd
@@ -0,0 +1,68 @@
+@ECHO OFF
+
+@SET GOOS=windows
+@SET GOARCH=amd64
+@SET FILENAME=go2rtc_win64.zip
+go build -ldflags "-s -w" -trimpath && 7z a -mx9 -sdel %FILENAME% go2rtc.exe
+
+@SET GOOS=windows
+@SET GOARCH=386
+@SET FILENAME=go2rtc_win32.zip
+go build -ldflags "-s -w" -trimpath && 7z a -mx9 -sdel %FILENAME% go2rtc.exe
+
+@SET GOOS=windows
+@SET GOARCH=arm64
+@SET FILENAME=go2rtc_win_arm64.zip
+go build -ldflags "-s -w" -trimpath && 7z a -mx9 -sdel %FILENAME% go2rtc.exe
+
+@SET GOOS=linux
+@SET GOARCH=amd64
+@SET FILENAME=go2rtc_linux_amd64
+go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx --best --lzma %FILENAME%
+
+@SET GOOS=linux
+@SET GOARCH=386
+@SET FILENAME=go2rtc_linux_i386
+go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx --best --lzma %FILENAME%
+
+@SET GOOS=linux
+@SET GOARCH=arm64
+@SET FILENAME=go2rtc_linux_arm64
+go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx --best --lzma %FILENAME%
+
+@SET GOOS=linux
+@SET GOARCH=arm
+@SET GOARM=7
+@SET FILENAME=go2rtc_linux_arm
+go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx --best --lzma %FILENAME%
+
+@SET GOOS=linux
+@SET GOARCH=arm
+@SET GOARM=6
+@SET FILENAME=go2rtc_linux_armv6
+go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx --best --lzma %FILENAME%
+
+@SET GOOS=linux
+@SET GOARCH=mipsle
+@SET FILENAME=go2rtc_linux_mipsel
+go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx --best --lzma %FILENAME%
+
+@SET GOOS=darwin
+@SET GOARCH=amd64
+@SET FILENAME=go2rtc_mac_amd64.zip
+go build -ldflags "-s -w" -trimpath && 7z a -mx9 -sdel %FILENAME% go2rtc
+
+@SET GOOS=darwin
+@SET GOARCH=arm64
+@SET FILENAME=go2rtc_mac_arm64.zip
+go build -ldflags "-s -w" -trimpath && 7z a -mx9 -sdel %FILENAME% go2rtc
+
+@SET GOOS=freebsd
+@SET GOARCH=amd64
+@SET FILENAME=go2rtc_freebsd_amd64.zip
+go build -ldflags "-s -w" -trimpath && 7z a -mx9 -sdel %FILENAME% go2rtc
+
+@SET GOOS=freebsd
+@SET GOARCH=arm64
+@SET FILENAME=go2rtc_freebsd_arm64.zip
+go build -ldflags "-s -w" -trimpath && 7z a -mx9 -sdel %FILENAME% go2rtc
diff --git a/installs_on_host/go2rtc/scripts/build.sh b/installs_on_host/go2rtc/scripts/build.sh
new file mode 100755
index 0000000..ed188c2
--- /dev/null
+++ b/installs_on_host/go2rtc/scripts/build.sh
@@ -0,0 +1,47 @@
+#!/bin/sh
+
+set -e  # Exit immediately if a command exits with a non-zero status.
+set -u  # Treat unset variables as an error when substituting.
+
+check_command() {
+    if ! command -v "$1" >/dev/null
+    then
+        echo "Error: $1 could not be found. Please install it." >&2
+        return 1
+    fi
+}
+
+build_zip() {
+  go build -ldflags "-s -w" -trimpath -o $2
+  7z a -mx9 -sdel $1 $2
+}
+
+build_upx() {
+  go build -ldflags "-s -w" -trimpath -o $1
+  upx --best --lzma $1
+}
+
+check_command go
+check_command 7z
+check_command upx
+
+export CGO_ENABLED=0
+
+set -x  # Print commands and their arguments as they are executed.
+
+GOOS=windows  GOARCH=amd64        build_zip go2rtc_win64.zip     go2rtc.exe
+GOOS=windows  GOARCH=386          build_zip go2rtc_win32.zip     go2rtc.exe
+GOOS=windows  GOARCH=arm64        build_zip go2rtc_win_arm64.zip go2rtc.exe
+
+GOOS=linux    GOARCH=amd64        build_upx go2rtc_linux_amd64
+GOOS=linux    GOARCH=386          build_upx go2rtc_linux_i386
+GOOS=linux    GOARCH=arm64        build_upx go2rtc_linux_arm64
+GOOS=linux    GOARCH=mipsle       build_upx go2rtc_linux_mipsel
+GOOS=linux    GOARCH=arm GOARM=7  build_upx go2rtc_linux_arm
+GOOS=linux    GOARCH=arm GOARM=6  build_upx go2rtc_linux_armv6
+
+GOOS=darwin   GOARCH=amd64        build_zip go2rtc_mac_amd64.zip go2rtc
+GOOS=darwin   GOARCH=arm64        build_zip go2rtc_mac_arm64.zip go2rtc
+
+GOOS=freebsd  GOARCH=amd64        build_zip go2rtc_freebsd_amd64.zip go2rtc
+GOOS=freebsd  GOARCH=arm64        build_zip go2rtc_freebsd_arm64.zip go2rtc
diff --git a/installs_on_host/go2rtc/website/.vitepress/config.js b/installs_on_host/go2rtc/website/.vitepress/config.js
new file mode 100644
index 0000000..792f2e7
--- /dev/null
+++ b/installs_on_host/go2rtc/website/.vitepress/config.js
@@ -0,0 +1,188 @@
+import {defineConfig} from 'vitepress';
+
+function replace_link(md) {
+    md.core.ruler.after('inline', 'replace-link', function (state) {
+        for (const block of state.tokens) {
+            if (block.type === 'inline' && block.children) {
+                for (const token of block.children) {
+                    const href = token.attrGet('href');
+                    if (href && href.indexOf('README.md') >= 0) {
+                        // token.attrJoin('style', 'color:red;');
+                        token.attrSet('href', href.replace('README.md', 'index.md'));
+                    }
+                }
+            }
+        }
+        return true;
+    });
+}
+
+export default defineConfig({
+    title: 'go2rtc',
+    description: 'Ultimate camera streaming application',
+    head: [
+        // first line (green bold) of Telegram card, autodetect from hostname
+        ['meta', { property: 'og:site_name', content: 'go2rtc.org' }],
+        // second line of Telegram card (black bold), autodetect from site description
+        ['meta', { property: 'og:title', content: 'go2rtc - Ultimate camera streaming application' }],
+        // third line of Telegram card, autodetect from site description
+        ['meta', { property: 'og:description', content: 'Support alsa, doorbird, dvrip, eseecloud, ffmpeg, gopro, hass, hls, homekit, mjpeg, mp4, mpegts, nest, onvif, ring, roborock, rtmp, rtsp, tapo, vigi, tuya, v4l2, webrtc, wyze, xiaomi.' }],
+        ['meta', { property: 'og:url', content: 'https://go2rtc.org/' }],
+        ['meta', { property: 'og:image', content: 'https://go2rtc.org/images/logo.png' }],
+        // important for Telegram - the image will be at the bottom and large
+        ['meta', { property: 'twitter:card', content: 'summary_large_image' }],
+    ],
+    sitemap: {hostname: 'https://go2rtc.org'},
+
+    themeConfig: {
+        nav: [
+            {text: 'Home', link: '/'},
+        ],
+        sidebar: [
+            {
+                items: [
+                    {text: 'Installation', link: '/#installation'},
+                    {text: 'Configuration', link: '/#configuration'},
+                    {text: 'Security', link: '/#security'},
+                ],
+            },
+            {
+                text: 'Features',
+                items: [
+                    {text: 'Streaming input', link: '/#streaming-input'},
+                    {text: 'Streaming output', link: '/#streaming-output'},
+                    {text: 'Streaming ingest', link: '/#streaming-ingest'},
+                    {text: 'Two-way audio', link: '/#two-way-audio'},
+                    {text: 'Stream to camera', link: '/#stream-to-camera'},
+                    {text: 'Publish stream', link: '/#publish-stream'},
+                    {text: 'Preload stream', link: '/#preload-stream'},
+                    {text: 'Streaming stats', link: '/#streaming-stats'},
+                ],
+                collapsed: false,
+            },
+            {
+                text: 'Codecs',
+                items: [
+                    {text: 'Codecs filters', link: '/#codecs-filters'},
+                    {text: 'Codecs madness', link: '/#codecs-madness'},
+                    {text: 'Built-in transcoding', link: '/#built-in-transcoding'},
+                    {text: 'Codecs negotiation', link: '/#codecs-negotiation'},
+                ],
+                collapsed: true,
+            },
+            {
+                text: 'Other',
+                items: [
+                    {text: 'Projects using go2rtc', link: '/#projects-using-go2rtc'},
+                    {text: 'Camera experience', link: '/#camera-experience'},
+                    {text: 'Tips', link: '/#tips'},
+                ],
+                collapsed: true,
+            },
+            {
+                text: 'Core modules',
+                items: [
+                    {text: 'app', link: '/internal/app/'},
+                    {text: 'api', link: '/internal/api/'},
+                    {text: 'streams', link: '/internal/streams/'},
+                ],
+                collapsed: false,
+            },
+            {
+                text: 'Main modules',
+                items: [
+                    {text: 'http', link: '/internal/http/'},
+                    {text: 'mjpeg', link: '/internal/mjpeg/'},
+                    {text: 'mp4', link: '/internal/mp4/'},
+                    {text: 'rtsp', link: '/internal/rtsp/'},
+                    {text: 'webrtc', link: '/internal/webrtc/'},
+                ],
+                collapsed: false,
+            },
+            {
+                text: 'Other modules',
+                items: [
+                    {text: 'hls', link: '/internal/hls/'},
+                    {text: 'homekit', link: '/internal/homekit/'},
+                    {text: 'onvif', link: '/internal/onvif/'},
+                    {text: 'rtmp', link: '/internal/rtmp/'},
+                    {text: 'webtorrent', link: '/internal/webtorrent/'},
+                    {text: 'wyoming', link: '/internal/wyoming/'},
+                ],
+                collapsed: false,
+            },
+            {
+                text: 'Script sources',
+                items: [
+                    {text: 'echo', link: '/internal/echo/'},
+                    {text: 'exec', link: '/internal/exec/'},
+                    {text: 'expr', link: '/internal/expr/'},
+                    {text: 'ffmpeg', link: '/internal/ffmpeg/'},
+                ],
+                collapsed: false,
+            },
+            {
+                text: 'Other sources',
+                items: [
+                    {text: 'alsa', link: '/internal/alsa/'},
+                    {text: 'bubble', link: '/internal/bubble/'},
+                    {text: 'doorbird', link: '/internal/doorbird/'},
+                    {text: 'dvrip', link: '/internal/dvrip/'},
+                    {text: 'eseecloud', link: '/internal/eseecloud/'},
+                    {text: 'flussonic', link: '/internal/flussonic/'},
+                    {text: 'gopro', link: '/internal/gopro/'},
+                    {text: 'hass', link: '/internal/hass/'},
+                    {text: 'isapi', link: '/internal/isapi/'},
+                    {text: 'ivideon', link: '/internal/ivideon/'},
+                    {text: 'kasa', link: '/internal/kasa/'},
+                    {text: 'mpeg', link: '/internal/mpeg/'},
+                    {text: 'multitrans', link: '/internal/multitrans/'},
+                    {text: 'nest', link: '/internal/nest/'},
+                    {text: 'ring', link: '/internal/ring/'},
+                    {text: 'roborock', link: '/internal/roborock/'},
+                    {text: 'tapo', link: '/internal/tapo/'},
+                    {text: 'tuya', link: '/internal/tuya/'},
+                    {text: 'v4l2', link: '/internal/v4l2/'},
+                    {text: 'wyze', link: '/internal/wyze/'},
+                    {text: 'xiaomi', link: '/internal/xiaomi/'},
+                    {text: 'yandex', link: '/internal/yandex/'},
+                ],
+                collapsed: false,
+            },
+            {
+                text: 'Helper modules',
+                items: [
+                    {text: 'debug', link: '/internal/debug/'},
+                    {text: 'ngrok', link: '/internal/ngrok/'},
+                    {text: 'pinggy', link: '/internal/pinggy/'},
+                    {text: 'srtp', link: '/internal/srtp/'},
+                ],
+                collapsed: false,
+            },
+
+        ],
+        socialLinks: [
+            {icon: 'github', link: 'https://github.com/AlexxIT/go2rtc'}
+        ],
+        outline: [2, 3],
+        search: {provider: 'local'},
+    },
+
+    rewrites(id) {
+        // change file names
+        return id.replace('README.md', 'index.md');
+    },
+
+    markdown: {
+        config: (md) => {
+            // change markdown links
+            md.use(replace_link);
+        }
+    },
+
+    srcDir: '..',
+    srcExclude: ['examples/', 'pkg/'],
+
+    // cleanUrls: true,
+    ignoreDeadLinks: true,
+});
diff --git a/installs_on_host/go2rtc/website/README.md b/installs_on_host/go2rtc/website/README.md
new file mode 100644
index 0000000..81a2ad0
--- /dev/null
+++ b/installs_on_host/go2rtc/website/README.md
@@ -0,0 +1,9 @@
+# WebSite
+
+These are the sources of the [go2rtc.org](https://go2rtc.org/) website. It's content published on GitHub Pages and is a mirror of [alexxit.github.io/go2rtc/](http://alexxit.github.io/go2rtc/).
+
+The site contains:
+
+- Project's documentation, which is compiled via [vitepress](https://github.com/vuejs/vitepress) from `README.md` files located in the root of the repository, as well as in the `internal` folder.
+- Project's API in OpenAPI format, and the [Redoc](https://github.com/Redocly/redoc) viewer
+- Project's assets (logo).
diff --git a/installs_on_host/go2rtc/website/api/index.html b/installs_on_host/go2rtc/website/api/index.html
new file mode 100644
index 0000000..2f67678
--- /dev/null
+++ b/installs_on_host/go2rtc/website/api/index.html
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <title>API | go2rtc</title>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <link href="https://fonts.googleapis.com/css?family=Montserrat:300,400,700|Roboto:300,400,700" rel="stylesheet">
+    <style>
+        body {
+            margin: 0;
+            padding: 0;
+        }
+    </style>
+</head>
+<body>
+<redoc spec-url="openapi.yaml"></redoc>
+<script src="https://cdn.redoc.ly/redoc/latest/bundles/redoc.standalone.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/installs_on_host/go2rtc/website/api/openapi.yaml b/installs_on_host/go2rtc/website/api/openapi.yaml
new file mode 100644
index 0000000..b611057
--- /dev/null
+++ b/installs_on_host/go2rtc/website/api/openapi.yaml
@@ -0,0 +1,1197 @@
+openapi: 3.1.0
+
+info:
+  title: go2rtc
+  version: 1.9.13
+  license: { name: MIT,url: https://opensource.org/licenses/MIT }
+  contact: { url: https://github.com/AlexxIT/go2rtc }
+  description: |
+    Ultimate camera streaming application with support RTSP, RTMP, HTTP-FLV, WebRTC, MSE, HLS, MP4, MJPEG, HomeKit, FFmpeg, etc.
+
+servers:
+  - url: http://localhost:1984
+
+tags:
+  - name: Application
+    description: "[Module: API](https://github.com/AlexxIT/go2rtc#module-api)"
+  - name: Config
+    description: "[Configuration](https://github.com/AlexxIT/go2rtc#configuration)"
+  - name: Streams list
+    description: "[Module: Streams](https://github.com/AlexxIT/go2rtc#module-streams)"
+  - name: Consume stream
+  - name: HLS
+  - name: Snapshot
+  - name: Produce stream
+  - name: WebSocket
+    description: "WebSocket API endpoint: `/api/ws` (see `api/README.md`)"
+  - name: Discovery
+  - name: HomeKit
+  - name: ONVIF
+  - name: RTSPtoWebRTC
+  - name: WebTorrent
+    description: "[Module: WebTorrent](https://github.com/AlexxIT/go2rtc#module-webtorrent)"
+  - name: FFmpeg
+  - name: Debug
+
+components:
+  parameters:
+    stream_src_path:
+      name: src
+      in: path
+      description: Source stream name
+      required: true
+      schema: { type: string }
+      example: camera1
+
+    stream_dst_path:
+      name: dst
+      in: path
+      description: Destination stream name
+      required: true
+      schema: { type: string }
+      example: camera1
+
+    stream_src_query:
+      name: src
+      in: query
+      description: Source stream name
+      required: true
+      schema: { type: string }
+      example: camera1
+
+    hls_session_id_path:
+      name: id
+      in: path
+      description: HLS session ID (passed as query param `id`)
+      required: true
+      schema: { type: string }
+      example: DvmHdd9w
+
+    mp4_filter:
+      name: mp4
+      in: query
+      description: MP4 codecs filter
+      required: false
+      schema:
+        type: string
+        enum: [ "", flac, all ]
+      example: flac
+
+    video_filter:
+      name: video
+      in: query
+      description: Video codecs filter
+      schema:
+        type: string
+        enum: [ "", all, h264, h265, mjpeg ]
+      example: h264,h265
+
+    audio_filter:
+      name: audio
+      in: query
+      description: Audio codecs filter
+      schema:
+        type: string
+        enum: [ "", all, aac, opus, pcm, pcmu, pcma ]
+      example: aac
+
+  responses:
+    discovery:
+      description: ""
+      content:
+        application/json:
+          example: { streams: [ { "name": "Camera 1","url": "..." } ] }
+
+    webtorrent:
+      description: ""
+      content:
+        application/json:
+          example: { share: AKDypPy4zz, pwd: H0Km1HLTTP }
+
+paths:
+  /api:
+    get:
+      summary: Get application info
+      tags: [ Application ]
+      responses:
+        "200":
+          description: ""
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  config_path: { type: string, example: "/config/go2rtc.yaml" }
+                  host: { type: string, example: "192.168.1.123:1984" }
+                  rtsp:
+                    type: object
+                    properties:
+                      listen: { type: string, example: ":8554" }
+                      default_query: { type: string, example: "video&audio" }
+                  version: { type: string, example: "1.9.12" }
+
+  /api/exit:
+    post:
+      summary: Close application
+      tags: [ Application ]
+      parameters:
+        - name: code
+          in: query
+          description: Application exit code
+          required: false
+          schema: { type: integer }
+          example: 100
+      responses:
+        default:
+          description: ""
+
+  /api/restart:
+    post:
+      summary: Restart daemon
+      description: Restarts the daemon.
+      tags: [ Application ]
+      responses:
+        default:
+          description: ""
+
+  /api/log:
+    get:
+      summary: Get in-memory logs buffer
+      description: |
+        Returns current log output from the in-memory circular buffer.
+      tags: [ Application ]
+      responses:
+        "200":
+          description: OK
+          content:
+            application/jsonlines:
+              example: |
+                {"level":"info","version":"1.9.13","platform":"linux/amd64","revision":"dfe4755","time":1766841087331,"message":"go2rtc"}
+    delete:
+      summary: Clear in-memory logs buffer
+      tags: [ Application ]
+      responses:
+        "200":
+          description: ""
+          content:
+            text/plain: { example: "" }
+
+  /api/config:
+    get:
+      summary: Get main config file content
+      tags: [ Config ]
+      responses:
+        "200":
+          description: ""
+          content:
+            application/yaml: { example: "streams:..." }
+        "404":
+          description: Config file not found
+    post:
+      summary: Rewrite main config file
+      tags: [ Config ]
+      requestBody:
+        content:
+          "*/*": { example: "streams:..." }
+      responses:
+        default:
+          description: ""
+    patch:
+      summary: Merge changes to main config file
+      tags: [ Config ]
+      requestBody:
+        content:
+          "*/*": { example: "streams:..." }
+      responses:
+        default:
+          description: ""
+
+
+
+  /api/streams:
+    get:
+      summary: Get all streams info
+      tags: [ Streams list ]
+      responses:
+        "200":
+          description: ""
+          content:
+            application/json:
+              schema:
+                type: object
+                additionalProperties:
+                  type: object
+                  properties:
+                    producers:
+                      type: array
+                    consumers:
+                      type: array
+    put:
+      summary: Create new stream
+      tags: [ Streams list ]
+      parameters:
+        - name: src
+          in: query
+          description: Stream source (URI)
+          required: true
+          schema: { type: string }
+          example: "rtsp://rtsp:12345678@192.168.1.123/av_stream/ch0"
+        - name: name
+          in: query
+          description: Stream name
+          required: false
+          schema: { type: string }
+          example: camera1
+      responses:
+        default:
+          description: ""
+    patch:
+      summary: Update stream source
+      tags: [ Streams list ]
+      parameters:
+        - name: src
+          in: query
+          description: Stream source (URI)
+          required: true
+          schema: { type: string }
+          example: "rtsp://rtsp:12345678@192.168.1.123/av_stream/ch0"
+        - name: name
+          in: query
+          description: Stream name
+          required: true
+          schema: { type: string }
+          example: camera1
+      responses:
+        default:
+          description: ""
+    delete:
+      summary: Delete stream
+      tags: [ Streams list ]
+      parameters:
+        - name: src
+          in: query
+          description: Stream name
+          required: true
+          schema: { type: string }
+          example: camera1
+      responses:
+        default:
+          description: ""
+    post:
+      summary: Send stream from source to destination
+      description: "[Stream to camera](https://github.com/AlexxIT/go2rtc#stream-to-camera)"
+      tags: [ Streams list ]
+      parameters:
+        - name: src
+          in: query
+          description: Stream source (URI)
+          required: true
+          schema: { type: string }
+          example: "ffmpeg:http://example.com/song.mp3#audio=pcma#input=file"
+        - name: dst
+          in: query
+          description: Destination stream name
+          required: true
+          schema: { type: string }
+          example: camera1
+      responses:
+        default:
+          description: ""
+
+  /api/streams.dot:
+    get:
+      summary: Get streams graph in Graphviz DOT format
+      tags: [ Streams list ]
+      parameters:
+        - name: src
+          in: query
+          description: Stream name filter. Repeat `src` to include multiple streams.
+          required: false
+          schema: { type: string }
+          example: camera1
+      responses:
+        "200":
+          description: OK
+          content:
+            text/vnd.graphviz:
+              example: "digraph { ... }"
+
+  /api/preload:
+    get:
+      summary: Get all preloaded streams
+      tags: [ Streams list ]
+      responses:
+        "200":
+          description: ""
+          content:
+            application/json:
+              schema:
+                type: object
+                additionalProperties:
+                  type: object
+                  properties:
+                    consumer:
+                      type: object
+                    query:
+                      type: string
+                      example: "video&audio"
+    put:
+      summary: Preload new stream
+      tags: [ Streams list ]
+      parameters:
+        - name: src
+          in: query
+          description: Stream source (name)
+          required: true
+          schema: { type: string }
+          example: "camera1"
+        - name: video
+          in: query
+          description: Video codecs filter
+          required: false
+          schema: { type: string }
+          example: all,h264,h265,...
+        - name: audio
+          in: query
+          description: Audio codecs filter
+          required: false
+          schema: { type: string }
+          example: all,aac,opus,...
+        - name: microphone
+          in: query
+          description: Microphone codecs filter
+          required: false
+          schema: { type: string }
+          example: all,aac,opus,...
+      responses:
+        default:
+          description: ""
+    delete:
+      summary: Delete preloaded stream
+      tags: [ Streams list ]
+      parameters:
+        - name: src
+          in: query
+          description: Stream source (name)
+          required: true
+          schema: { type: string }
+          example: "camera1"
+      responses:
+        default:
+          description: ""
+
+  /api/schemes:
+    get:
+      summary: Get supported source URL schemes
+      tags: [ Streams list ]
+      responses:
+        "200":
+          description: OK
+          content:
+            application/json:
+              schema:
+                type: array
+                items: { type: string }
+              example: [ rtsp, rtmp, webrtc, ffmpeg, hass ]
+
+
+  /api/streams?src={src}:
+    get:
+      summary: Get stream info in JSON format
+      tags: [ Consume stream ]
+      parameters:
+        - $ref: "#/components/parameters/stream_src_path"
+      responses:
+        "200":
+          description: ""
+          content:
+            application/json:
+              schema:
+                type: object
+                additionalProperties:
+                  type: object
+                  properties:
+                    producers:
+                      type: array
+                      items: { type: object }
+                    consumers:
+                      type: array
+                      items: { type: object }
+
+  /api/webrtc?src={src}:
+    post:
+      summary: Get stream in WebRTC format (WHEP)
+      description: "[Module: WebRTC](https://github.com/AlexxIT/go2rtc#module-webrtc)"
+      tags: [ Consume stream ]
+      parameters:
+        - $ref: "#/components/parameters/stream_src_path"
+      requestBody:
+        description: |
+          Support:
+          - JSON format (`Content-Type: application/json`)
+          - WHEP standard (`Content-Type: application/sdp`)
+          - raw SDP (`Content-Type: anything`)
+        required: true
+        content:
+          application/json: { example: { type: offer, sdp: "v=0..." } }
+          "application/sdp": { example: "v=0..." }
+          "*/*": { example: "v=0..." }
+      responses:
+        "200":
+          description: "Response on JSON or raw SDP"
+          content:
+            application/json: { example: { type: answer, sdp: "v=0..." } }
+            application/sdp: { example: "v=0..." }
+        "201":
+          description: "Response on `Content-Type: application/sdp`"
+          content:
+            application/sdp: { example: "v=0..." }
+
+  /api/stream.mp4?src={src}:
+    get:
+      summary: Get stream in MP4 format (HTTP progressive)
+      description: "[Module: MP4](https://github.com/AlexxIT/go2rtc#module-mp4)"
+      tags: [ Consume stream ]
+      parameters:
+        - $ref: "#/components/parameters/stream_src_path"
+        - name: duration
+          in: query
+          description: Limit the length of the stream in seconds
+          required: false
+          schema: { type: string }
+          example: 15
+        - name: filename
+          in: query
+          description: Download as a file with this name
+          required: false
+          schema: { type: string }
+          example: camera1.mp4
+        - name: rotate
+          in: query
+          description: "Rotate video (degrees). Supported values: 90, 180, 270."
+          required: false
+          schema: { type: integer, enum: [ 90, 180, 270 ] }
+        - name: scale
+          in: query
+          description: Scale video in format `width:height`
+          required: false
+          schema: { type: string, example: "1280:720" }
+        - $ref: "#/components/parameters/mp4_filter"
+        - $ref: "#/components/parameters/video_filter"
+        - $ref: "#/components/parameters/audio_filter"
+      responses:
+        200:
+          description: ""
+          content: { video/mp4: { example: "" } }
+
+  /api/stream.m3u8?src={src}:
+    get:
+      summary: Get stream in HLS format
+      description: "[Module: HLS](https://github.com/AlexxIT/go2rtc#module-hls)"
+      tags: [ Consume stream, HLS ]
+      parameters:
+        - $ref: "#/components/parameters/stream_src_path"
+        - $ref: "#/components/parameters/mp4_filter"
+        - $ref: "#/components/parameters/video_filter"
+        - $ref: "#/components/parameters/audio_filter"
+      responses:
+        200:
+          description: ""
+          content: { application/vnd.apple.mpegurl: { example: "" } }
+
+  /api/hls/playlist.m3u8?id={id}:
+    get:
+      summary: Get HLS media playlist for an active session
+      tags: [ HLS ]
+      parameters:
+        - $ref: "#/components/parameters/hls_session_id_path"
+      responses:
+        "200":
+          description: OK
+          content:
+            application/vnd.apple.mpegurl: { example: "" }
+        "404":
+          description: Session not found
+
+  /api/hls/segment.ts?id={id}:
+    get:
+      summary: Get HLS MPEG-TS segment for an active session
+      tags: [ HLS ]
+      parameters:
+        - $ref: "#/components/parameters/hls_session_id_path"
+      responses:
+        "200":
+          description: OK
+          content:
+            video/mp2t: { example: "" }
+        "404":
+          description: Segment or session not found
+
+  /api/hls/init.mp4?id={id}:
+    get:
+      summary: Get HLS fMP4 init segment for an active session
+      tags: [ HLS ]
+      parameters:
+        - $ref: "#/components/parameters/hls_session_id_path"
+      responses:
+        "200":
+          description: OK
+          content:
+            video/mp4: { example: "" }
+        "404":
+          description: Segment or session not found
+
+  /api/hls/segment.m4s?id={id}:
+    get:
+      summary: Get HLS fMP4 media segment for an active session
+      tags: [ HLS ]
+      parameters:
+        - $ref: "#/components/parameters/hls_session_id_path"
+      responses:
+        "200":
+          description: OK
+          content:
+            video/iso.segment: { example: "" }
+        "404":
+          description: Segment or session not found
+
+  /api/stream.mjpeg?src={src}:
+    get:
+      summary: Get stream in MJPEG format
+      description: "[Module: MJPEG](https://github.com/AlexxIT/go2rtc#module-mjpeg)"
+      tags: [ Consume stream ]
+      parameters:
+        - $ref: "#/components/parameters/stream_src_path"
+      responses:
+        200:
+          description: ""
+          content: { multipart/x-mixed-replace: { example: "" } }
+
+  /api/stream.ascii?src={src}:
+    get:
+      summary: Get stream in ASCII-art format (ANSI escape codes)
+      description: "[Module: MJPEG](https://github.com/AlexxIT/go2rtc#module-mjpeg)"
+      tags: [ Consume stream ]
+      parameters:
+        - $ref: "#/components/parameters/stream_src_path"
+        - name: color
+          in: query
+          description: Foreground mode (`8`, `256`, `rgb` or ANSI SGR code)
+          required: false
+          schema: { type: string }
+        - name: back
+          in: query
+          description: Background mode (`8`, `256`, `rgb` or ANSI SGR code)
+          required: false
+          schema: { type: string }
+        - name: text
+          in: query
+          description: Charset preset (empty/default, `block`) or custom characters
+          required: false
+          schema: { type: string }
+      responses:
+        "200":
+          description: OK
+          content:
+            text/plain: { example: "" }
+        "404":
+          description: Stream not found
+
+  /api/stream.y4m?src={src}:
+    get:
+      summary: Get stream in YUV4MPEG2 format (y4m)
+      tags: [ Consume stream ]
+      parameters:
+        - $ref: "#/components/parameters/stream_src_path"
+      responses:
+        "200":
+          description: OK
+          content:
+            application/octet-stream: { example: "" }
+        "404":
+          description: Stream not found
+
+  /api/stream.ts?src={src}:
+    get:
+      summary: Get stream in MPEG-TS format
+      tags: [ Consume stream ]
+      parameters:
+        - $ref: "#/components/parameters/stream_src_path"
+      responses:
+        "200":
+          description: OK
+          content:
+            video/mp2t: { example: "" }
+        "404":
+          description: Stream not found
+
+  /api/stream.aac?src={src}:
+    get:
+      summary: Get stream audio in AAC (ADTS) format
+      tags: [ Consume stream ]
+      parameters:
+        - $ref: "#/components/parameters/stream_src_path"
+      responses:
+        "200":
+          description: OK
+          content:
+            audio/aac: { example: "" }
+        "404":
+          description: Stream not found
+
+  /api/stream.flv?src={src}:
+    get:
+      summary: Get stream in FLV format
+      tags: [ Consume stream ]
+      parameters:
+        - $ref: "#/components/parameters/stream_src_path"
+      responses:
+        "200":
+          description: OK
+          content:
+            video/x-flv: { example: "" }
+        "404":
+          description: Stream not found
+
+  /api/frame.jpeg?src={src}:
+    get:
+      summary: Get snapshot in JPEG format
+      description: "[Module: MJPEG](https://github.com/AlexxIT/go2rtc#module-mjpeg)"
+      tags: [ Snapshot ]
+      parameters:
+        - $ref: "#/components/parameters/stream_src_path"
+        - name: name
+          in: query
+          description: Optional stream name to create/update if `src` is a URL
+          required: false
+          schema: { type: string }
+        - name: width
+          in: query
+          description: "Scale output width (alias: `w`)"
+          required: false
+          schema: { type: integer, minimum: 1 }
+        - name: height
+          in: query
+          description: "Scale output height (alias: `h`)"
+          required: false
+          schema: { type: integer, minimum: 1 }
+        - name: rotate
+          in: query
+          description: "Rotate output (degrees). Supported values: 90, 180, 270."
+          required: false
+          schema: { type: integer, enum: [ 90, 180, 270 ] }
+        - name: hardware
+          in: query
+          description: "Hardware acceleration engine for FFmpeg snapshot transcoding (alias: `hw`)"
+          required: false
+          schema: { type: string }
+      responses:
+        "200":
+          description: ""
+          content:
+            image/jpeg: { example: "" }
+
+  /api/frame.mp4?src={src}:
+    get:
+      summary: Get snapshot in MP4 format
+      description: "[Module: MP4](https://github.com/AlexxIT/go2rtc#module-mp4)"
+      tags: [ Snapshot ]
+      parameters:
+        - $ref: "#/components/parameters/stream_src_path"
+        - name: filename
+          in: query
+          description: Download as a file with this name
+          required: false
+          schema: { type: string }
+          example: camera1.mp4
+      responses:
+        200:
+          description: ""
+          content:
+            video/mp4: { example: "" }
+
+
+
+  /api/webrtc?dst={dst}:
+    post:
+      summary: Post stream in WebRTC format (WHIP)
+      description: "[Incoming: WebRTC/WHIP](https://github.com/AlexxIT/go2rtc#incoming-webrtcwhip)"
+      tags: [ Produce stream ]
+      parameters:
+        - $ref: "#/components/parameters/stream_dst_path"
+      responses:
+        "201":
+          description: Created
+          headers:
+            Location:
+              description: Resource URL for session
+              schema: { type: string }
+          content:
+            application/sdp: { example: "v=0..." }
+        "404":
+          description: Stream not found
+
+  /api/stream?dst={dst}:
+    post:
+      summary: Post stream in auto-detected format
+      description: |
+        Incoming source with automatic format detection. Use for pushing a stream into an existing `dst` stream.
+      tags: [ Produce stream ]
+      parameters:
+        - $ref: "#/components/parameters/stream_dst_path"
+      responses:
+        default:
+          description: ""
+
+  /api/stream.flv?dst={dst}:
+    post:
+      summary: Post stream in FLV format
+      description: "[Incoming sources](https://github.com/AlexxIT/go2rtc#incoming-sources)"
+      tags: [ Produce stream ]
+      parameters:
+        - $ref: "#/components/parameters/stream_dst_path"
+      responses:
+        default:
+          description: ""
+
+  /api/stream.ts?dst={dst}:
+    post:
+      summary: Post stream in MPEG-TS format
+      description: "[Incoming sources](https://github.com/AlexxIT/go2rtc#incoming-sources)"
+      tags: [ Produce stream ]
+      parameters:
+        - $ref: "#/components/parameters/stream_dst_path"
+      responses:
+        default:
+          description: ""
+
+  /api/stream.mjpeg?dst={dst}:
+    post:
+      summary: Post stream in MJPEG format
+      description: "[Incoming sources](https://github.com/AlexxIT/go2rtc#incoming-sources)"
+      tags: [ Produce stream ]
+      parameters:
+        - $ref: "#/components/parameters/stream_dst_path"
+      responses:
+        default:
+          description: ""
+
+
+  /api/ffmpeg:
+    post:
+      summary: Play file/live/TTS into a stream via FFmpeg
+      description: |
+        Helper endpoint for "stream to camera" scenarios.
+        Exactly one of `file`, `live`, `text` should be provided.
+      tags: [ FFmpeg ]
+      parameters:
+        - name: dst
+          in: query
+          description: Destination stream name
+          required: true
+          schema: { type: string }
+          example: camera1
+        - name: file
+          in: query
+          description: Input URL to treat as file (`#input=file`)
+          required: false
+          schema: { type: string }
+          example: "http://example.com/song.mp3"
+        - name: live
+          in: query
+          description: Live input URL
+          required: false
+          schema: { type: string }
+          example: "http://example.com/live.mp3"
+        - name: text
+          in: query
+          description: Text-to-speech phrase
+          required: false
+          schema: { type: string }
+          example: "Hello"
+        - name: voice
+          in: query
+          description: Optional TTS voice (engine-dependent)
+          required: false
+          schema: { type: string }
+      responses:
+        "200":
+          description: OK
+        "400":
+          description: Invalid parameters
+        "404":
+          description: Stream not found
+
+
+  /api/dvrip:
+    get:
+      summary: DVRIP cameras discovery
+      description: "[Source: DVRIP](https://github.com/AlexxIT/go2rtc#source-dvrip)"
+      tags: [ Discovery ]
+      responses:
+        "200": { $ref: "#/components/responses/discovery" }
+
+  /api/ffmpeg/devices:
+    get:
+      summary: FFmpeg USB devices discovery
+      description: "[Source: FFmpeg Device](https://github.com/AlexxIT/go2rtc#source-ffmpeg-device)"
+      tags: [ Discovery ]
+      responses:
+        "200": { $ref: "#/components/responses/discovery" }
+  
+  /api/ffmpeg/hardware:
+    get:
+      summary: FFmpeg hardware transcoding discovery
+      description: "[Hardware acceleration](https://github.com/AlexxIT/go2rtc/wiki/Hardware-acceleration)"
+      tags: [ Discovery ]
+      responses:
+        "200": { $ref: "#/components/responses/discovery" }
+  
+  /api/v4l2:
+    get:
+      summary: V4L2 video devices discovery (Linux)
+      tags: [ Discovery ]
+      responses:
+        "200": { $ref: "#/components/responses/discovery" }
+  
+  /api/alsa:
+    get:
+      summary: ALSA audio devices discovery (Linux)
+      tags: [ Discovery ]
+      responses:
+        "200": { $ref: "#/components/responses/discovery" }
+  
+  /api/gopro:
+    get:
+      summary: GoPro cameras discovery
+      tags: [ Discovery ]
+      responses:
+        "200": { $ref: "#/components/responses/discovery" }
+
+  /api/ring:
+    get:
+      summary: Ring cameras discovery
+      description: |
+        Provide either `email`/`password` (and optional `code` for 2FA) or `refresh_token`.
+        If 2FA is required, returns a JSON prompt instead of sources.
+      tags: [ Discovery ]
+      parameters:
+        - name: email
+          in: query
+          required: false
+          schema: { type: string }
+        - name: password
+          in: query
+          required: false
+          schema: { type: string }
+        - name: code
+          in: query
+          required: false
+          schema: { type: string }
+        - name: refresh_token
+          in: query
+          required: false
+          schema: { type: string }
+      responses:
+        "200":
+          description: OK
+          content:
+            application/json: { example: "" }
+
+  /api/tuya:
+    get:
+      summary: Tuya cameras discovery
+      tags: [ Discovery ]
+      parameters:
+        - name: region
+          in: query
+          description: Tuya API host (region)
+          required: true
+          schema: { type: string }
+          example: "openapi.tuyaus.com"
+        - name: email
+          in: query
+          required: true
+          schema: { type: string }
+        - name: password
+          in: query
+          required: true
+          schema: { type: string }
+      responses:
+        "200": { $ref: "#/components/responses/discovery" }
+        "400":
+          description: Invalid parameters
+        "404":
+          description: No cameras found
+  
+  /api/hass:
+    get:
+      summary: Home Assistant cameras discovery
+      description: "[Source: Hass](https://github.com/AlexxIT/go2rtc#source-hass)"
+      tags: [ Discovery ]
+      responses:
+        "200": { $ref: "#/components/responses/discovery" }
+        "404": { description: No Hass config }
+
+  /api/discovery/homekit:
+    get:
+      summary: HomeKit cameras discovery
+      description: "[Source: HomeKit](https://github.com/AlexxIT/go2rtc#source-homekit)"
+      tags: [ Discovery ]
+      responses:
+        "200": { $ref: "#/components/responses/discovery" }
+
+  /api/nest:
+    get:
+      summary: Nest cameras discovery
+      tags: [ Discovery ]
+      parameters:
+        - name: client_id
+          in: query
+          required: true
+          schema: { type: string }
+        - name: client_secret
+          in: query
+          required: true
+          schema: { type: string }
+        - name: refresh_token
+          in: query
+          required: true
+          schema: { type: string }
+        - name: project_id
+          in: query
+          required: true
+          schema: { type: string }
+      responses:
+        "200": { $ref: "#/components/responses/discovery" }
+
+  /api/onvif:
+    get:
+      summary: ONVIF cameras discovery
+      description: "[Source: ONVIF](https://github.com/AlexxIT/go2rtc#source-onvif)"
+      tags: [ Discovery ]
+      parameters:
+        - name: src
+          in: query
+          description: Optional ONVIF device URL to enumerate profiles
+          required: false
+          schema: { type: string }
+          example: "onvif://user:pass@192.168.1.50:80"
+      responses:
+        "200": { $ref: "#/components/responses/discovery" }
+
+  /api/roborock:
+    get:
+      summary: Roborock vacuums discovery (requires prior auth)
+      description: "[Source: Roborock](https://github.com/AlexxIT/go2rtc#source-roborock)"
+      tags: [ Discovery ]
+      responses:
+        "200": { $ref: "#/components/responses/discovery" }
+        "404":
+          description: No auth
+    post:
+      summary: Roborock login and discovery
+      tags: [ Discovery ]
+      requestBody:
+        required: true
+        content:
+          multipart/form-data:
+            schema:
+              type: object
+              properties:
+                username: { type: string }
+                password: { type: string }
+              required: [ username, password ]
+      responses:
+        "200": { $ref: "#/components/responses/discovery" }
+
+  /api/homekit:
+    get:
+      summary: Get HomeKit servers state
+      tags: [ HomeKit ]
+      parameters:
+        - name: id
+          in: query
+          description: Optional stream name (server ID)
+          required: false
+          schema: { type: string }
+      responses:
+        "200":
+          description: OK
+          content:
+            application/json: { example: "" }
+        "404":
+          description: Server not found
+    post:
+      summary: Pair HomeKit camera and create/update stream
+      tags: [ HomeKit ]
+      parameters:
+        - name: id
+          in: query
+          description: Stream name to create/update
+          required: true
+          schema: { type: string }
+        - name: src
+          in: query
+          description: HomeKit URL (without pin)
+          required: true
+          schema: { type: string }
+        - name: pin
+          in: query
+          description: HomeKit PIN
+          required: true
+          schema: { type: string }
+      responses:
+        "200":
+          description: OK
+    delete:
+      summary: Unpair HomeKit camera and delete stream
+      tags: [ HomeKit ]
+      parameters:
+        - name: id
+          in: query
+          description: Stream name / server ID
+          required: true
+          schema: { type: string }
+      responses:
+        "200":
+          description: OK
+        "404":
+          description: Stream not found
+
+  /api/homekit/accessories:
+    get:
+      summary: Get HomeKit accessories JSON for a stream
+      tags: [ HomeKit ]
+      parameters:
+        - name: id
+          in: query
+          description: Stream name
+          required: true
+          schema: { type: string }
+      responses:
+        "200":
+          description: OK
+          content:
+            application/json: { example: { } }
+        "404":
+          description: Stream not found
+
+  /pair-setup:
+    post:
+      summary: HomeKit Pair Setup (HAP)
+      description: HomeKit Accessory Protocol endpoint (TLV8).
+      tags: [ HomeKit ]
+      requestBody:
+        required: true
+        content:
+          application/pairing+tlv8: { example: "" }
+      responses:
+        "200":
+          description: OK
+          content:
+            application/pairing+tlv8: { example: "" }
+
+  /pair-verify:
+    post:
+      summary: HomeKit Pair Verify (HAP)
+      description: HomeKit Accessory Protocol endpoint (TLV8).
+      tags: [ HomeKit ]
+      requestBody:
+        required: true
+        content:
+          application/pairing+tlv8: { example: "" }
+      responses:
+        "200":
+          description: OK
+          content:
+            application/pairing+tlv8: { example: "" }
+
+
+  /onvif/:
+    get:
+      summary: ONVIF server implementation
+      description: Simple realisation of the ONVIF protocol. Accepts any suburl requests
+      tags: [ ONVIF ]
+      responses:
+        default:
+          description: ""
+
+
+
+  /stream/:
+    get:
+      summary: RTSPtoWebRTC server implementation
+      description: Simple API for support [RTSPtoWebRTC](https://www.home-assistant.io/integrations/rtsp_to_webrtc/) integration
+      tags: [ RTSPtoWebRTC ]
+      responses:
+        default:
+          description: ""
+
+
+  /api/ws:
+    get:
+      summary: WebSocket endpoint
+      description: |
+        Upgrade to WebSocket and exchange JSON messages:
+        - Request: `{ "type": "...", "value": ... }`
+        - Response: `{ "type": "...", "value": ... }`
+        
+        Supported message types depend on enabled modules (see `api/README.md`).
+      tags: [ WebSocket ]
+      parameters:
+        - name: src
+          in: query
+          description: Stream name (consumer)
+          required: false
+          schema: { type: string }
+        - name: dst
+          in: query
+          description: Stream name (producer)
+          required: false
+          schema: { type: string }
+      responses:
+        "101": { description: Switching Protocols }
+
+
+
+  /api/webtorrent?src={src}:
+    get:
+      summary: Get WebTorrent share info
+      tags: [ WebTorrent ]
+      parameters:
+        - $ref: "#/components/parameters/stream_src_path"
+      responses:
+        200: { $ref: "#/components/responses/webtorrent" }
+    post:
+      summary: Add WebTorrent share
+      tags: [ WebTorrent ]
+      parameters:
+        - $ref: "#/components/parameters/stream_src_path"
+      responses:
+        200: { $ref: "#/components/responses/webtorrent" }
+    delete:
+      summary: Delete WebTorrent share
+      tags: [ WebTorrent ]
+      parameters:
+        - $ref: "#/components/parameters/stream_src_path"
+      responses:
+        default: { description: "" }
+
+  /api/webtorrent:
+    get:
+      summary: Get all WebTorrent shares info
+      tags: [ WebTorrent ]
+      responses:
+        200: { $ref: "#/components/responses/discovery" }
+
+
+
+  /api/stack:
+    get:
+      summary: Show list unknown goroutines
+      tags: [ Debug ]
+      responses:
+        200:
+          description: ""
+          content: { text/plain: { example: "" } }
diff --git a/installs_on_host/go2rtc/website/favicon.ico b/installs_on_host/go2rtc/website/favicon.ico
new file mode 100644
index 0000000..aade0bf
Binary files /dev/null and b/installs_on_host/go2rtc/website/favicon.ico differ
diff --git a/installs_on_host/go2rtc/website/icons/android-chrome-192x192.png b/installs_on_host/go2rtc/website/icons/android-chrome-192x192.png
new file mode 100644
index 0000000..bc88ad3
Binary files /dev/null and b/installs_on_host/go2rtc/website/icons/android-chrome-192x192.png differ
diff --git a/installs_on_host/go2rtc/website/icons/android-chrome-512x512.png b/installs_on_host/go2rtc/website/icons/android-chrome-512x512.png
new file mode 100644
index 0000000..6647f6b
Binary files /dev/null and b/installs_on_host/go2rtc/website/icons/android-chrome-512x512.png differ
diff --git a/installs_on_host/go2rtc/website/icons/apple-touch-icon-180x180.png b/installs_on_host/go2rtc/website/icons/apple-touch-icon-180x180.png
new file mode 100644
index 0000000..b3a6050
Binary files /dev/null and b/installs_on_host/go2rtc/website/icons/apple-touch-icon-180x180.png differ
diff --git a/installs_on_host/go2rtc/website/icons/favicon.ico b/installs_on_host/go2rtc/website/icons/favicon.ico
new file mode 100644
index 0000000..aade0bf
Binary files /dev/null and b/installs_on_host/go2rtc/website/icons/favicon.ico differ
diff --git a/installs_on_host/go2rtc/website/images/go2rtc.png b/installs_on_host/go2rtc/website/images/go2rtc.png
new file mode 100644
index 0000000..a1fa7ba
Binary files /dev/null and b/installs_on_host/go2rtc/website/images/go2rtc.png differ
diff --git a/installs_on_host/go2rtc/website/images/logo.gif b/installs_on_host/go2rtc/website/images/logo.gif
new file mode 100644
index 0000000..fcaf45e
Binary files /dev/null and b/installs_on_host/go2rtc/website/images/logo.gif differ
diff --git a/installs_on_host/go2rtc/website/images/logo.png b/installs_on_host/go2rtc/website/images/logo.png
new file mode 100644
index 0000000..2f5bab6
Binary files /dev/null and b/installs_on_host/go2rtc/website/images/logo.png differ
diff --git a/installs_on_host/go2rtc/website/images/webui-config.png b/installs_on_host/go2rtc/website/images/webui-config.png
new file mode 100644
index 0000000..9a98afb
Binary files /dev/null and b/installs_on_host/go2rtc/website/images/webui-config.png differ
diff --git a/installs_on_host/go2rtc/website/images/webui-net.png b/installs_on_host/go2rtc/website/images/webui-net.png
new file mode 100644
index 0000000..7c2ea6a
Binary files /dev/null and b/installs_on_host/go2rtc/website/images/webui-net.png differ
diff --git a/installs_on_host/go2rtc/website/manifest.json b/installs_on_host/go2rtc/website/manifest.json
new file mode 100644
index 0000000..1bfd357
--- /dev/null
+++ b/installs_on_host/go2rtc/website/manifest.json
@@ -0,0 +1,18 @@
+{
+  "name": "go2rtc",
+  "icons": [
+    {
+      "src": "https://go2rtc.org/icons/android-chrome-192x192.png",
+      "sizes": "192x192",
+      "type": "image/png"
+    },
+    {
+      "src": "https://go2rtc.org/icons/android-chrome-512x512.png",
+      "sizes": "512x512",
+      "type": "image/png"
+    }
+  ],
+  "display": "standalone",
+  "theme_color": "#000000",
+  "background_color": "#000000"
+}
diff --git a/installs_on_host/go2rtc/website/webtorrent/index.html b/installs_on_host/go2rtc/website/webtorrent/index.html
new file mode 100644
index 0000000..6a4b905
--- /dev/null
+++ b/installs_on_host/go2rtc/website/webtorrent/index.html
@@ -0,0 +1,189 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>webtorrent - go2rtc</title>
+    <style>
+        body {
+            background-color: black;
+            margin: 0;
+            padding: 0;
+        }
+
+        html, body, video {
+            height: 100%;
+            width: 100%;
+        }
+
+        div {
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            display: flex;
+            flex-direction: column;
+            transform: translateX(-50%) translateY(-50%);
+        }
+    </style>
+</head>
+<body>
+<video id="video" autoplay controls playsinline muted></video>
+<div id="login">
+    <input id="share" type="text" placeholder="share">
+    <input id="pwd" type="text" placeholder="password">
+    <button id="connect">connect</button>
+</div>
+<script>
+    async function PeerConnection(media) {
+        const pc = new RTCPeerConnection({
+            iceServers: [{urls: 'stun:stun.l.google.com:19302'}]
+        });
+
+        const localTracks = [];
+
+        if (/camera|microphone/.test(media)) {
+            const tracks = await getMediaTracks('user', {
+                video: media.indexOf('camera') >= 0,
+                audio: media.indexOf('microphone') >= 0,
+            });
+            tracks.forEach(track => {
+                pc.addTransceiver(track, {direction: 'sendonly'});
+                if (track.kind === 'video') localTracks.push(track);
+            });
+        }
+
+        if (media.indexOf('display') >= 0) {
+            const tracks = await getMediaTracks('display', {
+                video: true,
+                audio: media.indexOf('speaker') >= 0,
+            });
+            tracks.forEach(track => {
+                pc.addTransceiver(track, {direction: 'sendonly'});
+                if (track.kind === 'video') localTracks.push(track);
+            });
+        }
+
+        if (/video|audio/.test(media)) {
+            const tracks = ['video', 'audio']
+                .filter(kind => media.indexOf(kind) >= 0)
+                .map(kind => pc.addTransceiver(kind, {direction: 'recvonly'}).receiver.track);
+            localTracks.push(...tracks);
+        }
+
+        document.getElementById('video').srcObject = new MediaStream(localTracks);
+
+        return pc;
+    }
+
+    async function getMediaTracks(media, constraints) {
+        try {
+            const stream = media === 'user'
+                ? await navigator.mediaDevices.getUserMedia(constraints)
+                : await navigator.mediaDevices.getDisplayMedia(constraints);
+            return stream.getTracks();
+        } catch (e) {
+            console.warn(e);
+            return [];
+        }
+    }
+
+    function getOffer(pc, timeout) {
+        return new Promise((resolve, reject) => {
+            pc.addEventListener('icegatheringstatechange', () => {
+                if (pc.iceGatheringState === 'complete') resolve(pc.localDescription.sdp);
+            });
+
+            pc.createOffer().then(offer => pc.setLocalDescription(offer));
+
+            setTimeout(() => resolve(pc.localDescription.sdp), timeout || 5000);
+        });
+    }
+</script>
+<script>
+    function decode(buffer) {
+        return String.fromCharCode(...new Uint8Array(buffer));
+    }
+
+    function encode(string) {
+        return Uint8Array.from(string, c => c.charCodeAt(0));
+    }
+
+    async function cipher(share, pwd) {
+        const hash = await crypto.subtle.digest('SHA-256', encode(share));
+        const nonce = (Date.now() * 1000000).toString(36);
+
+        const ivData = await crypto.subtle.digest('SHA-256', encode(share + ':' + nonce));
+        const keyData = await crypto.subtle.digest('SHA-256', encode(nonce + ':' + pwd));
+        const key = await crypto.subtle.importKey(
+            'raw', keyData, {name: 'AES-GCM'}, false, ['encrypt', 'decrypt'],
+        );
+
+        return {
+            hash: btoa(decode(hash)),
+            nonce: nonce,
+            encrypt: async function (plaintext) {
+                const cryptotext = await crypto.subtle.encrypt(
+                    {name: 'AES-GCM', iv: ivData.slice(0, 12), additionalData: encode(nonce)},
+                    key, encode(plaintext),
+                );
+                return btoa(decode(cryptotext));
+            },
+            decrypt: async function (cryptotext) {
+                const plaintext = await crypto.subtle.decrypt(
+                    {name: 'AES-GCM', iv: ivData.slice(0, 12), additionalData: encode(nonce)},
+                    key, encode(atob(cryptotext)),
+                );
+                return decode(plaintext);
+            }
+        };
+    }
+</script>
+<script>
+    async function connect(share, pwd, media, tracker) {
+        const crypto = await cipher(share, pwd);
+        const pc = await PeerConnection(media || 'video+audio');
+        const offer = await crypto.encrypt(await getOffer(pc));
+
+        const ws = new WebSocket(tracker || 'wss://tracker.openwebtorrent.com/');
+        ws.addEventListener('open', () => {
+            ws.send(JSON.stringify({
+                action: 'announce',
+                info_hash: crypto.hash,
+                peer_id: Math.random().toString(36).substring(2),
+                offers: [{
+                    offer_id: crypto.nonce,
+                    offer: {type: 'offer', sdp: offer},
+                }],
+                numwant: 1,
+            }));
+        });
+
+        ws.addEventListener('message', async (ev) => {
+            const msg = JSON.parse(ev.data);
+            if (!msg.answer) return;
+
+            const answer = await crypto.decrypt(msg.answer.sdp);
+            await pc.setRemoteDescription({type: 'answer', sdp: answer});
+
+            ws.close();
+        });
+    }
+
+    document.getElementById('connect').addEventListener('click', () => {
+        const share = document.getElementById('share').value;
+        const pwd = document.getElementById('pwd').value;
+        connect(share, pwd);
+        document.getElementById('login').style.display = 'none';
+    });
+
+    if (location.hash) {
+        const params = new URLSearchParams(location.hash.substring(1));
+        const share = params.get('share');
+        const pwd = params.get('pwd');
+        const media = params.get('media');
+        const tracker = params.get('tr');
+        connect(share, pwd, media, tracker);
+        document.getElementById('login').style.display = 'none';
+    }
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/installs_on_host/go2rtc/www/README.md b/installs_on_host/go2rtc/www/README.md
new file mode 100644
index 0000000..6fd49ce
--- /dev/null
+++ b/installs_on_host/go2rtc/www/README.md
@@ -0,0 +1,69 @@
+# www
+
+This folder contains static HTTP and JS content that is embedded into the application during build. An external developer can use it as a basis for integrating go2rtc into their project or for developing a custom web interface for go2rtc.
+
+## HTTP API
+
+`www/stream.html` - universal viewer with support params in URL:
+
+- multiple streams on page `src=camera1&src=camera2...`
+- stream technology autoselection `mode=webrtc,webrtc/tcp,mse,hls,mp4,mjpeg`
+- stream technology comparison `src=camera1&mode=webrtc&mode=mse&mode=mp4`
+- player width setting in pixels `width=320px` or percents `width=50%`
+
+`www/webrtc.html` - WebRTC viewer with support two way audio and params in URL:
+
+- `media=video+audio` - simple viewer
+- `media=video+audio+microphone` - two way audio from camera
+- `media=camera+microphone` - stream from browser
+- `media=display+speaker` - stream from desktop
+
+## JavaScript API
+
+- You can write your viewer from the scratch
+- You can extend the built-in viewer - `www/video-rtc.js`
+- Check example - `www/video-stream.js`
+- Check example - https://github.com/AlexxIT/WebRTC
+
+`video-rtc.js` features:
+
+- support technologies:
+    - WebRTC over UDP or TCP
+    - MSE or HLS 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 HLS, than MJPEG
+
+## Browser support
+
+[ECMAScript 2019 (ES10)](https://caniuse.com/?search=es10) supported by [iOS 12](https://en.wikipedia.org/wiki/IOS_12) (iPhone 5S, iPad Air, iPad Mini 2, etc.).
+
+But [ECMAScript 2017 (ES8)](https://caniuse.com/?search=es8) almost fine (`es6 + async`) and recommended for [React+TypeScript](https://github.com/typescript-cheatsheets/react).
+
+## Known problems
+
+- Autoplay doesn't work for WebRTC in Safari [read more](https://developer.apple.com/documentation/webkit/delivering_video_content_for_safari/).
+
+## Useful links
+
+- https://www.webrtc-experiment.com/DetectRTC/
+- https://divtable.com/table-styler/
+- https://www.chromium.org/audio-video/
+- https://web.dev/i18n/en/fast-playback-with-preload/#manual_buffering
+- https://developer.mozilla.org/en-US/docs/Web/API/Media_Source_Extensions_API
+- https://chromium.googlesource.com/external/w3c/web-platform-tests/+/refs/heads/master/media-source/mediasource-is-type-supported.html
+- https://googlechrome.github.io/samples/media/sourcebuffer-changetype.html
+- https://chromestatus.com/feature/5100845653819392
+- https://developer.apple.com/documentation/webkit/delivering_video_content_for_safari
+- https://dirask.com/posts/JavaScript-supported-Audio-Video-MIME-Types-by-MediaRecorder-Chrome-and-Firefox-jERn81
+- https://privacycheck.sec.lrz.de/active/fp_cpt/fp_can_play_type.html
diff --git a/installs_on_host/go2rtc/www/add.html b/installs_on_host/go2rtc/www/add.html
new file mode 100644
index 0000000..a2e0d85
--- /dev/null
+++ b/installs_on_host/go2rtc/www/add.html
@@ -0,0 +1,569 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>add - go2rtc</title>
+    <style>
+        main > button {
+            background-color: #444;
+            color: white;
+            cursor: pointer;
+            padding: 14px;
+            width: 100%;
+            border: none;
+            text-align: left;
+            font-size: 16px;
+            font-weight: bold;
+        }
+
+        main > div {
+            display: none;
+            gap: 10px;
+        }
+    </style>
+</head>
+<body>
+
+<script src="main.js"></script>
+
+<script>
+    function drawTable(table, data) {
+        const cols = ['id', 'name', 'info', 'url', 'location'];
+        const th = (row) => cols.reduce((html, k) => k in row ? `${html}<th>${k}</th>` : html, '<tr>') + '</tr>';
+        const td = (row) => cols.reduce((html, k) => k in row ? `${html}<td style="word-break: break-word; white-space: normal;">${row[k]}</td>` : html, '<tr>') + '</tr>';
+
+        const thead = th(data.sources[0]);
+        const tbody = data.sources.reduce((html, source) => `${html}${td(source)}`, '');
+
+        table.innerHTML = `<thead>${thead}</thead><tbody>${tbody}</tbody>`;
+    }
+
+    async function getSources(tableID, url) {
+        const table = document.getElementById(tableID);
+        table.innerText = 'loading...';
+
+        const r = typeof url === 'string' ? await fetch(url, {cache: 'no-cache'}) : url;
+        if (!r.ok) {
+            table.innerText = await r.text();
+            return;
+        }
+
+        drawTable(table, await r.json());
+    }
+</script>
+
+<main>
+    <button id="stream">Temporary stream</button>
+    <div>
+        <form id="stream-form">
+            <input type="text" name="name" placeholder="name">
+            <input type="text" name="src" placeholder="url" required size="30">
+            <button type="submit">add</button>
+        </form>
+    </div>
+    <script>
+        document.getElementById('stream').addEventListener('click', async ev => {
+            ev.target.nextElementSibling.style.display = 'grid';
+        });
+
+        document.getElementById('stream-form').addEventListener('submit', async ev => {
+            ev.preventDefault();
+
+            const url = new URL('api/streams', location.href);
+            url.searchParams.set('name', ev.target.elements['name'].value);
+            url.searchParams.set('src', ev.target.elements['src'].value);
+
+            const r = await fetch(url, {method: 'PUT'});
+            alert(r.ok ? 'OK' : 'ERROR: ' + await r.text());
+        });
+    </script>
+
+
+    <button id="alsa">ALSA (Linux audio)</button>
+    <div>
+        <table id="alsa-table"></table>
+    </div>
+    <script>
+        document.getElementById('alsa').addEventListener('click', async ev => {
+            ev.target.nextElementSibling.style.display = 'grid';
+            await getSources('alsa-table', 'api/alsa');
+        });
+    </script>
+
+
+    <button id="homekit">Apple HomeKit</button>
+    <div>
+        <form id="homekit-pair">
+            <input type="text" name="id" placeholder="stream id" required>
+            <input type="text" name="src" placeholder="src" required size="30">
+            <input type="text" name="pin" placeholder="pin" required size="10">
+            <button type="submit">pair</button>
+        </form>
+        <form id="homekit-unpair">
+            <input type="text" name="id" placeholder="stream id" required>
+            <button type="submit">unpair</button>
+        </form>
+        <table id="homekit-table"></table>
+    </div>
+    <script>
+        async function reloadHomeKit() {
+            await getSources('homekit-table', 'api/discovery/homekit');
+
+            const rows = document.querySelectorAll('#homekit-table tr');
+            rows.forEach((row, i) => {
+                let commands = '';
+                if (row.children[2].innerText.indexOf('status=1') > 0) {
+                    commands += '<a href="#">pair</a>';
+                } else if (i > 0 && row.children[3].innerText) {
+                    commands += '<a href="#">unpair</a>';
+                }
+                row.innerHTML += i > 0 ? `<td>${commands}</td>` : '<th>commands</th>';
+            });
+        }
+
+        document.getElementById('homekit').addEventListener('click', async ev => {
+            ev.target.nextElementSibling.style.display = 'grid';
+            await reloadHomeKit();
+        });
+
+        document.getElementById('homekit-table').addEventListener('click', ev => {
+            if (ev.target.innerText === 'pair') {
+                const form = document.querySelector('#homekit-pair');
+                const row = ev.target.closest('tr');
+                form.children[0].value = row.children[0].innerText;
+                form.children[1].value = row.children[2].innerText;
+            } else if (ev.target.innerText === 'unpair') {
+                const form = document.querySelector('#homekit-unpair');
+                const row = ev.target.closest('tr');
+                form.children[0].value = row.children[3].innerText;
+            }
+        });
+
+        document.getElementById('homekit-pair').addEventListener('submit', async ev => {
+            ev.preventDefault();
+
+            const params = new URLSearchParams(new FormData(ev.target));
+            const r = await fetch('api/homekit', {method: 'POST', body: params});
+            alert(r.ok ? 'OK' : 'ERROR: ' + await r.text());
+
+            await reloadHomeKit();
+        });
+
+        document.getElementById('homekit-unpair').addEventListener('submit', async ev => {
+            ev.preventDefault();
+
+            const params = new URLSearchParams(new FormData(ev.target));
+            const r = await fetch('api/homekit?' + params.toString(), {method: 'DELETE'});
+            alert(r.ok ? 'OK' : 'ERROR: ' + await r.text());
+
+            await reloadHomeKit();
+        });
+    </script>
+
+
+    <button id="dvrip">DVRIP</button>
+    <div>
+        <table id="dvrip-table"></table>
+    </div>
+    <script>
+        document.getElementById('dvrip').addEventListener('click', async ev => {
+            ev.target.nextElementSibling.style.display = 'grid';
+            await getSources('dvrip-table', 'api/dvrip');
+        });
+    </script>
+
+
+    <button id="devices">FFmpeg Devices (USB)</button>
+    <div>
+        <table id="devices-table"></table>
+    </div>
+    <script>
+        document.getElementById('devices').addEventListener('click', async ev => {
+            ev.target.nextElementSibling.style.display = 'grid';
+            await getSources('devices-table', 'api/ffmpeg/devices');
+        });
+    </script>
+
+
+    <button id="hardware">FFmpeg Hardware</button>
+    <div>
+        <table id="hardware-table"></table>
+    </div>
+    <script>
+        document.getElementById('hardware').addEventListener('click', async ev => {
+            ev.target.nextElementSibling.style.display = 'grid';
+            await getSources('hardware-table', 'api/ffmpeg/hardware');
+        });
+    </script>
+
+
+    <button id="nest">Google Nest</button>
+    <div>
+        <form id="nest-form">
+            <input type="text" name="client_id" placeholder="client_id" required>
+            <input type="text" name="client_secret" placeholder="client_secret" required>
+            <input type="text" name="refresh_token" placeholder="refresh_token" required>
+            <input type="text" name="project_id" placeholder="project_id" required>
+            <button type="submit">login</button>
+        </form>
+        <table id="nest-table"></table>
+    </div>
+    <script>
+        document.getElementById('nest').addEventListener('click', async ev => {
+            ev.target.nextElementSibling.style.display = 'grid';
+        });
+
+        document.getElementById('nest-form').addEventListener('submit', async ev => {
+            ev.preventDefault();
+
+            const query = new URLSearchParams(new FormData(ev.target));
+            const url = new URL('api/nest?' + query.toString(), location.href);
+
+            const r = await fetch(url, {cache: 'no-cache'});
+            await getSources('nest-table', r);
+        });
+    </script>
+
+    <button id="gopro">GoPro</button>
+    <div>
+        <table id="gopro-table"></table>
+    </div>
+    <script>
+        document.getElementById('gopro').addEventListener('click', async ev => {
+            ev.target.nextElementSibling.style.display = 'grid';
+            await getSources('gopro-table', 'api/gopro');
+        });
+    </script>
+
+
+    <button id="hass">Home Assistant</button>
+    <div>
+        <table id="hass-table"></table>
+    </div>
+    <script>
+        document.getElementById('hass').addEventListener('click', async ev => {
+            ev.target.nextElementSibling.style.display = 'grid';
+            await getSources('hass-table', 'api/hass');
+        });
+    </script>
+
+
+    <button id="onvif">ONVIF</button>
+    <div>
+        <form id="onvif-form">
+            <input type="text" name="src" placeholder="onvif://user:pass@192.168.1.123:80" required size="30">
+            <button type="submit">test</button>
+        </form>
+        <table id="onvif-table"></table>
+    </div>
+    <script>
+        document.getElementById('onvif').addEventListener('click', async ev => {
+            ev.target.nextElementSibling.style.display = 'grid';
+            await getSources('onvif-table', 'api/onvif');
+        });
+
+        document.getElementById('onvif-form').addEventListener('submit', async ev => {
+            ev.preventDefault();
+
+            const url = new URL('api/onvif', location.href);
+            url.searchParams.set('src', ev.target.elements['src'].value);
+
+            await getSources('onvif-table', url.toString());
+        });
+    </script>
+
+
+    <button id="ring">Ring</button>
+    <div>
+        <form id="ring-credentials-form">
+            <input type="email" name="email" placeholder="email" required>
+            <input type="password" name="password" placeholder="password" required>
+            <div id="tfa-field" style="display: none">
+                <input type="text" name="code" placeholder="2FA code">
+                <div id="tfa-prompt"></div>
+            </div>
+            <button type="submit">login</button>
+        </form>
+        <form id="ring-token-form">
+            <input type="text" name="refresh_token" placeholder="refresh_token" required>
+            <button type="submit">login</button>
+        </form>
+        <table id="ring-table"></table>
+    </div>
+    <script>
+        document.getElementById('ring').addEventListener('click', async ev => {
+            ev.target.nextElementSibling.style.display = 'grid';
+        });
+
+        async function handleRingAuth(ev) {
+            ev.preventDefault();
+
+            const table = document.getElementById('ring-table');
+            table.innerText = 'loading...';
+
+            const query = new URLSearchParams(new FormData(ev.target));
+            const url = new URL('api/ring?' + query.toString(), location.href);
+
+            const r = await fetch(url, {cache: 'no-cache'});
+
+            if (!r.ok) {
+                table.innerText = (await r.text()) || 'Unknown error';
+                return;
+            }
+
+            const data = await r.json();
+
+            table.innerText = '';
+
+            if (data.needs_2fa) {
+                document.getElementById('tfa-field').style.display = 'block';
+                document.getElementById('tfa-prompt').textContent = data.prompt || 'Enter 2FA code';
+                return;
+            }
+
+            drawTable(table, data);
+        }
+
+        document.getElementById('ring-credentials-form').addEventListener('submit', handleRingAuth);
+        document.getElementById('ring-token-form').addEventListener('submit', handleRingAuth);
+    </script>
+
+
+    <button id="tuya">Tuya</button>
+    <div>
+        <form id="tuya-credentials-form">
+            <select name="region" required>
+                <option value="protect-eu.ismartlife.me">EU Central</option>
+                <option value="protect-we.ismartlife.me">EU East</option>
+                <option value="protect-us.ismartlife.me">US West</option>
+                <option value="protect-ue.ismartlife.me">US East</option>
+                <option value="protect.ismartlife.me">China</option>
+                <option value="protect-in.ismartlife.me">India</option>
+            </select>
+            <input type="email" name="email" placeholder="email" required>
+            <input type="password" name="password" placeholder="password" required>
+            <button type="submit">login</button>
+        </form>
+        <table id="tuya-table"></table>
+    </div>
+    <script>
+        document.getElementById('tuya').addEventListener('click', async ev => {
+            ev.target.nextElementSibling.style.display = 'grid';
+        });
+
+        document.getElementById('tuya-credentials-form').addEventListener('submit', async ev => {
+            ev.preventDefault();
+
+            const table = document.getElementById('tuya-table');
+            table.innerText = 'loading...';
+
+            const query = new URLSearchParams(new FormData(ev.target));
+            const url = new URL('api/tuya?' + query.toString(), location.href);
+
+            const r = await fetch(url, {cache: 'no-cache'});
+
+            if (!r.ok) {
+                table.innerText = (await r.text()) || 'Unknown error';
+                return;
+            }
+
+            const data = await r.json();
+
+            table.innerText = '';
+
+            drawTable(table, data);
+        });
+    </script>
+
+
+    <button id="roborock">Roborock</button>
+    <div>
+        <form id="roborock-form">
+            <input type="text" name="username" placeholder="username" required>
+            <input type="password" name="password" placeholder="password" required>
+            <button type="submit">login</button>
+        </form>
+        <table id="roborock-table">
+        </table>
+    </div>
+    <script>
+        document.getElementById('roborock').addEventListener('click', async ev => {
+            ev.target.nextElementSibling.style.display = 'grid';
+            await getSources('roborock-table', 'api/roborock');
+        });
+
+        document.getElementById('roborock-form').addEventListener('submit', async ev => {
+            ev.preventDefault();
+            const r = await fetch('api/roborock', {method: 'POST', body: new FormData(ev.target)});
+            await getSources('roborock-table', r);
+        });
+    </script>
+
+
+    <button id="v4l2">V4L2 (Linux video)</button>
+    <div>
+        <table id="v4l2-table"></table>
+    </div>
+    <script>
+        document.getElementById('v4l2').addEventListener('click', async ev => {
+            ev.target.nextElementSibling.style.display = 'grid';
+            await getSources('v4l2-table', 'api/v4l2');
+        });
+    </script>
+
+
+    <button id="wyze">Wyze</button>
+    <div>
+        <p style="margin: 5px 0; font-size: 12px; color: #888;">
+            API Key required: <a href="https://support.wyze.com/hc/en-us/articles/16129834216731" target="_blank">Get your API Key</a>
+        </p>
+        <form id="wyze-login-form">
+            <input type="text" name="api_id" placeholder="API ID" required size="20">
+            <input type="text" name="api_key" placeholder="API Key" required size="36">
+            <input type="email" name="email" placeholder="email" required>
+            <input type="password" name="password" placeholder="password" required>
+            <button type="submit">login</button>
+        </form>
+        <form id="wyze-devices-form">
+            <select id="wyze-id" name="id" required></select>
+            <button type="submit">load devices</button>
+        </form>
+        <table id="wyze-table"></table>
+    </div>
+    <script>
+        async function wyzeReload(ev) {
+            if (ev) ev.target.nextElementSibling.style.display = 'grid';
+
+            const r = await fetch('api/wyze', {'cache': 'no-cache'});
+            const data = await r.json();
+            const users = document.getElementById('wyze-id');
+            users.innerHTML = data.map(item => `<option value="${item}">${item}</option>`).join('');
+        }
+
+        document.getElementById('wyze').addEventListener('click', wyzeReload);
+
+        document.getElementById('wyze-login-form').addEventListener('submit', async ev => {
+            ev.preventDefault();
+
+            const table = document.getElementById('wyze-table');
+            table.innerText = 'loading...';
+
+            const params = new URLSearchParams(new FormData(ev.target));
+            const r = await fetch('api/wyze', {method: 'POST', body: params});
+
+            if (!r.ok) {
+                table.innerText = (await r.text()) || 'Unknown error';
+                return;
+            }
+
+            const data = await r.json();
+            table.innerText = '';
+            drawTable(table, data);
+            wyzeReload();
+        });
+
+        document.getElementById('wyze-devices-form').addEventListener('submit', async ev => {
+            ev.preventDefault();
+            const params = new URLSearchParams(new FormData(ev.target));
+            await getSources('wyze-table', 'api/wyze?' + params.toString());
+        });
+    </script>
+
+
+    <button id="xiaomi">Xiaomi</button>
+    <div>
+        <form id="xiaomi-login-form">
+            <input type="text" name="username" placeholder="username" required>
+            <input type="password" name="password" placeholder="password" required>
+            <button type="submit">login</button>
+        </form>
+        <form id="xiaomi-captcha-form">
+            <img id="xiaomi-captcha">
+            <input type="text" name="captcha" placeholder="captcha" required size="10">
+            <button type="submit">send</button>
+        </form>
+        <form id="xiaomi-verify-form">
+            <label id="xiaomi-verify"></label>
+            <input type="text" name="verify" placeholder="verify" required size="10">
+            <button type="submit">send</button>
+        </form>
+        <form id="xiaomi-devices-form">
+            <select id="xiaomi-id" name="id" required></select>
+            <select name="region" required>
+                <option value="cn">China</option>
+                <option value="de">Europe</option>
+                <option value="i2">India</option>
+                <option value="ru">Russia</option>
+                <option value="sg">Singapore</option>
+                <option value="us">United States</option>
+            </select>
+            <button type="submit">load devices</button>
+        </form>
+        <table id="xiaomi-table"></table>
+    </div>
+    <script>
+        async function xiaomiReload(ev) {
+            if (ev) ev.target.nextElementSibling.style.display = 'grid';
+
+            document.getElementById('xiaomi-login-form').style.display = 'flex';
+            document.getElementById('xiaomi-captcha-form').style.display = 'none';
+            document.getElementById('xiaomi-verify-form').style.display = 'none';
+
+            const r = await fetch('api/xiaomi', {'cache': 'no-cache'});
+            const data = await r.json();
+            const users = document.getElementById('xiaomi-id');
+            users.innerHTML = data.map(item => `<option value="${item}">${item}</option>`).join('');
+        }
+
+        document.getElementById('xiaomi').addEventListener('click', xiaomiReload);
+
+        async function xiaomiLogin(ev) {
+            ev.preventDefault();
+            const params = new URLSearchParams(new FormData(ev.target));
+            const r = await fetch('api/xiaomi', {method: 'POST', body: params});
+            if (r.status === 401) {
+                /** @type {{captcha: string, verify_email: string, verify_phone: string}} */
+                const data = await r.json();
+                document.getElementById('xiaomi-login-form').style.display = 'none';
+                if (data.captcha) {
+                    document.getElementById('xiaomi-captcha-form').style.display = 'flex';
+                    document.getElementById('xiaomi-captcha').src = 'data:image/jpeg;base64,' + data.captcha;
+                } else {
+                    document.getElementById('xiaomi-verify-form').style.display = 'flex';
+                    document.getElementById('xiaomi-verify').innerText = data.verify_email || data.verify_phone;
+                }
+            } else if (r.ok) {
+                alert('OK');
+                xiaomiReload();
+            } else {
+                alert('ERROR: ' + await r.text());
+            }
+        }
+
+        document.getElementById('xiaomi-login-form').addEventListener('submit', xiaomiLogin);
+        document.getElementById('xiaomi-captcha-form').addEventListener('submit', xiaomiLogin);
+        document.getElementById('xiaomi-verify-form').addEventListener('submit', xiaomiLogin);
+
+        document.getElementById('xiaomi-devices-form').addEventListener('submit', async ev => {
+            ev.preventDefault();
+            const params = new URLSearchParams(new FormData(ev.target));
+            await getSources('xiaomi-table', 'api/xiaomi?' + params.toString());
+        });
+    </script>
+
+
+    <button id="webtorrent">WebTorrent Shares</button>
+    <div>
+        <table id="webtorrent-table"></table>
+    </div>
+    <script>
+        document.getElementById('webtorrent').addEventListener('click', async ev => {
+            ev.target.nextElementSibling.style.display = 'grid';
+            await getSources('webtorrent-table', 'api/webtorrent');
+        });
+    </script>
+</main>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/installs_on_host/go2rtc/www/config.html b/installs_on_host/go2rtc/www/config.html
new file mode 100644
index 0000000..026b5be
--- /dev/null
+++ b/installs_on_host/go2rtc/www/config.html
@@ -0,0 +1,1230 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>config - go2rtc</title>
+    <style>
+        html, body {
+            height: 100%;
+        }
+
+        #config {
+            flex: 1 1 auto;
+            border-top: 1px solid #ccc;
+            min-height: 300px;
+        }
+    </style>
+</head>
+<body>
+
+<script src="main.js"></script>
+
+<main>
+    <div>
+        <button id="save">Save & Restart</button>
+        <button id="suggest" title="ctrl + space">Suggest</button>
+    </div>
+</main>
+<div id="config"></div>
+
+<script src="https://cdn.jsdelivr.net/npm/monaco-editor@0.55.1/min/vs/loader.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/js-yaml@4.1.0/dist/js-yaml.min.js"></script>
+<script>
+    /* global require, monaco */
+    const monacoRoot = 'https://cdn.jsdelivr.net/npm/monaco-editor@0.55.1/min';
+
+    window.MonacoEnvironment = {
+        getWorkerUrl: function () {
+            return `data:text/javascript;charset=utf-8,${encodeURIComponent(`
+                self.MonacoEnvironment = { baseUrl: '${monacoRoot}/' };
+                importScripts('${monacoRoot}/vs/base/worker/workerMain.js');
+            `)}`;
+        }
+    };
+
+    require.config({paths: {vs: `${monacoRoot}/vs`}});
+
+    require(['vs/editor/editor.main'], () => {
+        const container = document.getElementById('config');
+        container.textContent = '';
+
+        const ensureYamlLanguage = () => {
+            const languages =
+                (window.monaco &&
+                    monaco.languages &&
+                    typeof monaco.languages.getLanguages === 'function' &&
+                    monaco.languages.getLanguages()) ||
+                [];
+            const hasYaml = languages.some((l) => l.id === 'yaml');
+            if (hasYaml) return;
+
+            monaco.languages.register({
+                id: 'yaml',
+                extensions: ['.yaml', '.yml'],
+                aliases: ['YAML', 'yaml'],
+                mimetypes: ['application/x-yaml', 'text/yaml'],
+            });
+
+            monaco.languages.setLanguageConfiguration('yaml', {
+                comments: {lineComment: '#'},
+                brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+                autoClosingPairs: [
+                    {open: '{', close: '}'},
+                    {open: '[', close: ']'},
+                    {open: '(', close: ')'},
+                    {open: '"', close: '"'},
+                    {open: '\'', close: '\''},
+                ],
+                surroundingPairs: [
+                    {open: '{', close: '}'},
+                    {open: '[', close: ']'},
+                    {open: '(', close: ')'},
+                    {open: '"', close: '"'},
+                    {open: '\'', close: '\''},
+                ],
+            });
+
+            monaco.languages.setMonarchTokensProvider('yaml', {
+                tokenizer: {
+                    root: [
+                        [/^\s*(---|\.\.\.)\s*$/, 'delimiter'],
+                        [/#.*$/, 'comment'],
+                        [/^\s*-\s+/, 'delimiter'],
+                        [/[A-Za-z0-9_-]+(?=\s*:)/, 'key'],
+                        [/:/, 'delimiter'],
+                        [/[{}\[\](),]/, 'delimiter'],
+                        [/\b(true|false|null|~)\b/, 'keyword'],
+                        [/-?\d+(\.\d+)?\b/, 'number'],
+                        [/"/, 'string', '@string_double'],
+                        [/'/, 'string', '@string_single'],
+                        [/[^#\s{}\[\](),]+/, 'string'],
+                        [/\s+/, ''],
+                    ],
+                    string_double: [
+                        [/[^\\"]+/, 'string'],
+                        [/\\./, 'string.escape'],
+                        [/"/, 'string', '@pop'],
+                    ],
+                    string_single: [
+                        [/[^']+/, 'string'],
+                        [/'/, 'string', '@pop'],
+                    ],
+                },
+            });
+        };
+
+        ensureYamlLanguage();
+
+        const prefersDark = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;
+        monaco.editor.setTheme(prefersDark ? 'vs-dark' : 'vs');
+
+        const editor = monaco.editor.create(container, {
+            language: 'yaml',
+            minimap: {enabled: false},
+            automaticLayout: true,
+            tabSize: 2,
+            insertSpaces: true,
+            quickSuggestions: {other: true, comments: false, strings: true},
+            suggestOnTriggerCharacters: true,
+            wordBasedSuggestions: false,
+            suggest: {showWords: false},
+            scrollBeyondLastLine: false,
+        });
+
+        const stripInlineComment = (line) => {
+            let inSingle = false;
+            let inDouble = false;
+            for (let i = 0; i < line.length; i++) {
+                const ch = line[i];
+                if (ch === '\'' && !inDouble) {
+                    inSingle = !inSingle;
+                    continue;
+                }
+                if (ch === '"' && !inSingle) {
+                    inDouble = !inDouble;
+                    continue;
+                }
+                if (ch === '#' && !inSingle && !inDouble) {
+                    if (i === 0 || /\s/.test(line[i - 1])) return line.slice(0, i);
+                }
+            }
+            return line;
+        };
+
+        const countIndent = (line) => {
+            let indent = 0;
+            for (let i = 0; i < line.length; i++) {
+                if (line[i] === ' ') {
+                    indent++;
+                } else if (line[i] === '\t') {
+                    indent += 2;
+                } else {
+                    break;
+                }
+            }
+            return indent;
+        };
+
+        const parseListItem = (line) => {
+            const m = line.match(/^([ \t]*)-/);
+            if (!m) return null;
+
+            const dashIndex = m[1].length;
+            if (dashIndex + 1 < line.length && !/\s/.test(line[dashIndex + 1])) return null;
+
+            let afterDashIndex = dashIndex + 1;
+            while (afterDashIndex < line.length && /\s/.test(line[afterDashIndex])) afterDashIndex++;
+
+            const spacesAfterDash = Math.max(1, afterDashIndex - (dashIndex + 1));
+
+            return {
+                indent: countIndent(m[1]),
+                dashIndex,
+                afterDashIndex,
+                rest: line.slice(afterDashIndex),
+                contentIndent: countIndent(m[1]) + 1 + spacesAfterDash,
+            };
+        };
+
+        const parseKey = (line) => {
+            const m = line.match(/^([ \t]*)/);
+            const indentStr = m ? m[0] : '';
+            const indentIndex = indentStr.length;
+            const indent = countIndent(indentStr);
+
+            if (indentIndex >= line.length) return null;
+
+            const i = indentIndex;
+            let key = '';
+            let rawKey = '';
+            let isQuoted = false;
+            let keyStartIndex = i;
+            let keyEndIndex = i;
+            let colonIndex = -1;
+
+            const parseQuotedKey = (quoteChar) => {
+                isQuoted = true;
+                let j = i + 1;
+                if (quoteChar === '"') {
+                    while (j < line.length) {
+                        if (line[j] === '\\') {
+                            j += 2;
+                            continue;
+                        }
+                        if (line[j] === '"') break;
+                        j++;
+                    }
+                } else {
+                    while (j < line.length) {
+                        if (line[j] === '\'') {
+                            if (line[j + 1] === '\'') {
+                                j += 2;
+                                continue;
+                            }
+                            break;
+                        }
+                        j++;
+                    }
+                }
+
+                if (j >= line.length) return null;
+                rawKey = line.slice(i, j + 1);
+                if (quoteChar === '"') {
+                    key = line.slice(i + 1, j).replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+                } else {
+                    key = line.slice(i + 1, j).replace(/''/g, '\'');
+                }
+                keyStartIndex = i;
+                keyEndIndex = j + 1;
+
+                let k = j + 1;
+                while (k < line.length && /\s/.test(line[k])) k++;
+                if (k >= line.length || line[k] !== ':') return null;
+                colonIndex = k;
+                return colonIndex;
+            };
+
+            if (line[i] === '"' || line[i] === '\'') {
+                if (parseQuotedKey(line[i]) === null) return null;
+            } else {
+                let j = i;
+                while (j < line.length) {
+                    if (line[j] === ':') {
+                        if (j + 1 >= line.length || /\s/.test(line[j + 1])) {
+                            colonIndex = j;
+                            break;
+                        }
+                    }
+                    j++;
+                }
+                if (colonIndex === -1) return null;
+                rawKey = line.slice(i, colonIndex).replace(/\s+$/, '');
+                if (!rawKey) return null;
+                key = rawKey;
+                keyStartIndex = i;
+                keyEndIndex = i + rawKey.length;
+            }
+
+            const after = line.slice(colonIndex + 1);
+            const isContainer = after.trim() === '' || after.trim().startsWith('#');
+            const valueStartIndex = colonIndex + 1;
+
+            return {
+                indent,
+                key,
+                rawKey,
+                isQuoted,
+                isContainer,
+                after,
+                keyStartIndex,
+                keyEndIndex,
+                colonIndex,
+                valueStartIndex
+            };
+        };
+
+        const unique = (arr) => [...new Set(arr)];
+
+        const toYamlScalar = (v) => {
+            if (v === '') return '\'\'';
+            if (typeof v === 'string') return v;
+            if (typeof v === 'number') return String(v);
+            if (typeof v === 'boolean') return v ? 'true' : 'false';
+            return JSON.stringify(v);
+        };
+
+        const createSchemaTools = (schemaRoot) => {
+            const resolveRef = (schema, seen = new Set()) => {
+                if (!schema || typeof schema !== 'object') return schema;
+                if (typeof schema.$ref === 'string') {
+                    const ref = schema.$ref;
+                    if (ref.startsWith('#/definitions/')) {
+                        if (seen.has(ref)) return schema;
+                        seen.add(ref);
+                        const name = ref.slice('#/definitions/'.length);
+                        const def = schemaRoot.definitions && schemaRoot.definitions[name];
+                        if (!def) return schema;
+                        const resolved = resolveRef(def, seen);
+                        const rest = Object.assign({}, schema);
+                        delete rest.$ref;
+                        return Object.assign({}, resolved, rest);
+                    }
+                }
+                return schema;
+            };
+
+            const mergeProps = (schemas) => {
+                const props = {};
+                for (const s of schemas) {
+                    const schema = resolveRef(s);
+                    if (schema && schema.properties && typeof schema.properties === 'object') {
+                        Object.assign(props, schema.properties);
+                    }
+                }
+                return props;
+            };
+
+            const getObjectProperties = (schema) => {
+                schema = resolveRef(schema);
+                if (!schema) return {};
+                if (schema.properties && typeof schema.properties === 'object') return schema.properties;
+                if (Array.isArray(schema.anyOf)) return mergeProps(schema.anyOf);
+                return {};
+            };
+
+            const getPropertySchema = (schema, key) => {
+                schema = resolveRef(schema);
+                if (!schema) return null;
+
+                if (schema.properties && schema.properties[key]) return resolveRef(schema.properties[key]);
+
+                if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
+                    return resolveRef(schema.additionalProperties);
+                }
+
+                if (Array.isArray(schema.anyOf)) {
+                    for (const alt of schema.anyOf) {
+                        const res = getPropertySchema(alt, key);
+                        if (res) return res;
+                    }
+                }
+
+                return null;
+            };
+
+            const getValueSuggestions = (schema) => {
+                schema = resolveRef(schema);
+                if (!schema) return [];
+
+                const values = [];
+
+                const addFrom = (s) => {
+                    s = resolveRef(s);
+                    if (!s) return;
+                    if (Array.isArray(s.enum)) values.push(...s.enum);
+                    if ('const' in s) values.push(s.const);
+                    if (Array.isArray(s.examples)) values.push(...s.examples);
+                    if ('default' in s) values.push(s.default);
+                };
+
+                if (Array.isArray(schema.anyOf)) {
+                    for (const alt of schema.anyOf) addFrom(alt);
+                } else {
+                    addFrom(schema);
+                }
+
+                return unique(values);
+            };
+
+            const getSchemaTypes = (schema, seen = new Set()) => {
+                schema = resolveRef(schema);
+                if (!schema || typeof schema !== 'object') return new Set();
+
+                if (Array.isArray(schema.anyOf)) {
+                    const types = new Set();
+                    for (const alt of schema.anyOf) {
+                        for (const t of getSchemaTypes(alt, seen)) types.add(t);
+                    }
+                    return types;
+                }
+
+                if (Array.isArray(schema.oneOf)) {
+                    const types = new Set();
+                    for (const alt of schema.oneOf) {
+                        for (const t of getSchemaTypes(alt, seen)) types.add(t);
+                    }
+                    return types;
+                }
+
+                if (Array.isArray(schema.type)) return new Set(schema.type);
+                if (typeof schema.type === 'string') return new Set([schema.type]);
+                if (schema.properties || schema.additionalProperties) return new Set(['object']);
+                if (schema.items) return new Set(['array']);
+                return new Set();
+            };
+
+            const schemaAllowsType = (schema, actualType) => {
+                const types = getSchemaTypes(schema);
+                if (actualType === 'integer' && types.has('number')) return true;
+                return types.has(actualType);
+            };
+
+            const schemaTypesLabel = (schema) => {
+                const types = Array.from(getSchemaTypes(schema));
+                if (types.length === 0) return 'any';
+                return types.sort().join(' | ');
+            };
+
+            const getArrayItemSchema = (schema) => {
+                schema = resolveRef(schema);
+                if (!schema) return null;
+                if (schema.type === 'array' && schema.items) return resolveRef(schema.items);
+                if (Array.isArray(schema.anyOf)) {
+                    for (const alt of schema.anyOf) {
+                        const item = getArrayItemSchema(alt);
+                        if (item) return item;
+                    }
+                }
+                return null;
+            };
+
+            return {
+                schemaRoot,
+                resolveRef,
+                getObjectProperties,
+                getPropertySchema,
+                getValueSuggestions,
+                getSchemaTypes,
+                schemaAllowsType,
+                schemaTypesLabel,
+                getArrayItemSchema,
+            };
+        };
+
+        const isIntLike = (s) => /^[+-]?\d+$/.test(s);
+        const isNumberLike = (s) => (
+            /^[+-]?(?:\d*\.\d+|\d+\.\d*)(?:[eE][+-]?\d+)?$/.test(s) ||
+            /^[+-]?\d+(?:[eE][+-]?\d+)$/.test(s) ||
+            isIntLike(s)
+        );
+
+        const classifyYamlScalar = (raw) => {
+            const v = raw.trim();
+            if (!v) return {type: 'null'};
+            if (/^\$\{[^}{]+\}$/.test(v)) return {type: 'dynamic'};
+            if (v.startsWith('[')) return {type: 'array'};
+            if (v.startsWith('{')) return {type: 'object'};
+            if (v.startsWith('"') || v.startsWith('\'')) return {type: 'string'};
+            if (v === 'true' || v === 'false') return {type: 'boolean'};
+            if (v === 'null' || v === '~') return {type: 'null'};
+            if (isIntLike(v)) return {type: 'integer'};
+            if (isNumberLike(v)) return {type: 'number'};
+            return {type: 'string'};
+        };
+
+        const parseYamlValue = (raw) => {
+            const trimmed = raw.trim();
+            if (!trimmed) return {ok: false};
+            if (/^\$\{[^}{]+\}$/.test(trimmed)) return {ok: false, dynamic: true};
+            if (trimmed.startsWith('|') || trimmed.startsWith('>')) return {ok: false, block: true};
+            if (window.jsyaml && window.jsyaml.load) {
+                try {
+                    return {ok: true, value: window.jsyaml.load(trimmed)};
+                } catch (e) {
+                    // nothing
+                }
+            }
+            if (trimmed.startsWith('"') && trimmed.endsWith('"') && trimmed.length >= 2) {
+                const inner = trimmed.slice(1, -1);
+                return {ok: true, value: inner.replace(/\\"/g, '"').replace(/\\\\/g, '\\')};
+            }
+            if (trimmed.startsWith('\'') && trimmed.endsWith('\'') && trimmed.length >= 2) {
+                const inner = trimmed.slice(1, -1);
+                return {ok: true, value: inner.replace(/''/g, '\'')};
+            }
+            if (trimmed === 'true' || trimmed === 'false') return {ok: true, value: trimmed === 'true'};
+            if (trimmed === 'null' || trimmed === '~') return {ok: true, value: null};
+            if (isIntLike(trimmed)) return {ok: true, value: parseInt(trimmed, 10)};
+            if (isNumberLike(trimmed)) return {ok: true, value: Number(trimmed)};
+            return {ok: true, value: trimmed};
+        };
+
+        const lintYamlModel = (model, schemaTools) => {
+            const markers = [];
+            const markedLines = new Set();
+            let blockScalarParentIndent = null;
+
+            const isBlockScalarHeader = (text) => {
+                const rawText = (text == null) ? '' : text;
+                const t = rawText.trimStart ? rawText.trimStart() : rawText.replace(/^\s+/, '');
+                return t.startsWith('|') || t.startsWith('>');
+            };
+
+            const checkChildIndent = (ctx, childIndent, lineNumber) => {
+                if (!ctx) return;
+                if (ctx.childIndent == null) {
+                    ctx.childIndent = childIndent;
+                    return;
+                }
+                if (childIndent !== ctx.childIndent) {
+                    markLineError(lineNumber, `YAML: inconsistent indentation (expected ${ctx.childIndent} spaces)`, 1);
+                }
+            };
+
+            const markLineError = (lineNumber, message, startColumn = 1) => {
+                if (markedLines.has(`${lineNumber}:${message}`)) return;
+                markedLines.add(`${lineNumber}:${message}`);
+                const lineText = model.getLineContent(lineNumber);
+                markers.push({
+                    severity: monaco.MarkerSeverity.Error,
+                    message,
+                    startLineNumber: lineNumber,
+                    startColumn,
+                    endLineNumber: lineNumber,
+                    endColumn: Math.max(startColumn + 1, lineText.length + 1),
+                });
+            };
+
+            if (window.jsyaml && window.jsyaml.load) {
+                try {
+                    window.jsyaml.load(model.getValue());
+                } catch (e) {
+                    const mark = (e && e.mark) || {};
+                    const line = typeof mark.line === 'number' ? mark.line + 1 : 1;
+                    const column = typeof mark.column === 'number' ? mark.column + 1 : 1;
+                    const reason = e && e.reason;
+                    const messageText = e && e.message;
+                    markLineError(line, reason ? `YAML: ${reason}` : `YAML: ${messageText || 'Invalid YAML'}`, column);
+                }
+            }
+
+            const pushMarker = (m) => markers.push(m);
+
+            const getExpectedContainerType = (schema) => {
+                if (!schemaTools) return null;
+                const types = schemaTools.getSchemaTypes(schema);
+                const wantsObject = types.has('object');
+                const wantsArray = types.has('array');
+                if (wantsObject && !wantsArray) return 'object';
+                if (wantsArray && !wantsObject) return 'array';
+                return null;
+            };
+
+            const stack = [{
+                indent: -1,
+                schema: (schemaTools && schemaTools.schemaRoot) || null,
+                expected: 'object',
+                actual: null,
+                keys: new Map(),
+                childIndent: null,
+                origin: null,
+                reportedTypeMismatch: false,
+            }];
+
+            let hasTopLevelKey = false;
+            let hasTopLevelList = false;
+            const lineCount = model.getLineCount();
+            for (let lineNumber = 1; lineNumber <= lineCount; lineNumber++) {
+                let line = model.getLineContent(lineNumber);
+                if (!line.trim()) continue;
+                line = stripInlineComment(line).trimEnd();
+                if (!line.trim()) continue;
+                const kv = parseKey(line);
+                if (kv && kv.indent === 0) hasTopLevelKey = true;
+                const li = parseListItem(line);
+                if (li && li.indent === 0) hasTopLevelList = true;
+            }
+
+            const setActualType = (ctx, actual, fallbackLineNumber) => {
+                if (ctx.actual !== null) return;
+                ctx.actual = actual;
+                if (ctx.origin && ctx.expected && ctx.expected !== actual && !ctx.reportedTypeMismatch) {
+                    pushMarker({
+                        severity: monaco.MarkerSeverity.Error,
+                        message: `Type mismatch: expected ${ctx.expected}, got ${actual}`,
+                        startLineNumber: ctx.origin.lineNumber,
+                        startColumn: ctx.origin.startColumn,
+                        endLineNumber: ctx.origin.lineNumber,
+                        endColumn: ctx.origin.endColumn,
+                    });
+                    ctx.reportedTypeMismatch = true;
+                } else if (!ctx.origin && ctx.expected && ctx.expected !== actual && fallbackLineNumber) {
+                    pushMarker({
+                        severity: monaco.MarkerSeverity.Error,
+                        message: `Type mismatch: expected ${ctx.expected}, got ${actual}`,
+                        startLineNumber: fallbackLineNumber,
+                        startColumn: 1,
+                        endLineNumber: fallbackLineNumber,
+                        endColumn: 2,
+                    });
+                    ctx.reportedTypeMismatch = true;
+                }
+            };
+
+            const checkValueType = (schema, actualType, lineNumber, startColumn, endColumn, keyName) => {
+                if (!schemaTools || !schema) return;
+                if (actualType === 'dynamic') return;
+                if (schemaTools.schemaAllowsType(schema, actualType)) return;
+                pushMarker({
+                    severity: monaco.MarkerSeverity.Error,
+                    message: `Type mismatch for ${keyName ? `"${keyName}"` : 'value'}: expected ${schemaTools.schemaTypesLabel(schema)}, got ${actualType}`,
+                    startLineNumber: lineNumber,
+                    startColumn,
+                    endLineNumber: lineNumber,
+                    endColumn: Math.max(startColumn + 1, endColumn),
+                });
+            };
+
+            const valueEquals = (a, b) => {
+                if (a === b) return true;
+                if (typeof a !== typeof b) return false;
+                if (a && b && typeof a === 'object') {
+                    const aIsArray = Array.isArray(a);
+                    const bIsArray = Array.isArray(b);
+                    if (aIsArray !== bIsArray) return false;
+                    if (aIsArray) {
+                        if (a.length !== b.length) return false;
+                        for (let i = 0; i < a.length; i++) {
+                            if (!valueEquals(a[i], b[i])) return false;
+                        }
+                        return true;
+                    }
+                    const aKeys = Object.keys(a);
+                    const bKeys = Object.keys(b);
+                    if (aKeys.length !== bKeys.length) return false;
+                    for (const key of aKeys) {
+                        if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+                        if (!valueEquals(a[key], b[key])) return false;
+                    }
+                    return true;
+                }
+                return false;
+            };
+
+            const schemaAllowsTypeLoose = (schema, actualType) => {
+                if (!schemaTools || !schema) return true;
+                const types = schemaTools.getSchemaTypes(schema);
+                if (types.size === 0) return true;
+                if (actualType === 'integer' && types.has('number')) return true;
+                return types.has(actualType);
+            };
+
+            const collectConstraintSchemas = (schema, actualType) => {
+                if (!schemaTools || !schema) return [];
+                schema = schemaTools.resolveRef(schema);
+                if (!schema) return [];
+                if (Array.isArray(schema.anyOf)) {
+                    const res = [];
+                    for (const alt of schema.anyOf) res.push(...collectConstraintSchemas(alt, actualType));
+                    return res;
+                }
+                if (Array.isArray(schema.oneOf)) {
+                    const res = [];
+                    for (const alt of schema.oneOf) res.push(...collectConstraintSchemas(alt, actualType));
+                    return res;
+                }
+                if (!schemaAllowsTypeLoose(schema, actualType)) return [];
+                return [schema];
+            };
+
+            const getSchemaEnumValues = (schema) => {
+                const values = [];
+                if (Array.isArray(schema.enum)) values.push(...schema.enum);
+                if (Object.prototype.hasOwnProperty.call(schema, 'const')) values.push(schema.const);
+                return values;
+            };
+
+            const checkValueConstraints = (schema, actualType, rawValue, lineNumber, startColumn, endColumn, keyName) => {
+                if (!schemaTools || !schema) return;
+                if (actualType === 'dynamic') return;
+                const parsed = parseYamlValue(rawValue);
+                if (!parsed.ok) return;
+
+                const candidates = collectConstraintSchemas(schema, actualType);
+                if (candidates.length === 0) return;
+
+                const hasConstraints = candidates.some((s) => (
+                    (Array.isArray(s.enum) || Object.prototype.hasOwnProperty.call(s, 'const')) ||
+                    (actualType === 'string' && typeof s.pattern === 'string')
+                ));
+                if (!hasConstraints) return;
+
+                const hasUnconstrained = candidates.some((s) => (
+                    !(Array.isArray(s.enum) || Object.prototype.hasOwnProperty.call(s, 'const')) &&
+                    !(actualType === 'string' && typeof s.pattern === 'string')
+                ));
+                if (hasUnconstrained) return;
+
+                const value = parsed.value;
+                const matchesAny = candidates.some((s) => {
+                    const enums = getSchemaEnumValues(s);
+                    if (enums.length > 0 && !enums.some((v) => valueEquals(v, value))) return false;
+                    if (actualType === 'string' && typeof s.pattern === 'string') {
+                        try {
+                            const re = new RegExp(s.pattern);
+                            if (!re.test(String(value))) return false;
+                        } catch (e) {
+                            return true;
+                        }
+                    }
+                    return true;
+                });
+                if (matchesAny) return;
+
+                const enumValues = [];
+                const patterns = [];
+                for (const s of candidates) {
+                    enumValues.push(...getSchemaEnumValues(s));
+                    if (actualType === 'string' && typeof s.pattern === 'string') patterns.push(s.pattern);
+                }
+                const enumLabel = unique(enumValues).map((v) => toYamlScalar(v)).join(', ');
+                const patternLabel = unique(patterns).join(' | ');
+
+                let message;
+                const label = keyName ? `"${keyName}"` : 'value';
+                if (enumValues.length && patterns.length) {
+                    message = `Value for ${label} must be one of: ${enumLabel}; or match pattern: ${patternLabel}`;
+                } else if (enumValues.length) {
+                    message = `Value for ${label} must be one of: ${enumLabel}`;
+                } else if (patterns.length) {
+                    message = `Value for ${label} must match pattern: ${patternLabel}`;
+                } else {
+                    return;
+                }
+
+                pushMarker({
+                    severity: monaco.MarkerSeverity.Error,
+                    message,
+                    startLineNumber: lineNumber,
+                    startColumn,
+                    endLineNumber: lineNumber,
+                    endColumn: Math.max(startColumn + 1, endColumn),
+                });
+            };
+
+            for (let lineNumber = 1; lineNumber <= lineCount; lineNumber++) {
+                let line = model.getLineContent(lineNumber);
+                if (!line.trim()) continue;
+
+                line = stripInlineComment(line).trimEnd();
+                if (!line.trim()) continue;
+
+                const indent = countIndent(line);
+                if (blockScalarParentIndent !== null) {
+                    if (indent <= blockScalarParentIndent) {
+                        blockScalarParentIndent = null;
+                    } else {
+                        continue; // treat as block scalar content
+                    }
+                }
+
+                if (indent === 0 && (hasTopLevelKey || hasTopLevelList)) {
+                    const trimmed = line.trim();
+                    if (trimmed !== '---' && trimmed !== '...' && !trimmed.startsWith('#')) {
+                        const listItem0 = parseListItem(line);
+                        const kv0 = parseKey(line);
+                        const flow0 = trimmed.startsWith('{') || trimmed.startsWith('[');
+                        if (!flow0 && !listItem0 && !kv0) {
+                            markLineError(lineNumber, 'YAML: unexpected content at document root');
+                            continue;
+                        }
+                    }
+                }
+
+                const listItem = parseListItem(line);
+                if (listItem) {
+                    if (listItem.indent > 0 && (hasTopLevelKey || hasTopLevelList) && stack.length === 1) {
+                        markLineError(lineNumber, 'YAML: unexpected indentation at document root', 1);
+                    }
+                    while (stack.length > 1 && listItem.indent <= stack[stack.length - 1].indent) stack.pop();
+
+                    const parent = stack[stack.length - 1];
+                    checkChildIndent(parent, listItem.indent, lineNumber);
+                    setActualType(parent, 'array', lineNumber);
+
+                    const itemSchema = schemaTools ? schemaTools.getArrayItemSchema(parent.schema) : null;
+                    const itemExpected = getExpectedContainerType(itemSchema);
+
+                    const itemCtx = {
+                        indent: listItem.indent,
+                        schema: itemSchema,
+                        expected: itemExpected,
+                        actual: null,
+                        keys: new Map(),
+                        childIndent: null,
+                        origin: {lineNumber, startColumn: listItem.dashIndex + 1, endColumn: listItem.dashIndex + 2},
+                        reportedTypeMismatch: false,
+                    };
+                    stack.push(itemCtx);
+
+                    if (!listItem.rest) continue;
+                    if (isBlockScalarHeader(listItem.rest)) {
+                        blockScalarParentIndent = listItem.indent;
+                        checkValueType(itemSchema, 'string', lineNumber, listItem.afterDashIndex + 1, line.length + 1, null);
+                        continue;
+                    }
+
+                    const inline = parseKey(' '.repeat(listItem.afterDashIndex) + listItem.rest);
+                    if (inline) {
+                        // handle inline mapping in the same line: "- key: value"
+                        const kv = inline;
+                        while (stack.length > 1 && kv.indent <= stack[stack.length - 1].indent) stack.pop();
+                        const ctx = stack[stack.length - 1];
+                        checkChildIndent(ctx, kv.indent, lineNumber);
+                        setActualType(ctx, 'object', lineNumber);
+
+                        const prev = ctx.keys.get(kv.key);
+                        if (prev) {
+                            pushMarker({
+                                severity: monaco.MarkerSeverity.Warning,
+                                message: `Duplicate key "${kv.key}" (previous at line ${prev.lineNumber})`,
+                                startLineNumber: lineNumber,
+                                startColumn: kv.keyStartIndex + 1,
+                                endLineNumber: lineNumber,
+                                endColumn: kv.keyEndIndex + 1,
+                            });
+                        } else {
+                            ctx.keys.set(kv.key, {lineNumber});
+                        }
+
+                        if (!kv.isQuoted && isNumberLike(kv.rawKey.trim())) {
+                            pushMarker({
+                                severity: monaco.MarkerSeverity.Error,
+                                message: `Map keys must be strings. Quote numeric key as '${kv.rawKey}':`,
+                                startLineNumber: lineNumber,
+                                startColumn: kv.keyStartIndex + 1,
+                                endLineNumber: lineNumber,
+                                endColumn: kv.keyEndIndex + 1,
+                            });
+                        }
+
+                        const propSchema = schemaTools ? schemaTools.getPropertySchema(ctx.schema, kv.key) : null;
+                        if (isBlockScalarHeader(kv.after)) {
+                            blockScalarParentIndent = kv.indent;
+                        }
+                        if (kv.isContainer) {
+                            stack.push({
+                                indent: kv.indent,
+                                schema: propSchema,
+                                expected: getExpectedContainerType(propSchema),
+                                actual: null,
+                                keys: new Map(),
+                                childIndent: null,
+                                origin: {lineNumber, startColumn: kv.keyStartIndex + 1, endColumn: kv.keyEndIndex + 1},
+                                reportedTypeMismatch: false,
+                            });
+                        } else if (propSchema) {
+                            const valueText = kv.after.trim();
+                            const actual = classifyYamlScalar(valueText).type;
+                            const valueStartColumn = kv.valueStartIndex + 1 + (kv.after.length - kv.after.trimStart().length);
+                            checkValueType(propSchema, actual, lineNumber, valueStartColumn, line.length + 1, kv.key);
+                            checkValueConstraints(propSchema, actual, valueText, lineNumber, valueStartColumn, line.length + 1, kv.key);
+                        }
+                        continue;
+                    }
+
+                    const scalar = classifyYamlScalar(listItem.rest).type;
+                    checkValueType(itemSchema, scalar, lineNumber, listItem.afterDashIndex + 1, line.length + 1, null);
+                    checkValueConstraints(itemSchema, scalar, listItem.rest, lineNumber, listItem.afterDashIndex + 1, line.length + 1, null);
+                    continue;
+                }
+
+                const kv = parseKey(line);
+                if (!kv) {
+                    markLineError(lineNumber, 'YAML: expected a map key (key:) or list item (-)', indent + 1);
+                    continue;
+                }
+                if (kv.indent > 0 && (hasTopLevelKey || hasTopLevelList) && stack.length === 1) {
+                    markLineError(lineNumber, 'YAML: unexpected indentation at document root', 1);
+                }
+
+                while (stack.length > 1 && kv.indent <= stack[stack.length - 1].indent) stack.pop();
+                const ctx = stack[stack.length - 1];
+                checkChildIndent(ctx, kv.indent, lineNumber);
+                setActualType(ctx, 'object', lineNumber);
+
+                const prev = ctx.keys.get(kv.key);
+                if (prev) {
+                    pushMarker({
+                        severity: monaco.MarkerSeverity.Warning,
+                        message: `Duplicate key "${kv.key}" (previous at line ${prev.lineNumber})`,
+                        startLineNumber: lineNumber,
+                        startColumn: kv.keyStartIndex + 1,
+                        endLineNumber: lineNumber,
+                        endColumn: kv.keyEndIndex + 1,
+                    });
+                } else {
+                    ctx.keys.set(kv.key, {lineNumber});
+                }
+
+                if (!kv.isQuoted && isNumberLike(kv.rawKey.trim())) {
+                    pushMarker({
+                        severity: monaco.MarkerSeverity.Error,
+                        message: `Map keys must be strings. Quote numeric key as '${kv.rawKey}':`,
+                        startLineNumber: lineNumber,
+                        startColumn: kv.keyStartIndex + 1,
+                        endLineNumber: lineNumber,
+                        endColumn: kv.keyEndIndex + 1,
+                    });
+                }
+
+                const propSchema = schemaTools ? schemaTools.getPropertySchema(ctx.schema, kv.key) : null;
+                if (kv.isContainer) {
+                    stack.push({
+                        indent: kv.indent,
+                        schema: propSchema,
+                        expected: getExpectedContainerType(propSchema),
+                        actual: null,
+                        keys: new Map(),
+                        childIndent: null,
+                        origin: {lineNumber, startColumn: kv.keyStartIndex + 1, endColumn: kv.keyEndIndex + 1},
+                        reportedTypeMismatch: false,
+                    });
+                    continue;
+                }
+
+                if (isBlockScalarHeader(kv.after)) {
+                    blockScalarParentIndent = kv.indent;
+                }
+
+                if (!propSchema) continue;
+
+                const actual = classifyYamlScalar(kv.after).type;
+                const valueStartColumn = kv.valueStartIndex + 1 + (kv.after.length - kv.after.trimStart().length);
+                checkValueType(propSchema, actual, lineNumber, valueStartColumn, line.length + 1, kv.key);
+                checkValueConstraints(propSchema, actual, kv.after, lineNumber, valueStartColumn, line.length + 1, kv.key);
+            }
+
+            return markers;
+        };
+
+        let schemaTools = null;
+        let completionProvider = null;
+        let hoverProvider = null;
+
+        const scheduleLint = (() => {
+            let handle = null;
+            return () => {
+                if (handle) clearTimeout(handle);
+                handle = setTimeout(() => {
+                    const model = editor.getModel();
+                    if (!model) return;
+                    monaco.editor.setModelMarkers(model, 'yaml-lint', lintYamlModel(model, schemaTools));
+                }, 250);
+            };
+        })();
+
+        editor.onDidChangeModelContent(() => scheduleLint());
+
+        const setupYamlHints = (schemaRoot) => {
+            schemaTools = createSchemaTools(schemaRoot);
+            scheduleLint();
+
+            const {
+                resolveRef,
+                getObjectProperties,
+                getPropertySchema,
+                getValueSuggestions,
+            } = schemaTools;
+
+            const buildContextStack = (model, upToLineNumber) => {
+                const stack = [{indent: -1, schema: schemaRoot}];
+
+                for (let lineNumber = 1; lineNumber <= upToLineNumber; lineNumber++) {
+                    let line = model.getLineContent(lineNumber);
+                    if (!line.trim()) continue;
+
+                    line = stripInlineComment(line).trimEnd();
+                    if (!line.trim()) continue;
+
+                    const listItem = parseListItem(line);
+                    if (listItem) {
+                        while (stack.length > 1 && listItem.indent <= stack[stack.length - 1].indent) stack.pop();
+                        const parent = resolveRef(stack[stack.length - 1].schema);
+                        if (parent && parent.type === 'array' && parent.items) {
+                            stack.push({indent: listItem.indent, schema: resolveRef(parent.items)});
+                        } else {
+                            stack.push({indent: listItem.indent, schema: null});
+                        }
+
+                        const inline = listItem.rest ? parseKey(' '.repeat(listItem.contentIndent) + listItem.rest) : null;
+                        if (inline && inline.isContainer) {
+                            while (stack.length > 1 && inline.indent <= stack[stack.length - 1].indent) stack.pop();
+                            const ctx = resolveRef(stack[stack.length - 1].schema);
+                            const next = ctx ? getPropertySchema(ctx, inline.key) : null;
+                            stack.push({indent: inline.indent, schema: next});
+                        }
+                        continue;
+                    }
+
+                    const kv = parseKey(line);
+                    if (!kv) continue;
+                    while (stack.length > 1 && kv.indent <= stack[stack.length - 1].indent) stack.pop();
+                    if (!kv.isContainer) continue;
+
+                    const ctx = resolveRef(stack[stack.length - 1].schema);
+                    const next = ctx ? getPropertySchema(ctx, kv.key) : null;
+                    stack.push({indent: kv.indent, schema: next});
+                }
+
+                return stack;
+            };
+
+            if (completionProvider) completionProvider.dispose();
+            completionProvider = monaco.languages.registerCompletionItemProvider('yaml', {
+                triggerCharacters: [':', ' '],
+                provideCompletionItems: (model, position) => {
+                    const line = model.getLineContent(position.lineNumber);
+                    const lineNoComment = stripInlineComment(line);
+                    const lineNoCommentTrimmedEnd = lineNoComment.trimEnd();
+                    const listItem = parseListItem(lineNoCommentTrimmedEnd);
+
+                    const wordUntil = model.getWordUntilPosition(position);
+                    const range = new monaco.Range(position.lineNumber, wordUntil.startColumn, position.lineNumber, wordUntil.endColumn);
+
+                    const cursorIndex = position.column - 1;
+                    let contentStartIndex = 0;
+                    if (listItem) {
+                        contentStartIndex = listItem.afterDashIndex;
+                    } else {
+                        contentStartIndex = countIndent(lineNoComment);
+                    }
+
+                    if (cursorIndex < contentStartIndex) return {suggestions: []};
+
+                    const text = lineNoCommentTrimmedEnd.slice(contentStartIndex);
+                    const cursorInText = cursorIndex - contentStartIndex;
+                    const colonIndex = text.indexOf(':');
+                    const isValueContext = colonIndex >= 0 && cursorInText > colonIndex;
+
+                    const stack = buildContextStack(model, position.lineNumber - 1);
+
+                    const effectiveIndent = listItem ? listItem.contentIndent : countIndent(lineNoComment);
+                    while (stack.length > 1 && effectiveIndent <= stack[stack.length - 1].indent) stack.pop();
+
+                    let contextSchema = resolveRef(stack[stack.length - 1].schema);
+
+                    if (listItem && cursorIndex >= listItem.afterDashIndex && contextSchema && contextSchema.type === 'array') {
+                        contextSchema = resolveRef(contextSchema.items);
+                    }
+
+                    if (!contextSchema) return {suggestions: []};
+
+                    // Scalar array item (e.g. "- tcp4") - suggest values (enum/examples/default)
+                    if (listItem && colonIndex === -1 && !isValueContext) {
+                        const props = getObjectProperties(contextSchema);
+                        if (!props || Object.keys(props).length === 0) {
+                            const values = getValueSuggestions(contextSchema);
+                            const suggestions = values.map((v) => ({
+                                label: toYamlScalar(v),
+                                kind: monaco.languages.CompletionItemKind.Value,
+                                insertText: toYamlScalar(v),
+                                range,
+                            }));
+                            return {suggestions};
+                        }
+                    }
+
+                    if (!isValueContext) {
+                        const props = getObjectProperties(contextSchema);
+                        const suggestions = Object.keys(props).map((key) => {
+                            const s = resolveRef(props[key]);
+                            const wantsArray = s && s.type === 'array';
+                            const wantsBlock = s && (s.type === 'object' || wantsArray || s.properties);
+                            const indent = listItem ? ' '.repeat(listItem.contentIndent) : ' '.repeat(countIndent(lineNoComment));
+                            const innerIndent = indent + '  ';
+
+                            const insertText = wantsArray ? `${key}:\n${indent}` : (wantsBlock ? `${key}:\n${innerIndent}` : `${key}: `);
+                            const hasValueSuggestions = !wantsBlock && getValueSuggestions(s).length > 0;
+
+                            return {
+                                label: key,
+                                kind: monaco.languages.CompletionItemKind.Property,
+                                insertText,
+                                insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                                command: (wantsBlock || hasValueSuggestions) ? {id: 'editor.action.triggerSuggest'} : undefined,
+                                documentation: s && s.description,
+                                range,
+                            };
+                        });
+
+                        return {suggestions};
+                    }
+
+                    const keyName = text.slice(0, colonIndex).trim();
+                    const keySchema = getPropertySchema(contextSchema, keyName);
+                    if (!keySchema) return {suggestions: []};
+
+                    const values = getValueSuggestions(keySchema);
+                    const suggestions = values.map((v) => ({
+                        label: toYamlScalar(v),
+                        kind: monaco.languages.CompletionItemKind.Value,
+                        insertText: toYamlScalar(v),
+                        range,
+                    }));
+
+                    return {suggestions};
+                }
+            });
+
+            if (hoverProvider) hoverProvider.dispose();
+            hoverProvider = monaco.languages.registerHoverProvider('yaml', {
+                provideHover: (model, position) => {
+                    if (!schemaTools) return null;
+
+                    const line = model.getLineContent(position.lineNumber);
+                    const lineNoComment = stripInlineComment(line).trimEnd();
+                    const listItem = parseListItem(lineNoComment);
+
+                    const cursorIndex = position.column - 1;
+                    if (listItem && cursorIndex < listItem.afterDashIndex) return null;
+
+                    let kv;
+                    let effectiveIndent;
+                    let keyStartIndex;
+                    let keyEndIndex;
+
+                    if (listItem) {
+                        if (!listItem.rest) return null;
+                        const synthetic = ' '.repeat(listItem.contentIndent) + listItem.rest;
+                        kv = parseKey(synthetic);
+                        if (!kv) return null;
+                        effectiveIndent = listItem.contentIndent;
+                        keyStartIndex = listItem.afterDashIndex + (kv.keyStartIndex - listItem.contentIndent);
+                        keyEndIndex = listItem.afterDashIndex + (kv.keyEndIndex - listItem.contentIndent);
+                    } else {
+                        kv = parseKey(lineNoComment);
+                        if (!kv) return null;
+                        effectiveIndent = countIndent(lineNoComment);
+                        keyStartIndex = kv.keyStartIndex;
+                        keyEndIndex = kv.keyEndIndex;
+                    }
+
+                    if (cursorIndex < keyStartIndex || cursorIndex >= keyEndIndex) return null;
+
+                    const stack = buildContextStack(model, position.lineNumber - 1);
+                    while (stack.length > 1 && effectiveIndent <= stack[stack.length - 1].indent) stack.pop();
+
+                    let contextSchema = resolveRef(stack[stack.length - 1].schema);
+                    if (listItem && cursorIndex >= listItem.afterDashIndex && contextSchema && contextSchema.type === 'array') {
+                        contextSchema = resolveRef(contextSchema.items);
+                    }
+
+                    if (!contextSchema) return null;
+                    const propSchema = getPropertySchema(contextSchema, kv.key);
+                    if (!propSchema) return null;
+
+                    const resolved = resolveRef(propSchema);
+                    const description = resolved && resolved.description;
+                    if (!description) return null;
+
+                    return {
+                        range: new monaco.Range(
+                            position.lineNumber,
+                            keyStartIndex + 1,
+                            position.lineNumber,
+                            keyEndIndex + 1
+                        ),
+                        contents: [{value: description}],
+                    };
+                }
+            });
+        };
+
+        const layout = () => {
+            const top = container.getBoundingClientRect().top;
+            container.style.height = `${Math.max(200, window.innerHeight - top)}px`;
+            editor.layout();
+        };
+        window.addEventListener('resize', layout);
+        layout();
+
+        let dump;
+
+        document.getElementById('save').addEventListener('click', async () => {
+            let r = await fetch('api/config', {cache: 'no-cache'});
+            if (r.ok && dump !== await r.text()) {
+                alert('Config was changed from another place. Refresh the page and make changes again');
+                return;
+            }
+
+            r = await fetch('api/config', {method: 'POST', body: editor.getValue()});
+            if (r.ok) {
+                alert('OK');
+                dump = editor.getValue();
+                await fetch('api/restart', {method: 'POST'});
+            } else {
+                alert(await r.text());
+            }
+        });
+
+        document.getElementById('suggest').addEventListener('click', () => {
+            editor.trigger('source', 'editor.action.triggerSuggest', {});
+        });
+
+        (async () => {
+            try {
+                const r = await fetch('schema.json', {cache: 'no-cache'});
+                if (r.ok) setupYamlHints(await r.json());
+            } catch (e) {
+                // ignore schema load errors
+            }
+
+            const r = await fetch('api/config', {cache: 'no-cache'});
+            if (r.status === 410) {
+                alert('Config file is not set');
+            } else if (r.status === 404) {
+                editor.setValue(''); // config file not exist
+            } else if (r.ok) {
+                dump = await r.text();
+                editor.setValue(dump);
+            } else {
+                alert(`Unknown error: ${r.statusText} (${r.status})`);
+            }
+        })();
+    });
+</script>
+
+</body>
+</html>
diff --git a/installs_on_host/go2rtc/www/hls.html b/installs_on_host/go2rtc/www/hls.html
new file mode 100644
index 0000000..70f5cdc
--- /dev/null
+++ b/installs_on_host/go2rtc/www/hls.html
@@ -0,0 +1,37 @@
+<!doctype html>
+<html lang="en">
+<head>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>hls - go2rtc</title>
+    <style>
+        body {
+            background-color: black;
+            margin: 0;
+            padding: 0;
+        }
+
+        html, body, video {
+            height: 100%;
+            width: 100%;
+        }
+    </style>
+</head>
+<body>
+<script src="https://cdn.jsdelivr.net/npm/hls.js@1"></script>
+<video id="video" autoplay controls playsinline muted></video>
+<script>
+    // http://192.168.1.123:1984/hls.html?src=demo&mp4
+    const url = new URL('api/stream.m3u8' + location.search, location.href);
+
+    const video = document.getElementById('video');
+    /* global Hls */
+    if (Hls.isSupported()) {
+        const hls = new Hls();
+        hls.loadSource(url.toString());
+        hls.attachMedia(video);
+    } else if (video.canPlayType('application/vnd.apple.mpegurl')) {
+        video.src = url.toString();
+    }
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/installs_on_host/go2rtc/www/index.html b/installs_on_host/go2rtc/www/index.html
new file mode 100644
index 0000000..69126e6
--- /dev/null
+++ b/installs_on_host/go2rtc/www/index.html
@@ -0,0 +1,157 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>go2rtc</title>
+    <style>
+        .controls {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 10px;
+            align-items: center;
+        }
+
+        .info {
+            color: #888;
+        }
+    </style>
+</head>
+<body>
+
+<script src="main.js"></script>
+
+<main>
+    <div class="controls">
+        <button>stream</button>
+        modes
+        <label><input type="checkbox" name="webrtc" checked>webrtc</label>
+        <label><input type="checkbox" name="mse" checked>mse</label>
+        <label><input type="checkbox" name="hls" checked>hls</label>
+        <label><input type="checkbox" name="mjpeg" checked>mjpeg</label>
+    </div>
+    <table>
+        <thead>
+        <tr>
+            <th><label><input id="selectall" type="checkbox">name</label></th>
+            <th>online</th>
+            <th>commands</th>
+        </tr>
+        </thead>
+        <tbody id="streams">
+        </tbody>
+    </table>
+    <div class="info"></div>
+</main>
+
+<script>
+    const templates = [
+        '<a href="stream.html?src={name}">stream</a>',
+        '<a href="links.html?src={name}">links</a>',
+        '<a href="#" data-name="{name}">delete</a>',
+    ];
+
+    document.querySelector('.controls > button')
+        .addEventListener('click', () => {
+            const url = new URL('stream.html', location.href);
+
+            const streams = document.querySelectorAll('#streams input');
+            streams.forEach(i => {
+                if (i.checked) url.searchParams.append('src', i.name);
+            });
+
+            if (!url.searchParams.has('src')) return;
+
+            let mode = document.querySelectorAll('.controls input');
+            mode = Array.from(mode).filter(i => i.checked).map(i => i.name).join(',');
+
+            window.location.href = `${url}&mode=${mode}`;
+        });
+
+    const tbody = document.getElementById('streams');
+    tbody.addEventListener('click', async ev => {
+        if (ev.target.innerText !== 'delete') return;
+
+        ev.preventDefault();
+
+        const src = decodeURIComponent(ev.target.dataset.name);
+
+        const message = `Please type the name of the stream "${src}" to confirm its deletion from the configuration. This action is irreversible.`;
+        if (prompt(message) !== src) {
+            alert('Stream name does not match. Deletion cancelled.');
+            return;
+        }
+
+        const url = new URL('api/streams', location.href);
+        url.searchParams.set('src', src);
+
+        try {
+            await fetch(url, {method: 'DELETE'});
+            reload();
+        } catch (error) {
+            console.error('Failed to delete the stream:', error);
+        }
+    });
+
+    document.getElementById('selectall').addEventListener('change', ev => {
+        document.querySelectorAll('#streams input').forEach(el => {
+            el.checked = ev.target.checked;
+        });
+    });
+
+    function reload() {
+        const url = new URL('api/streams', location.href);
+        const checkboxStates = {};
+        tbody.querySelectorAll('input[type="checkbox"][name]').forEach(checkbox => {
+            checkboxStates[checkbox.name] = checkbox.checked;
+        });
+        fetch(url, {cache: 'no-cache'}).then(r => r.json()).then(data => {
+            const existingIds = Array.from(tbody.querySelectorAll('tr')).map(tr => tr.dataset['id']);
+            const fetchedIds = [];
+
+            for (const [key, value] of Object.entries(data)) {
+                const name = key.replace(/[<">]/g, ''); // sanitize
+                fetchedIds.push(name);
+
+                let tr = tbody.querySelector(`tr[data-id="${name}"]`);
+                const online = value && value.consumers ? value.consumers.length : 0;
+                const src = encodeURIComponent(name);
+                const links = templates.map(link => link.replace('{name}', src)).join(' ');
+
+                if (!tr) {
+                    tr = document.createElement('tr');
+                    tr.dataset['id'] = name;
+                    tbody.appendChild(tr);
+                }
+
+                const isChecked = checkboxStates[name] ? 'checked' : '';
+                tr.innerHTML =
+                    `<td><label><input type="checkbox" name="${name}" ${isChecked}>${name}</label></td>` +
+                    `<td><a href="api/streams?src=${src}">${online} / info</a> / <a href="api/streams?src=${src}&video=all&audio=all&microphone">probe</a> / <a href="net.html?src=${src}">net</a></td>` +
+                    `<td>${links}</td>`;
+            }
+
+            // Remove old rows
+            existingIds.forEach(id => {
+                if (!fetchedIds.includes(id)) {
+                    const trToRemove = tbody.querySelector(`tr[data-id="${id}"]`);
+                    tbody.removeChild(trToRemove);
+                }
+            });
+        });
+    }
+
+    // Auto-reload
+    setInterval(reload, 1000);
+
+    const url = new URL('api', location.href);
+    fetch(url, {cache: 'no-cache'}).then(r => r.json()).then(data => {
+        const info = document.querySelector('.info');
+        info.innerText = `version: ${data.version} / config: ${data.config_path}`;
+    });
+
+    reload();
+</script>
+
+</body>
+</html>
diff --git a/installs_on_host/go2rtc/www/links.html b/installs_on_host/go2rtc/www/links.html
new file mode 100644
index 0000000..13e08ed
--- /dev/null
+++ b/installs_on_host/go2rtc/www/links.html
@@ -0,0 +1,268 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>links - go2rtc</title>
+    <style>
+        div > li {
+            list-style-type: none;
+            padding-left: 10px;
+            position: relative;
+        }
+
+        div > li:before {
+            content: "-";
+            position: absolute;
+            left: 0;
+        }
+    </style>
+</head>
+<body>
+
+<script src="main.js"></script>
+
+<main>
+    <div id="links"></div>
+    <script>
+        const src = new URLSearchParams(location.search).get('src').replace(/[<">]/g, ''); // sanitize
+
+        const links = document.getElementById('links');
+
+        links.innerHTML = `
+        <h2>Any codec in source</h2>
+        <li><a href="stream.html?src=${src}">stream.html</a> with auto-select mode / browsers: all / codecs: H264, H265*, MJPEG, JPEG, AAC, PCMU, PCMA, OPUS</li>
+        <li><a href="api/streams?src=${src}">info.json</a> page with active connections</li>
+    `;
+
+        const url = new URL('api', location.href);
+        fetch(url, {cache: 'no-cache'}).then(r => r.json()).then(data => {
+            let rtsp = location.host + ':8554';
+            try {
+                const host = data.host.match(/^[^:]+/)[0];
+                const port = data.rtsp.listen.match(/[0-9]+$/)[0];
+                rtsp = `${host}:${port}`;
+            } catch (e) {
+            }
+
+            links.innerHTML += `
+            <li><a href="rtsp://${rtsp}/${src}">rtsp</a> with only one video and one audio / codecs: any</li>
+            <li><a href="rtsp://${rtsp}/${src}?mp4">rtsp</a> for MP4 recording (Hass or Frigate) / codecs: H264, H265, AAC</li>
+            <li><a href="rtsp://${rtsp}/${src}?video=all&audio=all">rtsp</a> with all tracks / codecs: any</li>
+
+            <pre>ffplay -fflags nobuffer -flags low_delay -rtsp_transport tcp "rtsp://${rtsp}/${src}"</pre>
+
+            <h2>H264/H265 source</h2>
+            <li><a href="stream.html?src=${src}&mode=webrtc">stream.html</a> WebRTC stream / browsers: all / codecs: H264, PCMU, PCMA, OPUS / +H265 in Safari</li>
+            <li><a href="stream.html?src=${src}&mode=mse">stream.html</a> MSE stream / browsers: Chrome, Firefox, Safari Mac/iPad / codecs: H264, H265*, AAC, PCMA*, PCMU*, PCM* / +OPUS in Chrome and Firefox</li>
+            <li><a href="api/stream.mp4?src=${src}">stream.mp4</a> legacy MP4 stream with AAC audio / browsers: Chrome, Firefox / codecs: H264, H265*, AAC</li>
+            <li><a href="api/stream.mp4?src=${src}&mp4=flac">stream.mp4</a> modern MP4 stream with common audio / browsers: Chrome, Firefox / codecs: H264, H265*, AAC, FLAC (PCMA, PCMU, PCM)</li>
+            <li><a href="api/stream.mp4?src=${src}&mp4=all">stream.mp4</a> MP4 stream with any audio / browsers: Chrome / codecs: H264, H265*, AAC, OPUS, MP3, FLAC (PCMA, PCMU, PCM)</li>
+            <li><a href="api/frame.mp4?src=${src}">frame.mp4</a> snapshot in MP4-format / browsers: all / codecs: H264, H265*</li>
+            <li><a href="api/stream.m3u8?src=${src}">stream.m3u8</a> legacy HLS/TS / browsers: Safari all, Chrome Android / codecs: H264</li>
+            <li><a href="api/stream.m3u8?src=${src}&mp4">stream.m3u8</a> legacy HLS/fMP4 / browsers: Safari all, Chrome Android / codecs: H264, H265*, AAC</li>
+            <li><a href="api/stream.m3u8?src=${src}&mp4=flac">stream.m3u8</a> modern HLS/fMP4 / browsers: Safari all, Chrome Android / codecs: H264, H265*, AAC, FLAC (PCMA, PCMU, PCM)</li>
+
+            <h2>MJPEG source</h2>
+            <li><a href="stream.html?src=${src}&mode=mjpeg">stream.html</a> with MJPEG mode / browsers: all / codecs: MJPEG, JPEG</li>
+            <li><a href="api/stream.mjpeg?src=${src}">stream.mjpeg</a> MJPEG stream / browsers: all / codecs: MJPEG, JPEG</li>
+            <li><a href="api/frame.jpeg?src=${src}">frame.jpeg</a> snapshot in JPEG-format / browsers: all / codecs: MJPEG, JPEG</li>
+        `;
+        });
+    </script>
+
+    <div id="homekit" style="display: none">
+        <h2>HomeKit server</h2>
+    </div>
+    <script>
+        fetch(`api/homekit?id=${src}`, {cache: 'no-cache'}).then(async (r) => {
+            if (!r.ok) return;
+
+            const div = document.querySelector('#homekit');
+            div.innerHTML += `<div><a href="${r.url}">info.json</a> page with active connections</div>`;
+            div.style = '';
+
+            /** @type {{name: string, category_id: string, setup_code: string, setup_id: string, setup_uri: string}} */
+            const data = await r.json();
+            if (data.setup_code === undefined) return;
+
+            const script = document.createElement('script');
+            script.src = 'https://cdn.jsdelivr.net/npm/qrcodejs@1.0.0/qrcode.min.js';
+            script.async = true;
+            script.onload = () => {
+                /* global BigInt */
+                const categoryID = BigInt(data.category_id);
+                const pin = BigInt(data.setup_code.replaceAll('-', ''));
+                const payload = categoryID << BigInt(31) | BigInt(2 << 27) | pin;
+                const setupURI = `X-HM://${payload.toString(36).toUpperCase().padStart(9, '0')}${data.setup_id}`;
+
+                div.innerHTML += `<pre>Setup Name: ${data.name}
+Setup Code: ${data.setup_code}</pre>
+<div id="homekit-qrcode"></div>`;
+
+                /* global QRCode */
+                new QRCode('homekit-qrcode', {text: setupURI, width: 128, height: 128});
+            };
+            document.head.appendChild(script);
+        });
+    </script>
+
+    <div>
+        <h2>Play audio</h2>
+        <label><input type="radio" name="play" value="file" checked>
+            file - play remote (https://example.com/song.mp3) or local (/media/song.mp3) file
+        </label>
+        <label><input type="radio" name="play" value="live">
+            live - play remote live stream (radio, etc.)
+        </label>
+        <label><input type="radio" name="play" value="text">
+            text - play Text To Speech (if your FFmpeg support this)
+        </label>
+        <br>
+        <input id="play-url" type="text" placeholder="path / url / text">
+        <button id="play-send">send</button>
+        / cameras with two way audio support
+    </div>
+    <script>
+        document.getElementById('play-send').addEventListener('click', ev => {
+            ev.preventDefault();
+            // action - file / live / text
+            const action = document.querySelector('input[name="play"]:checked').value;
+            const url = new URL('api/ffmpeg', location.href);
+            url.searchParams.set('dst', src);
+            url.searchParams.set(action, document.getElementById('play-url').value);
+            fetch(url, {method: 'POST'});
+        });
+    </script>
+
+    <div>
+        <h2>Publish stream</h2>
+        <pre>YouTube:  rtmps://xxx.rtmp.youtube.com/live2/xxxx-xxxx-xxxx-xxxx-xxxx
+Telegram: rtmps://xxx-x.rtmp.t.me/s/xxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxx</pre>
+        <input id="pub-url" type="text" placeholder="url">
+        <button id="pub-send">send</button>
+        / Telegram RTMPS server
+    </div>
+    <script>
+        document.getElementById('pub-send').addEventListener('click', ev => {
+            ev.preventDefault();
+            const url = new URL('api/streams', location.href);
+            url.searchParams.set('src', src);
+            url.searchParams.set('dst', document.getElementById('pub-url').value);
+            fetch(url, {method: 'POST'});
+        });
+    </script>
+
+    <div id="webrtc">
+        <h2>WebRTC Magic</h2>
+        <label><input type="radio" name="webrtc" value="video+audio" checked>
+            video+audio = simple viewer
+        </label>
+        <label><input type="radio" name="webrtc" value="video+audio+microphone">
+            video+audio+microphone = two way audio from camera
+        </label>
+        <label><input type="radio" name="webrtc" value="camera+microphone">
+            camera+microphone = stream from browser
+        </label>
+        <label><input type="radio" name="webrtc" value="display+speaker">
+            display+speaker = broadcast software
+        </label>
+
+        <br>
+        <li><a id="local" href="webrtc.html?src=">webrtc.html</a> local WebRTC viewer</li>
+
+        <li>
+            <a id="shareadd" href="#">share link</a>
+            <a id="shareget" href="#">copy link</a>
+            <a id="sharedel" href="#">delete</a>
+            external WebRTC viewer
+        </li>
+    </div>
+    <script>
+        function webrtcLinksUpdate() {
+            const media = document.querySelector('input[name="webrtc"]:checked').value;
+
+            const direction = media.indexOf('video') >= 0 || media === 'audio' ? 'src' : 'dst';
+            document.getElementById('local').href = `webrtc.html?${direction}=${src}&media=${media}`;
+
+            const share = document.getElementById('shareget');
+            share.href = `https://go2rtc.org/webtorrent/#${share.dataset.auth}&media=${media}`;
+        }
+
+        function share(method) {
+            const url = new URL('api/webtorrent', location.href);
+            url.searchParams.set('src', src);
+            return fetch(url, {method: method, cache: 'no-cache'});
+        }
+
+        function onshareadd(r) {
+            document.getElementById('shareget').dataset['auth'] = `share=${r.share}&pwd=${r.pwd}`;
+
+            document.getElementById('shareadd').style.display = 'none';
+            document.getElementById('shareget').style.display = '';
+            document.getElementById('sharedel').style.display = '';
+
+            webrtcLinksUpdate();
+        }
+
+        function onsharedel() {
+            document.getElementById('shareadd').style.display = '';
+            document.getElementById('shareget').style.display = 'none';
+            document.getElementById('sharedel').style.display = 'none';
+        }
+
+        function copyTextToClipboard(text) {
+            // https://web.dev/patterns/clipboard/copy-text
+            if (navigator.clipboard && window.isSecureContext) {
+                navigator.clipboard.writeText(text).catch(err => {
+                    console.error(err.name, err.message);
+                });
+            } else {
+                const textarea = document.createElement('textarea');
+                textarea.value = text;
+                textarea.style.opacity = '0';
+                document.body.appendChild(textarea);
+
+                textarea.focus();
+                textarea.select();
+
+                try {
+                    document.execCommand('copy');
+                } catch (err) {
+                    console.error(err.name, err.message);
+                }
+
+                document.body.removeChild(textarea);
+            }
+        }
+
+        document.getElementById('shareadd').addEventListener('click', ev => {
+            ev.preventDefault();
+            share('POST').then(r => r.json()).then(r => onshareadd(r));
+        });
+
+        document.getElementById('shareget').addEventListener('click', ev => {
+            ev.preventDefault();
+            copyTextToClipboard(ev.target.href);
+        });
+
+        document.getElementById('sharedel').addEventListener('click', ev => {
+            ev.preventDefault();
+            share('DELETE').then(() => onsharedel());
+        });
+
+        document.getElementById('webrtc').addEventListener('click', ev => {
+            if (ev.target.tagName === 'INPUT') webrtcLinksUpdate();
+        });
+
+        share('GET').then(r => {
+            if (r.ok) r.json().then(r => onshareadd(r));
+            else onsharedel();
+        });
+
+        webrtcLinksUpdate();
+    </script>
+</main>
+
+</body>
+</html>
diff --git a/installs_on_host/go2rtc/www/log.html b/installs_on_host/go2rtc/www/log.html
new file mode 100644
index 0000000..5809c45
--- /dev/null
+++ b/installs_on_host/go2rtc/www/log.html
@@ -0,0 +1,145 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>log - go2rtc</title>
+    <style>
+        main > div {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 10px;
+        }
+
+        table tbody {
+            font-size: 13px;
+        }
+
+        .trace {
+            color: #585858 !important;
+        }
+
+        .debug {
+            color: #808080 !important;
+        }
+
+        .info {
+            color: #0174DF !important;
+        }
+
+        .warn {
+            color: #FF9966 !important;
+        }
+
+        .error {
+            color: #DF0101 !important;
+        }
+    </style>
+</head>
+<body>
+
+<script src="main.js"></script>
+
+<main>
+    <div>
+        <button id="clean">Clean</button>
+        <button id="update">Auto Update: ON</button>
+        <button id="reverse">Reverse Log Order: OFF</button>
+    </div>
+    <table>
+        <thead>
+        <tr>
+            <th style="width: 100px">Time</th>
+            <th style="width: 40px">Level</th>
+            <th>Message</th>
+        </tr>
+        </thead>
+        <tbody id="log">
+        </tbody>
+    </table>
+</main>
+
+<script>
+    document.getElementById('clean').addEventListener('click', async () => {
+        const r = await fetch('api/log', {method: 'DELETE'});
+        if (r.ok) reload();
+        alert(await r.text());
+    });
+
+    // Sanitizes the input text to prevent XSS when inserting into the DOM
+    function escapeHTML(text) {
+        return text
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#039;')
+            .replace(/\n/g, '<br>');
+    }
+
+    const reverseBtn = document.getElementById('reverse');
+    const update = document.getElementById('update');
+
+    let reverseOrder = false;
+    let autoUpdateEnabled = true;
+
+    reverseBtn.textContent = `Reverse Log Order: ${reverseOrder ? 'ON' : 'OFF'}`;
+    update.textContent = `Auto Update: ${autoUpdateEnabled ? 'ON' : 'OFF'}`;
+
+    function applyLogStyling(jsonlines) {
+        const KEYS = ['time', 'level', 'message'];
+        let lines = JSON.parse('[' + jsonlines.trimEnd().replaceAll('\n', ',') + ']');
+        if (reverseOrder) {
+            lines = lines.reverse();
+        }
+        return lines.map(line => {
+            const ts = new Date(line['time']).toLocaleString(undefined, {
+                hour: 'numeric',
+                minute: 'numeric',
+                second: 'numeric',
+                fractionalSecondDigits: 3
+            });
+            const msg = Object.keys(line).reduce((msg, key) => {
+                return KEYS.indexOf(key) < 0 ? `${msg} ${key}=${line[key]}` : msg;
+            }, line['message']);
+            return `<tr class="${line['level']}"><td>${ts}</td><td>${line['level']}</td><td>${escapeHTML(msg)}</td></tr>`;
+        }).join('');
+    }
+
+    function reload() {
+        const url = new URL('api/log', location.href);
+        fetch(url, {cache: 'no-cache'})
+            .then(response => response.text())
+            .then(data => {
+                // Apply styling to the log data
+                document.getElementById('log').innerHTML = applyLogStyling(data);
+            })
+            .catch(error => {
+                console.error('An error occurred:', error);
+            });
+    }
+
+    reload();
+
+    update.textContent = `Auto Update: ${autoUpdateEnabled ? 'ON' : 'OFF'}`;
+    update.addEventListener('click', () => {
+        autoUpdateEnabled = !autoUpdateEnabled;
+        update.textContent = `Auto Update: ${autoUpdateEnabled ? 'ON' : 'OFF'}`;
+    });
+
+    // Toggle log order
+    reverseBtn.textContent = `Reverse Log Order: ${reverseOrder ? 'ON' : 'OFF'}`;
+    reverseBtn.addEventListener('click', () => {
+        reverseOrder = !reverseOrder;
+        reverseBtn.textContent = `Reverse Log Order: ${reverseOrder ? 'ON' : 'OFF'}`;
+        reload(); // Reload logs to apply the new order
+    });
+
+    // Reload the logs every 5 seconds
+    setInterval(() => {
+        if (autoUpdateEnabled) reload();
+    }, 5000);
+</script>
+
+</body>
+</html>
diff --git a/installs_on_host/go2rtc/www/main.js b/installs_on_host/go2rtc/www/main.js
new file mode 100644
index 0000000..d562917
--- /dev/null
+++ b/installs_on_host/go2rtc/www/main.js
@@ -0,0 +1,135 @@
+document.head.innerHTML += `
+<style>
+    body {
+        background-color: white;  /* fix Hass black theme */
+        display: flex;
+        flex-direction: column;
+        font-family: Arial, sans-serif;
+        margin: 0;
+    }
+
+    /* navigation block */
+    nav {
+        background-color: #333;
+        overflow: hidden;
+    }
+
+    nav a {
+        float: left;
+        display: block;
+        color: #f2f2f2;
+        text-align: center;
+        padding: 14px 16px;
+        text-decoration: none;
+        font-size: 17px;
+    }
+
+    nav a:hover {
+        background-color: #ddd;
+        color: black;
+    }
+
+    /* main block */
+    main {
+        padding: 10px;
+        display: flex;
+        flex-direction: column;
+        gap: 10px;
+    }
+
+    /* checkbox */
+    label {
+        display: flex;
+        gap: 5px;
+        align-items: center;
+        cursor: pointer;
+    }
+
+    input[type="checkbox"] {
+        width: 18px;
+        height: 18px;
+        cursor: pointer;
+    }
+
+    /* form */
+    form {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 10px;
+    }
+
+    input[type="text"], input[type="email"], input[type="password"], select {
+        padding: 10px;
+        border: 1px solid #ccc;
+        border-radius: 4px;
+        font-size: 16px;
+    }
+
+    button {
+        padding: 10px 20px;
+        border: 1px solid #ccc;
+        border-radius: 4px;
+        cursor: pointer;
+        font-size: 16px;
+    }
+
+    /* table */
+    table {
+        width: 100%;
+        background-color: white;
+        border-collapse: collapse;
+        margin: 0 auto;
+        overflow: hidden;
+    }
+
+    th, td {
+        padding: 12px 15px;
+        text-align: left;
+        border-bottom: 1px solid #e0e0e0;
+    }
+
+    th {
+        background-color: #444;
+        color: white;
+    }
+
+    tr:nth-child(even) {
+        background-color: #fafafa;
+    }
+
+    tr:hover {
+        background-color: #edf7ff;
+        transition: background-color 0.3s ease;
+    }
+
+    /* table on mobile */
+    @media (max-width: 480px) {
+        table, thead, tbody, th, td, tr {
+            display: block;
+        }
+
+        th, td {
+            box-sizing: border-box;
+            width: 100% !important;
+            border: none;
+        }
+
+        tr {
+            margin-bottom: 10px;
+            border-radius: 4px;
+        }
+    }
+</style>
+`;
+
+document.body.innerHTML = `
+<header>
+    <nav>
+        <a href="index.html"><b>go2rtc</b></a>
+        <a href="add.html">add</a>
+        <a href="config.html">config</a>
+        <a href="log.html">log</a>
+        <a href="net.html">net</a>
+    </nav>
+</header>
+` + document.body.innerHTML;
diff --git a/installs_on_host/go2rtc/www/net.html b/installs_on_host/go2rtc/www/net.html
new file mode 100644
index 0000000..1c2a697
--- /dev/null
+++ b/installs_on_host/go2rtc/www/net.html
@@ -0,0 +1,74 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>net - go2rtc</title>
+    <script src="https://cdn.jsdelivr.net/npm/vis-network@10.0.2/standalone/umd/vis-network.min.js"></script>
+    <style>
+        html, body, #network {
+            height: 100%;
+        }
+    </style>
+</head>
+<body>
+
+<script src="main.js"></script>
+
+<div id="network"></div>
+
+<script>
+    /* global vis */
+    window.addEventListener('load', () => {
+        const url = new URL('api/streams.dot' + location.search, location.href);
+
+        const container = document.getElementById('network');
+        const options = {
+            edges: {
+                font: {align: 'middle'},
+                smooth: false,
+            },
+            nodes: {shape: 'box'},
+            physics: false,
+        };
+
+        let network;
+
+        async function update() {
+            try {
+                const response = await fetch(url, {cache: 'no-cache'});
+                const dotData = await response.text();
+                const data = vis.parseDOTNetwork(dotData);
+
+                if (!network) {
+                    network = new vis.Network(container, data, options);
+                    network.storePositions();
+                } else {
+                    const positions = network.getPositions();
+                    const viewPosition = network.getViewPosition();
+                    const scale = network.getScale();
+                    const selectedNodes = network.getSelectedNodes();
+
+                    network.setData(data);
+
+                    for (const nodeId in positions) {
+                        network.moveNode(nodeId, positions[nodeId].x, positions[nodeId].y);
+                    }
+
+                    network.moveTo({position: viewPosition, scale: scale});
+
+                    network.selectNodes(selectedNodes);
+                }
+            } catch (error) {
+                console.error('Error fetching or updating network data:', error);
+            }
+
+            setTimeout(update, 5000);
+        }
+
+        update();
+    });
+</script>
+
+</body>
+</html>
diff --git a/installs_on_host/go2rtc/www/schema.json b/installs_on_host/go2rtc/www/schema.json
new file mode 100644
index 0000000..27fee57
--- /dev/null
+++ b/installs_on_host/go2rtc/www/schema.json
@@ -0,0 +1,750 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "go2rtc",
+  "type": "object",
+  "additionalProperties": false,
+  "definitions": {
+    "listen": {
+      "type": "string",
+      "anyOf": [
+        {
+          "type": "string",
+          "pattern": ":[0-9]{1,5}$"
+        },
+        {
+          "type": "string",
+          "const": ""
+        }
+      ]
+    },
+    "log_level": {
+      "type": "string",
+      "enum": [
+        "trace",
+        "debug",
+        "info",
+        "warn",
+        "error",
+        "fatal",
+        "panic",
+        "disabled"
+      ]
+    },
+    "source": {
+      "type": "string",
+      "examples": [
+        "rtsp://username:password@192.168.1.123/cam/realmonitor?channel=1&subtype=0&unicast=true&proto=Onvif",
+        "rtsp://username:password@192.168.1.123/stream1",
+        "rtsp://username:password@192.168.1.123/h264Preview_01_main",
+        "rtmp://192.168.1.123/bcs/channel0_main.bcs?channel=0&stream=0&user=username&password=password",
+        "http://192.168.1.123/flv?port=1935&app=bcs&stream=channel0_main.bcs&user=username&password=password",
+        "http://username:password@192.168.1.123/cgi-bin/snapshot.cgi?channel=1",
+        "ffmpeg:media.mp4#video=h264#hardware#width=1920#height=1080#rotate=180#audio=copy",
+        "ffmpeg:virtual?video=testsrc&size=4K#video=h264#hardware#bitrate=50M",
+        "exec:ffmpeg -re -i media.mp4 -c copy -rtsp_transport tcp -f rtsp {output}",
+        "onvif://username:password@192.168.1.123:80?subtype=0",
+        "tapo://password@192.168.1.123:8800?channel=0&subtype=0"
+      ]
+    }
+  },
+  "properties": {
+    "api": {
+      "type": "object",
+      "properties": {
+        "listen": {
+          "type": "string",
+          "default": ":1984",
+          "examples": [
+            "127.0.0.1:1984"
+          ]
+        },
+        "username": {
+          "description": "Basic auth for WebUI",
+          "type": "string",
+          "examples": [
+            "admin"
+          ]
+        },
+        "password": {
+          "type": "string"
+        },
+        "local_auth": {
+          "description": "Enable auth check for localhost requests",
+          "type": "boolean",
+          "default": false
+        },
+        "base_path": {
+          "description": "API prefix for serving on suburl (/api => /rtc/api)",
+          "type": "string",
+          "examples": [
+            "/rtc"
+          ]
+        },
+        "static_dir": {
+          "description": "Folder for static files (custom web interface)",
+          "type": "string",
+          "examples": [
+            "www"
+          ]
+        },
+        "origin": {
+          "description": "Allow CORS requests (only * supported)",
+          "type": "string",
+          "enum": [
+            "*",
+            ""
+          ]
+        },
+        "tls_listen": {
+          "type": "string"
+        },
+        "tls_cert": {
+          "type": "string",
+          "examples": [
+            "-----BEGIN CERTIFICATE-----",
+            "/ssl/fullchain.pem"
+          ]
+        },
+        "tls_key": {
+          "type": "string",
+          "examples": [
+            "-----BEGIN PRIVATE KEY-----",
+            "/ssl/privkey.pem"
+          ]
+        },
+        "unix_listen": {
+          "type": "string",
+          "examples": [
+            "/tmp/go2rtc.sock"
+          ]
+        },
+        "allow_paths": {
+          "description": "Allow only these HTTP paths (full paths, including base_path)",
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "examples": [
+            [
+              "/api",
+              "/api/streams",
+              "/api/webrtc"
+            ]
+          ]
+        }
+      }
+    },
+    "app": {
+      "type": "object",
+      "properties": {
+        "modules": {
+          "description": "Enable only these modules (empty / omitted means all)",
+          "type": "array",
+          "items": {
+            "type": "string",
+            "enum": [
+              "api",
+              "ws",
+              "http",
+              "rtsp",
+              "webrtc",
+              "mp4",
+              "hls",
+              "mjpeg",
+              "hass",
+              "homekit",
+              "onvif",
+              "rtmp",
+              "webtorrent",
+              "wyoming",
+              "echo",
+              "exec",
+              "expr",
+              "ffmpeg",
+              "alsa",
+              "v4l2",
+              "bubble",
+              "doorbird",
+              "dvrip",
+              "eseecloud",
+              "flussonic",
+              "gopro",
+              "isapi",
+              "ivideon",
+              "kasa",
+              "mpeg",
+              "nest",
+              "ring",
+              "roborock",
+              "tapo",
+              "tuya",
+              "xiaomi",
+              "yandex",
+              "debug",
+              "ngrok",
+              "pinggy",
+              "srtp"
+            ]
+          }
+        }
+      }
+    },
+    "env": {
+      "description": "Config variables that can be referenced as ${NAME} / ${NAME:default}",
+      "type": "object",
+      "additionalProperties": {
+        "type": "string"
+      }
+    },
+    "echo": {
+      "type": "object",
+      "properties": {
+        "allow_paths": {
+          "description": "Allow only these binaries for echo: URLs (exact cmd name/path)",
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "exec": {
+      "type": "object",
+      "properties": {
+        "allow_paths": {
+          "description": "Allow only these binaries for exec: URLs (exact cmd name/path)",
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "examples": [
+            [
+              "ffmpeg",
+              "/usr/bin/ffmpeg"
+            ]
+          ]
+        }
+      }
+    },
+    "ffmpeg": {
+      "type": "object",
+      "properties": {
+        "bin": {
+          "type": "string",
+          "default": "ffmpeg"
+        },
+        "global": {
+          "type": "string",
+          "default": "-hide_banner"
+        },
+        "file": {
+          "type": "string",
+          "default": "-re -i {input}"
+        },
+        "http": {
+          "type": "string",
+          "default": "-fflags nobuffer -flags low_delay -i {input}"
+        },
+        "rtsp": {
+          "type": "string",
+          "default": "-fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i {input}"
+        },
+        "rtsp/udp": {
+          "type": "string",
+          "default": "-fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -i {input}"
+        }
+      },
+      "additionalProperties": {
+        "description": "FFmpeg template",
+        "type": "string"
+      }
+    },
+    "hass": {
+      "type": "object",
+      "properties": {
+        "config": {
+          "description": "Home Assistant config directory path",
+          "type": "string",
+          "examples": [
+            "/config"
+          ]
+        }
+      }
+    },
+    "homekit": {
+      "type": "object",
+      "additionalProperties": {
+        "type": [
+          "object",
+          "null"
+        ],
+        "properties": {
+          "pin": {
+            "description": "HomeKit pairing PIN",
+            "type": "string",
+            "default": "19550224",
+            "anyOf": [
+              {
+                "type": "string",
+                "pattern": "^[0-9]{8}$"
+              },
+              {
+                "type": "string",
+                "pattern": "^[0-9]{3}-[0-9]{2}-[0-9]{3}$"
+              }
+            ]
+          },
+          "name": {
+            "type": "string"
+          },
+          "device_id": {
+            "type": "string"
+          },
+          "device_private": {
+            "type": "string"
+          },
+          "category_id": {
+            "description": "Accessory category: `bridge`, `doorbell` or numeric ID",
+            "type": "string",
+            "default": "camera",
+            "anyOf": [
+              {
+                "type": "string",
+                "enum": [
+                  "bridge",
+                  "camera",
+                  "doorbell"
+                ]
+              },
+              {
+                "type": "string",
+                "pattern": "^[0-9]+$"
+              },
+              {
+                "type": "string",
+                "const": ""
+              }
+            ]
+          },
+          "pairings": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          }
+        }
+      }
+    },
+    "log": {
+      "type": "object",
+      "properties": {
+        "format": {
+          "description": "Log format: color/json/text or empty for autodetect",
+          "type": "string",
+          "default": "color",
+          "enum": [
+            "",
+            "color",
+            "json",
+            "text"
+          ]
+        },
+        "level": {
+          "description": "Defaul log level",
+          "default": "info",
+          "$ref": "#/definitions/log_level"
+        },
+        "output": {
+          "description": "Log output: stdout/stderr/file[:path] or empty (memory only)",
+          "type": "string",
+          "default": "stdout",
+          "anyOf": [
+            {
+              "type": "string",
+              "enum": [
+                "",
+                "stdout",
+                "stderr"
+              ]
+            },
+            {
+              "type": "string",
+              "pattern": "^file(:.+)?$",
+              "examples": [
+                "file",
+                "file:go2rtc.log"
+              ]
+            }
+          ]
+        },
+        "time": {
+          "type": "string",
+          "default": "UNIXMS",
+          "anyOf": [
+            {
+              "type": "string",
+              "enum": [
+                "",
+                "UNIXMS",
+                "UNIXMICRO",
+                "UNIXNANO",
+                "2006-01-02T15:04:05Z07:00",
+                "2006-01-02T15:04:05.999999999Z07:00"
+              ]
+            },
+            {
+              "type": "string"
+            }
+          ]
+        },
+        "api": {
+          "$ref": "#/definitions/log_level"
+        },
+        "echo": {
+          "$ref": "#/definitions/log_level"
+        },
+        "exec": {
+          "description": "Value `exec: debug` will print stderr",
+          "$ref": "#/definitions/log_level"
+        },
+        "expr": {
+          "$ref": "#/definitions/log_level"
+        },
+        "ffmpeg": {
+          "description": "Will only be displayed with `exec: debug` setting",
+          "default": "error",
+          "$ref": "#/definitions/log_level"
+        },
+        "hass": {
+          "$ref": "#/definitions/log_level"
+        },
+        "hls": {
+          "$ref": "#/definitions/log_level"
+        },
+        "homekit": {
+          "$ref": "#/definitions/log_level"
+        },
+        "mjpeg": {
+          "$ref": "#/definitions/log_level"
+        },
+        "mp4": {
+          "$ref": "#/definitions/log_level"
+        },
+        "ngrok": {
+          "$ref": "#/definitions/log_level"
+        },
+        "onvif": {
+          "$ref": "#/definitions/log_level"
+        },
+        "rtmp": {
+          "$ref": "#/definitions/log_level"
+        },
+        "rtsp": {
+          "$ref": "#/definitions/log_level"
+        },
+        "streams": {
+          "$ref": "#/definitions/log_level"
+        },
+        "webrtc": {
+          "$ref": "#/definitions/log_level"
+        },
+        "webtorrent": {
+          "$ref": "#/definitions/log_level"
+        },
+        "wyoming": {
+          "$ref": "#/definitions/log_level"
+        }
+      }
+    },
+    "ngrok": {
+      "type": "object",
+      "properties": {
+        "command": {
+          "type": "string",
+          "examples": [
+            "ngrok tcp 8555 --authtoken xxx",
+            "ngrok start --all --config ngrok.yaml"
+          ]
+        }
+      }
+    },
+    "pinggy": {
+      "type": "object",
+      "properties": {
+        "tunnel": {
+          "description": "Expose local address via Pinggy",
+          "type": "string",
+          "examples": [
+            "http://127.0.0.1:1984",
+            "tcp://192.168.1.123:554"
+          ]
+        }
+      }
+    },
+    "preload": {
+      "description": "Preload streams on startup (map stream name => probe query, default `video&audio`)",
+      "type": "object",
+      "additionalProperties": {
+        "type": "string",
+        "examples": [
+          "video&audio",
+          "video"
+        ]
+      }
+    },
+    "publish": {
+      "type": "object",
+      "additionalProperties": {
+        "anyOf": [
+          {
+            "type": "string",
+            "examples": [
+              "rtmp://xxx.rtmp.youtube.com/live2/xxxx-xxxx-xxxx-xxxx-xxxx",
+              "rtmps://xxx-x.rtmp.t.me/s/xxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxx"
+            ]
+          },
+          {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          }
+        ]
+      }
+    },
+    "rtmp": {
+      "type": "object",
+      "properties": {
+        "listen": {
+          "type": "string",
+          "examples": [
+            ":1935"
+          ]
+        }
+      }
+    },
+    "rtsp": {
+      "type": "object",
+      "properties": {
+        "listen": {
+          "type": "string",
+          "default": ":8554"
+        },
+        "username": {
+          "type": "string",
+          "examples": [
+            "admin"
+          ]
+        },
+        "password": {
+          "type": "string"
+        },
+        "default_query": {
+          "type": "string",
+          "default": "video&audio"
+        },
+        "pkt_size": {
+          "type": "integer"
+        }
+      }
+    },
+    "srtp": {
+      "description": "SRTP server for HomeKit",
+      "type": "object",
+      "properties": {
+        "listen": {
+          "type": "string",
+          "default": ":8443"
+        }
+      }
+    },
+    "streams": {
+      "type": "object",
+      "additionalProperties": {
+        "anyOf": [
+          {
+            "$ref": "#/definitions/source"
+          },
+          {
+            "type": "array",
+            "items": {
+              "$ref": "#/definitions/source"
+            }
+          },
+          {
+            "type": "null"
+          }
+        ]
+      }
+    },
+    "xiaomi": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "string"
+      }
+    },
+    "webrtc": {
+      "type": "object",
+      "properties": {
+        "listen": {
+          "type": "string",
+          "default": ":8555",
+          "examples": [
+            ":8555/udp"
+          ]
+        },
+        "candidates": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "examples": [
+              "216.58.210.174:8555",
+              "stun:8555",
+              "home.duckdns.org:8555"
+            ]
+          }
+        },
+        "ice_servers": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "urls": {
+                "type": "array",
+                "items": {
+                  "type": "string",
+                  "examples": [
+                    "stun:stun.l.google.com:19302",
+                    "turn:123.123.123.123:3478"
+                  ]
+                }
+              },
+              "username": {
+                "type": "string"
+              },
+              "credential": {
+                "type": "string"
+              }
+            }
+          }
+        },
+        "filters": {
+          "type": "object",
+          "properties": {
+            "candidates": {
+              "description": "Keep only these candidates",
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "interfaces": {
+              "description": "Keep only these interfaces",
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "ips": {
+              "description": "Keep only these IP-addresses",
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "networks": {
+              "description": "Use only these network types",
+              "type": "array",
+              "items": {
+                "type": "string",
+                "enum": [
+                  "tcp4",
+                  "tcp6",
+                  "udp4",
+                  "udp6"
+                ]
+              }
+            },
+            "udp_ports": {
+              "description": "Use only these UDP ports range [min, max]",
+              "type": "array",
+              "items": {
+                "type": "integer"
+              },
+              "maxItems": 2,
+              "minItems": 2
+            }
+          }
+        }
+      }
+    },
+    "webtorrent": {
+      "type": "object",
+      "properties": {
+        "trackers": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "shares": {
+          "additionalProperties": {
+            "type": "object",
+            "properties": {
+              "pwd": {
+                "type": "string",
+                "minLength": 4
+              },
+              "src": {
+                "type": "string"
+              }
+            }
+          }
+        }
+      }
+    },
+    "wyoming": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "listen": {
+            "description": "Listen address for Wyoming server",
+            "type": "string"
+          },
+          "name": {
+            "description": "Optional satellite name (default: stream name)",
+            "type": "string"
+          },
+          "mode": {
+            "description": "Optional mode: mic / snd / default",
+            "type": "string",
+            "enum": [
+              "",
+              "mic",
+              "snd"
+            ]
+          },
+          "event": {
+            "description": "Event handlers (map event type => expr script)",
+            "type": "object",
+            "additionalProperties": {
+              "type": "string"
+            }
+          },
+          "wake_uri": {
+            "description": "Optional WAKE service URI (ex. tcp://host:port?name=...)",
+            "type": "string",
+            "examples": [
+              "tcp://192.168.1.23:10400"
+            ]
+          },
+          "vad_threshold": {
+            "description": "Optional VAD threshold (0.1..3.5 typical)",
+            "type": "number"
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/installs_on_host/go2rtc/www/static.go b/installs_on_host/go2rtc/www/static.go
new file mode 100644
index 0000000..064fec3
--- /dev/null
+++ b/installs_on_host/go2rtc/www/static.go
@@ -0,0 +1,8 @@
+package www
+
+import "embed"
+
+//go:embed *.html
+//go:embed *.js
+//go:embed *.json
+var Static embed.FS
diff --git a/installs_on_host/go2rtc/www/stream.html b/installs_on_host/go2rtc/www/stream.html
new file mode 100644
index 0000000..de7ad12
--- /dev/null
+++ b/installs_on_host/go2rtc/www/stream.html
@@ -0,0 +1,67 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <link rel="apple-touch-icon" href="https://go2rtc.org/icons/apple-touch-icon-180x180.png" sizes="180x180">
+    <link rel="icon" href="https://go2rtc.org/icons/favicon.ico">
+    <link rel="manifest" href="https://go2rtc.org/manifest.json">
+    <title>stream - go2rtc</title>
+    <style>
+        body {
+            background: black;
+            margin: 0;
+            padding: 0;
+            display: flex;
+            font-family: Arial, Helvetica, sans-serif;
+        }
+
+        html, body {
+            height: 100%;
+            width: 100%;
+        }
+
+        .flex {
+            flex-wrap: wrap;
+            align-content: flex-start;
+            align-items: flex-start;
+        }
+    </style>
+</head>
+<body>
+<script type="module" src="./video-stream.js"></script>
+<script type="module">
+    const params = new URLSearchParams(location.search);
+
+    // support multiple streams and multiple modes
+    const streams = params.getAll('src');
+    const modes = params.getAll('mode');
+    if (modes.length === 0) modes.push('');
+
+    while (modes.length > streams.length) {
+        streams.push(streams[0]);
+    }
+    while (streams.length > modes.length) {
+        modes.push(modes[0]);
+    }
+
+    if (streams.length > 1) {
+        document.body.className = 'flex';
+    }
+
+    const background = params.get('background') !== 'false';
+    const width = '1 0 ' + (params.get('width') || '320px');
+
+    for (let i = 0; i < streams.length; i++) {
+        /** @type {VideoStream} */
+        const video = document.createElement('video-stream');
+        video.background = background;
+        video.mode = modes[i] || video.mode;
+        video.style.flex = width;
+        video.src = new URL('api/ws?src=' + encodeURIComponent(streams[i]), location.href);
+        document.body.appendChild(video);
+    }
+
+    document.title = streams.join('/') + ' - go2rtc';
+</script>
+</body>
+</html>
diff --git a/installs_on_host/go2rtc/www/video-rtc.js b/installs_on_host/go2rtc/www/video-rtc.js
new file mode 100644
index 0000000..953fdae
--- /dev/null
+++ b/installs_on_host/go2rtc/www/video-rtc.js
@@ -0,0 +1,695 @@
+/**
+ * VideoRTC v1.6.0 - Video player for go2rtc streaming application.
+ *
+ * All modern web technologies are supported in almost any browser except Apple Safari.
+ *
+ * Support:
+ * - ECMAScript 2017 (ES8) = ES6 + async
+ * - RTCPeerConnection for Safari iOS 11.0+
+ * - IntersectionObserver for Safari iOS 12.2+
+ * - ManagedMediaSource for Safari 17+
+ *
+ * Doesn't support:
+ * - MediaSource for Safari iOS
+ * - Customized built-in elements (extends HTMLVideoElement) because Safari
+ * - Autoplay for WebRTC in Safari
+ */
+export class VideoRTC extends HTMLElement {
+    constructor() {
+        super();
+
+        this.DISCONNECT_TIMEOUT = 5000;
+        this.RECONNECT_TIMEOUT = 15000;
+
+        this.CODECS = [
+            'avc1.640029',      // H.264 high 4.1 (Chromecast 1st and 2nd Gen)
+            'avc1.64002A',      // H.264 high 4.2 (Chromecast 3rd Gen)
+            'avc1.640033',      // H.264 high 5.1 (Chromecast with Google TV)
+            'hvc1.1.6.L153.B0', // H.265 main 5.1 (Chromecast Ultra)
+            'mp4a.40.2',        // AAC LC
+            'mp4a.40.5',        // AAC HE
+            'flac',             // FLAC (PCM compatible)
+            'opus',             // OPUS Chrome, Firefox
+        ];
+
+        /**
+         * [config] Supported modes (webrtc, webrtc/tcp, mse, hls, mp4, mjpeg).
+         * @type {string}
+         */
+        this.mode = 'webrtc,mse,hls,mjpeg';
+
+        /**
+         * [Config] Requested medias (video, audio, microphone).
+         * @type {string}
+         */
+        this.media = 'video,audio';
+
+        /**
+         * [config] Run stream when not displayed on the screen. Default `false`.
+         * @type {boolean}
+         */
+        this.background = false;
+
+        /**
+         * [config] Run stream only when player in the viewport. Stop when user scroll out player.
+         * Value is percentage of visibility from `0` (not visible) to `1` (full visible).
+         * Default `0` - disable;
+         * @type {number}
+         */
+        this.visibilityThreshold = 0;
+
+        /**
+         * [config] Run stream only when browser page on the screen. Stop when user change browser
+         * tab or minimise browser windows.
+         * @type {boolean}
+         */
+        this.visibilityCheck = true;
+
+        /**
+         * [config] WebRTC configuration
+         * @type {RTCConfiguration}
+         */
+        this.pcConfig = {
+            bundlePolicy: 'max-bundle',
+            iceServers: [{urls: ['stun:stun.cloudflare.com:3478', 'stun:stun.l.google.com:19302']}],
+            sdpSemantics: 'unified-plan',  // important for Chromecast 1
+        };
+
+        /**
+         * [info] WebSocket connection state. Values: CONNECTING, OPEN, CLOSED
+         * @type {number}
+         */
+        this.wsState = WebSocket.CLOSED;
+
+        /**
+         * [info] WebRTC connection state.
+         * @type {number}
+         */
+        this.pcState = WebSocket.CLOSED;
+
+        /**
+         * @type {HTMLVideoElement}
+         */
+        this.video = null;
+
+        /**
+         * @type {WebSocket}
+         */
+        this.ws = null;
+
+        /**
+         * @type {string|URL}
+         */
+        this.wsURL = '';
+
+        /**
+         * @type {RTCPeerConnection}
+         */
+        this.pc = null;
+
+        /**
+         * @type {number}
+         */
+        this.connectTS = 0;
+
+        /**
+         * @type {string}
+         */
+        this.mseCodecs = '';
+
+        /**
+         * [internal] Disconnect TimeoutID.
+         * @type {number}
+         */
+        this.disconnectTID = 0;
+
+        /**
+         * [internal] Reconnect TimeoutID.
+         * @type {number}
+         */
+        this.reconnectTID = 0;
+
+        /**
+         * [internal] Handler for receiving Binary from WebSocket.
+         * @type {Function}
+         */
+        this.ondata = null;
+
+        /**
+         * [internal] Handlers list for receiving JSON from WebSocket.
+         * @type {Object.<string,Function>}
+         */
+        this.onmessage = null;
+    }
+
+    /**
+     * Set video source (WebSocket URL). Support relative path.
+     * @param {string|URL} value
+     */
+    set src(value) {
+        if (typeof value !== 'string') value = value.toString();
+        if (value.startsWith('http')) {
+            value = 'ws' + value.substring(4);
+        } else if (value.startsWith('/')) {
+            value = 'ws' + location.origin.substring(4) + value;
+        }
+
+        this.wsURL = value;
+
+        this.onconnect();
+    }
+
+    /**
+     * Play video. Support automute when autoplay blocked.
+     * https://developer.chrome.com/blog/autoplay/
+     */
+    play() {
+        this.video.play().catch(() => {
+            if (!this.video.muted) {
+                this.video.muted = true;
+                this.video.play().catch(er => {
+                    console.warn(er);
+                });
+            }
+        });
+    }
+
+    /**
+     * Send message to server via WebSocket
+     * @param {Object} value
+     */
+    send(value) {
+        if (this.ws) this.ws.send(JSON.stringify(value));
+    }
+
+    /** @param {Function} isSupported */
+    codecs(isSupported) {
+        return this.CODECS
+            .filter(codec => this.media.includes(codec.includes('vc1') ? 'video' : 'audio'))
+            .filter(codec => isSupported(`video/mp4; codecs="${codec}"`)).join();
+    }
+
+    /**
+     * `CustomElement`. Invoked each time the custom element is appended into a
+     * document-connected element.
+     */
+    connectedCallback() {
+        if (this.disconnectTID) {
+            clearTimeout(this.disconnectTID);
+            this.disconnectTID = 0;
+        }
+
+        // because video autopause on disconnected from DOM
+        if (this.video) {
+            const seek = this.video.seekable;
+            if (seek.length > 0) {
+                this.video.currentTime = seek.end(seek.length - 1);
+            }
+            this.play();
+        } else {
+            this.oninit();
+        }
+
+        this.onconnect();
+    }
+
+    /**
+     * `CustomElement`. Invoked each time the custom element is disconnected from the
+     * document's DOM.
+     */
+    disconnectedCallback() {
+        if (this.background || this.disconnectTID) return;
+        if (this.wsState === WebSocket.CLOSED && this.pcState === WebSocket.CLOSED) return;
+
+        this.disconnectTID = setTimeout(() => {
+            if (this.reconnectTID) {
+                clearTimeout(this.reconnectTID);
+                this.reconnectTID = 0;
+            }
+
+            this.disconnectTID = 0;
+
+            this.ondisconnect();
+        }, this.DISCONNECT_TIMEOUT);
+    }
+
+    /**
+     * Creates child DOM elements. Called automatically once on `connectedCallback`.
+     */
+    oninit() {
+        this.video = document.createElement('video');
+        this.video.controls = true;
+        this.video.playsInline = true;
+        this.video.preload = 'auto';
+
+        this.video.style.display = 'block'; // fix bottom margin 4px
+        this.video.style.width = '100%';
+        this.video.style.height = '100%';
+
+        this.appendChild(this.video);
+
+        this.video.addEventListener('error', ev => {
+            const err = this.video.error;
+            // https://developer.mozilla.org/en-US/docs/Web/API/MediaError/code
+            const MEDIA_ERRORS = {
+                1: 'MEDIA_ERR_ABORTED',
+                2: 'MEDIA_ERR_NETWORK',
+                3: 'MEDIA_ERR_DECODE',
+                4: 'MEDIA_ERR_SRC_NOT_SUPPORTED'
+            };
+            console.error('[VideoRTC] Video error:', {
+                error: err ? MEDIA_ERRORS[err.code] : 'unknown',
+                message: err ? err.message : 'unknown',
+                codecs: this.mseCodecs || 'not set',
+                readyState: this.video.readyState,
+                networkState: this.video.networkState,
+                currentTime: this.video.currentTime
+            });
+            if (this.ws) this.ws.close(); // run reconnect for broken MSE stream
+        });
+
+        // all Safari lies about supported audio codecs
+        const m = window.navigator.userAgent.match(/Version\/(\d+).+Safari/);
+        if (m) {
+            // AAC from v13, FLAC from v14, OPUS - unsupported
+            const skip = m[1] < '13' ? 'mp4a.40.2' : m[1] < '14' ? 'flac' : 'opus';
+            this.CODECS.splice(this.CODECS.indexOf(skip));
+        }
+
+        if (this.background) return;
+
+        if ('hidden' in document && this.visibilityCheck) {
+            document.addEventListener('visibilitychange', () => {
+                if (document.hidden) {
+                    this.disconnectedCallback();
+                } else if (this.isConnected) {
+                    this.connectedCallback();
+                }
+            });
+        }
+
+        if ('IntersectionObserver' in window && this.visibilityThreshold) {
+            const observer = new IntersectionObserver(entries => {
+                entries.forEach(entry => {
+                    if (!entry.isIntersecting) {
+                        this.disconnectedCallback();
+                    } else if (this.isConnected) {
+                        this.connectedCallback();
+                    }
+                });
+            }, {threshold: this.visibilityThreshold});
+            observer.observe(this);
+        }
+    }
+
+    /**
+     * Connect to WebSocket. Called automatically on `connectedCallback`.
+     * @return {boolean} true if the connection has started.
+     */
+    onconnect() {
+        if (!this.isConnected || !this.wsURL || this.ws || this.pc) return false;
+
+        // CLOSED or CONNECTING => CONNECTING
+        this.wsState = WebSocket.CONNECTING;
+
+        this.connectTS = Date.now();
+
+        this.ws = new WebSocket(this.wsURL);
+        this.ws.binaryType = 'arraybuffer';
+        this.ws.addEventListener('open', () => this.onopen());
+        this.ws.addEventListener('close', () => this.onclose());
+
+        return true;
+    }
+
+    ondisconnect() {
+        this.wsState = WebSocket.CLOSED;
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+
+        this.pcState = WebSocket.CLOSED;
+        if (this.pc) {
+            this.pc.getSenders().forEach(sender => {
+                if (sender.track) sender.track.stop();
+            });
+            this.pc.close();
+            this.pc = null;
+        }
+
+        this.video.src = '';
+        this.video.srcObject = null;
+    }
+
+    /**
+     * @returns {Array.<string>} of modes (mse, webrtc, etc.)
+     */
+    onopen() {
+        // CONNECTING => OPEN
+        this.wsState = WebSocket.OPEN;
+
+        this.ws.addEventListener('message', ev => {
+            if (typeof ev.data === 'string') {
+                const msg = JSON.parse(ev.data);
+                for (const mode in this.onmessage) {
+                    this.onmessage[mode](msg);
+                }
+            } else {
+                this.ondata(ev.data);
+            }
+        });
+
+        this.ondata = null;
+        this.onmessage = {};
+
+        const modes = [];
+
+        if (this.mode.includes('mse') && ('MediaSource' in window || 'ManagedMediaSource' in window)) {
+            modes.push('mse');
+            this.onmse();
+        } else if (this.mode.includes('hls') && this.video.canPlayType('application/vnd.apple.mpegurl')) {
+            modes.push('hls');
+            this.onhls();
+        } else if (this.mode.includes('mp4')) {
+            modes.push('mp4');
+            this.onmp4();
+        }
+
+        if (this.mode.includes('webrtc') && 'RTCPeerConnection' in window) {
+            modes.push('webrtc');
+            this.onwebrtc();
+        }
+
+        if (this.mode.includes('mjpeg')) {
+            if (modes.length) {
+                this.onmessage['mjpeg'] = msg => {
+                    if (msg.type !== 'error' || msg.value.indexOf(modes[0]) !== 0) return;
+                    this.onmjpeg();
+                };
+            } else {
+                modes.push('mjpeg');
+                this.onmjpeg();
+            }
+        }
+
+        return modes;
+    }
+
+    /**
+     * @return {boolean} true if reconnection has started.
+     */
+    onclose() {
+        if (this.wsState === WebSocket.CLOSED) return false;
+
+        // CONNECTING, OPEN => CONNECTING
+        this.wsState = WebSocket.CONNECTING;
+        this.ws = null;
+
+        // reconnect no more than once every X seconds
+        const delay = Math.max(this.RECONNECT_TIMEOUT - (Date.now() - this.connectTS), 0);
+
+        this.reconnectTID = setTimeout(() => {
+            this.reconnectTID = 0;
+            this.onconnect();
+        }, delay);
+
+        return true;
+    }
+
+    onmse() {
+        /** @type {MediaSource} */
+        let ms;
+
+        if ('ManagedMediaSource' in window) {
+            const MediaSource = window.ManagedMediaSource;
+
+            ms = new MediaSource();
+            ms.addEventListener('sourceopen', () => {
+                this.send({type: 'mse', value: this.codecs(MediaSource.isTypeSupported)});
+            }, {once: true});
+
+            this.video.disableRemotePlayback = true;
+            this.video.srcObject = ms;
+        } else {
+            ms = new MediaSource();
+            ms.addEventListener('sourceopen', () => {
+                URL.revokeObjectURL(this.video.src);
+                this.send({type: 'mse', value: this.codecs(MediaSource.isTypeSupported)});
+            }, {once: true});
+
+            this.video.src = URL.createObjectURL(ms);
+            this.video.srcObject = null;
+        }
+
+        this.play();
+
+        this.mseCodecs = '';
+
+        this.onmessage['mse'] = msg => {
+            if (msg.type !== 'mse') return;
+
+            this.mseCodecs = msg.value;
+
+            const sb = ms.addSourceBuffer(msg.value);
+            sb.mode = 'segments'; // segments or sequence
+            sb.addEventListener('updateend', () => {
+                if (!sb.updating && bufLen > 0) {
+                    try {
+                        const data = buf.slice(0, bufLen);
+                        sb.appendBuffer(data);
+                        bufLen = 0;
+                    } catch (e) {
+                        // console.debug(e);
+                    }
+                }
+
+                if (!sb.updating && sb.buffered && sb.buffered.length) {
+                    const end = sb.buffered.end(sb.buffered.length - 1);
+                    const start = end - 5;
+                    const start0 = sb.buffered.start(0);
+                    if (start > start0) {
+                        sb.remove(start0, start);
+                        ms.setLiveSeekableRange(start, end);
+                    }
+                    if (this.video.currentTime < start) {
+                        this.video.currentTime = start;
+                    }
+                    const gap = end - this.video.currentTime;
+                    this.video.playbackRate = gap > 0.1 ? gap : 0.1;
+                    // console.debug('VideoRTC.buffered', gap, this.video.playbackRate, this.video.readyState);
+                }
+            });
+
+            const buf = new Uint8Array(2 * 1024 * 1024);
+            let bufLen = 0;
+
+            this.ondata = data => {
+                if (sb.updating || bufLen > 0) {
+                    const b = new Uint8Array(data);
+                    buf.set(b, bufLen);
+                    bufLen += b.byteLength;
+                    // console.debug('VideoRTC.buffer', b.byteLength, bufLen);
+                } else {
+                    try {
+                        sb.appendBuffer(data);
+                    } catch (e) {
+                        // console.debug(e);
+                    }
+                }
+            };
+        };
+    }
+
+    onwebrtc() {
+        const pc = new RTCPeerConnection(this.pcConfig);
+
+        pc.addEventListener('icecandidate', ev => {
+            if (ev.candidate && this.mode.includes('webrtc/tcp') && ev.candidate.protocol === 'udp') return;
+
+            const candidate = ev.candidate ? ev.candidate.toJSON().candidate : '';
+            this.send({type: 'webrtc/candidate', value: candidate});
+        });
+
+        pc.addEventListener('connectionstatechange', () => {
+            if (pc.connectionState === 'connected') {
+                const tracks = pc.getTransceivers()
+                    .filter(tr => tr.currentDirection === 'recvonly') // skip inactive
+                    .map(tr => tr.receiver.track);
+                /** @type {HTMLVideoElement} */
+                const video2 = document.createElement('video');
+                video2.addEventListener('loadeddata', () => this.onpcvideo(video2), {once: true});
+                video2.srcObject = new MediaStream(tracks);
+            } else if (pc.connectionState === 'failed' || pc.connectionState === 'disconnected') {
+                pc.close(); // stop next events
+
+                this.pcState = WebSocket.CLOSED;
+                this.pc = null;
+
+                this.onconnect();
+            }
+        });
+
+        this.onmessage['webrtc'] = msg => {
+            switch (msg.type) {
+                case 'webrtc/candidate':
+                    if (this.mode.includes('webrtc/tcp') && msg.value.includes(' udp ')) return;
+
+                    pc.addIceCandidate({candidate: msg.value, sdpMid: '0'}).catch(er => {
+                        console.warn(er);
+                    });
+                    break;
+                case 'webrtc/answer':
+                    pc.setRemoteDescription({type: 'answer', sdp: msg.value}).catch(er => {
+                        console.warn(er);
+                    });
+                    break;
+                case 'error':
+                    if (!msg.value.includes('webrtc/offer')) return;
+                    pc.close();
+            }
+        };
+
+        this.createOffer(pc).then(offer => {
+            this.send({type: 'webrtc/offer', value: offer.sdp});
+        });
+
+        this.pcState = WebSocket.CONNECTING;
+        this.pc = pc;
+    }
+
+    /**
+     * @param pc {RTCPeerConnection}
+     * @return {Promise<RTCSessionDescriptionInit>}
+     */
+    async createOffer(pc) {
+        try {
+            if (this.media.includes('microphone')) {
+                const media = await navigator.mediaDevices.getUserMedia({audio: true});
+                media.getTracks().forEach(track => {
+                    pc.addTransceiver(track, {direction: 'sendonly'});
+                });
+            }
+        } catch (e) {
+            console.warn(e);
+        }
+
+        for (const kind of ['video', 'audio']) {
+            if (this.media.includes(kind)) {
+                pc.addTransceiver(kind, {direction: 'recvonly'});
+            }
+        }
+
+        const offer = await pc.createOffer();
+        await pc.setLocalDescription(offer);
+        return offer;
+    }
+
+    /**
+     * @param video2 {HTMLVideoElement}
+     */
+    onpcvideo(video2) {
+        if (this.pc) {
+            // Video+Audio > Video, H265 > H264, Video > Audio, WebRTC > MSE
+            let rtcPriority = 0, msePriority = 0;
+
+            /** @type {MediaStream} */
+            const stream = video2.srcObject;
+            if (stream.getVideoTracks().length > 0) {
+                // not the best, but a pretty simple way to check a codec
+                const isH265Supported =  this.pc.remoteDescription.sdp.includes('H265/90000');
+                rtcPriority += isH265Supported ? 0x240 : 0x220;
+            }
+            if (stream.getAudioTracks().length > 0) rtcPriority += 0x102;
+
+            if (this.mseCodecs.includes('hvc1.')) msePriority += 0x230;
+            if (this.mseCodecs.includes('avc1.')) msePriority += 0x210;
+            if (this.mseCodecs.includes('mp4a.')) msePriority += 0x101;
+
+            if (rtcPriority >= msePriority) {
+                this.video.srcObject = stream;
+                this.play();
+
+                this.pcState = WebSocket.OPEN;
+
+                this.wsState = WebSocket.CLOSED;
+                if (this.ws) {
+                    this.ws.close();
+                    this.ws = null;
+                }
+            } else {
+                this.pcState = WebSocket.CLOSED;
+                if (this.pc) {
+                    this.pc.close();
+                    this.pc = null;
+                }
+            }
+        }
+
+        video2.srcObject = null;
+    }
+
+    onmjpeg() {
+        this.ondata = data => {
+            this.video.controls = false;
+            this.video.poster = 'data:image/jpeg;base64,' + VideoRTC.btoa(data);
+        };
+
+        this.send({type: 'mjpeg'});
+    }
+
+    onhls() {
+        this.onmessage['hls'] = msg => {
+            if (msg.type !== 'hls') return;
+
+            const url = 'http' + this.wsURL.substring(2, this.wsURL.indexOf('/ws')) + '/hls/';
+            const playlist = msg.value.replace('hls/', url);
+            this.video.src = 'data:application/vnd.apple.mpegurl;base64,' + btoa(playlist);
+            this.play();
+        };
+
+        this.send({type: 'hls', value: this.codecs(type => this.video.canPlayType(type))});
+    }
+
+    onmp4() {
+        /** @type {HTMLCanvasElement} **/
+        const canvas = document.createElement('canvas');
+        /** @type {CanvasRenderingContext2D} */
+        let context;
+
+        /** @type {HTMLVideoElement} */
+        const video2 = document.createElement('video');
+        video2.autoplay = true;
+        video2.playsInline = true;
+        video2.muted = true;
+
+        video2.addEventListener('loadeddata', () => {
+            if (!context) {
+                canvas.width = video2.videoWidth;
+                canvas.height = video2.videoHeight;
+                context = canvas.getContext('2d');
+            }
+
+            context.drawImage(video2, 0, 0, canvas.width, canvas.height);
+
+            this.video.controls = false;
+            this.video.poster = canvas.toDataURL('image/jpeg');
+        });
+
+        this.ondata = data => {
+            video2.src = 'data:video/mp4;base64,' + VideoRTC.btoa(data);
+        };
+
+        this.send({type: 'mp4', value: this.codecs(this.video.canPlayType)});
+    }
+
+    static btoa(buffer) {
+        const bytes = new Uint8Array(buffer);
+        const len = bytes.byteLength;
+        let binary = '';
+        for (let i = 0; i < len; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return window.btoa(binary);
+    }
+}
diff --git a/installs_on_host/go2rtc/www/video-stream.js b/installs_on_host/go2rtc/www/video-stream.js
new file mode 100644
index 0000000..5b7c1ea
--- /dev/null
+++ b/installs_on_host/go2rtc/www/video-stream.js
@@ -0,0 +1,103 @@
+import {VideoRTC} from './video-rtc.js';
+
+/**
+ * This is example, how you can extend VideoRTC player for your app.
+ * Also you can check this example: https://github.com/AlexxIT/WebRTC
+ */
+class VideoStream extends VideoRTC {
+    set divMode(value) {
+        this.querySelector('.mode').innerText = value;
+        this.querySelector('.status').innerText = '';
+    }
+
+    set divError(value) {
+        const state = this.querySelector('.mode').innerText;
+        if (state !== 'loading') return;
+        this.querySelector('.mode').innerText = 'error';
+        this.querySelector('.status').innerText = value;
+    }
+
+    /**
+     * Custom GUI
+     */
+    oninit() {
+        console.debug('stream.oninit');
+        super.oninit();
+
+        this.innerHTML = `
+        <style>
+        video-stream {
+            position: relative;
+        }
+        .info {
+            position: absolute;
+            top: 0;
+            left: 0;
+            right: 0;
+            padding: 12px;
+            color: white;
+            display: flex;
+            justify-content: space-between;
+            pointer-events: none;
+        }
+        </style>
+        <div class="info">
+            <div class="status"></div>
+            <div class="mode"></div>
+        </div>
+        `;
+
+        const info = this.querySelector('.info');
+        this.insertBefore(this.video, info);
+    }
+
+    onconnect() {
+        console.debug('stream.onconnect');
+        const result = super.onconnect();
+        if (result) this.divMode = 'loading';
+        return result;
+    }
+
+    ondisconnect() {
+        console.debug('stream.ondisconnect');
+        super.ondisconnect();
+    }
+
+    onopen() {
+        console.debug('stream.onopen');
+        const result = super.onopen();
+
+        this.onmessage['stream'] = msg => {
+            console.debug('stream.onmessge', msg);
+            switch (msg.type) {
+                case 'error':
+                    this.divError = msg.value;
+                    break;
+                case 'mse':
+                case 'hls':
+                case 'mp4':
+                case 'mjpeg':
+                    this.divMode = msg.type.toUpperCase();
+                    break;
+            }
+        };
+
+        return result;
+    }
+
+    onclose() {
+        console.debug('stream.onclose');
+        return super.onclose();
+    }
+
+    onpcvideo(ev) {
+        console.debug('stream.onpcvideo');
+        super.onpcvideo(ev);
+
+        if (this.pcState !== WebSocket.CLOSED) {
+            this.divMode = 'RTC';
+        }
+    }
+}
+
+customElements.define('video-stream', VideoStream);
diff --git a/installs_on_host/go2rtc/www/webrtc-sync.html b/installs_on_host/go2rtc/www/webrtc-sync.html
new file mode 100644
index 0000000..89d742b
--- /dev/null
+++ b/installs_on_host/go2rtc/www/webrtc-sync.html
@@ -0,0 +1,66 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>webrtc - go2rtc</title>
+    <style>
+        body {
+            background-color: black;
+            margin: 0;
+            padding: 0;
+        }
+
+        html, body, video {
+            height: 100%;
+            width: 100%;
+        }
+    </style>
+</head>
+<body>
+<video id="video" autoplay controls playsinline muted></video>
+<script>
+    async function PeerConnection(media) {
+        const pc = new RTCPeerConnection({
+            iceServers: [{urls: ['stun:stun.cloudflare.com:3478', 'stun:stun.l.google.com:19302']}]
+        });
+
+        document.getElementById('video').srcObject = new MediaStream([
+            pc.addTransceiver('audio', {direction: 'sendrecv'}).receiver.track,
+            pc.addTransceiver('video', {direction: 'sendrecv'}).receiver.track,
+        ]);
+
+        const tracks = await navigator.mediaDevices.getUserMedia({
+            video: media.indexOf('camera') >= 0,
+            audio: media.indexOf('microphone') >= 0,
+        });
+        tracks.getTracks().forEach(track => {
+            pc.addTrack(track);
+        });
+
+        return pc;
+    }
+
+    function getCompleteOffer(pc, timeout) {
+        return new Promise((resolve, reject) => {
+            pc.addEventListener('icegatheringstatechange', () => {
+                if (pc.iceGatheringState === 'complete') resolve(pc.localDescription.sdp);
+            });
+
+            pc.createOffer().then(offer => pc.setLocalDescription(offer));
+
+            setTimeout(() => resolve(pc.localDescription.sdp), timeout || 3000);
+        });
+    }
+
+    async function connect() {
+        const media = new URLSearchParams(location.search).get('media');
+        const pc = await PeerConnection(media);
+        const url = new URL('api/webrtc' + location.search, location.href);
+        const r = await fetch(url, {method: 'POST', body: await getCompleteOffer(pc)});
+        await pc.setRemoteDescription({type: 'answer', sdp: await r.text()});
+    }
+
+    connect();
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/installs_on_host/go2rtc/www/webrtc.html b/installs_on_host/go2rtc/www/webrtc.html
new file mode 100644
index 0000000..dc12178
--- /dev/null
+++ b/installs_on_host/go2rtc/www/webrtc.html
@@ -0,0 +1,107 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>webrtc - go2rtc</title>
+    <style>
+        body {
+            background-color: black;
+            margin: 0;
+            padding: 0;
+        }
+
+        html, body, video {
+            height: 100%;
+            width: 100%;
+        }
+    </style>
+</head>
+<body>
+<video id="video" autoplay controls playsinline muted></video>
+<script>
+    async function PeerConnection(media) {
+        const pc = new RTCPeerConnection({
+            iceServers: [{urls: ['stun:stun.cloudflare.com:3478', 'stun:stun.l.google.com:19302']}]
+        });
+
+        const localTracks = [];
+
+        if (/camera|microphone/.test(media)) {
+            const tracks = await getMediaTracks('user', {
+                video: media.indexOf('camera') >= 0,
+                audio: media.indexOf('microphone') >= 0,
+            });
+            tracks.forEach(track => {
+                pc.addTransceiver(track, {direction: 'sendonly'});
+                if (track.kind === 'video') localTracks.push(track);
+            });
+        }
+
+        if (media.indexOf('display') >= 0) {
+            const tracks = await getMediaTracks('display', {
+                video: true,
+                audio: media.indexOf('speaker') >= 0,
+            });
+            tracks.forEach(track => {
+                pc.addTransceiver(track, {direction: 'sendonly'});
+                if (track.kind === 'video') localTracks.push(track);
+            });
+        }
+
+        if (/video|audio/.test(media)) {
+            const tracks = ['video', 'audio']
+                .filter(kind => media.indexOf(kind) >= 0)
+                .map(kind => pc.addTransceiver(kind, {direction: 'recvonly'}).receiver.track);
+            localTracks.push(...tracks);
+        }
+
+        document.getElementById('video').srcObject = new MediaStream(localTracks);
+
+        return pc;
+    }
+
+    async function getMediaTracks(media, constraints) {
+        try {
+            const stream = media === 'user'
+                ? await navigator.mediaDevices.getUserMedia(constraints)
+                : await navigator.mediaDevices.getDisplayMedia(constraints);
+            return stream.getTracks();
+        } catch (e) {
+            console.warn(e);
+            return [];
+        }
+    }
+
+    async function connect(media) {
+        const pc = await PeerConnection(media);
+        const url = new URL('api/ws' + location.search, location.href);
+        const ws = new WebSocket('ws' + url.toString().substring(4));
+
+        ws.addEventListener('open', () => {
+            pc.addEventListener('icecandidate', ev => {
+                if (!ev.candidate) return;
+                const msg = {type: 'webrtc/candidate', value: ev.candidate.candidate};
+                ws.send(JSON.stringify(msg));
+            });
+
+            pc.createOffer().then(offer => pc.setLocalDescription(offer)).then(() => {
+                const msg = {type: 'webrtc/offer', value: pc.localDescription.sdp};
+                ws.send(JSON.stringify(msg));
+            });
+        });
+
+        ws.addEventListener('message', ev => {
+            const msg = JSON.parse(ev.data);
+            if (msg.type === 'webrtc/candidate') {
+                pc.addIceCandidate({candidate: msg.value, sdpMid: '0'});
+            } else if (msg.type === 'webrtc/answer') {
+                pc.setRemoteDescription({type: 'answer', sdp: msg.value});
+            }
+        });
+    }
+
+    const media = new URLSearchParams(location.search).get('media');
+    connect(media || 'video+audio');
+</script>
+</body>
+</html>
\ No newline at end of file