Update version to 0.1-rc.6

Refactor docker image and ci

.github/workflows/builder.yml

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

.github/workflows/ci.yml

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

Dockerfile

@@ -0,0 +1,55 @@
+# 0. Prepare images
+ARG PYTHON_VERSION="3.11"
+ARG GO_VERSION="1.19"
+ARG NGROK_VERSION="3"
+
+FROM python:${PYTHON_VERSION}-alpine AS base
+FROM golang:${GO_VERSION}-alpine AS go
+FROM ngrok/ngrok:${NGROK_VERSION}-alpine AS ngrok
+
+
+# 1. Build go2rtc binary
+FROM go AS build
+
+WORKDIR /build
+
+# Cache dependencies
+COPY go.mod go.sum ./
+RUN go mod download
+
+COPY . .
+RUN CGO_ENABLED=0 go build -ldflags "-s -w" -trimpath
+
+
+# 2. Collect all files
+FROM scratch AS rootfs
+
+COPY --from=build /build/go2rtc /usr/local/bin/
+COPY --from=ngrok /bin/ngrok /usr/local/bin/
+COPY ./build/docker/run.sh /
+
+
+# 3. Final image
+FROM base
+
+# Install ffmpeg, bash (for run.sh), tini (for signal handling),
+# and other common tools for the echo source.
+RUN apk add --no-cache tini ffmpeg bash curl jq
+
+# Hardware Acceleration for Intel CPU (+50MB)
+ARG TARGETARCH
+
+RUN if [ "${TARGETARCH}" = "amd64" ]; then apk add --no-cache libva-intel-driver intel-media-driver; fi
+
+# Hardware: AMD and NVidia VAAPI (not sure about this)
+# RUN libva-glx mesa-va-gallium
+# Hardware: AMD and NVidia VDPAU (not sure about this)
+# RUN libva-vdpau-driver mesa-vdpau-gallium (+150MB total)
+
+COPY --from=rootfs / /
+
+RUN chmod a+x /run.sh && mkdir -p /config
+
+ENTRYPOINT ["/sbin/tini", "--"]
+
+CMD ["/run.sh"]

README.md

@@ -6,9 +6,10 @@ Ultimate camera streaming application with support RTSP, WebRTC, HomeKit, FFmpeg
 
 - zero-dependency and zero-config [small app](#go2rtc-binary) for all OS (Windows, macOS, Linux, ARM)
 - zero-delay for many supported protocols (lowest possible streaming latency)
-- streaming from [RTSP](#source-rtsp), [RTMP](#source-rtmp), [MJPEG](#source-ffmpeg), [HLS/HTTP](#source-ffmpeg), [USB Cameras](#source-ffmpeg-device) and [other sources](#module-streams)
+- streaming from [RTSP](#source-rtsp), [RTMP](#source-rtmp), [HTTP](#source-http) (FLV/MJPEG/JPEG), [FFmpeg](#source-ffmpeg), [USB Cameras](#source-ffmpeg-device) and [other sources](#module-streams)
 - streaming to [RTSP](#module-rtsp), [WebRTC](#module-webrtc), [MSE/MP4](#module-mp4) or [MJPEG](#module-mjpeg)
 - first project in the World with support streaming from [HomeKit Cameras](#source-homekit)
+- first project in the World with support H265 for WebRTC in browser ([read more](https://github.com/AlexxIT/Blog/issues/5))
 - on the fly transcoding for unsupported codecs via [FFmpeg](#source-ffmpeg)
 - multi-source 2-way [codecs negotiation](#codecs-negotiation)
    - mixing tracks from different sources to single stream
@@ -26,35 +27,6 @@ Ultimate camera streaming application with support RTSP, WebRTC, HomeKit, FFmpeg
 - [MediaSoup](https://mediasoup.org/) framework routing idea
 - HomeKit Accessory Protocol from [@brutella](https://github.com/brutella/hap)
 
-## Codecs negotiation
-
-For example, you want to watch RTSP-stream from [Dahua IPC-K42](https://www.dahuasecurity.com/fr/products/All-Products/Network-Cameras/Wireless-Series/Wi-Fi-Series/4MP/IPC-K42) camera in your Chrome browser.
-
-- this camera support 2-way audio standard **ONVIF Profile T**
-- this camera support codecs **H264, H265** for send video, and you select `H264` in camera settings
-- this camera support codecs **AAC, PCMU, PCMA** for send audio (from mic), and you select `AAC/16000` in camera settings
-- this camera support codecs **AAC, PCMU, PCMA** for receive audio (to speaker), you don't need to select them
-- your browser support codecs **H264, VP8, VP9, AV1** for receive video, you don't need to select them
-- your browser support codecs **OPUS, PCMU, PCMA** for send and receive audio, you don't need to select them
-- you can't get camera audio directly, because its audio codecs doesn't match with your browser codecs 
-   - so you decide to use transcoding via FFmpeg and add this setting to config YAML file
-   - you have chosen `OPUS/48000/2` codec, because it is higher quality than the `PCMU/8000` or `PCMA/8000`
-
-Now you have stream with two sources - **RTSP and FFmpeg**:
-
-```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 match codecs for you browser and all your stream sources. This called **multi-source 2-way codecs negotiation**. And this is one of the main features of this app.
-
-![](assets/codecs.svg)
-
-**PS.** You can select `PCMU` or `PCMA` codec in camera setting and don't use transcoding at all. Or you can select `AAC` codec for main stream and `PCMU` codec for second stream and add both RTSP to YAML config, this also will work fine.
-
 ## Fast start
 
 1. Download [binary](#go2rtc-binary) or use [Docker](#go2rtc-docker) or [Home Assistant Add-on](#go2rtc-home-assistant-add-on)
@@ -78,13 +50,14 @@ Download binary for your OS from [latest release](https://github.com/AlexxIT/go2
 
 - `go2rtc_win64.zip` - Windows 64-bit
 - `go2rtc_win32.zip` - Windows 32-bit
+- `go2rtc_win_arm64.zip` - Windows ARM 64-bit
 - `go2rtc_linux_amd64` - Linux 64-bit
 - `go2rtc_linux_i386` - Linux 32-bit
 - `go2rtc_linux_arm64` - Linux ARM 64-bit (ex. Raspberry 64-bit OS)
 - `go2rtc_linux_arm` - Linux ARM 32-bit (ex. Raspberry 32-bit OS)
-- `go2rtc_linux_mipsel` - Linux on MIPS (ex. [Xiaomi Gateway 3](https://github.com/AlexxIT/XiaomiGateway3))
+- `go2rtc_linux_mipsel` - Linux MIPS (ex. [Xiaomi Gateway 3](https://github.com/AlexxIT/XiaomiGateway3))
-- `go2rtc_mac_amd64` - Mac with Intel
+- `go2rtc_mac_amd64.zip` - Mac Intel 64-bit
-- `go2rtc_mac_arm64` - Mac with M1
+- `go2rtc_mac_arm64.zip` - Mac ARM 64-bit
 
 Don't forget to fix the rights `chmod +x go2rtc_xxx_xxx` on Linux and Mac.
 
@@ -127,7 +100,8 @@ Available modules:
 - [api](#module-api) - HTTP API (important for WebRTC support)
 - [rtsp](#module-rtsp) - RTSP Server (important for FFmpeg support)
 - [webrtc](#module-webrtc) - WebRTC Server
-- [mp4](#module-mp4) - MSE, MP4 stream and MP4 shapshot
+- [mp4](#module-mp4) - MSE, MP4 stream and MP4 shapshot Server
+- [mjpeg](#module-mjpeg) - MJPEG Server
 - [ffmpeg](#source-ffmpeg) - FFmpeg integration
 - [ngrok](#module-ngrok) - Ngrok integration (external access for private network)
 - [hass](#module-hass) - Home Assistant integration
@@ -140,8 +114,9 @@ Available modules:
 Available source types:
 
 - [rtsp](#source-rtsp) - `RTSP` and `RTSPS` cameras
-- [rtmp](#source-rtmp) - `RTMP` and `HTTP-FLV` streams
+- [rtmp](#source-rtmp) - `RTMP` streams
-- [ffmpeg](#source-ffmpeg) - FFmpeg integration (`MJPEG`, `HLS`, `files` and others)
+- [http](#source-http) - `HTTP-FLV`, `JPEG` (snapshots), `MJPEG` streams 
+- [ffmpeg](#source-ffmpeg) - FFmpeg integration (`HLS`, `files` and many others)
 - [ffmpeg:device](#source-ffmpeg-device) - local USB Camera or Webcam
 - [exec](#source-exec) - advanced FFmpeg and GStreamer integration
 - [echo](#source-echo) - get stream link from bash or python
@@ -176,13 +151,35 @@ streams:
 
 #### Source: RTMP
 
-You can get stream from RTMP server, for example [Frigate](https://docs.frigate.video/configuration/rtmp). Support ONLY `H264` video codec without audio.
+You can get stream from RTMP server, for example [Frigate](https://docs.frigate.video/configuration/rtmp).
 
 ```yaml
 streams:
   rtmp_stream: rtmp://192.168.1.123/live/camera1
 ```
 
+#### Source: HTTP
+
+Support Content-Type:
+
+- **HTTP-FLV** (`video/x-flv`) - same as RTMP, but over HTTP
+- **HTTP-JPEG** (`image/jpeg`) - camera snapshot link, can be converted by go2rtc to MJPEG stream
+- **HTTP-MJPEG** (`multipart/x`) - simple MJPEG stream over HTTP
+
+```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
+```
+
+**PS.** Dahua camera has bug: if you select MJPEG codec for RTSP second stream - snapshot won't work.
+
 #### Source: FFmpeg
 
 You can get any stream or 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.
@@ -207,24 +204,27 @@ streams:
   hls: ffmpeg:https://devstreaming-cdn.apple.com/videos/streaming/examples/bipbop_16x9/gear5/prog_index.m3u8#video=copy
 
   # [MJPEG] video will be transcoded to H264
-  mjpeg: ffmpeg:http://185.97.122.128/cgi-bin/faststream.jpg?stream=half&fps=15#video=h264
+  mjpeg: ffmpeg:http://185.97.122.128/cgi-bin/faststream.jpg#video=h264
 
   # [RTSP] video with rotation, should be transcoded, so select H264
-  rotate: ffmpeg:rtsp://rtsp:12345678@192.168.1.123/av_stream/ch0#raw=-vf transpose=1#video=h264
+  rotate: ffmpeg:rtsp://rtsp:12345678@192.168.1.123/av_stream/ch0#video=h264#rotate=90
 ```
 
-All trascoding formats has [built-in templates](https://github.com/AlexxIT/go2rtc/blob/master/cmd/ffmpeg/ffmpeg.go): `h264`, `h264/ultra`, `h264/high`, `h265`, `opus`, `pcmu`, `pcmu/16000`, `pcmu/48000`, `pcma`, `pcma/16000`, `pcma/48000`, `aac/16000`.
+All trascoding formats has [built-in templates](https://github.com/AlexxIT/go2rtc/blob/master/cmd/ffmpeg/ffmpeg.go): `h264`, `h264/ultra`, `h264/high`, `h265`, `opus`, `pcmu`, `pcmu/16000`, `pcmu/48000`, `pcma`, `pcma/16000`, `pcma/48000`, `aac`, `aac/16000`.
 
 But you can override them via YAML config. You can also add your own formats to config and use them with source params.
 
 ```yaml
 ffmpeg:
   bin: ffmpeg                                        # path to ffmpeg binary
-  h264: "-codec:v libx264 -g 30 -preset superfast -tune zerolatency -profile main -level 4.1"
+  h264: "-codec:v libx264 -g:v 30 -preset:v superfast -tune:v zerolatency -profile:v main -level:v 4.1"
   mycodec: "-any args that support ffmpeg..."
 ```
 
-Also you can use `raw` param for any additional FFmpeg arguments. As example for video rotation (`#raw=-vf transpose=1`). Remember that rotation is not possible without transcoding, so add supported codec as second param (`#video=h264`).
+- You can use `video` and `audio` params multiple times (ex. `#video=copy#audio=copy#audio=pcmu`)
+- You can use go2rtc stream name as ffmpeg input (ex. `ffmpeg:camera1#video=h264`)
+- You can use `rotate` params with `90`, `180`, `270` or `-90` values, important with transcoding (ex. `#video=h264#rotate=90`)
+- You can use `raw` param for any additional FFmpeg arguments (ex. `#raw=-vf transpose=1`).
 
 #### Source: FFmpeg Device
 
@@ -279,6 +279,24 @@ You can pair device with go2rtc on the HomeKit page. If you can't see your devic
 
 If you see a device but it does not have a pair button - it is paired to some ecosystem (Apple Home, Home Assistant, HomeBridge etc). You need to delete device from that ecosystem, and it will be available for pairing. If you cannot unpair device, you will have to reset it.
 
+**Important:**
+
+- HomeKit audio uses very non-standard **AAC-ELD** codec with very non-standard params and specification violation
+- Audio can be transcoded by [ffmpeg](#source-ffmpeg) source with `#async` option
+- Audio can be played by `ffplay` with `-use_wallclock_as_timestamps 1 -async 1` options
+- Audio can't be played in `VLC` and probably any other player
+
+Recommended settings for using HomeKit Camera with WebRTC, MSE, MP4, RTSP:
+
+```
+streams:
+  aqara_g3:
+    - hass:Camera-Hub-G3-AB12
+    - ffmpeg:aqara_g3#audio=aac#audio=opus#async
+```
+
+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).
 
 #### Source: Ivideon
@@ -312,7 +330,34 @@ More cameras, like [Tuya](https://www.home-assistant.io/integrations/tuya/), [ON
 
 The HTTP API is the main part for interacting with the application. Default address: `http://127.0.0.1:1984/`.
 
-- you can use WebRTC only when HTTP API enabled
+go2rtc has its own JS video player (`video-rtc.js`) with:
+
+- support technologies:
+   - WebRTC over UDP or TCP
+   - MSE or MP4 or MJPEG over WebSocket 
+- automatic selection best technology according on:
+   - codecs inside your stream
+   - current browser capabilities
+   - current network configuration
+- automatic stop stream while browser or page not active
+- automatic stop stream while player not inside page viewport
+- automatic reconnection
+
+Technology selection based on priorities:
+
+1. Video and Audio better than just Video
+2. H265 better than H264
+3. WebRTC better than MSE, than MP4, than MJPEG
+
+go2rtc has simple HTML page (`stream.html`) with support params in URL:
+
+- multiple streams on page `src=camera1&src=camera2...`
+- stream technology autoselection `mode=webrtc,mse,mp4,mjpeg`
+- stream technology comparison `src=camera1&mode=webrtc&mode=mse&mode=mp4`
+- player width setting in pixels `width=320px` or percents `width=50%`
+
+**Module config**
+
 - you can disable HTTP API with `listen: ""` and use, for example, only RTSP client/server protocol
 - you can enable HTTP API only on localhost with `listen: "127.0.0.1:1984"` setting
 - you can change API `base_path` and host go2rtc on your main app webserver suburl
@@ -320,15 +365,20 @@ The HTTP API is the main part for interacting with the application. Default addr
 
 ```yaml
 api:
-  listen: ":1984"  # HTTP API port ("" - disabled)
+  listen: ":1984"    # default ":1984", HTTP API port ("" - disabled)
-  base_path: ""    # API prefix for serve on suburl
+  base_path: "/rtc"  # default "", API prefix for serve on suburl (/api => /rtc/api)
-  static_dir: ""   # folder for static files (custom web interface)
+  static_dir: "www"  # default "", folder for static files (custom web interface)
+  origin: "*"        # default "", allow CORS requests (only * supported)
 ```
 
 **PS. go2rtc** doesn't provide HTTPS or password protection. Use [Nginx](https://nginx.org/) or [Ngrok](#module-ngrok) or [Home Assistant Add-on](#go2rtc-home-assistant-add-on) for this tasks.
 
 **PS2.** You can access microphone (for 2-way audio) only with HTTPS ([read more](https://stackoverflow.com/questions/52759992/how-to-access-camera-and-microphone-in-chrome-without-https)).
 
+**PS3.** MJPEG over WebSocket plays better than native MJPEG because Chrome [bug](https://bugs.chromium.org/p/chromium/issues/detail?id=527446).
+
+**PS4.** MP4 over WebSocket was created only for Apple iOS because it doesn't support MSE and native MP4.
+
 ### Module: RTSP
 
 You can get any stream as RTSP-stream: `rtsp://192.168.1.123:8554/{stream_name}`
@@ -336,10 +386,15 @@ You can get any stream as RTSP-stream: `rtsp://192.168.1.123:8554/{stream_name}`
 - you can omit the codec filters, so one first video and one first audio will be selected
 - you can set `?video=copy` or just `?video`, so only one first video without audio will be selected
 - you can set multiple video or audio, so all of them will be selected
+- you can enable external password protection for your RTSP streams
+
+Password protection always disabled for localhost calls (ex. FFmpeg or Hass on same server)
 
 ```yaml
 rtsp:
-  listen: ":8554"
+  listen: ":8554"  # RTSP Server TCP port, default - 8554
+  username: admin  # optional, default - disabled
+  password: pass   # optional, default - disabled
 ```
 
 ### Module: WebRTC
@@ -478,7 +533,8 @@ View almost any Hass camera using `WebRTC` technology, supported codecs `H264`/`
 When the stream starts - the camera `entity_id` will be added to go2rtc "on the fly". You don't need to add cameras manually to [go2rtc config](#configuration). Some cameras (like [Nest](https://www.home-assistant.io/integrations/nest/)) have a dynamic link to the stream, it will be updated each time a stream is started from the Hass interface. 
 
 1. Hass > Settings > Integrations > Add Integration > [RTSPtoWebRTC](https://my.home-assistant.io/redirect/config_flow_start/?domain=rtsp_to_webrtc) > `http://127.0.0.1:1984/`
-2. Use Picture Entity or Picture Glance lovelace card
+2. RTSPtoWebRTC > Configure > STUN server: `stun.l.google.com:19302`
+3. Use Picture Entity or Picture Glance lovelace card
 
 You can add camera `entity_id` to [go2rtc config](#configuration) if you need transcoding:
 
@@ -495,20 +551,32 @@ Provides several features:
 
 1. MSE stream (fMP4 over WebSocket)
 2. Camera snapshots in MP4 format (single frame), can be sent to [Telegram](https://www.telegram.org/)
-3. Progressive MP4 stream - bad format for streaming because of high latency, doesn't work in Safari 
+3. MP4 "file stream" - bad format for streaming because of high latency, doesn't work in Safari 
 
 ### Module: MJPEG
 
-**Important.** For stream as MJPEG format, your source MUST contain the MJPEG codec. If your camera outputs H264/H265 - you SHOULD use transcoding. With this example, your stream will have both H264 and MJPEG codecs:
+**Important.** For stream as MJPEG format, your source MUST contain the MJPEG codec. If your stream has a MJPEG codec - you can receive **MJPEG stream** or **JPEG snapshots** via API.
+
+You can receive an MJPEG stream in several ways:
+
+- some cameras support MJPEG codec inside [RTSP stream](#source-rtsp) (ex. second stream for Dahua cameras)
+- some cameras has HTTP link with [MJPEG stream](#source-http)
+- some cameras has HTTP link with snapshots - go2rtc can convert them to [MJPEG stream](#source-http)
+- you can convert H264/H265 stream from your camera via [FFmpeg integraion](#source-ffmpeg)
+
+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:rtsp://rtsp:12345678@192.168.1.123/av_stream/ch0#video=mjpeg
+    - ffmpeg:camera1#video=mjpeg
 ```
 
-Example link to MJPEG: `http://192.168.1.123:1984/api/stream.mjpeg?src=camera1`
+API examples:
+
+- MJPEG stream: `http://192.168.1.123:1984/api/stream.mjpeg?src=camera1`
+- JPEG snapshots: `http://192.168.1.123:1984/api/frame.jpeg?src=camera1`
 
 ### Module: Log
 
@@ -555,20 +623,19 @@ PS. Additionally WebRTC opens a lot of random UDP ports for transmit encrypted m
 
 `AVC/H.264` codec can be played almost anywhere. But `HEVC/H.265` has a lot of limitations in supporting with different devices and browsers. It's all about patents and money, you can't do anything about it.
 
-Device | WebRTC | MSE | MP4
+| Device              | WebRTC      | MSE         | MP4         |
--------|--------|-----|----
+|---------------------|-------------|-------------|-------------|
-*latency*       | best        | medium      | bad
+| *latency*           | best        | medium      | bad         |
-Desktop Chrome  | H264        | H264, H265* | H264, H265*
+| Desktop Chrome 107+ | H264        | H264, H265* | H264, H265* |
-Desktop Safari  | H264, H265* | H264        | no
+| Desktop Edge        | H264        | H264, H265* | H264, H265* |
-Desktop Edge    | H264        | H264, H265* | H264, H265*
+| Desktop Safari      | H264, H265* | H264, H265  | **no!**     |
-Desktop Firefox | H264        | H264        | H264
+| Desktop Firefox     | H264        | H264        | H264        |
-Desktop Opera   | no          | H264        | H264
+| Android Chrome 107+ | H264        | H264, H265* | H264        |
-iPhone Safari   | H264, H265* | no          | no
+| iPad Safari 13+     | H264, H265* | H264, H265  | **no!**     |
-iPad Safari     | H264, H265* | H264        | no
+| iPhone Safari 13+   | H264, H265* | **no!**     | **no!**     |
-Android Chrome  | H264        | H264        | H264
+| masOS Hass App      | no          | no          | no          |
-masOS Hass App  | no          | no          | no
 
-- Chrome H265: [read this](https://github.com/StaZhu/enable-chromium-hevc-hardware-decoding)
+- Chrome H265: [read this](https://chromestatus.com/feature/5186511939567616) and [read this](https://github.com/StaZhu/enable-chromium-hevc-hardware-decoding)
 - Edge H265: [read this](https://www.reddit.com/r/MicrosoftEdge/comments/v9iw8k/enable_hevc_support_in_edge/)
 - Desktop Safari H265: Menu > Develop > Experimental > WebRTC H265
 - iOS Safari H265: Settings > Safari > Advanced > Experimental > WebRTC H265
@@ -578,6 +645,41 @@ masOS Hass App  | no          | no          | no
 - WebRTC audio codecs: `PCMU/8000`, `PCMA/8000`, `OPUS/48000/2`
 - MSE/MP4 audio codecs: `AAC`
 
+**Apple devices**
+
+- all Apple devices don't support MP4 stream (they only support progressive loading of static files)
+- iPhones don't support MSE technology because it competes with the HLS technology, invented by Apple
+- HLS is the worst technology for **live** streaming, it still exists only because of iPhones
+
+## Codecs negotiation
+
+For example, you want to watch RTSP-stream from [Dahua IPC-K42](https://www.dahuasecurity.com/fr/products/All-Products/Network-Cameras/Wireless-Series/Wi-Fi-Series/4MP/IPC-K42) camera in your Chrome browser.
+
+- this camera support 2-way audio standard **ONVIF Profile T**
+- this camera support codecs **H264, H265** for send video, and you select `H264` in camera settings
+- this camera support codecs **AAC, PCMU, PCMA** for send audio (from mic), and you select `AAC/16000` in camera settings
+- this camera support codecs **AAC, PCMU, PCMA** for receive audio (to speaker), you don't need to select them
+- your browser support codecs **H264, VP8, VP9, AV1** for receive video, you don't need to select them
+- your browser support codecs **OPUS, PCMU, PCMA** for send and receive audio, you don't need to select them
+- you can't get camera audio directly, because its audio codecs doesn't match with your browser codecs
+  - so you decide to use transcoding via FFmpeg and add this setting to config YAML file
+  - you have chosen `OPUS/48000/2` codec, because it is higher quality than the `PCMU/8000` or `PCMA/8000`
+
+Now you have stream with two sources - **RTSP and FFmpeg**:
+
+```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 match codecs for you browser and all your stream sources. This called **multi-source 2-way codecs negotiation**. And this is one of the main features of this app.
+
+![](assets/codecs.svg)
+
+**PS.** You can select `PCMU` or `PCMA` codec in camera setting and don't use transcoding at all. Or you can select `AAC` codec for main stream and `PCMU` codec for second stream and add both RTSP to YAML config, this also will work fine.
+
 ## TIPS
 
 **Using apps for low RTSP delay**

build/docker/run.sh

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

build/hassio/Dockerfile

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

build/hassio/config.yaml

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

build/hassio/run.sh

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

cmd/api/api.go

@@ -4,8 +4,6 @@ import (
 	"encoding/json"
 	"github.com/AlexxIT/go2rtc/cmd/app"
 	"github.com/AlexxIT/go2rtc/cmd/streams"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
-	"github.com/gorilla/websocket"
 	"github.com/rs/zerolog"
 	"net"
 	"net/http"
@@ -17,6 +15,7 @@ func Init() {
 			Listen    string `yaml:"listen"`
 			BasePath  string `yaml:"base_path"`
 			StaticDir string `yaml:"static_dir"`
+			Origin    string `yaml:"origin"`
 		} `yaml:"api"`
 	}
 
@@ -34,7 +33,7 @@ func Init() {
 	log = app.GetLogger("api")
 
 	initStatic(cfg.Mod.StaticDir)
-	initWS()
+	initWS(cfg.Mod.Origin)
 
 	HandleFunc("api/streams", streamsHandler)
 	HandleFunc("api/ws", apiWS)
@@ -48,16 +47,18 @@ func Init() {
 
 	log.Info().Str("addr", cfg.Mod.Listen).Msg("[api] listen")
 
-	go func() {
 	s := http.Server{}
+	s.Handler = http.DefaultServeMux
 
 	if log.Trace().Enabled() {
-			s.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		s.Handler = middlewareLog(s.Handler)
-				log.Trace().Stringer("url", r.URL).Msgf("[api] %s", r.Method)
-				http.DefaultServeMux.ServeHTTP(w, r)
-			})
 	}
 
+	if cfg.Mod.Origin == "*" {
+		s.Handler = middlewareCORS(s.Handler)
+	}
+
+	go func() {
 		if err = s.Serve(listener); err != nil {
 			log.Fatal().Err(err).Msg("[api] serve")
 		}
@@ -75,13 +76,25 @@ func HandleFunc(pattern string, handler http.HandlerFunc) {
 	http.HandleFunc(pattern, handler)
 }
 
-func HandleWS(msgType string, handler WSHandler) {
+const StreamNotFound = "stream not found"
-	wsHandlers[msgType] = handler
-}
 
 var basePath string
 var log zerolog.Logger
-var wsHandlers = make(map[string]WSHandler)
+
+func middlewareLog(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		log.Trace().Msgf("[api] %s %s", r.Method, r.URL)
+		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")
+		next.ServeHTTP(w, r)
+	})
+}
 
 func streamsHandler(w http.ResponseWriter, r *http.Request) {
 	src := r.URL.Query().Get("src")
@@ -111,29 +124,3 @@ func streamsHandler(w http.ResponseWriter, r *http.Request) {
 	e.SetIndent("", "  ")
 	_ = e.Encode(v)
 }
-
-func apiWS(w http.ResponseWriter, r *http.Request) {
-	ctx := new(Context)
-	if err := ctx.Upgrade(w, r); err != nil {
-		log.Error().Err(err).Msg("[api.ws] upgrade")
-		return
-	}
-	defer ctx.Close()
-
-	for {
-		msg := new(streamer.Message)
-		if err := ctx.Conn.ReadJSON(msg); err != nil {
-			if websocket.IsUnexpectedCloseError(
-				err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure,
-			) {
-				log.Error().Err(err).Msg("[api.ws] readJSON")
-			}
-			return
-		}
-
-		handler := wsHandlers[msg.Type]
-		if handler != nil {
-			handler(ctx, msg)
-		}
-	}
-}

cmd/api/ws.go

@@ -1,7 +1,6 @@
 package api
 
 import (
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/gorilla/websocket"
 	"net/http"
 	"net/url"
@@ -9,11 +8,29 @@ import (
 	"sync"
 )
 
-func initWS() {
+// Message - struct for data exchange in Web API
+type Message struct {
+	Type  string      `json:"type"`
+	Value interface{} `json:"value,omitempty"`
+}
+
+type WSHandler func(tr *Transport, msg *Message) error
+
+func HandleWS(msgType string, handler WSHandler) {
+	wsHandlers[msgType] = handler
+}
+
+var wsHandlers = make(map[string]WSHandler)
+
+func initWS(origin string) {
 	wsUp = &websocket.Upgrader{
 		ReadBufferSize:  1024,
-		WriteBufferSize: 512000,
+		WriteBufferSize: 2028,
 	}
+
+	switch origin {
+	case "":
+		// same origin + ignore port
 		wsUp.CheckOrigin = func(r *http.Request) bool {
 			origin := r.Header["Origin"]
 			if len(origin) == 0 {
@@ -26,60 +43,96 @@ func initWS() {
 			if o.Host == r.Host {
 				return true
 			}
-		log.Trace().Msgf("[api.ws] origin: %s, host: %s", o.Host, r.Host)
+			log.Trace().Msgf("[api.ws] origin=%s, host=%s", o.Host, r.Host)
-		// some users change Nginx external port using Docker port
+			// https://github.com/AlexxIT/go2rtc/issues/118
-		// so origin will be with a port and host without
 			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 interface{}) {
+		if data, ok := msg.([]byte); ok {
+			_ = ws.WriteMessage(websocket.BinaryMessage, data)
+		} else {
+			_ = ws.WriteJSON(msg)
+		}
+	})
+
+	for {
+		msg := new(Message)
+		if err = ws.ReadJSON(msg); err != nil {
+			log.Trace().Err(err).Caller().Send()
+			_ = ws.Close()
+			break
+		}
+
+		if handler := wsHandlers[msg.Type]; handler != nil {
+			go func() {
+				if err = handler(tr, msg); err != nil {
+					tr.Write(&Message{Type: "error", Value: msg.Type + ": " + err.Error()})
+				}
+			}()
+		}
+	}
+
+	tr.Close()
 }
 
 var wsUp *websocket.Upgrader
 
-type WSHandler func(ctx *Context, msg *streamer.Message)
+type Transport struct {
-
-type Context struct {
-	Conn     *websocket.Conn
 	Request  *http.Request
 	Consumer interface{} // TODO: rewrite
 
+	mx sync.Mutex
+
+	onChange func()
+	onWrite  func(msg interface{})
 	onClose  []func()
-	mu      sync.Mutex
 }
 
-func (ctx *Context) Upgrade(w http.ResponseWriter, r *http.Request) (err error) {
+func (t *Transport) OnWrite(f func(msg interface{})) {
-	ctx.Conn, err = wsUp.Upgrade(w, r, nil)
+	t.mx.Lock()
-	ctx.Request = r
+	if t.onChange != nil {
-	return
+		t.onChange()
+	}
+	t.onWrite = f
+	t.mx.Unlock()
 }
 
-func (ctx *Context) Close() {
+func (t *Transport) Write(msg interface{}) {
-	for _, f := range ctx.onClose {
+	t.mx.Lock()
+	t.onWrite(msg)
+	t.mx.Unlock()
+}
+
+func (t *Transport) Close() {
+	for _, f := range t.onClose {
 		f()
 	}
-	_ = ctx.Conn.Close()
 }
 
-func (ctx *Context) Write(msg interface{}) {
+func (t *Transport) OnChange(f func()) {
-	ctx.mu.Lock()
+	t.onChange = f
-
-	if data, ok := msg.([]byte); ok {
-		_ = ctx.Conn.WriteMessage(websocket.BinaryMessage, data)
-	} else {
-		_ = ctx.Conn.WriteJSON(msg)
-	}
-
-	ctx.mu.Unlock()
 }
 
-func (ctx *Context) Error(err error) {
+func (t *Transport) OnClose(f func()) {
-	ctx.Write(&streamer.Message{
+	t.onClose = append(t.onClose, f)
-		Type: "error", Value: err.Error(),
-	})
-}
-
-func (ctx *Context) OnClose(f func()) {
-	ctx.onClose = append(ctx.onClose, f)
 }

cmd/app/app.go

@@ -10,7 +10,7 @@ import (
 	"runtime"
 )
 
-var Version = "0.1-rc.3"
+var Version = "0.1-rc.6"
 var UserAgent = "go2rtc/" + Version
 
 func Init() {

cmd/ffmpeg/ffmpeg.go

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

cmd/ffmpeg/hardware.go

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

cmd/ffmpeg/hardware_darwin.go

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

cmd/ffmpeg/hardware_linux.go

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

cmd/ffmpeg/hardware_windows.go

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

cmd/http/http.go

@@ -0,0 +1,56 @@
+package http
+
+import (
+	"errors"
+	"fmt"
+	"github.com/AlexxIT/go2rtc/cmd/streams"
+	"github.com/AlexxIT/go2rtc/pkg/mjpeg"
+	"github.com/AlexxIT/go2rtc/pkg/rtmp"
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/AlexxIT/go2rtc/pkg/tcp"
+	"net/http"
+	"strings"
+)
+
+func Init() {
+	streams.HandleFunc("http", handle)
+	streams.HandleFunc("https", handle)
+}
+
+func handle(url string) (streamer.Producer, error) {
+	// first we get the Content-Type to define supported producer
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := tcp.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	if res.StatusCode != http.StatusOK {
+		return nil, errors.New(res.Status)
+	}
+
+	ct := res.Header.Get("Content-Type")
+	if i := strings.IndexByte(ct, ';'); i > 0 {
+		ct = ct[:i]
+	}
+
+	switch ct {
+	case "image/jpeg", "multipart/x-mixed-replace":
+		return mjpeg.NewClient(res), nil
+	case "video/x-flv":
+		var conn *rtmp.Client
+		if conn, err = rtmp.Accept(res); err != nil {
+			return nil, err
+		}
+		if err = conn.Describe(); err != nil {
+			return nil, err
+		}
+		return conn, nil
+	}
+
+	return nil, fmt.Errorf("unsupported Content-Type: %s", ct)
+}

cmd/mjpeg/mjpeg.go

@@ -1,6 +1,7 @@
 package mjpeg
 
 import (
+	"errors"
 	"github.com/AlexxIT/go2rtc/cmd/api"
 	"github.com/AlexxIT/go2rtc/cmd/streams"
 	"github.com/AlexxIT/go2rtc/pkg/mjpeg"
@@ -12,12 +13,15 @@ import (
 func Init() {
 	api.HandleFunc("api/frame.jpeg", handlerKeyframe)
 	api.HandleFunc("api/stream.mjpeg", handlerStream)
+
+	api.HandleWS("mjpeg", handlerWS)
 }
 
 func handlerKeyframe(w http.ResponseWriter, r *http.Request) {
 	src := r.URL.Query().Get("src")
 	stream := streams.GetOrNew(src)
 	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
 		return
 	}
 
@@ -40,8 +44,12 @@ func handlerKeyframe(w http.ResponseWriter, r *http.Request) {
 
 	stream.RemoveConsumer(cons)
 
-	w.Header().Set("Content-Type", "image/jpeg")
+	h := w.Header()
-	w.Header().Set("Content-Length", strconv.Itoa(len(data)))
+	h.Set("Content-Type", "image/jpeg")
+	h.Set("Content-Length", strconv.Itoa(len(data)))
+	h.Set("Cache-Control", "no-cache")
+	h.Set("Connection", "close")
+	h.Set("Pragma", "no-cache")
 
 	if _, err := w.Write(data); err != nil {
 		log.Error().Err(err).Caller().Send()
@@ -54,23 +62,25 @@ func handlerStream(w http.ResponseWriter, r *http.Request) {
 	src := r.URL.Query().Get("src")
 	stream := streams.GetOrNew(src)
 	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
 		return
 	}
 
-	exit := make(chan struct{})
+	flusher := w.(http.Flusher)
 
 	cons := &mjpeg.Consumer{}
 	cons.Listen(func(msg interface{}) {
 		switch msg := msg.(type) {
 		case []byte:
 			data := []byte(header + strconv.Itoa(len(msg)))
-			data = append(data, 0x0D, 0x0A, 0x0D, 0x0A)
+			data = append(data, '\r', '\n', '\r', '\n')
 			data = append(data, msg...)
-			data = append(data, 0x0D, 0x0A)
+			data = append(data, '\r', '\n')
 
-			if _, err := w.Write(data); err != nil {
+			// Chrome bug: mjpeg image always shows the second to last image
-				exit <- struct{}{}
+			// https://bugs.chromium.org/p/chromium/issues/detail?id=527446
-			}
+			_, _ = w.Write(data)
+			flusher.Flush()
 		}
 	})
 
@@ -79,11 +89,43 @@ func handlerStream(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	w.Header().Set("Content-Type", `multipart/x-mixed-replace; boundary=frame`)
+	h := w.Header()
+	h.Set("Content-Type", "multipart/x-mixed-replace; boundary=frame")
+	h.Set("Cache-Control", "no-cache")
+	h.Set("Connection", "close")
+	h.Set("Pragma", "no-cache")
 
-	<-exit
+	<-r.Context().Done()
 
 	stream.RemoveConsumer(cons)
 
 	//log.Trace().Msg("[api.mjpeg] close")
 }
+
+func handlerWS(tr *api.Transport, _ *api.Message) error {
+	src := tr.Request.URL.Query().Get("src")
+	stream := streams.GetOrNew(src)
+	if stream == nil {
+		return errors.New(api.StreamNotFound)
+	}
+
+	cons := &mjpeg.Consumer{}
+	cons.Listen(func(msg interface{}) {
+		if data, ok := msg.([]byte); ok {
+			tr.Write(data)
+		}
+	})
+
+	if err := stream.AddConsumer(cons); err != nil {
+		log.Error().Err(err).Caller().Send()
+		return err
+	}
+
+	tr.Write(&api.Message{Type: "mjpeg"})
+
+	tr.OnClose(func() {
+		stream.RemoveConsumer(cons)
+	})
+
+	return nil
+}

cmd/mp4/mp4.go

@@ -15,7 +15,8 @@ import (
 func Init() {
 	log = app.GetLogger("mp4")
 
-	api.HandleWS(MsgTypeMSE, handlerWS)
+	api.HandleWS("mse", handlerWSMSE)
+	api.HandleWS("mp4", handlerWSMP4)
 
 	api.HandleFunc("api/frame.mp4", handlerKeyframe)
 	api.HandleFunc("api/stream.mp4", handlerMP4)
@@ -31,12 +32,13 @@ func handlerKeyframe(w http.ResponseWriter, r *http.Request) {
 	src := r.URL.Query().Get("src")
 	stream := streams.GetOrNew(src)
 	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
 		return
 	}
 
 	exit := make(chan []byte)
 
-	cons := &mp4.Keyframe{}
+	cons := &mp4.Segment{OnlyKeyframe: true}
 	cons.Listen(func(msg interface{}) {
 		if data, ok := msg.([]byte); ok && exit != nil {
 			exit <- data
@@ -63,15 +65,16 @@ func handlerKeyframe(w http.ResponseWriter, r *http.Request) {
 }
 
 func handlerMP4(w http.ResponseWriter, r *http.Request) {
+	log.Trace().Msgf("[mp4] %s %+v", r.Method, r.Header)
+
 	if isChromeFirst(w, r) || isSafari(w, r) {
 		return
 	}
 
-	log.Trace().Msgf("[api.mp4] %+v", r)
-
 	src := r.URL.Query().Get("src")
 	stream := streams.GetOrNew(src)
 	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
 		return
 	}
 

cmd/mp4/mse.go

@@ -1,57 +0,0 @@
-package mp4
-
-import (
-	"github.com/AlexxIT/go2rtc/cmd/api"
-	"github.com/AlexxIT/go2rtc/cmd/streams"
-	"github.com/AlexxIT/go2rtc/pkg/mp4"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
-)
-
-const MsgTypeMSE = "mse" // fMP4
-
-const packetSize = 8192
-
-func handlerWS(ctx *api.Context, msg *streamer.Message) {
-	src := ctx.Request.URL.Query().Get("src")
-	stream := streams.GetOrNew(src)
-	if stream == nil {
-		return
-	}
-
-	cons := &mp4.Consumer{}
-	cons.UserAgent = ctx.Request.UserAgent()
-	cons.RemoteAddr = ctx.Request.RemoteAddr
-
-	cons.Listen(func(msg interface{}) {
-		if data, ok := msg.([]byte); ok {
-			for len(data) > packetSize {
-				ctx.Write(data[:packetSize])
-				data = data[packetSize:]
-			}
-			ctx.Write(data)
-		}
-	})
-
-	if err := stream.AddConsumer(cons); err != nil {
-		log.Warn().Err(err).Caller().Send()
-		ctx.Error(err)
-		return
-	}
-
-	ctx.OnClose(func() {
-		stream.RemoveConsumer(cons)
-	})
-
-	ctx.Write(&streamer.Message{Type: MsgTypeMSE, Value: cons.MimeType()})
-
-	data, err := cons.Init()
-	if err != nil {
-		log.Warn().Err(err).Caller().Send()
-		ctx.Error(err)
-		return
-	}
-
-	ctx.Write(data)
-
-	cons.Start()
-}

cmd/mp4/ws.go

@@ -0,0 +1,135 @@
+package mp4
+
+import (
+	"errors"
+	"github.com/AlexxIT/go2rtc/cmd/api"
+	"github.com/AlexxIT/go2rtc/cmd/streams"
+	"github.com/AlexxIT/go2rtc/pkg/mp4"
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"strings"
+)
+
+const packetSize = 1400
+
+func handlerWSMSE(tr *api.Transport, msg *api.Message) error {
+	src := tr.Request.URL.Query().Get("src")
+	stream := streams.GetOrNew(src)
+	if stream == nil {
+		return errors.New(api.StreamNotFound)
+	}
+
+	cons := &mp4.Consumer{}
+	cons.UserAgent = tr.Request.UserAgent()
+	cons.RemoteAddr = tr.Request.RemoteAddr
+
+	if codecs, ok := msg.Value.(string); ok {
+		log.Trace().Str("codecs", codecs).Msgf("[mp4] new WS/MSE consumer")
+		cons.Medias = parseMedias(codecs, true)
+	}
+
+	cons.Listen(func(msg interface{}) {
+		if data, ok := msg.([]byte); ok {
+			for len(data) > packetSize {
+				tr.Write(data[:packetSize])
+				data = data[packetSize:]
+			}
+			tr.Write(data)
+		}
+	})
+
+	if err := stream.AddConsumer(cons); err != nil {
+		log.Warn().Err(err).Caller().Send()
+		return err
+	}
+
+	tr.OnClose(func() {
+		stream.RemoveConsumer(cons)
+	})
+
+	tr.Write(&api.Message{Type: "mse", Value: cons.MimeType()})
+
+	data, err := cons.Init()
+	if err != nil {
+		log.Warn().Err(err).Caller().Send()
+		return err
+	}
+
+	tr.Write(data)
+
+	cons.Start()
+
+	return nil
+}
+
+func handlerWSMP4(tr *api.Transport, msg *api.Message) error {
+	src := tr.Request.URL.Query().Get("src")
+	stream := streams.GetOrNew(src)
+	if stream == nil {
+		return errors.New(api.StreamNotFound)
+	}
+
+	cons := &mp4.Segment{}
+
+	if codecs, ok := msg.Value.(string); ok {
+		log.Trace().Str("codecs", codecs).Msgf("[mp4] new WS/MP4 consumer")
+		cons.Medias = parseMedias(codecs, false)
+	}
+
+	cons.Listen(func(msg interface{}) {
+		if data, ok := msg.([]byte); ok {
+			tr.Write(data)
+		}
+	})
+
+	if err := stream.AddConsumer(cons); err != nil {
+		log.Error().Err(err).Caller().Send()
+		return err
+	}
+
+	tr.Write(&api.Message{Type: "mp4", Value: cons.MimeType})
+
+	tr.OnClose(func() {
+		stream.RemoveConsumer(cons)
+	})
+
+	return nil
+}
+
+func parseMedias(codecs string, parseAudio bool) (medias []*streamer.Media) {
+	var videos []*streamer.Codec
+	var audios []*streamer.Codec
+
+	for _, name := range strings.Split(codecs, ",") {
+		switch name {
+		case "avc1.640029":
+			codec := &streamer.Codec{Name: streamer.CodecH264}
+			videos = append(videos, codec)
+		case "hvc1.1.6.L153.B0":
+			codec := &streamer.Codec{Name: streamer.CodecH265}
+			videos = append(videos, codec)
+		case "mp4a.40.2":
+			codec := &streamer.Codec{Name: streamer.CodecAAC}
+			audios = append(audios, codec)
+		}
+	}
+
+	if videos != nil {
+		media := &streamer.Media{
+			Kind:      streamer.KindVideo,
+			Direction: streamer.DirectionRecvonly,
+			Codecs:    videos,
+		}
+		medias = append(medias, media)
+	}
+
+	if audios != nil && parseAudio {
+		media := &streamer.Media{
+			Kind:      streamer.KindAudio,
+			Direction: streamer.DirectionRecvonly,
+			Codecs:    audios,
+		}
+		medias = append(medias, media)
+	}
+
+	return
+}

cmd/rtmp/rtmp.go

@@ -8,8 +8,6 @@ import (
 
 func Init() {
 	streams.HandleFunc("rtmp", handle)
-	streams.HandleFunc("http", handle)
-	streams.HandleFunc("https", handle)
 }
 
 func handle(url string) (streamer.Producer, error) {
@@ -17,5 +15,8 @@ func handle(url string) (streamer.Producer, error) {
 	if err := conn.Dial(); err != nil {
 		return nil, err
 	}
+	if err := conn.Describe(); err != nil {
+		return nil, err
+	}
 	return conn, nil
 }

cmd/rtsp/rtsp.go

@@ -15,6 +15,8 @@ func Init() {
 	var conf struct {
 		Mod struct {
 			Listen   string `yaml:"listen"`
+			Username string `yaml:"username"`
+			Password string `yaml:"password"`
 		} `yaml:"rtsp"`
 	}
 
@@ -52,7 +54,13 @@ func Init() {
 			if err != nil {
 				return
 			}
-			go tcpHandler(conn)
+
+			c := rtsp.NewServer(conn)
+			// 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)
 		}
 	}()
 }
@@ -121,13 +129,12 @@ func rtspHandler(url string) (streamer.Producer, error) {
 	return conn, nil
 }
 
-func tcpHandler(c net.Conn) {
+func tcpHandler(conn *rtsp.Conn) {
 	var name string
 	var closer func()
 
 	trace := log.Trace().Enabled()
 
-	conn := rtsp.NewServer(c)
 	conn.Listen(func(msg interface{}) {
 		if trace {
 			switch msg := msg.(type) {
@@ -140,6 +147,11 @@ func tcpHandler(c net.Conn) {
 
 		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)
@@ -161,6 +173,11 @@ func tcpHandler(c net.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)

cmd/streams/producer.go

@@ -24,6 +24,7 @@ type Producer struct {
 	template string
 
 	element streamer.Producer
+	lastErr error
 	tracks  []*streamer.Track
 
 	state   state
@@ -45,10 +46,9 @@ func (p *Producer) GetMedias() []*streamer.Media {
 	if p.state == stateNone {
 		log.Debug().Msgf("[streams] probe producer url=%s", p.url)
 
-		var err error
+		p.element, p.lastErr = GetProducer(p.url)
-		p.element, err = GetProducer(p.url)
+		if p.lastErr != nil || p.element == nil {
-		if err != nil || p.element == nil {
+			log.Error().Err(p.lastErr).Caller().Send()
-			log.Error().Err(err).Caller().Send()
 			return nil
 		}
 

cmd/streams/stream.go

@@ -3,7 +3,9 @@ package streams
 import (
 	"encoding/json"
 	"errors"
+	"fmt"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"strings"
 	"sync"
 )
 
@@ -55,6 +57,8 @@ func (s *Stream) AddConsumer(cons streamer.Consumer) (err error) {
 	consumer := &Consumer{element: cons}
 	var producers []*Producer // matched producers for consumer
 
+	var codecs string
+
 	// Step 1. Get consumer medias
 	for icc, consMedia := range cons.GetMedias() {
 		log.Trace().Stringer("media", consMedia).
@@ -67,6 +71,8 @@ func (s *Stream) AddConsumer(cons streamer.Consumer) (err error) {
 				log.Trace().Stringer("media", prodMedia).
 					Msgf("[streams] producer=%d candidate=%d", ip, ipc)
 
+				collectCodecs(prodMedia, &codecs)
+
 				// Step 3. Match consumer/producer codecs list
 				prodCodec := prodMedia.MatchMedia(consMedia)
 				if prodCodec != nil {
@@ -93,7 +99,18 @@ func (s *Stream) AddConsumer(cons streamer.Consumer) (err error) {
 
 	if len(producers) == 0 {
 		s.stopProducers()
-		return errors.New("couldn't find the matching tracks")
+
+		if len(codecs) > 0 {
+			return errors.New("codecs not match: " + codecs)
+		}
+
+		for i, producer := range s.producers {
+			if producer.lastErr != nil {
+				return fmt.Errorf("source %d error: %w", i, producer.lastErr)
+			}
+		}
+
+		return fmt.Errorf("sources unavailable: %d", len(s.producers))
 	}
 
 	s.mu.Lock()
@@ -216,3 +233,19 @@ func (s *Stream) removeProducer(i int) {
 		s.producers = append(s.producers[:i], s.producers[i+1:]...)
 	}
 }
+
+func collectCodecs(media *streamer.Media, codecs *string) {
+	for _, codec := range media.Codecs {
+		name := codec.Name
+		if name == streamer.CodecAAC {
+			name = "AAC"
+		}
+		if strings.Contains(*codecs, name) {
+			continue
+		}
+		if len(*codecs) > 0 {
+			*codecs += ","
+		}
+		*codecs += name
+	}
+}

cmd/webrtc/candidates.go

@@ -2,7 +2,6 @@ package webrtc
 
 import (
 	"github.com/AlexxIT/go2rtc/cmd/api"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/AlexxIT/go2rtc/pkg/webrtc"
 	"github.com/pion/sdp/v3"
 )
@@ -13,7 +12,27 @@ func AddCandidate(address string) {
 	candidates = append(candidates, address)
 }
 
-func addCanditates(answer string) (string, error) {
+func asyncCandidates(tr *api.Transport) {
+	for _, address := range candidates {
+		address, err := webrtc.LookupIP(address)
+		if err != nil {
+			log.Warn().Err(err).Caller().Send()
+			continue
+		}
+
+		cand, err := webrtc.NewCandidate(address)
+		if err != nil {
+			log.Warn().Err(err).Caller().Send()
+			continue
+		}
+
+		log.Trace().Str("candidate", cand).Msg("[webrtc] config")
+
+		tr.Write(&api.Message{Type: "webrtc/candidate", Value: cand})
+	}
+}
+
+func syncCanditates(answer string) (string, error) {
 	if len(candidates) == 0 {
 		return answer, nil
 	}
@@ -59,12 +78,14 @@ func addCanditates(answer string) (string, error) {
 	return string(data), nil
 }
 
-func candidateHandler(ctx *api.Context, msg *streamer.Message) {
+func candidateHandler(tr *api.Transport, msg *api.Message) error {
-	if ctx.Consumer == nil {
+	if tr.Consumer == nil {
-		return
+		return nil
 	}
-	if conn := ctx.Consumer.(*webrtc.Conn); conn != nil {
+	if conn := tr.Consumer.(*webrtc.Conn); conn != nil {
-		log.Trace().Str("candidate", msg.Value.(string)).Msg("[webrtc] remote")
+		s := msg.Value.(string)
-		conn.Push(msg)
+		log.Trace().Str("candidate", s).Msg("[webrtc] remote")
+		conn.AddCandidate(s)
 	}
+	return nil
 }

cmd/webrtc/webrtc.go

@@ -1,14 +1,14 @@
 package webrtc
 
 import (
+	"errors"
 	"github.com/AlexxIT/go2rtc/cmd/api"
 	"github.com/AlexxIT/go2rtc/cmd/app"
 	"github.com/AlexxIT/go2rtc/cmd/streams"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/AlexxIT/go2rtc/pkg/webrtc"
 	pion "github.com/pion/webrtc/v3"
 	"github.com/rs/zerolog"
-	"io/ioutil"
+	"io"
 	"net"
 	"net/http"
 )
@@ -33,7 +33,7 @@ func Init() {
 	address := cfg.Mod.Listen
 	pionAPI, err := webrtc.NewAPI(address)
 	if pionAPI == nil {
-		log.Error().Err(err).Msg("[webrtc] init API")
+		log.Error().Err(err).Caller().Msg("webrtc.NewAPI")
 		return
 	}
 
@@ -55,8 +55,8 @@ func Init() {
 
 	candidates = cfg.Mod.Candidates
 
-	api.HandleWS(webrtc.MsgTypeOffer, offerHandler)
+	api.HandleWS("webrtc/offer", asyncHandler)
-	api.HandleWS(webrtc.MsgTypeCandidate, candidateHandler)
+	api.HandleWS("webrtc/candidate", candidateHandler)
 
 	api.HandleFunc("api/webrtc", syncHandler)
 }
@@ -66,11 +66,11 @@ var log zerolog.Logger
 
 var NewPConn func() (*pion.PeerConnection, error)
 
-func offerHandler(ctx *api.Context, msg *streamer.Message) {
+func asyncHandler(tr *api.Transport, msg *api.Message) error {
-	src := ctx.Request.URL.Query().Get("src")
+	src := tr.Request.URL.Query().Get("src")
-	stream := streams.Get(src)
+	stream := streams.GetOrNew(src)
 	if stream == nil {
-		return
+		return errors.New(api.StreamNotFound)
 	}
 
 	log.Debug().Str("url", src).Msg("[webrtc] new consumer")
@@ -81,21 +81,23 @@ func offerHandler(ctx *api.Context, msg *streamer.Message) {
 	conn := new(webrtc.Conn)
 	conn.Conn, err = NewPConn()
 	if err != nil {
-		log.Error().Err(err).Msg("[webrtc] new conn")
+		log.Error().Err(err).Caller().Send()
-		return
+		return err
 	}
 
-	conn.UserAgent = ctx.Request.UserAgent()
+	conn.UserAgent = tr.Request.UserAgent()
 	conn.Listen(func(msg interface{}) {
 		switch msg := msg.(type) {
 		case pion.PeerConnectionState:
 			if msg == pion.PeerConnectionStateClosed {
 				stream.RemoveConsumer(conn)
 			}
-		case *streamer.Message:
+		case *pion.ICECandidate:
-			// subscribe on webrtc server candidates
+			if msg != nil {
-			log.Trace().Str("candidate", msg.Value.(string)).Msg("[webrtc] local")
+				s := msg.ToJSON().Candidate
-			ctx.Write(msg)
+				log.Trace().Str("candidate", s).Msg("[webrtc] local")
+				tr.Write(&api.Message{Type: "webrtc/candidate", Value: s})
+			}
 		}
 	})
 
@@ -104,41 +106,35 @@ func offerHandler(ctx *api.Context, msg *streamer.Message) {
 	log.Trace().Msgf("[webrtc] offer:\n%s", offer)
 
 	if err = conn.SetOffer(offer); err != nil {
-		log.Warn().Err(err).Msg("[api.webrtc] set offer")
+		log.Warn().Err(err).Caller().Send()
-		ctx.Error(err)
+		return err
-		return
 	}
 
 	// 2. AddConsumer, so we get new tracks
 	if err = stream.AddConsumer(conn); err != nil {
-		log.Warn().Err(err).Msg("[api.webrtc] add consumer")
+		log.Warn().Err(err).Caller().Send()
 		_ = conn.Conn.Close()
-		ctx.Error(err)
+		return err
-		return
 	}
 
 	conn.Init()
 
-	// exchange sdp without waiting all candidates
+	// 3. Exchange SDP without waiting all candidates
-	//answer, err := conn.ExchangeSDP(offer, false)
+	answer, err := conn.GetAnswer()
-	//answer, err := conn.GetAnswer()
-	answer, err := conn.GetCompleteAnswer()
-	if err == nil {
-		answer, err = addCanditates(answer)
-	}
 	log.Trace().Msgf("[webrtc] answer\n%s", answer)
 
 	if err != nil {
-		log.Error().Err(err).Msg("[webrtc] get answer")
+		log.Error().Err(err).Caller().Send()
-		ctx.Error(err)
+		return err
-		return
 	}
 
-	ctx.Write(&streamer.Message{
+	tr.Consumer = conn
-		Type: webrtc.MsgTypeAnswer, Value: answer,
-	})
 
-	ctx.Consumer = conn
+	tr.Write(&api.Message{Type: "webrtc/answer", Value: answer})
+
+	asyncCandidates(tr)
+
+	return nil
 }
 
 func syncHandler(w http.ResponseWriter, r *http.Request) {
@@ -149,21 +145,21 @@ func syncHandler(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// get offer
-	offer, err := ioutil.ReadAll(r.Body)
+	offer, err := io.ReadAll(r.Body)
 	if err != nil {
-		log.Error().Err(err).Caller().Send()
+		log.Error().Err(err).Caller().Msg("ioutil.ReadAll")
 		return
 	}
 
 	answer, err := ExchangeSDP(stream, string(offer), r.UserAgent())
 	if err != nil {
-		log.Error().Err(err).Caller().Send()
+		log.Error().Err(err).Caller().Msg("ExchangeSDP")
 		return
 	}
 
 	// send SDP to client
 	if _, err = w.Write([]byte(answer)); err != nil {
-		log.Error().Err(err).Caller().Send()
+		log.Error().Err(err).Caller().Msg("w.Write")
 	}
 }
 
@@ -174,7 +170,7 @@ func ExchangeSDP(
 	conn := new(webrtc.Conn)
 	conn.Conn, err = NewPConn()
 	if err != nil {
-		log.Error().Err(err).Msg("[webrtc] new conn")
+		log.Error().Err(err).Caller().Msg("NewPConn")
 		return
 	}
 
@@ -192,13 +188,13 @@ func ExchangeSDP(
 	log.Trace().Msgf("[webrtc] offer:\n%s", offer)
 
 	if err = conn.SetOffer(offer); err != nil {
-		log.Warn().Err(err).Msg("[api.webrtc] set offer")
+		log.Warn().Err(err).Caller().Msg("conn.SetOffer")
 		return
 	}
 
 	// 2. AddConsumer, so we get new tracks
 	if err = stream.AddConsumer(conn); err != nil {
-		log.Warn().Err(err).Msg("[api.webrtc] add consumer")
+		log.Warn().Err(err).Caller().Msg("stream.AddConsumer")
 		_ = conn.Conn.Close()
 		return
 	}
@@ -209,12 +205,12 @@ func ExchangeSDP(
 	//answer, err := conn.ExchangeSDP(offer, false)
 	answer, err = conn.GetCompleteAnswer()
 	if err == nil {
-		answer, err = addCanditates(answer)
+		answer, err = syncCanditates(answer)
 	}
 	log.Trace().Msgf("[webrtc] answer\n%s", answer)
 
 	if err != nil {
-		log.Error().Err(err).Msg("[webrtc] get answer")
+		log.Error().Err(err).Caller().Msg("conn.GetCompleteAnswer")
 	}
 
 	return

go.mod

@@ -1,6 +1,6 @@
 module github.com/AlexxIT/go2rtc
 
-go 1.17
+go 1.19
 
 require (
 	github.com/brutella/hap v0.0.17
@@ -26,6 +26,7 @@ require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/go-chi/chi v1.5.4 // indirect
 	github.com/google/uuid v1.3.0 // indirect
+	github.com/kr/pretty v0.2.1 // indirect
 	github.com/mattn/go-colorable v0.1.12 // indirect
 	github.com/mattn/go-isatty v0.0.14 // indirect
 	github.com/miekg/dns v1.1.50 // indirect
@@ -41,12 +42,11 @@ require (
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/xiam/to v0.0.0-20200126224905-d60d31e03561 // indirect
 	golang.org/x/crypto v0.0.0-20220516162934-403b01795ae8 // indirect
-	golang.org/x/mod v0.4.2 // indirect
+	golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 // indirect
 	golang.org/x/net v0.0.0-20220630215102-69896b714898 // indirect
-	golang.org/x/sys v0.0.0-20220622161953-175b2fd9d664 // indirect
+	golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab // indirect
 	golang.org/x/text v0.3.7 // indirect
-	golang.org/x/tools v0.1.6-0.20210726203631-07bc1bf47fb2 // indirect
+	golang.org/x/tools v0.1.11 // indirect
-	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
 )
 
 replace (

go.sum

@@ -4,7 +4,6 @@ github.com/AlexxIT/vdk v0.0.18-0.20221108193131-6168555b4f92 h1:cIeYMGaAirSZnrKR
 github.com/AlexxIT/vdk v0.0.18-0.20221108193131-6168555b4f92/go.mod h1:7ydHfSkflMZxBXfWR79dMjrT54xzvLxnPaByOa9Jpzg=
 github.com/brutella/dnssd v1.2.3 h1:4fBLjZjPH7SbcHhEcIJhZcC9nOhIDZ0m3rn9bjl1/i0=
 github.com/brutella/dnssd v1.2.3/go.mod h1:JoW2sJUrmVIef25G6lrLj7HS6Xdwh6q8WUIvMkkBYXs=
-github.com/cheekybits/genny v1.0.0/go.mod h1:+tQajlRqAUrPI7DOSpB0XAqZYtQakVtB7wXkRAgjxjQ=
 github.com/coreos/go-systemd/v22 v22.3.3-0.20220203105225-a9a7ef127534/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
@@ -15,7 +14,6 @@ github.com/go-chi/chi v1.5.4 h1:QHdzF2szwjqVV4wmByUnTcsbIg7UGaQ0tPF2t5GcAIs=
 github.com/go-chi/chi v1.5.4/go.mod h1:uaf8YgoFazUOkPBG7fxPftUylNumIev9awIWOENIuEg=
 github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
-github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
 github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
@@ -29,7 +27,6 @@ github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMyw
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
 github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
@@ -37,13 +34,12 @@ github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/ad
 github.com/hashicorp/mdns v1.0.5 h1:1M5hW1cunYeoXOqHwEb/GBDDHAFo0Yqb/uz/beC6LbE=
 github.com/hashicorp/mdns v1.0.5/go.mod h1:mtBihi+LeNXGtG8L9dX59gAEa12BDtBQSp4v/YAJqrc=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
-github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI=
+github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/lucas-clemente/quic-go v0.7.1-0.20190401152353-907071221cf9/go.mod h1:PpMmPfPKO9nKJ/psF49ESTAGQSdfXxlg1otPbEB2nOw=
-github.com/marten-seemann/qtls v0.2.3/go.mod h1:xzjG7avBwGGbdZ8dTGxlBnLArsVKLvwmjgmPuiQEcYk=
 github.com/mattn/go-colorable v0.1.12 h1:jF+Du6AlPIjs2BiUiQlKOX0rt3SujHxPnksPKZbaA40=
 github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
 github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
@@ -54,74 +50,49 @@ github.com/miekg/dns v1.1.50/go.mod h1:e3IlAVfNqAllflbibAZEWOXOQ+Ynzk/dDozDxY7Xn
 github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
 github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
 github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0=
 github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU=
-github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
 github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
 github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY=
-github.com/pion/datachannel v1.4.21/go.mod h1:oiNyP4gHx2DIwRzX/MFyH0Rz/Gz05OgBlayAI2hAWjg=
 github.com/pion/datachannel v1.5.2 h1:piB93s8LGmbECrpO84DnkIVWasRMk3IimbcXkTQLE6E=
 github.com/pion/datachannel v1.5.2/go.mod h1:FTGQWaHrdCwIJ1rw6xBIfZVkslikjShim5yr05XFuCQ=
-github.com/pion/dtls/v2 v2.0.1/go.mod h1:uMQkz2W0cSqY00xav7WByQ4Hb+18xeQh2oH2fRezr5U=
-github.com/pion/dtls/v2 v2.0.2/go.mod h1:27PEO3MDdaCfo21heT59/vsdmZc0zMt9wQPcSlLu/1I=
 github.com/pion/dtls/v2 v2.1.3/go.mod h1:o6+WvyLDAlXF7YiPB/RlskRoeK+/JtuaZa5emwQcWus=
 github.com/pion/dtls/v2 v2.1.5 h1:jlh2vtIyUBShchoTDqpCCqiYCyRFJ/lvf/gQ8TALs+c=
 github.com/pion/dtls/v2 v2.1.5/go.mod h1:BqCE7xPZbPSubGasRoDFJeTsyJtdD1FanJYL0JGheqY=
-github.com/pion/ice v0.7.18 h1:KbAWlzWRUdX9SmehBh3gYpIFsirjhSQsCw6K2MjYMK0=
-github.com/pion/ice v0.7.18/go.mod h1:+Bvnm3nYC6Nnp7VV6glUkuOfToB/AtMRZpOU8ihuf4c=
 github.com/pion/ice/v2 v2.2.6 h1:R/vaLlI1J2gCx141L5PEwtuGAGcyS6e7E0hDeJFq5Ig=
 github.com/pion/ice/v2 v2.2.6/go.mod h1:SWuHiOGP17lGromHTFadUe1EuPgFh/oCU6FCMZHooVE=
 github.com/pion/interceptor v0.1.11 h1:00U6OlqxA3FFB50HSg25J/8cWi7P6FbSzw4eFn24Bvs=
 github.com/pion/interceptor v0.1.11/go.mod h1:tbtKjZY14awXd7Bq0mmWvgtHB5MDaRN7HV3OZ/uy7s8=
 github.com/pion/logging v0.2.2 h1:M9+AIj/+pxNsDfAT64+MAVgJO0rsyLnoJKCqf//DoeY=
 github.com/pion/logging v0.2.2/go.mod h1:k0/tDVsRCX2Mb2ZEmTqNa7CWsQPc+YYCB7Q+5pahoms=
-github.com/pion/mdns v0.0.4/go.mod h1:R1sL0p50l42S5lJs91oNdUL58nm0QHrhxnSegr++qC0=
 github.com/pion/mdns v0.0.5 h1:Q2oj/JB3NqfzY9xGZ1fPzZzK7sDSD8rZPOvcIQ10BCw=
 github.com/pion/mdns v0.0.5/go.mod h1:UgssrvdD3mxpi8tMxAXbsppL3vJ4Jipw1mTCW+al01g=
-github.com/pion/quic v0.1.1/go.mod h1:zEU51v7ru8Mp4AUBJvj6psrSth5eEFNnVQK5K48oV3k=
-github.com/pion/randutil v0.0.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8=
 github.com/pion/randutil v0.1.0 h1:CFG1UdESneORglEsnimhUjf33Rwjubwj6xfiOXBa3mA=
 github.com/pion/randutil v0.1.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8=
-github.com/pion/rtcp v1.2.3/go.mod h1:zGhIv0RPRF0Z1Wiij22pUt5W/c9fevqSzT4jje/oK7I=
 github.com/pion/rtcp v1.2.9 h1:1ujStwg++IOLIEoOiIQ2s+qBuJ1VN81KW+9pMPsif+U=
 github.com/pion/rtcp v1.2.9/go.mod h1:qVPhiCzAm4D/rxb6XzKeyZiQK69yJpbUDJSF7TgrqNo=
-github.com/pion/rtp v1.6.0/go.mod h1:QgfogHsMBVE/RFNno467U/KBqfUywEH+HK+0rtnwsdI=
 github.com/pion/rtp v1.7.13 h1:qcHwlmtiI50t1XivvoawdCGTP4Uiypzfrsap+bijcoA=
 github.com/pion/rtp v1.7.13/go.mod h1:bDb5n+BFZxXx0Ea7E5qe+klMuqiBrP+w8XSjiWtCUko=
-github.com/pion/sctp v1.7.10/go.mod h1:EhpTUQu1/lcK3xI+eriS6/96fWetHGCvBi9MSsnaBN0=
 github.com/pion/sctp v1.8.0/go.mod h1:xFe9cLMZ5Vj6eOzpyiKjT9SwGM4KpK/8Jbw5//jc+0s=
 github.com/pion/sctp v1.8.2 h1:yBBCIrUMJ4yFICL3RIvR4eh/H2BTTvlligmSTy+3kiA=
 github.com/pion/sctp v1.8.2/go.mod h1:xFe9cLMZ5Vj6eOzpyiKjT9SwGM4KpK/8Jbw5//jc+0s=
-github.com/pion/sdp/v2 v2.4.0/go.mod h1:L2LxrOpSTJbAns244vfPChbciR/ReU1KWfG04OpkR7E=
 github.com/pion/sdp/v3 v3.0.5 h1:ouvI7IgGl+V4CrqskVtr3AaTrPvPisEOxwgpdktctkU=
 github.com/pion/sdp/v3 v3.0.5/go.mod h1:iiFWFpQO8Fy3S5ldclBkpXqmWy02ns78NOKoLLL0YQw=
-github.com/pion/srtp v1.5.1 h1:9Q3jAfslYZBt+C69SI/ZcONJh9049JUHZWYRRf5KEKw=
-github.com/pion/srtp v1.5.1/go.mod h1:B+QgX5xPeQTNc1CJStJPHzOlHK66ViMDWTT0HZTCkcA=
-github.com/pion/srtp/v2 v2.0.9/go.mod h1:5TtM9yw6lsH0ppNCehB/EjEUli7VkUgKSPJqWVqbhQ4=
 github.com/pion/srtp/v2 v2.0.10 h1:b8ZvEuI+mrL8hbr/f1YiJFB34UMrOac3R3N1yq2UN0w=
 github.com/pion/srtp/v2 v2.0.10/go.mod h1:XEeSWaK9PfuMs7zxXyiN252AHPbH12NX5q/CFDWtUuA=
 github.com/pion/stun v0.3.5 h1:uLUCBCkQby4S1cf6CGuR9QrVOKcvUwFeemaC865QHDg=
 github.com/pion/stun v0.3.5/go.mod h1:gDMim+47EeEtfWogA37n6qXZS88L5V6LqFcf+DZA2UA=
-github.com/pion/transport v0.6.0/go.mod h1:iWZ07doqOosSLMhZ+FXUTq+TamDoXSllxpbGcfkCmbE=
-github.com/pion/transport v0.8.10/go.mod h1:tBmha/UCjpum5hqTWhfAEs3CO4/tHSg0MYRhSzR+CZ8=
-github.com/pion/transport v0.10.0/go.mod h1:BnHnUipd0rZQyTVB2SBGojFHT9CBt5C5TcsJSQGkvSE=
-github.com/pion/transport v0.10.1/go.mod h1:PBis1stIILMiis0PewDw91WJeLJkyIMcEk+DwKOzf4A=
 github.com/pion/transport v0.12.2/go.mod h1:N3+vZQD9HlDP5GWkZ85LohxNsDcNgofQmyL6ojX5d8Q=
 github.com/pion/transport v0.12.3/go.mod h1:OViWW9SP2peE/HbwBvARicmAVnesphkNkCVZIWJ6q9A=
 github.com/pion/transport v0.13.0/go.mod h1:yxm9uXpK9bpBBWkITk13cLo1y5/ur5VQpG22ny6EP7g=
 github.com/pion/transport v0.13.1 h1:/UH5yLeQtwm2VZIPjxwnNFxjS4DFhyLfS4GlfuKUzfA=
 github.com/pion/transport v0.13.1/go.mod h1:EBxbqzyv+ZrmDb82XswEE0BjfQFtuw1Nu6sjnjWCsGg=
-github.com/pion/turn/v2 v2.0.4/go.mod h1:1812p4DcGVbYVBTiraUmP50XoKye++AMkbfp+N27mog=
 github.com/pion/turn/v2 v2.0.8 h1:KEstL92OUN3k5k8qxsXHpr7WWfrdp7iJZHx99ud8muw=
 github.com/pion/turn/v2 v2.0.8/go.mod h1:+y7xl719J8bAEVpSXBXvTxStjJv3hbz9YFflvkpcGPw=
-github.com/pion/udp v0.1.0/go.mod h1:BPELIjbwE9PRbd/zxI/KYBnbo7B6+oA6YuEaNE8lths=
 github.com/pion/udp v0.1.1 h1:8UAPvyqmsxK8oOjloDk4wUt63TzFe9WEJkg5lChlj7o=
 github.com/pion/udp v0.1.1/go.mod h1:6AFo+CMdKQm7UiA0eUPA8/eVCTx8jBIITLZHc9DWX5M=
-github.com/pion/webrtc/v2 v2.2.26/go.mod h1:XMZbZRNHyPDe1gzTIHFcQu02283YO45CbiwFgKvXnmc=
-github.com/pion/webrtc/v3 v3.1.42/go.mod h1:ffD9DulDrPxyWvDPUIPAOSAWx9GUlOExiJPf7cCcMLA=
 github.com/pion/webrtc/v3 v3.1.43 h1:YT3ZTO94UT4kSBvZnRAH82+0jJPUruiKr9CEstdlQzk=
 github.com/pion/webrtc/v3 v3.1.43/go.mod h1:G/J8k0+grVsjC/rjCZ24AKoCCxcFFODgh7zThNZGs0M=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
@@ -132,7 +103,6 @@ github.com/rs/zerolog v1.27.0 h1:1T7qCieN22GVc8S4Q2yuexzBb1EqjbgjSH9RohbMjKs=
 github.com/rs/zerolog v1.27.0/go.mod h1:7frBqO0oezxmnO7GF86FY++uy8I0Tk/If5ni1G9Qc0U=
 github.com/sclevine/agouti v3.0.0+incompatible/go.mod h1:b4WX9W9L1sfQKXeJf1mUTLZKJ48R1S7H23Ji7oFO5Bw=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
@@ -145,28 +115,21 @@ github.com/xiam/to v0.0.0-20200126224905-d60d31e03561 h1:SVoNK97S6JlaYlHcaC+79tg
 github.com/xiam/to v0.0.0-20200126224905-d60d31e03561/go.mod h1:cqbG7phSzrbdg3aj+Kn63bpVruzwDZi58CpxlZkjwzw=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
-golang.org/x/crypto v0.0.0-20190228161510-8dd112bcdc25/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200602180216-279210d13fed/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20200709230013-948cd5f35899/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20220131195533-30dcbda58838/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/crypto v0.0.0-20220427172511-eb4f295cb31f/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/crypto v0.0.0-20220516162934-403b01795ae8 h1:y+mHpWoQJNAHt26Nhh6JP7hvM71IRZureyvZhoVALIs=
 golang.org/x/crypto v0.0.0-20220516162934-403b01795ae8/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.4.2 h1:Gz96sIWK3OalVv/I/qNygP42zyoKp3xptRVCWRFEBvo=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 h1:6zppjxzCulZykYSLyVDYbneBfbaBIQPYMevg0bEwv2s=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20191126235420-ef20fe5d7933/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200602114024-627f9648deb9/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20201201195509-5d6afe98e0b7/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
@@ -190,13 +153,11 @@ golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cO
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190228124157-a34e9553db1e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200724161237-0e2f3a69832c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -210,8 +171,9 @@ golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220608164250-635b8c9b7f68/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220622161953-175b2fd9d664 h1:wEZYwx+kK+KlZ0hpvP2Ls1Xr4+RWnlzGFwPP0aiDjIU=
 golang.org/x/sys v0.0.0-20220622161953-175b2fd9d664/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab h1:2QkjZIsXupsJbJIdSjjUOgWK3aEtzyuh2mPt3l/CkeU=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -222,12 +184,12 @@ golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.1.6-0.20210726203631-07bc1bf47fb2 h1:BonxutuHCTL0rBDnZlKjpGIQFTjyUVTexFOdWkB6Fg0=
 golang.org/x/tools v0.1.6-0.20210726203631-07bc1bf47fb2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.1.11 h1:loJ25fNOEhSXfHrpoGj91eCUThwdNX6u24rO1xnNteY=
+golang.org/x/tools v0.1.11/go.mod h1:SgwaegtQh8clINPpECJMqnxLv9I09HLqnW3RMqW0CA4=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
 google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
@@ -242,7 +204,6 @@ gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogR
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
-gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

hardware.Dockerfile

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

main.go

@@ -9,6 +9,7 @@ import (
 	"github.com/AlexxIT/go2rtc/cmd/ffmpeg"
 	"github.com/AlexxIT/go2rtc/cmd/hass"
 	"github.com/AlexxIT/go2rtc/cmd/homekit"
+	"github.com/AlexxIT/go2rtc/cmd/http"
 	"github.com/AlexxIT/go2rtc/cmd/ivideon"
 	"github.com/AlexxIT/go2rtc/cmd/mjpeg"
 	"github.com/AlexxIT/go2rtc/cmd/mp4"
@@ -40,6 +41,7 @@ func main() {
 	webrtc.Init()
 	mp4.Init()
 	mjpeg.Init()
+	http.Init()
 
 	srtp.Init()
 	homekit.Init()

pkg/fake/producer.go

@@ -24,7 +24,7 @@ func (p *Producer) GetTrack(media *streamer.Media, codec *streamer.Codec) *strea
 		panic("you shall not pass!")
 	}
 
-	track := &streamer.Track{Codec: codec, Direction: media.Direction}
+	track := streamer.NewTrack(codec, media.Direction)
 
 	switch media.Direction {
 	case streamer.DirectionSendonly:

pkg/h264/rtp.go

@@ -36,6 +36,7 @@ func RTPDepay(track *streamer.Track) streamer.WrapperFunc {
 			}
 
 			if len(buf) == 0 {
+				for {
 					// Amcrest IP4M-1051: 9, 7, 8, 6, 28...
 					// Amcrest IP4M-1051: 9, 6, 1
 					switch NALUType(payload) {
@@ -52,10 +53,9 @@ func RTPDepay(track *streamer.Track) streamer.WrapperFunc {
 						}
 
 						payload = payload[i:]
-
+						continue
-					if NALUType(payload) == NALUTypeIFrame {
-						buf = append(buf, ps...)
 					}
+					break
 				}
 			}
 

pkg/h265/README.md

@@ -1,3 +1,4 @@
 ## Useful links
 
 - https://datatracker.ietf.org/doc/html/rfc7798
+- [Add initial support for WebRTC HEVC](https://trac.webkit.org/changeset/259452/webkit)

pkg/h265/helper.go

@@ -2,19 +2,57 @@ package h265
 
 import (
 	"encoding/base64"
+	"encoding/binary"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
 )
 
 const (
-	NALUnitTypeIFrame = 19
+	NALUTypePFrame  = 1
+	NALUTypeIFrame  = 19
+	NALUTypeIFrame2 = 20
+	NALUTypeIFrame3 = 21
+	NALUTypeVPS     = 32
+	NALUTypeSPS     = 33
+	NALUTypePPS     = 34
+	NALUTypeFU      = 49
 )
 
-func NALUnitType(b []byte) byte {
+func NALUType(b []byte) byte {
-	return b[4] >> 1
+	return (b[4] >> 1) & 0x3F
 }
 
 func IsKeyframe(b []byte) bool {
-	return NALUnitType(b) == NALUnitTypeIFrame
+	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) {

pkg/h265/rtp.go

@@ -1,84 +1,66 @@
 package h265
 
 import (
+	"encoding/binary"
 	"github.com/AlexxIT/go2rtc/pkg/h264"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
-	"github.com/deepch/vdk/codec/h265parser"
 	"github.com/pion/rtp"
 )
 
 func RTPDepay(track *streamer.Track) streamer.WrapperFunc {
-	vps, sps, pps := GetParameterSet(track.Codec.FmtpLine)
+	//vps, sps, pps := GetParameterSet(track.Codec.FmtpLine)
+	//ps := h264.EncodeAVC(vps, sps, pps)
 
-	var buffer []byte
+	buf := make([]byte, 0, 512*1024) // 512K
+	var nuStart int
 
 	return func(push streamer.WriterFunc) streamer.WriterFunc {
 		return func(packet *rtp.Packet) error {
-			nut := (packet.Payload[0] >> 1) & 0x3f
-			//fmt.Printf(
-			//	"[RTP] codec: %s, nalu: %2d, size: %6d, ts: %10d, pt: %2d, ssrc: %d, seq: %d\n",
-			//	track.Codec.Name, nut, len(packet.Payload), packet.Timestamp,
-			//	packet.PayloadType, packet.SSRC, packet.SequenceNumber,
-			//)
-
-			switch nut {
-			case h265parser.NAL_UNIT_UNSPECIFIED_49:
 			data := packet.Payload
+			nuType := (data[0] >> 1) & 0x3F
+			//log.Printf("[RTP] codec: %s, nalu: %2d, size: %6d, ts: %10d, pt: %2d, ssrc: %d, seq: %d, %v", track.Codec.Name, nuType, len(packet.Payload), packet.Timestamp, packet.PayloadType, packet.SSRC, packet.SequenceNumber, packet.Marker)
+
+			if nuType == NALUTypeFU {
 				switch data[2] >> 6 {
 				case 2: // begin
-					buffer = []byte{
+					nuType = data[2] & 0x3F
-						(data[0] & 0x81) | (data[2] & 0x3f << 1), data[1],
+
-					}
+					// push PS data before keyframe
-					buffer = append(buffer, data[3:]...)
+					//if len(buf) == 0 && nuType >= 19 && nuType <= 21 {
+					//	buf = append(buf, ps...)
+					//}
+
+					nuStart = len(buf)
+					buf = append(buf, 0, 0, 0, 0) // NAL unit size
+					buf = append(buf, (data[0]&0x81)|(nuType<<1), data[1])
+					buf = append(buf, data[3:]...)
 					return nil
 				case 0: // continue
-					buffer = append(buffer, data[3:]...)
+					buf = append(buf, data[3:]...)
 					return nil
 				case 1: // end
-					packet.Payload = append(buffer, data[3:]...)
+					buf = append(buf, data[3:]...)
+					binary.BigEndian.PutUint32(buf[nuStart:], uint32(len(buf)-nuStart-4))
 				}
-			case h265parser.NAL_UNIT_VPS:
+			} else {
-				vps = packet.Payload
+				nuStart = len(buf)
+				buf = append(buf, 0, 0, 0, 0) // NAL unit size
+				buf = append(buf, data...)
+				binary.BigEndian.PutUint32(buf[nuStart:], uint32(len(data)))
+			}
+
+			// collect all NAL Units for Access Unit
+			if !packet.Marker {
 				return nil
-			case h265parser.NAL_UNIT_SPS:
-				sps = packet.Payload
-				return nil
-			case h265parser.NAL_UNIT_PPS:
-				pps = packet.Payload
-				return nil
-			default:
-				//panic("not implemented")
 			}
 
-			var clone rtp.Packet
+			//log.Printf("[HEVC] %v, len: %d", Types(buf), len(buf))
 
-			nut = (packet.Payload[0] >> 1) & 0x3f
+			clone := *packet
-			if nut >= h265parser.NAL_UNIT_CODED_SLICE_BLA_W_LP && nut <= h265parser.NAL_UNIT_CODED_SLICE_CRA {
-				clone = *packet
 			clone.Version = h264.RTPPacketVersionAVC
-				clone.Payload = h264.EncodeAVC(vps)
+			clone.Payload = buf
-				if err := push(&clone); err != nil {
-					return err
-				}
 
-				clone = *packet
+			buf = buf[:0]
-				clone.Version = h264.RTPPacketVersionAVC
-				clone.Payload = h264.EncodeAVC(sps)
-				if err := push(&clone); err != nil {
-					return err
-				}
-
-				clone = *packet
-				clone.Version = h264.RTPPacketVersionAVC
-				clone.Payload = h264.EncodeAVC(pps)
-				if err := push(&clone); err != nil {
-					return err
-				}
-			}
-
-			clone = *packet
-			clone.Version = h264.RTPPacketVersionAVC
-			clone.Payload = h264.EncodeAVC(packet.Payload)
 
 			return push(&clone)
 		}
@@ -86,68 +68,80 @@ func RTPDepay(track *streamer.Track) streamer.WrapperFunc {
 }
 
 // SafariPay - generate Safari friendly payload for H265
+// https://github.com/AlexxIT/Blog/issues/5
 func SafariPay(mtu uint16) streamer.WrapperFunc {
 	sequencer := rtp.NewRandomSequencer()
 	size := int(mtu - 12) // rtp.Header size
 
-	var buffer []byte
-
 	return func(push streamer.WriterFunc) streamer.WriterFunc {
 		return func(packet *rtp.Packet) error {
 			if packet.Version != h264.RTPPacketVersionAVC {
 				return push(packet)
 			}
 
-			data := packet.Payload
+			// protect original packets from modification
-			data[0] = 0
+			au := make([]byte, len(packet.Payload))
-			data[1] = 0
+			copy(au, packet.Payload)
-			data[2] = 0
-			data[3] = 1
 
 			var start byte
 
-			nut := (data[4] >> 1) & 0b111111
+			for i := 0; i < len(au); {
-			//fmt.Printf("[H265] nut: %2d, size: %6d, data: %16x\n", nut, len(data), data[4:20])
+				size := int(binary.BigEndian.Uint32(au[i:])) + 4
-			switch {
+
-			case nut >= h265parser.NAL_UNIT_VPS && nut <= h265parser.NAL_UNIT_PPS:
+				// convert AVC to Annex-B
-				buffer = append(buffer, data...)
+				au[i] = 0
-				return nil
+				au[i+1] = 0
-			case nut >= h265parser.NAL_UNIT_CODED_SLICE_BLA_W_LP && nut <= h265parser.NAL_UNIT_CODED_SLICE_CRA:
+				au[i+2] = 0
-				buffer = append([]byte{3}, buffer...)
+				au[i+3] = 1
-				data = append(buffer, data...)
+
-				start = 1
+				switch NALUType(au[i:]) {
+				case NALUTypeIFrame, NALUTypeIFrame2, NALUTypeIFrame3:
+					start = 3
 				default:
-				data = append([]byte{2}, data...)
+					if start == 0 {
-				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
 				}
 
-			for len(data) > size {
 				clone := rtp.Packet{
 					Header: rtp.Header{
 						Version:        2,
-						Marker:         false,
+						Marker:         au == nil,
 						SequenceNumber: sequencer.NextSequenceNumber(),
 						Timestamp:      packet.Timestamp,
 					},
-					Payload: data[:size],
+					Payload: b,
 				}
 				if err := push(&clone); err != nil {
 					return err
 				}
 
-				data = append([]byte{start}, data[size:]...)
+				b = b[:1] // clear buffer
 			}
 
-			clone := rtp.Packet{
+			return nil
-				Header: rtp.Header{
-					Version:        2,
-					Marker:         true,
-					SequenceNumber: sequencer.NextSequenceNumber(),
-					Timestamp:      packet.Timestamp,
-				},
-				Payload: data,
-			}
-			return push(&clone)
 		}
 	}
 }

pkg/homekit/client.go

@@ -75,7 +75,7 @@ func (c *Client) GetTrack(media *streamer.Media, codec *streamer.Codec) *streame
 		}
 	}
 
-	track := &streamer.Track{Codec: codec, Direction: media.Direction}
+	track := streamer.NewTrack(codec, media.Direction)
 	c.tracks = append(c.tracks, track)
 	return track
 }

pkg/httpflv/httpflv.go

@@ -22,13 +22,17 @@ func Dial(uri string) (*Conn, error) {
 		return nil, err
 	}
 
+	return Accept(res)
+}
+
+func Accept(res *http.Response) (*Conn, error) {
 	c := Conn{
 		conn:   res.Body,
 		reader: bufio.NewReaderSize(res.Body, pio.RecommendBufioSize),
 		buf:    make([]byte, 256),
 	}
 
-	if _, err = io.ReadFull(c.reader, c.buf[:flvio.FileHeaderLength]); err != nil {
+	if _, err := io.ReadFull(c.reader, c.buf[:flvio.FileHeaderLength]); err != nil {
 		return nil, err
 	}
 

pkg/ivideon/client.go

@@ -165,7 +165,7 @@ func (c *Client) getTracks() error {
 					Name:        streamer.CodecH264,
 					ClockRate:   90000,
 					FmtpLine:    "profile-level-id=" + msg.CodecString[i+1:],
-					PayloadType: streamer.PayloadTypeMP4,
+					PayloadType: streamer.PayloadTypeRAW,
 				}
 
 				i = bytes.Index(msg.Data, []byte("avcC")) - 4
@@ -192,10 +192,7 @@ func (c *Client) getTracks() error {
 				}
 				c.medias = append(c.medias, media)
 
-				track := &streamer.Track{
+				track := streamer.NewTrack(codec, streamer.DirectionSendonly)
-					Direction: streamer.DirectionSendonly,
-					Codec:     codec,
-				}
 				c.tracks[msg.TrackID] = track
 
 			case "mp4a": // mp4a.40.2

pkg/mjpeg/README.md

@@ -2,3 +2,4 @@
 
 - https://www.rfc-editor.org/rfc/rfc2435
 - https://github.com/GStreamer/gst-plugins-good/blob/master/gst/rtp/gstrtpjpegdepay.c
+- https://mjpeg.sanford.io/

pkg/mjpeg/client.go

@@ -0,0 +1,152 @@
+package mjpeg
+
+import (
+	"bufio"
+	"errors"
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/AlexxIT/go2rtc/pkg/tcp"
+	"github.com/pion/rtp"
+	"io"
+	"net/http"
+	"net/textproto"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type Client struct {
+	streamer.Element
+
+	UserAgent  string
+	RemoteAddr string
+
+	closed bool
+	res    *http.Response
+
+	track *streamer.Track
+}
+
+func NewClient(res *http.Response) *Client {
+	codec := &streamer.Codec{
+		Name: streamer.CodecJPEG, ClockRate: 90000, PayloadType: streamer.PayloadTypeRAW,
+	}
+	return &Client{
+		res:   res,
+		track: streamer.NewTrack(codec, streamer.DirectionSendonly),
+	}
+}
+
+func (c *Client) GetMedias() []*streamer.Media {
+	return []*streamer.Media{{
+		Kind:      streamer.KindVideo,
+		Direction: streamer.DirectionSendonly,
+		Codecs:    []*streamer.Codec{c.track.Codec},
+	}}
+}
+
+func (c *Client) GetTrack(media *streamer.Media, codec *streamer.Codec) *streamer.Track {
+	return c.track
+}
+
+func (c *Client) Start() error {
+	ct := c.res.Header.Get("Content-Type")
+
+	if ct == "image/jpeg" {
+		return c.startJPEG()
+	}
+
+	// added in go1.18
+	if _, s, ok := strings.Cut(ct, "boundary="); ok {
+		return c.startMJPEG(s)
+	}
+
+	return errors.New("wrong Content-Type: " + ct)
+}
+
+func (c *Client) Stop() error {
+	c.closed = true
+	return nil
+}
+
+func (c *Client) startJPEG() error {
+	buf, err := io.ReadAll(c.res.Body)
+	if err != nil {
+		return err
+	}
+
+	packet := &rtp.Packet{Header: rtp.Header{Timestamp: now()}, Payload: buf}
+	_ = c.track.WriteRTP(packet)
+
+	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)
+		}
+
+		buf, err = io.ReadAll(res.Body)
+		if err != nil {
+			return err
+		}
+
+		packet = &rtp.Packet{Header: rtp.Header{Timestamp: now()}, Payload: buf}
+		_ = c.track.WriteRTP(packet)
+	}
+
+	return nil
+}
+
+func (c *Client) startMJPEG(boundary string) error {
+	boundary = "--" + boundary
+
+	r := bufio.NewReader(c.res.Body)
+	tp := textproto.NewReader(r)
+
+	for !c.closed {
+		s, err := tp.ReadLine()
+		if err != nil {
+			return err
+		}
+		if s != boundary {
+			return errors.New("wrong boundary: " + s)
+		}
+
+		header, err := tp.ReadMIMEHeader()
+		if err != nil {
+			return err
+		}
+
+		s = header.Get("Content-Length")
+		if s == "" {
+			return errors.New("no content length")
+		}
+
+		size, err := strconv.Atoi(s)
+		if err != nil {
+			return err
+		}
+
+		buf := make([]byte, size)
+		if _, err = io.ReadFull(r, buf); err != nil {
+			return err
+		}
+
+		packet := &rtp.Packet{Header: rtp.Header{Timestamp: now()}, Payload: buf}
+		_ = c.track.WriteRTP(packet)
+
+		if _, err = r.Discard(2); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func now() uint32 {
+	return uint32(time.Now().UnixMilli() * 90)
+}

pkg/mjpeg/consumer.go

@@ -26,70 +26,15 @@ func (c *Consumer) GetMedias() []*streamer.Media {
 }
 
 func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *streamer.Track {
-	var header, payload []byte
-
 	push := func(packet *rtp.Packet) error {
-		//fmt.Printf(
+		c.Fire(packet.Payload)
-		//	"[RTP] codec: %s, size: %6d, ts: %10d, pt: %2d, ssrc: %d, seq: %d, mark: %v\n",
-		//	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 header == nil {
-			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 2560x1920 and 2560x1440
-			if w == 512 && (h == 1920 || h == 1440) {
-				w = 2560
-			}
-
-			//fmt.Printf("t: %d, q: %d, w: %d, h: %d\n", t, q, w, h)
-			header = MakeHeaders(t, w, h, lqt, cqt)
-		}
-
-		// 3.1.9.  JPEG Payload
-		payload = append(payload, b...)
-
-		if packet.Marker {
-			b = append(header, payload...)
-			if end := b[len(b)-2:]; end[0] != 0xFF && end[1] != 0xD9 {
-				b = append(b, 0xFF, 0xD9)
-			}
-			c.Fire(b)
-
-			header = nil
-			payload = nil
-		}
-
 		return nil
 	}
+
+	if track.Codec.IsRTP() {
+		wrapper := RTPDepay(track)
+		push = wrapper(push)
+	}
+
 	return track.Bind(push)
 }

pkg/mjpeg/rfc2435.go

@@ -138,9 +138,9 @@ var chm_ac_symbols = []byte{
 	0xf9, 0xfa,
 }
 
-func MakeHeaders(t byte, w, h uint16, lqt, cqt []byte) []byte {
+func MakeHeaders(p []byte, t byte, w, h uint16, lqt, cqt []byte) []byte {
 	// Appendix A from https://www.rfc-editor.org/rfc/rfc2435
-	p := []byte{0xFF, 0xD8}
+	p = append(p, 0xFF, 0xD8)
 
 	p = MakeQuantHeader(p, lqt, 0)
 	p = MakeQuantHeader(p, cqt, 1)

pkg/mjpeg/rtp.go

@@ -0,0 +1,212 @@
+package mjpeg
+
+import (
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/pion/rtp"
+)
+
+func RTPDepay(track *streamer.Track) streamer.WrapperFunc {
+	buf := make([]byte, 0, 512*1024) // 512K
+
+	return func(push streamer.WriterFunc) streamer.WriterFunc {
+		return func(packet *rtp.Packet) error {
+			//log.Printf("[RTP] codec: %s, 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 2560x1920 and 2560x1440
+				if w == 512 && (h == 1920 || h == 1440) {
+					w = 2560
+				}
+
+				//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 nil
+			}
+
+			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
+
+			return push(&clone)
+		}
+	}
+}
+
+func RTPPay() streamer.WrapperFunc {
+	return func(push streamer.WriterFunc) streamer.WriterFunc {
+		return func(packet *rtp.Packet) error {
+			return nil
+		}
+	}
+}
+
+//func RTPPay() streamer.WrapperFunc {
+//	const packetSize = 1436
+//
+//	sequencer := rtp.NewRandomSequencer()
+//
+//	return func(push streamer.WriterFunc) streamer.WriterFunc {
+//		return func(packet *rtp.Packet) error {
+//			// reincode image to more common form
+//			img, err := jpeg.Decode(bytes.NewReader(packet.Payload))
+//			if err != nil {
+//				return 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 err
+//			}
+//
+//			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
+//
+//			p := buf.Bytes()
+//
+//			for jpgData == nil {
+//				// 2 bytes h1
+//				if p[0] != 0xFF {
+//					return nil
+//				}
+//
+//				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 nil
+//					}
+//					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,
+//				}
+//				if err := push(&clone); err != nil {
+//					return err
+//				}
+//			}
+//
+//			return nil
+//		}
+//	}
+//}

pkg/mp4/consumer.go

@@ -12,17 +12,29 @@ import (
 type Consumer struct {
 	streamer.Element
 
+	Medias     []*streamer.Media
 	UserAgent  string
 	RemoteAddr string
 
 	muxer  *Muxer
 	codecs []*streamer.Codec
-	start  bool
+	wait   byte
 
 	send int
 }
 
+const (
+	waitNone byte = iota
+	waitKeyframe
+	waitInit
+)
+
 func (c *Consumer) GetMedias() []*streamer.Media {
+	if c.Medias != nil {
+		return c.Medias
+	}
+
+	// default medias
 	return []*streamer.Media{
 		{
 			Kind:      streamer.KindVideo,
@@ -49,14 +61,19 @@ func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 	codec := track.Codec
 	switch codec.Name {
 	case streamer.CodecH264:
+		c.wait = waitInit
+
 		push := func(packet *rtp.Packet) error {
 			if packet.Version != h264.RTPPacketVersionAVC {
 				return nil
 			}
 
-			if !c.start {
+			if c.wait != waitNone {
+				if c.wait == waitInit || !h264.IsKeyframe(packet.Payload) {
 					return nil
 				}
+				c.wait = waitNone
+			}
 
 			buf := c.muxer.Marshal(trackID, packet)
 			c.send += len(buf)
@@ -66,24 +83,29 @@ func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 		}
 
 		var wrapper streamer.WrapperFunc
-		if codec.IsMP4() {
+		if codec.IsRTP() {
-			wrapper = h264.RepairAVC(track)
-		} else {
 			wrapper = h264.RTPDepay(track)
+		} else {
+			wrapper = h264.RepairAVC(track)
 		}
 		push = wrapper(push)
 
 		return track.Bind(push)
 
 	case streamer.CodecH265:
+		c.wait = waitInit
+
 		push := func(packet *rtp.Packet) error {
 			if packet.Version != h264.RTPPacketVersionAVC {
 				return nil
 			}
 
-			if !c.start {
+			if c.wait != waitNone {
+				if c.wait == waitInit || !h265.IsKeyframe(packet.Payload) {
 					return nil
 				}
+				c.wait = waitNone
+			}
 
 			buf := c.muxer.Marshal(trackID, packet)
 			c.send += len(buf)
@@ -92,7 +114,7 @@ func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 			return nil
 		}
 
-		if !codec.IsMP4() {
+		if codec.IsRTP() {
 			wrapper := h265.RTPDepay(track)
 			push = wrapper(push)
 		}
@@ -101,7 +123,7 @@ func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 
 	case streamer.CodecAAC:
 		push := func(packet *rtp.Packet) error {
-			if !c.start {
+			if c.wait != waitNone {
 				return nil
 			}
 
@@ -112,7 +134,7 @@ func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 			return nil
 		}
 
-		if !codec.IsMP4() {
+		if codec.IsRTP() {
 			wrapper := aac.RTPDepay(track)
 			push = wrapper(push)
 		}
@@ -133,7 +155,9 @@ func (c *Consumer) Init() ([]byte, error) {
 }
 
 func (c *Consumer) Start() {
-	c.start = true
+	if c.wait == waitInit {
+		c.wait = waitKeyframe
+	}
 }
 
 //

pkg/mp4/muxer.go

@@ -3,7 +3,6 @@ package mp4
 import (
 	"encoding/binary"
 	"encoding/hex"
-	"fmt"
 	"github.com/AlexxIT/go2rtc/pkg/h264"
 	"github.com/AlexxIT/go2rtc/pkg/h265"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
@@ -20,8 +19,6 @@ type Muxer struct {
 	fragIndex uint32
 	dts       []uint64
 	pts       []uint32
-	//data      []byte
-	//total     int
 }
 
 func (m *Muxer) MimeType(codecs []*streamer.Codec) string {
@@ -36,8 +33,9 @@ func (m *Muxer) MimeType(codecs []*streamer.Codec) string {
 		case streamer.CodecH264:
 			s += "avc1." + h264.GetProfileLevelID(codec.FmtpLine)
 		case streamer.CodecH265:
-			// +Safari +Chrome +Edge -iOS15 -Android13
+			// H.265 profile=main level=5.1
-			s += "hvc1.1.6.L93.B0" // hev1.1.6.L93.B0
+			// hvc1 - supported in Safari, hev1 - doesn't, both supported in Chrome
+			s += "hvc1.1.6.L153.B0"
 		case streamer.CodecAAC:
 			s += "mp4a.40.2"
 		}
@@ -97,7 +95,10 @@ func (m *Muxer) GetInit(codecs []*streamer.Codec) ([]byte, error) {
 		case streamer.CodecH265:
 			vps, sps, pps := h265.GetParameterSet(codec.FmtpLine)
 			if sps == nil {
-				return nil, fmt.Errorf("empty SPS: %#v", codec)
+				// some dummy SPS and PPS not a problem
+				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}
+				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}
+				pps = []byte{0x44, 0x01, 0xc0, 0x73, 0xc0, 0x4c, 0x90}
 			}
 
 			codecData, err := h265parser.NewCodecDataFromVPSAndSPSAndPPS(vps, sps, pps)
@@ -182,10 +183,13 @@ func (m *Muxer) GetInit(codecs []*streamer.Codec) ([]byte, error) {
 	return append(FTYP(), data...), nil
 }
 
-//func (m *Muxer) Rewind() {
+func (m *Muxer) Reset() {
-//	m.dts = 0
+	m.fragIndex = 0
-//	m.pts = 0
+	for i := range m.dts {
-//}
+		m.dts[i] = 0
+		m.pts[i] = 0
+	}
+}
 
 func (m *Muxer) Marshal(trackID byte, packet *rtp.Packet) []byte {
 	run := &mp4fio.TrackFragRun{
@@ -215,15 +219,16 @@ func (m *Muxer) Marshal(trackID byte, packet *rtp.Packet) []byte {
 	}
 
 	entry := mp4io.TrackFragRunEntry{
-		//Duration: 90000,
 		Size: uint32(len(packet.Payload)),
 	}
 
 	newTime := packet.Timestamp
 	if m.pts[trackID] > 0 {
-		//m.dts += uint64(newTime - m.pts)
 		entry.Duration = newTime - m.pts[trackID]
 		m.dts[trackID] += uint64(entry.Duration)
+	} else {
+		// important, or Safari will fail with first frame
+		entry.Duration = 1
 	}
 	m.pts[trackID] = newTime
 

pkg/mp4/segment.go

@@ -7,13 +7,20 @@ import (
 	"github.com/pion/rtp"
 )
 
-type Keyframe struct {
+type Segment struct {
 	streamer.Element
 
+	Medias       []*streamer.Media
 	MimeType     string
+	OnlyKeyframe bool
 }
 
-func (c *Keyframe) GetMedias() []*streamer.Media {
+func (c *Segment) GetMedias() []*streamer.Media {
+	if c.Medias != nil {
+		return c.Medias
+	}
+
+	// default medias
 	return []*streamer.Media{
 		{
 			Kind:      streamer.KindVideo,
@@ -26,7 +33,7 @@ func (c *Keyframe) GetMedias() []*streamer.Media {
 	}
 }
 
-func (c *Keyframe) AddTrack(media *streamer.Media, track *streamer.Track) *streamer.Track {
+func (c *Segment) AddTrack(media *streamer.Media, track *streamer.Track) *streamer.Track {
 	muxer := &Muxer{}
 
 	codecs := []*streamer.Codec{track.Codec}
@@ -40,7 +47,10 @@ func (c *Keyframe) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 
 	switch track.Codec.Name {
 	case streamer.CodecH264:
-		push := func(packet *rtp.Packet) error {
+		var push streamer.WriterFunc
+
+		if c.OnlyKeyframe {
+			push = func(packet *rtp.Packet) error {
 				if !h264.IsKeyframe(packet.Payload) {
 					return nil
 				}
@@ -50,12 +60,40 @@ func (c *Keyframe) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 
 				return nil
 			}
+		} else {
+			var buf []byte
+
+			push = func(packet *rtp.Packet) error {
+				if h264.IsKeyframe(packet.Payload) {
+					// fist frame - send only IFrame
+					// other frames - send IFrame and all PFrames
+					if buf == nil {
+						buf = append(buf, init...)
+						b := muxer.Marshal(0, packet)
+						buf = append(buf, b...)
+					}
+
+					c.Fire(buf)
+
+					buf = buf[:0]
+					buf = append(buf, init...)
+					muxer.Reset()
+				}
+
+				if buf != nil {
+					b := muxer.Marshal(0, packet)
+					buf = append(buf, b...)
+				}
+
+				return nil
+			}
+		}
 
 		var wrapper streamer.WrapperFunc
-		if track.Codec.IsMP4() {
+		if track.Codec.IsRTP() {
-			wrapper = h264.RepairAVC(track)
-		} else {
 			wrapper = h264.RTPDepay(track)
+		} else {
+			wrapper = h264.RepairAVC(track)
 		}
 		push = wrapper(push)
 
@@ -73,7 +111,7 @@ func (c *Keyframe) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 			return nil
 		}
 
-		if !track.Codec.IsMP4() {
+		if track.Codec.IsRTP() {
 			wrapper := h265.RTPDepay(track)
 			push = wrapper(push)
 		}

pkg/mp4f/consumer.go

@@ -89,7 +89,7 @@ func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 			return nil
 		}
 
-		if !codec.IsMP4() {
+		if !codec.IsRAW() {
 			wrapper := h264.RTPDepay(track)
 			push = wrapper(push)
 		}

pkg/rtmp/client.go

@@ -11,7 +11,7 @@ import (
 	"github.com/deepch/vdk/codec/h264parser"
 	"github.com/deepch/vdk/format/rtmp"
 	"github.com/pion/rtp"
-	"strings"
+	"net/http"
 	"time"
 )
 
@@ -41,16 +41,20 @@ func NewClient(uri string) *Client {
 }
 
 func (c *Client) Dial() (err error) {
-	if strings.HasPrefix(c.URI, "http") {
-		c.conn, err = httpflv.Dial(c.URI)
-	} else {
 	c.conn, err = rtmp.Dial(c.URI)
-	}
-
-	if err != nil {
 	return
-	}
+}
 
+// Accept - convert http.Response to Client
+func Accept(res *http.Response) (*Client, error) {
+	conn, err := httpflv.Accept(res)
+	if err != nil {
+		return nil, err
+	}
+	return &Client{URI: res.Request.URL.String(), conn: conn}, nil
+}
+
+func (c *Client) Describe() (err error) {
 	// important to get SPS/PPS
 	streams, err := c.conn.Streams()
 	if err != nil {
@@ -73,7 +77,7 @@ func (c *Client) Dial() (err error) {
 				Name:        streamer.CodecH264,
 				ClockRate:   90000,
 				FmtpLine:    fmtp,
-				PayloadType: streamer.PayloadTypeMP4,
+				PayloadType: streamer.PayloadTypeRAW,
 			}
 
 			media := &streamer.Media{
@@ -83,9 +87,7 @@ func (c *Client) Dial() (err error) {
 			}
 			c.medias = append(c.medias, media)
 
-			track := &streamer.Track{
+			track := streamer.NewTrack(codec, media.Direction)
-				Codec: codec, Direction: media.Direction,
-			}
 			c.tracks = append(c.tracks, track)
 
 		case av.AAC:
@@ -98,7 +100,7 @@ func (c *Client) Dial() (err error) {
 				Channels:  uint16(cd.Config.ChannelConfig),
 				//  a=fmtp:97 streamtype=5;profile-level-id=1;mode=AAC-hbr;sizelength=13;indexlength=3;indexdeltalength=3;config=1588
 				FmtpLine:    "streamtype=5;profile-level-id=1;mode=AAC-hbr;sizelength=13;indexlength=3;indexdeltalength=3;config=" + hex.EncodeToString(cd.ConfigBytes),
-				PayloadType: streamer.PayloadTypeMP4,
+				PayloadType: streamer.PayloadTypeRAW,
 			}
 
 			media := &streamer.Media{
@@ -108,9 +110,7 @@ func (c *Client) Dial() (err error) {
 			}
 			c.medias = append(c.medias, media)
 
-			track := &streamer.Track{
+			track := streamer.NewTrack(codec, media.Direction)
-				Codec: codec, Direction: media.Direction,
-			}
 			c.tracks = append(c.tracks, track)
 
 		default:

pkg/rtsp/conn.go

@@ -9,6 +9,7 @@ import (
 	"fmt"
 	"github.com/AlexxIT/go2rtc/pkg/aac"
 	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/mjpeg"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/AlexxIT/go2rtc/pkg/tcp"
 	"github.com/pion/rtcp"
@@ -99,6 +100,11 @@ func NewServer(conn net.Conn) *Conn {
 	return c
 }
 
+func (c *Conn) Auth(username, password string) {
+	info := url.UserPassword(username, password)
+	c.auth = tcp.NewAuth(info)
+}
+
 func (c *Conn) parseURI() (err error) {
 	c.URL, err = url.Parse(c.uri)
 	if err != nil {
@@ -398,6 +404,12 @@ func (c *Conn) SetupMedia(
 		}
 	}
 
+	// in case the track has already been setup before
+	if codec == nil {
+		c.state = StateSetup
+		return nil, nil
+	}
+
 	// we send our `interleaved`, but camera can answer with another
 
 	// Transport: RTP/AVP/TCP;unicast;interleaved=10-11;ssrc=10117CB7
@@ -429,9 +441,7 @@ func (c *Conn) SetupMedia(
 		return nil, err
 	}
 
-	track := &streamer.Track{
+	track := streamer.NewTrack(codec, media.Direction)
-		Codec: codec, Direction: media.Direction,
-	}
 
 	switch track.Direction {
 	case streamer.DirectionSendonly:
@@ -492,6 +502,17 @@ func (c *Conn) Accept() error {
 
 		c.Fire(req)
 
+		if !c.auth.Validate(req) {
+			res := &tcp.Response{
+				Status: "401 Unauthorized",
+				Header: map[string][]string{"Www-Authenticate": {`Basic realm="go2rtc"`}},
+			}
+			if err = c.Response(res); err != nil {
+				return err
+			}
+			continue
+		}
+
 		// Receiver: OPTIONS > DESCRIBE > SETUP... > PLAY > TEARDOWN
 		// Sender: OPTIONS > ANNOUNCE > SETUP... > RECORD > TEARDOWN
 		switch req.Method {
@@ -519,9 +540,7 @@ func (c *Conn) Accept() error {
 			// TODO: fix someday...
 			c.channels = map[byte]*streamer.Track{}
 			for i, media := range c.Medias {
-				track := &streamer.Track{
+				track := streamer.NewTrack(media.Codecs[0], media.Direction)
-					Codec: media.Codecs[0], Direction: media.Direction,
-				}
 				c.tracks = append(c.tracks, track)
 				c.channels[byte(i<<1)] = track
 			}
@@ -764,6 +783,8 @@ func (c *Conn) bindTrack(
 
 		size := packet.MarshalSize()
 
+		//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)
+
 		data := make([]byte, 4+size)
 		data[0] = '$'
 		data[1] = channel
@@ -782,7 +803,7 @@ func (c *Conn) bindTrack(
 		return nil
 	}
 
-	if track.Codec.IsMP4() {
+	if !track.Codec.IsRTP() {
 		switch track.Codec.Name {
 		case streamer.CodecH264:
 			wrapper := h264.RTPPay(1500)
@@ -790,6 +811,9 @@ func (c *Conn) bindTrack(
 		case streamer.CodecAAC:
 			wrapper := aac.RTPPay(1500)
 			push = wrapper(push)
+		case streamer.CodecJPEG:
+			wrapper := mjpeg.RTPPay()
+			push = wrapper(push)
 		}
 	}
 

pkg/rtsp/streamer.go

@@ -20,9 +20,10 @@ func (c *Conn) GetTrack(media *streamer.Media, codec *streamer.Codec) *streamer.
 		}
 	}
 
-	// can't setup new tracks from play state
+	// can't setup new tracks from play state - forcing a reconnection feature
 	if c.state == StatePlay {
-		return nil
+		go c.Close()
+		return streamer.NewTrack(codec, media.Direction)
 	}
 
 	track, err := c.SetupMedia(media, codec)

pkg/streamer/helpers.go

@@ -12,14 +12,6 @@ const (
 	JSONSend       = "send"
 )
 
-// Message - struct for data exchange in Web API
-type Message struct {
-	Type  string      `json:"type"`
-	Value interface{} `json:"value,omitempty"`
-}
-
-// other
-
 func Between(s, sub1, sub2 string) string {
 	i := strings.Index(s, sub1)
 	if i < 0 {

pkg/streamer/media.go

@@ -37,7 +37,7 @@ const (
 	CodecELD = "ELD" // AAC-ELD
 )
 
-const PayloadTypeMP4 byte = 255
+const PayloadTypeRAW byte = 255
 
 func GetKind(name string) string {
 	switch name {
@@ -139,8 +139,8 @@ func (c *Codec) String() string {
 	return s
 }
 
-func (c *Codec) IsMP4() bool {
+func (c *Codec) IsRTP() bool {
-	return c.PayloadType == PayloadTypeMP4
+	return c.PayloadType != PayloadTypeRAW
 }
 
 func (c *Codec) Clone() *Codec {

pkg/streamer/track.go

@@ -13,12 +13,18 @@ type Track struct {
 	Codec     *Codec
 	Direction string
 	sink      map[*Track]WriterFunc
-	sinkMu    sync.RWMutex
+	sinkMu    *sync.RWMutex
+}
+
+func NewTrack(codec *Codec, direction string) *Track {
+	return &Track{Codec: codec, Direction: direction, sinkMu: new(sync.RWMutex)}
 }
 
 func (t *Track) String() string {
 	s := t.Codec.String()
+	t.sinkMu.RLock()
 	s += fmt.Sprintf(", sinks=%d", len(t.sink))
+	t.sinkMu.RUnlock()
 	return s
 }
 
@@ -38,14 +44,12 @@ func (t *Track) Bind(w WriterFunc) *Track {
 		t.sink = map[*Track]WriterFunc{}
 	}
 
-	clone := &Track{
+	clone := *t
-		Codec: t.Codec, Direction: t.Direction, sink: t.sink,
+	t.sink[&clone] = w
-	}
-	t.sink[clone] = w
 
 	t.sinkMu.Unlock()
 
-	return clone
+	return &clone
 }
 
 func (t *Track) Unbind() {
@@ -55,7 +59,9 @@ func (t *Track) Unbind() {
 }
 
 func (t *Track) GetSink(from *Track) {
+	t.sinkMu.Lock()
 	t.sink = from.sink
+	t.sinkMu.Unlock()
 }
 
 func (t *Track) HasSink() bool {

pkg/tcp/auth.go

@@ -80,6 +80,24 @@ func (a *Auth) Write(req *Request) {
 	}
 }
 
+func (a *Auth) Validate(req *Request) bool {
+	if a == nil {
+		return true
+	}
+
+	header := req.Header.Get("Authorization")
+	if header == "" {
+		return false
+	}
+
+	if a.Method == AuthUnknown {
+		a.Method = AuthBasic
+		a.header = "Basic " + B64(a.user, a.pass)
+	}
+
+	return header == a.header
+}
+
 func Between(s, sub1, sub2 string) string {
 	i := strings.Index(s, sub1)
 	if i < 0 {

pkg/tcp/request.go

@@ -0,0 +1,68 @@
+package tcp
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// Do - http.Client with support Digest Authorization
+func Do(req *http.Request) (*http.Response, error) {
+	// need to create new client each time to reset timeout
+	client := http.Client{Timeout: time.Second * 5000}
+	res, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	if res.StatusCode == http.StatusUnauthorized && req.URL.User != nil {
+		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="`, `"`)
+
+		user := req.URL.User
+		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"`,
+				user, realm, nonce, uri, response,
+			)
+		case "auth":
+			nc := "00000001"
+			cnonce := "00000001" // TODO: random...
+			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)
+
+		res, err = client.Do(req)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return res, nil
+}

pkg/webrtc/conn.go

@@ -1,17 +1,8 @@
 package webrtc
 
 import (
-	"fmt"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/pion/webrtc/v3"
-	"sort"
-)
-
-const (
-	MsgTypeOffer         = "webrtc/offer"
-	MsgTypeOfferComplete = "webrtc/offer-complete"
-	MsgTypeAnswer        = "webrtc/answer"
-	MsgTypeCandidate     = "webrtc/candidate"
 )
 
 type Conn struct {
@@ -30,11 +21,7 @@ type Conn struct {
 
 func (c *Conn) Init() {
 	c.Conn.OnICECandidate(func(candidate *webrtc.ICECandidate) {
-		if candidate != nil {
+		c.Fire(candidate)
-			c.Fire(&streamer.Message{
-				Type: MsgTypeCandidate, Value: candidate.ToJSON().Candidate,
-			})
-		}
 	})
 
 	c.Conn.OnTrack(func(remote *webrtc.TrackRemote, receiver *webrtc.RTPReceiver) {
@@ -59,7 +46,11 @@ func (c *Conn) Init() {
 			}
 		}
 
-		fmt.Printf("TODO: webrtc ontrack %+v\n", remote)
+		//fmt.Printf("TODO: webrtc ontrack %+v\n", remote)
+	})
+
+	c.Conn.OnDataChannel(func(channel *webrtc.DataChannel) {
+		c.Fire(channel)
 	})
 
 	// OK connection:
@@ -100,12 +91,23 @@ func (c *Conn) SetOffer(offer string) (err error) {
 		return
 	}
 	rawSDP := []byte(c.Conn.RemoteDescription().SDP)
-	c.medias, err = streamer.UnmarshalSDP(rawSDP)
+	medias, err := streamer.UnmarshalSDP(rawSDP)
+	if err != nil {
+		return
+	}
 
 	// sort medias, so video will always be before audio
-	sort.Slice(c.medias, func(i, j int) bool {
+	// and ignore application media from Hass default lovelace card
-		return c.medias[i].Kind == streamer.KindVideo
+	for _, media := range medias {
-	})
+		if media.Kind == streamer.KindVideo {
+			c.medias = append(c.medias, media)
+		}
+	}
+	for _, media := range medias {
+		if media.Kind == streamer.KindAudio {
+			c.medias = append(c.medias, media)
+		}
+	}
 
 	return
 }

pkg/webrtc/consumer.go

@@ -57,10 +57,10 @@ func (c *Conn) AddTrack(media *streamer.Media, track *streamer.Track) *streamer.
 			wrapper := h264.RTPPay(1200)
 			push = wrapper(push)
 
-			if codec.IsMP4() {
+			if codec.IsRTP() {
-				wrapper = h264.RepairAVC(track)
-			} else {
 				wrapper = h264.RTPDepay(track)
+			} else {
+				wrapper = h264.RepairAVC(track)
 			}
 			push = wrapper(push)
 
@@ -108,14 +108,8 @@ func (c *Conn) AddTrack(media *streamer.Media, track *streamer.Track) *streamer.
 
 //
 
-func (c *Conn) Push(msg interface{}) {
+func (c *Conn) AddCandidate(candidate string) {
-	if msg := msg.(*streamer.Message); msg != nil {
+	_ = c.Conn.AddICECandidate(webrtc.ICECandidateInit{Candidate: candidate})
-		if msg.Type == MsgTypeCandidate {
-			_ = c.Conn.AddICECandidate(webrtc.ICECandidateInit{
-				Candidate: msg.Value.(string),
-			})
-		}
-	}
 }
 
 func (c *Conn) MarshalJSON() ([]byte, error) {

scripts/README.md

@@ -2,6 +2,7 @@
 
 - UPX-3.96 pack broken bin for `linux_mipsel`
 - UPX-3.95 pack broken bin for `mac_amd64`
+- UPX pack broken bin for `mac_arm64`
 - UPX windows pack is recognised by anti-viruses as malicious
 - `aarch64` = `arm64`
 - `armv7` = `arm`

scripts/build.cmd

@@ -3,45 +3,50 @@
 @SET GOOS=windows
 @SET GOARCH=amd64
 @SET FILENAME=go2rtc_win64.zip
-go build -ldflags "-s -w" -trimpath && 7z a -sdel %FILENAME% go2rtc.exe
+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 -sdel %FILENAME% go2rtc.exe
+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-3.96 %FILENAME%
+go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx %FILENAME%
 
 @SET GOOS=linux
 @SET GOARCH=386
 @SET FILENAME=go2rtc_linux_i386
-go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx-3.96 %FILENAME%
+go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx %FILENAME%
 
 @SET GOOS=linux
 @SET GOARCH=arm64
 @SET FILENAME=go2rtc_linux_arm64
-go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx-3.96 %FILENAME%
+go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx %FILENAME%
 
 @SET GOOS=linux
 @SET GOARCH=arm
 @SET GOARM=7
 @SET FILENAME=go2rtc_linux_arm
-go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx-3.96 %FILENAME%
+go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx %FILENAME%
 
 @SET GOOS=linux
 @SET GOARCH=mipsle
 @SET FILENAME=go2rtc_linux_mipsel
-go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx-3.95 %FILENAME%
+go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx %FILENAME%
 
 @SET GOOS=darwin
 @SET GOARCH=amd64
-@SET FILENAME=go2rtc_mac_amd64
+@SET FILENAME=go2rtc_mac_amd64.zip
-go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx-3.96 %FILENAME%
+go build -ldflags "-s -w" -trimpath && 7z a -mx9 -sdel %FILENAME% go2rtc
 
 @SET GOOS=darwin
 @SET GOARCH=arm64
-@SET FILENAME=go2rtc_mac_arm64
+@SET FILENAME=go2rtc_mac_arm64.zip
-go build -ldflags "-s -w" -trimpath -o %FILENAME% && upx-3.96 %FILENAME%
+go build -ldflags "-s -w" -trimpath && 7z a -mx9 -sdel %FILENAME% go2rtc

scripts/build_linux_amd64.cmd

@@ -1,5 +0,0 @@
-@SET GOOS=linux
-@SET GOARCH=amd64
-@cd ..
-del go2rtc
-go build -ldflags "-s -w" -trimpath

scripts/build_linux_arm.cmd

@@ -1,5 +0,0 @@
-@SET GOOS=linux
-@SET GOARCH=arm
-@cd ..
-del go2rtc
-go build -ldflags "-s -w" -trimpath

scripts/build_linux_mips.cmd

@@ -1,5 +0,0 @@
-@ECHO OFF
-@SET GOOS=linux
-@SET GOARCH=mipsle
-cd ..
-go build -ldflags "-s -w" -trimpath && upx-3.95 go2rtc

scripts/build_mac_amd64.cmd

@@ -1,5 +0,0 @@
-@SET GOOS=darwin
-@SET GOARCH=amd64
-@cd ..
-del go2rtc
-go build -ldflags "-s -w" -trimpath

scripts/build_win64.cmd

@@ -1,4 +0,0 @@
-@SET GOOS=windows
-@SET GOARCH=amd64
-cd ..
-go build -ldflags "-w -s" -trimpath

www/index.html

@@ -8,6 +8,10 @@
     <title>go2rtc</title>
 
     <style>
+        body {
+            font-family: Arial, Helvetica, sans-serif;
+        }
+
         table {
             background-color: white;
             text-align: left;
@@ -36,9 +40,23 @@
             text-align: center;
         }
 
+        label {
+            display: flex;
+            align-items: center;
+        }
+
         .header {
             padding: 5px 5px;
         }
+
+        .controls {
+            display: flex;
+            padding: 5px;
+        }
+
+        .controls > label {
+            margin-left: 10px;
+        }
     </style>
 </head>
 <body>
@@ -47,6 +65,13 @@
     <input id="src" type="text" placeholder="url">
     <a id="add" href="#">add</a>
 </div>
+<div class="controls">
+    <button>stream</button>
+    <label><input type="checkbox" name="webrtc" checked>webrtc</label>
+    <label><input type="checkbox" name="mse" checked>mse</label>
+    <label><input type="checkbox" name="mp4" checked>mp4</label>
+    <label><input type="checkbox" name="mjpeg" checked>mjpeg</label>
+</div>
 <table id="streams">
     <thead>
     <tr>
@@ -59,50 +84,71 @@
     </tbody>
 </table>
 <script>
-    const baseUrl = location.origin + location.pathname.substr(
+    const templates = [
-        0, location.pathname.lastIndexOf("/")
+        '<a href="stream.html?src={name}">stream</a>',
-    );
+        '<a href="webrtc.html?src={name}">2-way-aud</a>',
-
-    const links = [
-        '<a href="webrtc.html?src={name}">webrtc</a>',
-        '<a href="mse.html?src={name}">mse</a>',
-        // '<a href="video.html?src={name}">video</a>',
         '<a href="api/stream.mp4?src={name}">mp4</a>',
-        '<a href="api/frame.mp4?src={name}">frame</a>',
-        `<a href="rtsp://${location.hostname}:8554/{name}">rtsp</a>`,
         '<a href="api/stream.mjpeg?src={name}">mjpeg</a>',
+        `<a href="rtsp://${location.hostname}:8554/{name}">rtsp</a>`,
         '<a href="api/streams?src={name}">info</a>',
+        '<a href="#" data-name="{name}">delete</a>',
     ];
 
+    document.querySelector("#add")
+        .addEventListener("click", () => {
+            const src = document.querySelector("#src");
+            const url = new URL("api/streams", location.href);
+            url.searchParams.set("src", src.value);
+            fetch(url, {method: "PUT"}).then(reload);
+        });
+
+    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.querySelector("#streams > tbody");
+    tbody.addEventListener("click", ev => {
+        if (ev.target.innerText !== "delete") return;
+
+        ev.preventDefault();
+
+        const url = new URL("api/streams", location.href);
+        url.searchParams.set("src", ev.target.dataset.name);
+        fetch(url, {method: "DELETE"}).then(reload);
+    });
+
     function reload() {
-        fetch(`${baseUrl}/api/streams`).then(r => {
+        const url = new URL("api/streams", location.href);
-            r.json().then(data => {
+        fetch(url).then(r => r.json()).then(data => {
-                let html = '';
+            tbody.innerHTML = "";
 
             for (const [name, value] of Object.entries(data)) {
-                    const online = value !== null ? value.length : 0
+                const online = value ? value.length : 0;
-                    html += `<tr><td>${name || 'default'}</td><td>${online}</td><td>`;
+                const links = templates.map(link => {
-                    links.forEach(link => {
+                    return link.replace("{name}", encodeURIComponent(name));
-                        html += link.replace('{name}', encodeURIComponent(name)) + ' ';
+                }).join(" ");
-                    })
-                    html += `<a href="#" onclick="deleteStream('${name}')">delete</a>`;
-                    html += `</td></tr>`;
-                }
 
-                let content = document.getElementById('streams').getElementsByTagName('tbody')[0];
+                const tr = document.createElement("tr");
-                content.innerHTML = html
+                tr.dataset["id"] = name;
+                tr.innerHTML =
+                    `<td><label><input type="checkbox" name="${name}">${name}</label></td>` +
+                    `<td>${online}</td><td>${links}</td>`;
+                tbody.appendChild(tr);
+            }
         });
-        })
-    }
-
-    function deleteStream(src) {
-        fetch(`${baseUrl}/api/streams?src=${encodeURIComponent(src)}`, {method: 'DELETE'}).then(reload);
-    }
-
-    const addButton = document.querySelector('a#add');
-    addButton.onclick = () => {
-        let src = document.querySelector('input#src');
-        fetch(`${baseUrl}/api/streams?src=${encodeURIComponent(src.value)}`, {method: 'PUT'}).then(reload);
     }
 
     reload();

www/mse.html

@@ -1,99 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <title>go2rtc - MSE</title>
-    <style>
-        body {
-            margin: 0;
-            padding: 0;
-        }
-
-        html, body {
-            height: 100%;
-            width: 100%;
-        }
-
-        #video {
-            width: 100%;
-            height: 100%;
-            background: black;
-        }
-    </style>
-</head>
-<body>
-<!-- muted is important for autoplay -->
-<video id="video" autoplay controls playsinline muted></video>
-<script>
-    // support api_path
-    const baseUrl = location.origin + location.pathname.substr(
-        0, location.pathname.lastIndexOf("/")
-    );
-    const video = document.querySelector('#video');
-
-    function init() {
-        let mediaSource, sourceBuffer, queueBuffer = [];
-
-        const ws = new WebSocket(`ws${baseUrl.substr(4)}/api/ws${location.search}`);
-        ws.binaryType = "arraybuffer";
-
-        ws.onopen = () => {
-            mediaSource = new MediaSource();
-            video.src = URL.createObjectURL(mediaSource);
-            mediaSource.onsourceopen = () => {
-                mediaSource.onsourceopen = null;
-                URL.revokeObjectURL(video.src);
-                ws.send(JSON.stringify({"type": "mse"}));
-            };
-        };
-
-        ws.onmessage = ev => {
-            if (typeof ev.data === 'string') {
-                const data = JSON.parse(ev.data);
-                console.debug("ws.onmessage", data);
-
-                if (data.type === "mse") {
-                    sourceBuffer = mediaSource.addSourceBuffer(data.value);
-                    sourceBuffer.mode = "segments"; // segments or sequence
-                    sourceBuffer.onupdateend = () => {
-                        if (!sourceBuffer.updating && queueBuffer.length > 0) {
-                            try {
-                                sourceBuffer.appendBuffer(queueBuffer.shift());
-                            } catch (e) {
-                                // console.warn(e);
-                            }
-                        }
-                    }
-                }
-            } else if (sourceBuffer.updating || queueBuffer.length > 0) {
-                queueBuffer.push(ev.data);
-            } else {
-                try {
-                    sourceBuffer.appendBuffer(ev.data);
-                } catch (e) {
-                    // console.warn(e);
-                }
-            }
-
-            if (video.seekable.length > 0) {
-                const delay = video.seekable.end(video.seekable.length - 1) - video.currentTime;
-                if (delay < 1) {
-                    video.playbackRate = 1;
-                } else if (delay > 10) {
-                    video.playbackRate = 10;
-                } else if (delay > 2) {
-                    video.playbackRate = Math.floor(delay);
-                }
-            }
-        }
-
-        video.onpause = () => {
-            ws.close();
-            setTimeout(init, 0);
-        }
-    }
-
-    init();
-</script>
-</body>
-</html>

www/stream.html

@@ -0,0 +1,62 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>go2rtc - Stream</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);
+    }
+</script>
+</body>
+</html>

www/video-rtc.js

@@ -0,0 +1,597 @@
+/**
+ * Video player for go2rtc streaming application.
+ *
+ * All modern web technologies are supported in almost any browser except Apple Safari.
+ *
+ * Support:
+ * - RTCPeerConnection for Safari iOS 11.0+
+ * - IntersectionObserver for Safari iOS 12.2+
+ *
+ * Doesn't support:
+ * - MediaSource for Safari iOS all
+ * - Customized built-in elements (extends HTMLVideoElement) because all Safari
+ * - Public class fields because old Safari (before 14.0)
+ */
+export class VideoRTC extends HTMLElement {
+    constructor() {
+        super();
+
+        this.DISCONNECT_TIMEOUT = 5000;
+        this.RECONNECT_TIMEOUT = 30000;
+
+        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
+            "mp4a.69",          // MP3
+            "mp4a.6B",          // MP3
+        ];
+
+        /**
+         * [config] Supported modes (webrtc, mse, mp4, mjpeg).
+         * @type {string}
+         */
+        this.mode = "webrtc,mse,mp4,mjpeg";
+
+        /**
+         * [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 = {iceServers: [{urls: "stun:stun.l.google.com:19302"}]};
+
+        /**
+         * [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(er => {
+            if (er.name === "NotAllowedError" && !this.video.muted) {
+                this.video.muted = true;
+                this.video.play().catch(() => console.debug);
+            }
+        });
+    }
+
+    /**
+     * Send message to server via WebSocket
+     * @param {Object} value
+     */
+    send(value) {
+        if (this.ws) this.ws.send(JSON.stringify(value));
+    }
+
+    codecs(type) {
+        const test = type === "mse"
+            ? codec => MediaSource.isTypeSupported(`video/mp4; codecs="${codec}"`)
+            : codec => this.video.canPlayType(`video/mp4; codecs="${codec}"`);
+        return this.CODECS.filter(test).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.appendChild(this.video);
+
+        // important for second video for mode MP4
+        this.style.display = "block";
+        this.style.position = "relative";
+
+        this.video.style.display = "block"; // fix bottom margin 4px
+        this.video.style.width = "100%";
+        this.video.style.height = "100%"
+
+        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", ev => this.onopen(ev));
+        this.ws.addEventListener("close", ev => this.onclose(ev));
+
+        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.close();
+            this.pc = 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.indexOf("mse") >= 0 && "MediaSource" in window) { // iPhone
+            modes.push("mse");
+            this.onmse();
+        } else if (this.mode.indexOf("mp4") >= 0) {
+            modes.push("mp4");
+            this.onmp4();
+        }
+
+        if (this.mode.indexOf("webrtc") >= 0 && "RTCPeerConnection" in window) { // macOS Desktop app
+            modes.push("webrtc");
+            this.onwebrtc();
+        }
+
+        if (this.mode.indexOf("mjpeg") >= 0) {
+            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() {
+        const ms = new MediaSource();
+        ms.addEventListener("sourceopen", () => {
+            URL.revokeObjectURL(this.video.src);
+            this.send({type: "mse", value: this.codecs("mse")});
+        }, {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) return;
+                if (bufLen > 0) {
+                    try {
+                        sb.appendBuffer(buf.slice(0, bufLen));
+                    } catch (e) {
+                        // console.debug(e);
+                    }
+                    bufLen = 0;
+                } else if (sb.buffered && sb.buffered.length) {
+                    const end = sb.buffered.end(sb.buffered.length - 1) - 5;
+                    const start = sb.buffered.start(0);
+                    if (end > start) {
+                        sb.remove(start, end);
+                        ms.setLiveSeekableRange(end, end + 5);
+                    }
+                    // console.debug("VideoRTC.buffered", start, end);
+                }
+            });
+
+            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);
+
+        /** @type {HTMLVideoElement} */
+        const video2 = document.createElement("video");
+        video2.addEventListener("loadeddata", ev => this.onpcvideo(ev), {once: true});
+
+        pc.addEventListener("icecandidate", ev => {
+            const candidate = ev.candidate ? ev.candidate.toJSON().candidate : "";
+            this.send({type: "webrtc/candidate", value: candidate});
+        });
+
+        pc.addEventListener("track", ev => {
+            // when stream already init
+            if (video2.srcObject !== null) return;
+
+            // when audio track not exist in Chrome
+            if (ev.streams.length === 0) return;
+
+            // when audio track not exist in Firefox
+            if (ev.streams[0].id[0] === '{') return;
+
+            video2.srcObject = ev.streams[0];
+        });
+
+        pc.addEventListener("connectionstatechange", () => {
+            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":
+                    pc.addIceCandidate({
+                        candidate: msg.value,
+                        sdpMid: "0"
+                    }).catch(() => console.debug);
+                    break;
+                case "webrtc/answer":
+                    pc.setRemoteDescription({
+                        type: "answer",
+                        sdp: msg.value
+                    }).catch(() => console.debug);
+                    break;
+                case "error":
+                    if (msg.value.indexOf("webrtc/offer") < 0) return;
+                    pc.close();
+            }
+        };
+
+        // Safari doesn't support "offerToReceiveVideo"
+        pc.addTransceiver("video", {direction: "recvonly"});
+        pc.addTransceiver("audio", {direction: "recvonly"});
+
+        pc.createOffer().then(offer => {
+            pc.setLocalDescription(offer).then(() => {
+                this.send({type: "webrtc/offer", value: offer.sdp});
+            });
+        });
+
+        this.pcState = WebSocket.CONNECTING;
+        this.pc = pc;
+    }
+
+    /**
+     * @param ev {Event}
+     */
+    onpcvideo(ev) {
+        /** @type {HTMLVideoElement} */
+        const video2 = ev.target;
+        const state = this.pc.connectionState;
+
+        // Firefox doesn't support pc.connectionState
+        if (state === "connected" || state === "connecting" || !state) {
+            // Video+Audio > Video, H265 > H264, Video > Audio, WebRTC > MSE
+            let rtcPriority = 0, msePriority = 0;
+
+            /** @type {MediaStream} */
+            const ms = video2.srcObject;
+            if (ms.getVideoTracks().length > 0) rtcPriority += 0x220;
+            if (ms.getAudioTracks().length > 0) rtcPriority += 0x102;
+
+            if (this.mseCodecs.indexOf("hvc1.") >= 0) msePriority += 0x230;
+            if (this.mseCodecs.indexOf("avc1.") >= 0) msePriority += 0x210;
+            if (this.mseCodecs.indexOf("mp4a.") >= 0) msePriority += 0x101;
+
+            if (rtcPriority >= msePriority) {
+                this.video.srcObject = ms;
+                this.play();
+
+                this.pcState = WebSocket.OPEN;
+
+                this.wsState = WebSocket.CLOSED;
+                this.ws.close();
+                this.ws = null;
+            } else {
+                this.pcState = WebSocket.CLOSED;
+                this.pc.close();
+                this.pc = null;
+            }
+        }
+
+        video2.srcObject = null;
+    }
+
+    onmjpeg() {
+        this.ondata = data => {
+            this.video.poster = "data:image/jpeg;base64," + VideoRTC.btoa(data);
+        };
+
+        this.send({type: "mjpeg"});
+        this.video.controls = false;
+    }
+
+    onmp4() {
+        /** @type {HTMLVideoElement} */
+        let video2;
+
+        this.ondata = data => {
+            // first video with default position (set container size)
+            // second video with position=absolute and top=0px
+            if (video2) {
+                this.removeChild(this.video);
+                this.video.src = "";
+                this.video = video2;
+                video2.style.position = "";
+                video2.style.top = "";
+            }
+
+            video2 = this.video.cloneNode();
+            video2.style.position = "absolute";
+            video2.style.top = "0px";
+            this.appendChild(video2);
+
+            video2.src = "data:video/mp4;base64," + VideoRTC.btoa(data);
+            video2.play().catch(() => console.log);
+        };
+
+        this.ws.addEventListener("close", () => {
+            if (!video2) return;
+
+            this.removeChild(video2);
+            video2.src = "";
+        });
+
+        this.send({type: "mp4", value: this.codecs("mp4")});
+        this.video.controls = false;
+    }
+
+    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);
+    }
+}

www/video-stream.js

@@ -0,0 +1,85 @@
+import {VideoRTC} from "./video-rtc.js";
+
+class VideoStream extends VideoRTC {
+    constructor() {
+        super();
+
+        /** @type {HTMLDivElement} */
+        this.divMode = null;
+        /** @type {HTMLDivElement} */
+        this.divStatus = null;
+    }
+
+    /**
+     * Custom GUI
+     */
+    oninit() {
+        super.oninit();
+
+        this.innerHTML = `
+        <style>
+        .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>
+        `;
+
+        this.divStatus = this.querySelector(".status");
+        this.divMode = this.querySelector(".mode");
+
+        const info = this.querySelector(".info")
+        this.insertBefore(this.video, info);
+    }
+
+    onconnect() {
+        const result = super.onconnect();
+        if (result) {
+            this.divMode.innerText = "loading";
+        }
+        return result;
+    }
+
+    onopen() {
+        const result = super.onopen();
+
+        this.onmessage["stream"] = msg => {
+            switch (msg.type) {
+                case "error":
+                    this.divMode.innerText = "error";
+                    this.divStatus.innerText = msg.value;
+                    break;
+                case "mse":
+                case "mp4":
+                case "mjpeg":
+                    this.divMode.innerText = msg.type.toUpperCase();
+                    this.divStatus.innerText = "";
+                    break;
+            }
+        }
+
+        return result;
+    }
+
+    onpcvideo(ev) {
+        super.onpcvideo(ev);
+
+        if (this.pcState !== WebSocket.CLOSED) {
+            this.divMode.innerText = "RTC";
+            this.divStatus.innerText = "";
+        }
+    }
+}
+
+customElements.define("video-stream", VideoStream);

www/video.html

@@ -1,53 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <title>go2rtc - WebRTC</title>
-    <style>
-        body {
-            margin: 0;
-            padding: 0;
-        }
-
-        html, body {
-            height: 100%;
-            width: 100%;
-        }
-
-        #video {
-            /* video "container" size */
-            width: 100%;
-            height: 100%;
-            background: black;
-        }
-    </style>
-</head>
-<body>
-<video id="video" autoplay controls playsinline muted></video>
-<!--<video id="video" preload="auto" controls playsinline muted></video>-->
-<script>
-    const baseUrl = location.origin + location.pathname.substr(
-        0, location.pathname.lastIndexOf("/")
-    );
-    const video = document.getElementById('video');
-
-    video.oncanplay = ev => console.log(ev.type, ev);
-    video.onplaying = ev => console.log(ev.type, ev);
-    video.onwaiting = ev => console.log(ev.type, ev);
-    video.onseeking = ev => console.log(ev.type, ev);
-    video.onloadeddata = ev => console.log(ev.type, ev);
-    video.oncanplaythrough = ev => console.log(ev.type, ev);
-    // video.ondurationchange = ev => console.log(ev.type, ev);
-    // video.ontimeupdate = ev => console.log(ev.type, ev);
-    video.onplay = ev => console.log(ev.type, ev);
-    video.onpause = ev => console.log(ev.type, ev);
-    video.onsuspended = ev => console.log(ev.type, ev);
-    video.onemptied = ev => console.log(ev.type, ev);
-    video.onstalled = ev => console.log(ev.type, ev);
-
-    console.log("start");
-
-    video.src = baseUrl + "/api/stream.mp4" + location.search;
-</script>
-</body>
-</html>

www/webrtc.html

@@ -48,7 +48,7 @@
             console.debug('ws.onmessage', msg);
 
             if (msg.type === 'webrtc/candidate') {
-                pc.addIceCandidate({candidate: msg.value, sdpMid: ''});
+                pc.addIceCandidate({candidate: msg.value, sdpMid: '0'});
             } else if (msg.type === 'webrtc/answer') {
                 pc.setRemoteDescription({type: 'answer', sdp: msg.value});
             }