Update version to 1.2.0

Generate universal macOS binary on release

.github/workflows/builder.yml

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

.github/workflows/docker.yml

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

.github/workflows/release.yml

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

Dockerfile

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

README.md

@@ -6,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 to [RTSP](#module-rtsp), [WebRTC](#module-webrtc), [MSE/MP4](#module-mp4) or [MJPEG](#module-mjpeg)
+- 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), [HLS](#module-hls) or [MJPEG](#module-mjpeg)
 - first project in the World with support streaming from [HomeKit Cameras](#source-homekit)
+- first project in the World with support H265 for WebRTC in browser (Safari only, [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,46 +27,52 @@ 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](#fast-start)
+  * [go2rtc: Binary](#go2rtc-binary)
+  * [go2rtc: Docker](#go2rtc-docker)
+  * [go2rtc: Home Assistant Add-on](#go2rtc-home-assistant-add-on)
+  * [go2rtc: Home Assistant Integration](#go2rtc-home-assistant-integration)
+* [Configuration](#configuration)
+  * [Module: Streams](#module-streams)
+    * [Source: RTSP](#source-rtsp)
+    * [Source: RTMP](#source-rtmp)
+    * [Source: HTTP](#source-http)
+    * [Source: FFmpeg](#source-ffmpeg)
+    * [Source: FFmpeg Device](#source-ffmpeg-device)
+    * [Source: Exec](#source-exec)
+    * [Source: Echo](#source-echo)
+    * [Source: HomeKit](#source-homekit)
+    * [Source: Ivideon](#source-ivideon)
+    * [Source: Hass](#source-hass)
+  * [Module: API](#module-api)
+  * [Module: RTSP](#module-rtsp)
+  * [Module: WebRTC](#module-webrtc)
+  * [Module: Ngrok](#module-ngrok)
+  * [Module: Hass](#module-hass)
+  * [Module: MP4](#module-mp4)
+  * [Module: HLS](#module-hls)
+  * [Module: MJPEG](#module-mjpeg)
+  * [Module: Log](#module-log)
+* [Security](#security)
+* [Codecs filters](#codecs-filters)
+* [Codecs madness](#codecs-madness)
+* [Codecs negotiation](#codecs-negotiation)
+* [Projects using go2rtc](#projects-using-go2rtc)
+* [Camera experience](#cameras-experience)
+* [TIPS](#tips)
+* [FAQ](#faq)
 
 ## Fast start
 
-1. Download [binary](#go2rtc-binary) or use [Docker](#go2rtc-docker) or [Home Assistant Add-on](#go2rtc-home-assistant-add-on)
+1. Download [binary](#go2rtc-binary) or use [Docker](#go2rtc-docker) or Home Assistant [Add-on](#go2rtc-home-assistant-add-on) or [Integration](#go2rtc-home-assistant-integration)
 2. Open web interface: `http://localhost:1984/`
 
 **Optionally:**
 
 - add your [streams](#module-streams) to [config](#configuration) file
 - setup [external access](#module-webrtc) to webrtc
-- setup [external access](#module-ngrok) to web interface
-- install [ffmpeg](#source-ffmpeg) for transcoding
 
 **Developers:**
 
@@ -82,12 +89,16 @@ Download binary for your OS from [latest release](https://github.com/AlexxIT/go2
 - `go2rtc_linux_i386` - Linux 32-bit
 - `go2rtc_linux_arm64` - Linux ARM 64-bit (ex. Raspberry 64-bit OS)
 - `go2rtc_linux_arm` - Linux ARM 32-bit (ex. Raspberry 32-bit OS)
-- `go2rtc_linux_mipsel` - Linux on MIPS (ex. [Xiaomi Gateway 3](https://github.com/AlexxIT/XiaomiGateway3))
-- `go2rtc_mac_amd64` - Mac with Intel
-- `go2rtc_mac_arm64` - Mac with M1
+- `go2rtc_linux_mipsel` - Linux MIPS (ex. [Xiaomi Gateway 3](https://github.com/AlexxIT/XiaomiGateway3))
+- `go2rtc_mac_amd64.zip` - Mac Intel 64-bit
+- `go2rtc_mac_arm64.zip` - Mac ARM 64-bit
 
 Don't forget to fix the rights `chmod +x go2rtc_xxx_xxx` on Linux and Mac.
 
+### go2rtc: Docker
+
+Container [alexxit/go2rtc](https://hub.docker.com/r/alexxit/go2rtc) with support `amd64`, `386`, `arm64`, `arm`. This container is the same as [Home Assistant Add-on](#go2rtc-home-assistant-add-on), but can be used separately from Home Assistant. Container has preinstalled [FFmpeg](#source-ffmpeg), [Ngrok](#module-ngrok) and [Python](#source-echo).
+
 ### go2rtc: Home Assistant Add-on
 
 [![](https://my.home-assistant.io/badges/supervisor_addon.svg)](https://my.home-assistant.io/redirect/supervisor_addon/?addon=a889bffc_go2rtc&repository_url=https%3A%2F%2Fgithub.com%2FAlexxIT%2Fhassio-addons)
@@ -97,29 +108,19 @@ Don't forget to fix the rights `chmod +x go2rtc_xxx_xxx` on Linux and Mac.
     - go2rtc > Install > Start
 2. Setup [Integration](#module-hass)
 
-### go2rtc: Docker
+### go2rtc: Home Assistant Integration
 
-Container [alexxit/go2rtc](https://hub.docker.com/r/alexxit/go2rtc) with support `amd64`, `386`, `arm64`, `arm`. This container same as [Home Assistant Add-on](#go2rtc-home-assistant-add-on), but can be used separately from the Home Assistant. Container has preinstalled [FFmpeg](#source-ffmpeg), [Ngrok](#module-ngrok) and [Python](#source-echo).
-
-```yaml
-services:
-  go2rtc:
-    image: alexxit/go2rtc
-    network_mode: host
-    restart: always
-    volumes:
-      - "~/go2rtc.yaml:/config/go2rtc.yaml"
-```
+[WebRTC Camera](https://github.com/AlexxIT/WebRTC) custom component can be used on any [Home Assistant installation](https://www.home-assistant.io/installation/), including [HassWP](https://github.com/AlexxIT/HassWP) on Windows. It can automatically download and use the latest version of go2rtc. Or it can connect to an existing version of go2rtc. Addon installation in this case is optional.
 
 ## Configuration
 
-Create file `go2rtc.yaml` next to the app.
+- by default go2rtc will search `go2rtc.yaml` in the current work dirrectory
+- `api` server will start on default **1984 port** (TCP)
+- `rtsp` server will start on default **8554 port** (TCP)
+- `webrtc` will use port **8555** (TCP/UDP) for connections
+- `ffmpeg` will use default transcoding options
 
-- by default, you need to config only your `streams` links
-- `api` server will start on default **1984 port**
-- `rtsp` server will start on default **8554 port**
-- `webrtc` will use random UDP port for each connection
-- `ffmpeg` will use default transcoding options (you may install it [manually](https://ffmpeg.org/))
+Configuration options and a complete list of settings can be found in [the wiki](https://github.com/AlexxIT/go2rtc/wiki/Configuration).
 
 Available modules:
 
@@ -127,7 +128,9 @@ 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
+- [hls](#module-hls) - HLS TS or fMP4 stream Server
+- [mjpeg](#module-mjpeg) - MJPEG Server
 - [ffmpeg](#source-ffmpeg) - FFmpeg integration
 - [ngrok](#module-ngrok) - Ngrok integration (external access for private network)
 - [hass](#module-hass) - Home Assistant integration
@@ -140,8 +143,9 @@ Available modules:
 Available source types:
 
 - [rtsp](#source-rtsp) - `RTSP` and `RTSPS` cameras
-- [rtmp](#source-rtmp) - `RTMP` and `HTTP-FLV` streams
-- [ffmpeg](#source-ffmpeg) - FFmpeg integration (`MJPEG`, `HLS`, `files` and others)
+- [rtmp](#source-rtmp) - `RTMP` streams
+- [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 +180,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 +233,30 @@ 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"
+  bin: ffmpeg  # path to ffmpeg binary
+  h264: "-codec:v libx264 -g:v 30 -preset:v superfast -tune:v zerolatency -profile:v main -level:v 4.1"
   mycodec: "-any args that support ffmpeg..."
 ```
 
-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 `width` and/or `height` params, important with transcoding (ex. `#video=h264#width=1280`)
+- You can use `raw` param for any additional FFmpeg arguments (ex. `#raw=-vf transpose=1`).
+
+Read more about encoding [hardware acceleration](https://github.com/AlexxIT/go2rtc/wiki/Hardware-acceleration).
 
 #### Source: FFmpeg Device
 
@@ -279,6 +311,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 +362,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,71 +397,85 @@ The HTTP API is the main part for interacting with the application. Default addr
 
 ```yaml
 api:
-  listen: ":1984"  # HTTP API port ("" - disabled)
-  base_path: ""    # API prefix for serve on suburl
-  static_dir: ""   # folder for static files (custom web interface)
+  listen: ":1984"    # default ":1984", HTTP API port ("" - disabled)
+  username: "admin"  # default "", Basic auth for WebUI
+  password: "pass"   # default "", Basic auth for WebUI
+  base_path: "/rtc"  # default "", API prefix for serve on suburl (/api => /rtc/api)
+  static_dir: "www"  # default "", folder for static files (custom web interface)
+  origin: "*"        # default "", allow CORS requests (only * supported)
 ```
 
-**PS. go2rtc** doesn't provide HTTPS or password protection. Use [Nginx](https://nginx.org/) or [Ngrok](#module-ngrok) or [Home Assistant Add-on](#go2rtc-home-assistant-add-on) for this tasks.
+**PS:**
 
-**PS2.** You can access microphone (for 2-way audio) only with HTTPS ([read more](https://stackoverflow.com/questions/52759992/how-to-access-camera-and-microphone-in-chrome-without-https)).
+- go2rtc doesn't provide HTTPS. Use [Nginx](https://nginx.org/) or [Ngrok](#module-ngrok) or [Home Assistant Add-on](#go2rtc-home-assistant-add-on) for this tasks
+- 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))
+- MJPEG over WebSocket plays better than native MJPEG because Chrome [bug](https://bugs.chromium.org/p/chromium/issues/detail?id=527446)
+- MP4 over WebSocket was created only for Apple iOS because it doesn't support MSE and native MP4
 
 ### Module: RTSP
 
 You can get any stream as RTSP-stream: `rtsp://192.168.1.123:8554/{stream_name}`
 
-- you can omit the codec filters, so one first video and one first audio will be selected
-- you can set `?video=copy` or just `?video`, so only one first video without audio will be selected
-- you can set multiple video or audio, so all of them will be selected
+You can enable external password protection for your RTSP streams. Password protection always disabled for localhost calls (ex. FFmpeg or Hass on same server).
 
 ```yaml
 rtsp:
-  listen: ":8554"
+  listen: ":8554"    # RTSP Server TCP port, default - 8554
+  username: "admin"  # optional, default - disabled
+  password: "pass"   # optional, default - disabled
+  default_query: "video&audio"  # optional, default codecs filters 
 ```
 
+By default go2rtc provide RTSP-stream with only one first video and only one first audio. You can change it with the `default_query` setting:
+
+- `default_query: "mp4"` - MP4 compatible codecs (H264, H265, AAC)
+- `default_query: "video=all&audio=all"` - all tracks from all source (not all players can handle this)
+- `default_query: "video=h264,h265"` - only one video track (H264 or H265)
+- `default_query: "video&audio=all"` - only one first any video and all audio as separate tracks
+
+Read more about [codecs filters](#codecs-filters).
+
 ### Module: WebRTC
 
 WebRTC usually works without problems in the local network. But external access may require additional settings. It depends on what type of Internet do you have.
 
-- by default, WebRTC use two random UDP ports for each connection (video and audio)
-- you can enable one additional TCP port for all connections and use it for external access
+- by default, WebRTC uses both TCP and UDP on port 8555 for connections
+- you can use this port for external access
+- you can change the port in YAML config:
+
+```yaml
+webrtc:
+  listen: ":8555"  # address of your local server and port (TCP/UDP)
+```
 
 **Static public IP**
 
-- add some TCP port to YAML config (ex. 8555)
-- forward this port on your router (you can use same 8555 port or any other)
+- forward the port 8555 on your router (you can use same 8555 port or any other as external port)
 - add your external IP-address and external port to YAML config
 
 ```yaml
 webrtc:
-  listen: ":8555"  # address of your local server (TCP)
   candidates:
     - 216.58.210.174:8555  # if you have static public IP-address
 ```
 
 **Dynamic public IP**
 
-- add some TCP port to YAML config (ex. 8555)
-- forward this port on your router (you can use same 8555 port or any other)
+- forward the port 8555 on your router (you can use same 8555 port or any other as the external port)
 - add `stun` word and external port to YAML config
   - go2rtc automatically detects your external address with STUN-server
 
 ```yaml
 webrtc:
-  listen: ":8555"  # address of your local server (TCP)
   candidates:
     - stun:8555  # if you have dynamic public IP-address
 ```
 
 **Private IP**
 
-- add some TCP port to YAML config (ex. 8555)
 - setup integration with [Ngrok service](#module-ngrok)
 
 ```yaml
-webrtc:
-  listen: ":8555"  # address of your local server (TCP)
-
 ngrok:
   command: ...
 ```
@@ -462,23 +553,29 @@ tunnels:
 
 ### Module: Hass
 
-If you install **go2rtc** as [Hass Add-on](#go2rtc-home-assistant-add-on) - you need to use localhost IP-address. In other cases you need to use IP-address of server with **go2rtc** application.
+The best and easiest way to use go2rtc inside the Home Assistant is to install the custom integration [WebRTC Camera](#go2rtc-home-assistant-integration) and custom lovelace card.
 
-#### From go2rtc to Hass
+But go2rtc is also compatible and can be used with [RTSPtoWebRTC](https://www.home-assistant.io/integrations/rtsp_to_webrtc/) built-in integration.
 
-Add any supported [stream source](#module-streams) as [Generic Camera](https://www.home-assistant.io/integrations/generic/) and view stream with built-in [Stream](https://www.home-assistant.io/integrations/stream/) integration. Technology `HLS`, supported codecs: `H264`, poor latency.
+You have several options on how to add a camera to Home Assistant:
 
-1. Add your stream to [go2rtc config](#configuration)
-2. Hass > Settings > Integrations > Add Integration > [Generic Camera](https://my.home-assistant.io/redirect/config_flow_start/?domain=generic) > `rtsp://127.0.0.1:8554/camera1`
+1. Camera RTSP source => [Generic Camera](https://www.home-assistant.io/integrations/generic/)
+2. Camera [any source](#module-streams) => [go2rtc config](#configuration) => [Generic Camera](https://www.home-assistant.io/integrations/generic/)
+   - Install any [go2rtc](#fast-start)
+   - Add your stream to [go2rtc config](#configuration)
+   - Hass > Settings > Integrations > Add Integration > [Generic Camera](https://my.home-assistant.io/redirect/config_flow_start/?domain=generic) > `rtsp://127.0.0.1:8554/camera1` (change to your stream name)
 
-#### From Hass to go2rtc
+You have several options on how to watch the stream from the cameras in Home Assistant:
 
-View almost any Hass camera using `WebRTC` technology, supported codecs `H264`/`PCMU`/`PCMA`/`OPUS`, best latency.
-
-When the stream starts - the camera `entity_id` will be added to go2rtc "on the fly". You don't need to add cameras manually to [go2rtc config](#configuration). Some cameras (like [Nest](https://www.home-assistant.io/integrations/nest/)) have a dynamic link to the stream, it will be updated each time a stream is started from the Hass interface. 
-
-1. Hass > Settings > Integrations > Add Integration > [RTSPtoWebRTC](https://my.home-assistant.io/redirect/config_flow_start/?domain=rtsp_to_webrtc) > `http://127.0.0.1:1984/`
-2. Use Picture Entity or Picture Glance lovelace card
+1. `Camera Entity` => `Picture Entity Card` => Technology `HLS`, codecs: `H264/H265/AAC`, poor latency.
+2. `Camera Entity` => [RTSPtoWebRTC](https://www.home-assistant.io/integrations/rtsp_to_webrtc/) => `Picture Entity Card` => Technology `WebRTC`, codecs: `H264/PCMU/PCMA/OPUS`, best latency.
+   - Install any [go2rtc](#fast-start)
+   - Hass > Settings > Integrations > Add Integration > [RTSPtoWebRTC](https://my.home-assistant.io/redirect/config_flow_start/?domain=rtsp_to_webrtc) > `http://127.0.0.1:1984/`
+   - RTSPtoWebRTC > Configure > STUN server: `stun.l.google.com:19302`
+   - Use Picture Entity or Picture Glance lovelace card
+3. `Camera Entity` or `Camera URL` => [WebRTC Camera](https://github.com/AlexxIT/WebRTC) => Technology: `WebRTC/MSE/MP4/MJPEG`, codecs: `H264/H265/AAC/PCMU/PCMA/OPUS`, best latency, best compatibility.
+   - Install and add [WebRTC Camera](https://github.com/AlexxIT/WebRTC) custom integration
+   - Use WebRTC Camera custom lovelace card
 
 You can add camera `entity_id` to [go2rtc config](#configuration) if you need transcoding:
 
@@ -494,21 +591,53 @@ PS. Default Home Assistant lovelace cards don't support 2-way audio. You can use
 Provides several features:
 
 1. MSE stream (fMP4 over WebSocket)
-2. Camera snapshots in MP4 format (single frame), can be sent to [Telegram](https://www.telegram.org/)
-3. Progressive MP4 stream - bad format for streaming because of high latency, doesn't work in Safari 
+2. Camera snapshots in MP4 format (single frame), can be sent to [Telegram](https://github.com/AlexxIT/go2rtc/wiki/Snapshot-to-Telegram)
+3. MP4 "file stream" - bad format for streaming because of high start delay. This format doesn't work in all Safari browsers, but go2rtc will automatically redirect it to HLS/fMP4 it this case.
+
+API examples:
+
+- MP4 stream: `http://192.168.1.123:1984/api/stream.mp4?src=camera1`
+- MP4 snapshot: `http://192.168.1.123:1984/api/frame.mp4?src=camera1`
+
+Read more about [codecs filters](#codecs-filters).
+
+### Module: HLS
+
+[HLS](https://en.wikipedia.org/wiki/HTTP_Live_Streaming) is the worst technology for real-time streaming. It can only be useful on devices that do not support more modern technology, like [WebRTC](#module-webrtc), [MSE/MP4](#module-mp4).
+
+The go2rtc implementation differs from the standards and may not work with all players.
+
+API examples:
+
+- HLS/TS stream: `http://192.168.1.123:1984/api/stream.m3u8?src=camera1` (H264)
+- HLS/fMP4 stream: `http://192.168.1.123:1984/api/stream.m3u8?src=camera1&mp4` (H264, H265, AAC)
+
+Read more about [codecs filters](#codecs-filters).
 
 ### Module: MJPEG
 
-**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
 
@@ -527,7 +656,7 @@ log:
 
 ## Security
 
-By default `go2rtc` start Web interface on port `1984` and RTSP on port `8554`. Both ports are accessible from your local network. So anyone on your local network can watch video from your cameras without authorization. The same rule applies to the Home Assistant Add-on.
+By default `go2rtc` starts the Web interface on port `1984` and RTSP on port `8554`, as well as use port `8555` for WebRTC connections. The three ports are accessible from your local network. So anyone on your local network can watch video from your cameras without authorization. The same rule applies to the Home Assistant Add-on.
 
 This is not a problem if you trust your local network as much as I do. But you can change this behaviour with a `go2rtc.yaml` config:
 
@@ -539,7 +668,7 @@ rtsp:
   listen: "127.0.0.1:8554" # localhost
 
 webrtc:
-  listen: ":8555" # external TCP port
+  listen: ":8555" # external TCP/UDP port
 ```
 
 - local access to RTSP is not a problem for [FFmpeg](#source-ffmpeg) integration, because it runs locally on your server
@@ -549,34 +678,105 @@ webrtc:
 
 If you need Web interface protection without Home Assistant Add-on - you need to use reverse proxy, like [Nginx](https://nginx.org/), [Caddy](https://caddyserver.com/), [Ngrok](https://ngrok.com/), etc.
 
-PS. Additionally WebRTC opens a lot of random UDP ports for transmit encrypted media. They work without problems on the local network. And sometimes work for external access, even if you haven't opened ports on your router. But for stable external WebRTC access, you need to configure the TCP port.
+PS. Additionally WebRTC will try to use the 8555 UDP port for transmit encrypted media. It works without problems on the local network. And sometimes also works for external access, even if you haven't opened this port on your router ([read more](https://en.wikipedia.org/wiki/UDP_hole_punching)). But for stable external WebRTC access, you need to open the 8555 port on your router for both TCP and UDP.
+
+## Codecs filters
+
+go2rtc can automatically detect which codecs your device supports for [WebRTC](#module-webrtc) and [MSE](#module-mp4) technologies.
+
+But it cannot be done for [RTSP](#module-rtsp), [stream.mp4](#module-mp4), [HLS](#module-hls) technologies. You can manually add a codec filter when you create a link to a stream. The filters work the same for all three technologies. Filters do not create a new codec. They only select the suitable codec from existing sources. You can add new codecs to the stream using the [FFmpeg transcoding](#source-ffmpeg).
+
+Without filters:
+
+- RTSP will provide only the first video and only the first audio
+- MP4 will include only compatible codecs (H264, H265, AAC)
+- HLS will output in the legacy TS format (H264 without audio)
+
+Some examples:
+
+- `rtsp://192.168.1.123:8554/camera1?mp4` - useful for recording as MP4 files (e.g. Hass or Frigate)
+- `rtsp://192.168.1.123:8554/camera1?video=h264,h265&audio=aac` - full version of the filter above
+- `rtsp://192.168.1.123:8554/camera1?video=h264&audio=aac&audio=opus` - H264 video codec and two separate audio tracks
+- `rtsp://192.168.1.123:8554/camera1?video&audio=all` - any video codec and all audio codecs as separate tracks
+- `http://192.168.1.123:1984/api/stream.m3u8?src=camera1&mp4` - HLS stream with MP4 compatible codecs (HLS/fMP4)
+- `http://192.168.1.123:1984/api/stream.mp4?src=camera1&video=h264,h265&audio=aac,opus,mp3,pcma,pcmu` - MP4 file with non standard audio codecs, does not work in some players
 
 ## Codecs madness
 
-`AVC/H.264` codec can be played almost anywhere. But `HEVC/H.265` has a lot of limitations in supporting with different devices and browsers. It's all about patents and money, you can't do anything about it.
+`AVC/H.264` video can be played almost anywhere. But `HEVC/H.265` has a lot of limitations in supporting with different devices and browsers. It's all about patents and money, you can't do anything about it.
 
-Device | WebRTC | MSE | MP4
--------|--------|-----|----
-*latency*       | best        | medium      | bad
-Desktop Chrome  | H264        | H264, H265* | H264, H265*
-Desktop Safari  | H264, H265* | H264        | no
-Desktop Edge    | H264        | H264, H265* | H264, H265*
-Desktop Firefox | H264        | H264        | H264
-Desktop Opera   | no          | H264        | H264
-iPhone Safari   | H264, H265* | no          | no
-iPad Safari     | H264, H265* | H264        | no
-Android Chrome  | H264        | H264        | H264
-masOS Hass App  | no          | no          | no
+| Device              | WebRTC                        | MSE                    | stream.mp4                              |
+|---------------------|-------------------------------|------------------------|-----------------------------------------|
+| *latency*           | best                          | medium                 | bad                                     |
+| Desktop Chrome 107+ | H264, OPUS, PCMU, PCMA        | H264, H265*, AAC, OPUS | H264, H265*, AAC, OPUS, PCMU, PCMA, MP3 |
+| Desktop Edge        | H264, OPUS, PCMU, PCMA        | H264, H265*, AAC, OPUS | H264, H265*, AAC, OPUS, PCMU, PCMA, MP3 |
+| Desktop Safari      | H264, H265*, OPUS, PCMU, PCMA | H264, H265, AAC        | **no!**                                 |
+| Desktop Firefox     | H264, OPUS, PCMU, PCMA        | H264, AAC, OPUS        | H264, AAC, OPUS                         |
+| Android Chrome 107+ | H264, OPUS, PCMU, PCMA        | H264, H265*, AAC, OPUS | H264, ?, AAC, OPUS, PCMU, PCMA, MP3     |
+| iPad Safari 13+     | H264, H265*, OPUS, PCMU, PCMA | H264, H265, AAC        | **no!**                                 |
+| iPhone Safari 13+   | H264, H265*, OPUS, PCMU, PCMA | **no!**                | **no!**                                 |
+| masOS Hass App      | no                            | no                     | no                                      |
 
-- Chrome H265: [read this](https://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
 
 **Audio**
 
-- WebRTC audio codecs: `PCMU/8000`, `PCMA/8000`, `OPUS/48000/2`
-- MSE/MP4 audio codecs: `AAC`
+- **WebRTC** audio codecs: `PCMU/8000`, `PCMA/8000`, `OPUS/48000/2`
+- `OPUS` and `MP3` inside **MP4** is part of the standard, but some players do not support them anyway (especially Apple)
+- `PCMU` and `PCMA` inside **MP4** isn't a standard, but some players support them, for example Chromium browsers
+
+**Apple devices**
+
+- all Apple devices don't support MP4 stream (they only support progressive loading of static files)
+- iPhones don't support MSE technology because it competes with the HLS technology, invented by Apple
+- 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.
+
+## Projects using go2rtc
+
+- [Frigate 12+](https://frigate.video/) - open source NVR built around real-time AI object detection
+- [ring-mqtt](https://github.com/tsightler/ring-mqtt) - Ring devices to MQTT Bridge
+- [EufyP2PStream](https://github.com/oischinger/eufyp2pstream) - A small project that provides a Video/Audio Stream from Eufy cameras that don't directly support RTSP
+
+## Cameras experience
+
+- [Dahua](https://www.dahuasecurity.com/) - reference implementation streaming protocols, a lot of settings, high stream quality, multiple streaming clients
+- [Hikvision](https://www.hikvision.com/) - a lot of proprietary streaming technologies
+- [Reolink](https://reolink.com/) - some models has awful unusable RTSP realisation and not best HTTP-FLV alternative (I recommend that you contact Reolink support for new firmware), few settings
+- [Sonoff](https://sonoff.tech/) - very low stream quality, no settings, not best protocol implementation
+- [TP-Link](https://www.tp-link.com/) - few streaming clients, packet loss?
+- Chinese cheap noname cameras, Wyze Cams, Xiaomi cameras with hacks (usual has `/live/ch00_1` in RTSP URL) - awful but usable RTSP protocol realisation, low stream quality, few settings, packet loss?
 
 ## TIPS
 
@@ -585,23 +785,27 @@ masOS Hass App  | no          | no          | no
 - `ffplay -fflags nobuffer -flags low_delay "rtsp://192.168.1.123:8554/camera1"`
 - VLC > Preferences > Input / Codecs > Default Caching Level: Lowest Latency
 
+**Snapshots to Telegram**
+
+[read more](https://github.com/AlexxIT/go2rtc/wiki/Snapshot-to-Telegram)
+
 ## FAQ
 
 **Q. What's the difference between go2rtc, WebRTC Camera and RTSPtoWebRTC?**
 
 **go2rtc** is a new version of the server-side [WebRTC Camera](https://github.com/AlexxIT/WebRTC) integration, completely rewritten from scratch, with a number of fixes and a huge number of new features. It is compatible with native Home Assistant [RTSPtoWebRTC](https://www.home-assistant.io/integrations/rtsp_to_webrtc/) integration. So you [can use](#module-hass) default lovelace Picture Entity or Picture Glance.
 
-**Q. Why go2rtc is an addon and not an integration?**
+**Q. Should I use go2rtc addon or WebRTC Camera integration?**
 
-Because **go2rtc** is more than just viewing your stream online with WebRTC. You can use it all the time for your various tasks. But every time the Hass is rebooted - all integrations are also rebooted. So your streams may be interrupted if you use them in additional tasks.
+**go2rtc** is more than just viewing your stream online with WebRTC/MSE/HLS/etc. You can use it all the time for your various tasks. But every time the Hass is rebooted - all integrations are also rebooted. So your streams may be interrupted if you use them in additional tasks.
 
-When **go2rtc** is released, the **WebRTC Camera** integration will be updated. And you can decide whether to use the integration or the addon.
+Basic users can use **WebRTC Camera** integration. Advanced users can use go2rtc addon or Frigate 12+ addon.
 
 **Q. Which RTSP link should I use inside Hass?**
 
 You can use direct link to your cameras there (as you always do). **go2rtc** support zero-config feature. You may leave `streams` config section empty. And your streams will be created on the fly on first start from Hass. And your cameras will have multiple connections. Some from Hass directly and one from **go2rtc**.
 
-Also you can specify your streams in **go2rtc** [config file](#configuration) and use RTSP links to this addon. With additional features: multi-source [codecs negotiation](#codecs-negotiation) or FFmpeg [transcoding](#source-ffmpeg) for unsupported codecs. Or use them as source for Frigate. And your cameras will have one connection from **go2rtc**. And **go2rtc** will have multiple connection - some from Hass via RTSP protocol, some from your browser via WebRTC protocol.
+Also you can specify your streams in **go2rtc** [config file](#configuration) and use RTSP links to this addon. With additional features: multi-source [codecs negotiation](#codecs-negotiation) or FFmpeg [transcoding](#source-ffmpeg) for unsupported codecs. Or use them as source for Frigate. And your cameras will have one connection from **go2rtc**. And **go2rtc** will have multiple connection - some from Hass via RTSP protocol, some from your browser via WebRTC/MSE/HLS protocols.
 
 Use any config what you like.
 

build/docker/run.sh

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

build/hassio/Dockerfile

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

build/hassio/config.yaml

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

build/hassio/run.sh

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

cmd/api/api.go

@@ -3,20 +3,24 @@ package api
 import (
 	"encoding/json"
 	"github.com/AlexxIT/go2rtc/cmd/app"
-	"github.com/AlexxIT/go2rtc/cmd/streams"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
-	"github.com/gorilla/websocket"
 	"github.com/rs/zerolog"
 	"net"
 	"net/http"
+	"os"
+	"strconv"
+	"strings"
+	"sync"
 )
 
 func Init() {
 	var cfg struct {
 		Mod struct {
 			Listen    string `yaml:"listen"`
+			Username  string `yaml:"username"`
+			Password  string `yaml:"password"`
 			BasePath  string `yaml:"base_path"`
 			StaticDir string `yaml:"static_dir"`
+			Origin    string `yaml:"origin"`
 		} `yaml:"api"`
 	}
 
@@ -34,9 +38,11 @@ func Init() {
 	log = app.GetLogger("api")
 
 	initStatic(cfg.Mod.StaticDir)
-	initWS()
+	initWS(cfg.Mod.Origin)
 
-	HandleFunc("api/streams", streamsHandler)
+	HandleFunc("api", apiHandler)
+	HandleFunc("api/config", configHandler)
+	HandleFunc("api/exit", exitHandler)
 	HandleFunc("api/ws", apiWS)
 
 	// ensure we can listen without errors
@@ -48,16 +54,22 @@ func Init() {
 
 	log.Info().Str("addr", cfg.Mod.Listen).Msg("[api] listen")
 
+	s := http.Server{}
+	s.Handler = http.DefaultServeMux // 4th
+
+	if cfg.Mod.Origin == "*" {
+		s.Handler = middlewareCORS(s.Handler) // 3rd
+	}
+
+	if cfg.Mod.Username != "" {
+		s.Handler = middlewareAuth(cfg.Mod.Username, cfg.Mod.Password, s.Handler) // 2nd
+	}
+
+	if log.Trace().Enabled() {
+		s.Handler = middlewareLog(s.Handler) // 1st
+	}
+
 	go func() {
-		s := http.Server{}
-
-		if log.Trace().Enabled() {
-			s.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				log.Trace().Stringer("url", r.URL).Msgf("[api] %s", r.Method)
-				http.DefaultServeMux.ServeHTTP(w, r)
-			})
-		}
-
 		if err = s.Serve(listener); err != nil {
 			log.Fatal().Err(err).Msg("[api] serve")
 		}
@@ -75,65 +87,60 @@ func HandleFunc(pattern string, handler http.HandlerFunc) {
 	http.HandleFunc(pattern, handler)
 }
 
-func HandleWS(msgType string, handler WSHandler) {
-	wsHandlers[msgType] = handler
-}
+const StreamNotFound = "stream not found"
 
 var basePath string
 var log zerolog.Logger
-var wsHandlers = make(map[string]WSHandler)
 
-func streamsHandler(w http.ResponseWriter, r *http.Request) {
-	src := r.URL.Query().Get("src")
-	name := r.URL.Query().Get("name")
-	
-	if name == "" {
-		name = src
-	}
-
-	switch r.Method {
-	case "PUT":
-		streams.New(name, src)
-		return
-	case "DELETE":
-		streams.Delete(src)
-		return
-	}
-
-	var v interface{}
-	if src != "" {
-		v = streams.Get(src)
-	} else {
-		v = streams.All()
-	}
-
-	e := json.NewEncoder(w)
-	e.SetIndent("", "  ")
-	_ = e.Encode(v)
+func middlewareLog(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		log.Trace().Msgf("[api] %s %s %s", r.Method, r.URL, r.RemoteAddr)
+		next.ServeHTTP(w, r)
+	})
 }
 
-func 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")
+func middlewareAuth(username, password string, next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if !strings.HasPrefix(r.RemoteAddr, "127.") && !strings.HasPrefix(r.RemoteAddr, "[::1]") {
+			user, pass, ok := r.BasicAuth()
+			if !ok || user != username || pass != password {
+				w.Header().Set("Www-Authenticate", `Basic realm="go2rtc"`)
+				http.Error(w, "Unauthorized", http.StatusUnauthorized)
+				return
 			}
-			return
 		}
 
-		handler := wsHandlers[msg.Type]
-		if handler != nil {
-			handler(ctx, msg)
-		}
+		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)
+	})
+}
+
+var mu sync.Mutex
+
+func apiHandler(w http.ResponseWriter, r *http.Request) {
+	mu.Lock()
+	app.Info["host"] = r.Host
+	mu.Unlock()
+
+	if err := json.NewEncoder(w).Encode(app.Info); err != nil {
+		log.Warn().Err(err).Caller().Send()
 	}
 }
+
+func exitHandler(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		http.Error(w, "", http.StatusBadRequest)
+		return
+	}
+
+	s := r.URL.Query().Get("code")
+	code, _ := strconv.Atoi(s)
+	os.Exit(code)
+}

cmd/api/config.go

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

cmd/api/ws.go

@@ -1,85 +1,156 @@
 package api
 
 import (
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/gorilla/websocket"
 	"net/http"
 	"net/url"
 	"strings"
 	"sync"
+	"time"
 )
 
-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,
 	}
-	wsUp.CheckOrigin = func(r *http.Request) bool {
-		origin := r.Header["Origin"]
-		if len(origin) == 0 {
-			return true
-		}
-		o, err := url.Parse(origin[0])
-		if err != nil {
+
+	switch origin {
+	case "":
+		// same origin + ignore port
+		wsUp.CheckOrigin = func(r *http.Request) bool {
+			origin := r.Header["Origin"]
+			if len(origin) == 0 {
+				return true
+			}
+			o, err := url.Parse(origin[0])
+			if err != nil {
+				return false
+			}
+			if o.Host == r.Host {
+				return true
+			}
+			log.Trace().Msgf("[api.ws] origin=%s, host=%s", o.Host, r.Host)
+			// https://github.com/AlexxIT/go2rtc/issues/118
+			if i := strings.IndexByte(o.Host, ':'); i > 0 {
+				return o.Host[:i] == r.Host
+			}
 			return false
 		}
-		if o.Host == r.Host {
+	case "*":
+		// any origin
+		wsUp.CheckOrigin = func(r *http.Request) bool {
 			return true
 		}
-		log.Trace().Msgf("[api.ws] origin: %s, host: %s", o.Host, r.Host)
-		// some users change Nginx external port using Docker port
-		// 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
 	}
 }
 
+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{}) {
+		_ = ws.SetWriteDeadline(time.Now().Add(time.Second * 5))
+
+		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 {
+			if !websocket.IsCloseError(err, websocket.CloseNoStatusReceived) {
+				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 Context struct {
-	Conn     *websocket.Conn
+type Transport struct {
 	Request  *http.Request
 	Consumer interface{} // TODO: rewrite
 
-	onClose []func()
-	mu      sync.Mutex
+	closed bool
+	mx     sync.Mutex
+	wrmx   sync.Mutex
+
+	onChange func()
+	onWrite  func(msg interface{})
+	onClose  []func()
 }
 
-func (ctx *Context) Upgrade(w http.ResponseWriter, r *http.Request) (err error) {
-	ctx.Conn, err = wsUp.Upgrade(w, r, nil)
-	ctx.Request = r
-	return
+func (t *Transport) OnWrite(f func(msg interface{})) {
+	t.mx.Lock()
+	if t.onChange != nil {
+		t.onChange()
+	}
+	t.onWrite = f
+	t.mx.Unlock()
 }
 
-func (ctx *Context) Close() {
-	for _, f := range ctx.onClose {
+func (t *Transport) Write(msg interface{}) {
+	t.wrmx.Lock()
+	t.onWrite(msg)
+	t.wrmx.Unlock()
+}
+
+func (t *Transport) Close() {
+	t.mx.Lock()
+	for _, f := range t.onClose {
 		f()
 	}
-	_ = ctx.Conn.Close()
+	t.closed = true
+	t.mx.Unlock()
 }
 
-func (ctx *Context) Write(msg interface{}) {
-	ctx.mu.Lock()
+func (t *Transport) OnChange(f func()) {
+	t.mx.Lock()
+	t.onChange = f
+	t.mx.Unlock()
+}
 
-	if data, ok := msg.([]byte); ok {
-		_ = ctx.Conn.WriteMessage(websocket.BinaryMessage, data)
+func (t *Transport) OnClose(f func()) {
+	t.mx.Lock()
+	if t.closed {
+		f()
 	} else {
-		_ = ctx.Conn.WriteJSON(msg)
+		t.onClose = append(t.onClose, f)
 	}
-
-	ctx.mu.Unlock()
-}
-
-func (ctx *Context) Error(err error) {
-	ctx.Write(&streamer.Message{
-		Type: "error", Value: err.Error(),
-	})
-}
-
-func (ctx *Context) OnClose(f func()) {
-	ctx.onClose = append(ctx.onClose, f)
+	t.mx.Unlock()
 }

cmd/app/app.go

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

cmd/debug/debug.go

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

cmd/debug/stack.go

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

cmd/dvrip/dvrip.go

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

cmd/exec/exec.go

@@ -34,8 +34,13 @@ func Init() {
 			return false
 		}
 
-		waiter <- conn
-		return true
+		// unblocking write to channel
+		select {
+		case waiter <- conn:
+			return true
+		default:
+			return false
+		}
 	})
 
 	streams.HandleFunc("exec", Handle)
@@ -86,7 +91,13 @@ func Handle(url string) (streamer.Producer, error) {
 	chErr := make(chan error)
 
 	go func() {
-		chErr <- cmd.Wait()
+		err := cmd.Wait()
+		// unblocking write to channel
+		select {
+		case chErr <- err:
+		default:
+			log.Trace().Str("url", url).Msg("[exec] close")
+		}
 	}()
 
 	select {

cmd/ffmpeg/device/device_darwin.go

@@ -15,11 +15,11 @@ func deviceInputSuffix(videoIdx, audioIdx int) string {
 	audio := findMedia(streamer.KindAudio, audioIdx)
 	switch {
 	case video != nil && audio != nil:
-		return `"` + video.Title + `:` + audio.Title + `"`
+		return `"` + video.MID + `:` + audio.MID + `"`
 	case video != nil:
-		return `"` + video.Title + `"`
+		return `"` + video.MID + `"`
 	case audio != nil:
-		return `"` + audio.Title + `"`
+		return `"` + audio.MID + `"`
 	}
 	return ""
 }
@@ -57,7 +57,5 @@ process:
 }
 
 func loadMedia(kind, name string) *streamer.Media {
-	return &streamer.Media{
-		Kind: kind, Title: name,
-	}
+	return &streamer.Media{Kind: kind, MID: name}
 }

cmd/ffmpeg/device/device_linux.go

@@ -13,7 +13,7 @@ const deviceInputPrefix = "-f v4l2"
 
 func deviceInputSuffix(videoIdx, audioIdx int) string {
 	video := findMedia(streamer.KindVideo, videoIdx)
-	return video.Title
+	return video.MID
 }
 
 func loadMedias() {
@@ -44,7 +44,5 @@ func loadMedia(kind, name string) *streamer.Media {
 		return nil
 	}
 
-	return &streamer.Media{
-		Kind: kind, Title: name,
-	}
+	return &streamer.Media{Kind: kind, MID: name}
 }

cmd/ffmpeg/device/device_windows.go

@@ -15,11 +15,11 @@ func deviceInputSuffix(videoIdx, audioIdx int) string {
 	audio := findMedia(streamer.KindAudio, audioIdx)
 	switch {
 	case video != nil && audio != nil:
-		return `video="` + video.Title + `":audio=` + audio.Title + `"`
+		return `video="` + video.MID + `":audio=` + audio.MID + `"`
 	case video != nil:
-		return `video="` + video.Title + `"`
+		return `video="` + video.MID + `"`
 	case audio != nil:
-		return `audio="` + audio.Title + `"`
+		return `audio="` + audio.MID + `"`
 	}
 	return ""
 }
@@ -53,7 +53,5 @@ func loadMedias() {
 }
 
 func loadMedia(kind, name string) *streamer.Media {
-	return &streamer.Media{
-		Kind: kind, Title: name,
-	}
+	return &streamer.Media{Kind: kind, MID: name}
 }

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,190 +19,254 @@ func Init() {
 		Mod map[string]string `yaml:"ffmpeg"`
 	}
 
-	// defaults
-
-	cfg.Mod = map[string]string{
-		"bin": "ffmpeg",
-
-		// inputs
-		"file": "-re -stream_loop -1 -i {input}",
-		"http": "-fflags nobuffer -flags low_delay -i {input}",
-		"rtsp": "-fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_transport tcp -i {input}",
-
-		// output
-		"output": "-user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}",
-
-		// `-g 30` - group of picture, GOP, keyframe interval
-		// `-preset superfast` - we can't use ultrafast because it doesn't support `-profile main -level 4.1`
-		// `-tune zerolatency` - for minimal latency
-		// `-profile main -level 4.1` - most used streaming profile
-		// `-pix_fmt yuv420p` - if input pix format 4:2:2
-		"h264":       "-c:v libx264 -g:v 30 -preset:v superfast -tune:v zerolatency -profile:v main -level:v 4.1 -pix_fmt:v yuv420p",
-		"h264/ultra": "-c:v libx264 -g:v 30 -preset:v ultrafast -tune:v zerolatency",
-		"h264/high":  "-c:v libx264 -g:v 30 -preset:v superfast -tune:v zerolatency",
-		"h265":       "-c:v libx265 -g:v 30 -preset:v 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",
-		"pcmu/48000": "-c:a pcm_mulaw -ar:a 48000 -ac:a 1",
-		"pcma":       "-c:a pcm_alaw -ar:a 8000 -ac:a 1",
-		"pcma/16000": "-c:a pcm_alaw -ar:a 16000 -ac:a 1",
-		"pcma/48000": "-c:a pcm_alaw -ar:a 48000 -ac:a 1",
-		"aac":        "-c:a aac", // keep sample rate and channels
-		"aac/16000":  "-c:a aac -ar:a 16000 -ac:a 1",
-	}
+	cfg.Mod = defaults // will be overriden from yaml
 
 	app.LoadConfig(&cfg)
 
-	tpl := cfg.Mod
-
-	cmd := "exec:" + tpl["bin"] + " -hide_banner "
-
 	if app.GetLogger("exec").GetLevel() >= 0 {
-		cmd += "-v error "
+		defaults["global"] += " -v error"
 	}
 
-	streams.HandleFunc("ffmpeg", func(s string) (streamer.Producer, error) {
-		s = s[7:] // remove `ffmpeg:`
-
-		var query url.Values
-		var queryVideo, queryAudio bool
-
-		if i := strings.IndexByte(s, '#'); i > 0 {
-			query = parseQuery(s[i+1:])
-			queryVideo = query["video"] != nil
-			queryAudio = query["audio"] != nil
-			s = s[:i]
-		} else {
-			// by default query both video and audio
-			queryVideo = true
-			queryAudio = true
+	streams.HandleFunc("ffmpeg", func(url string) (streamer.Producer, error) {
+		args := parseArgs(url[7:]) // remove `ffmpeg:`
+		if args == nil {
+			return nil, errors.New("can't generate ffmpeg command")
 		}
-
-		var input string
-		if i := strings.Index(s, "://"); i > 0 {
-			switch s[:i] {
-			case "http", "https", "rtmp":
-				input = strings.Replace(tpl["http"], "{input}", s, 1)
-			case "rtsp", "rtsps":
-				// https://ffmpeg.org/ffmpeg-protocols.html#rtsp
-				// skip unnecessary input tracks
-				switch {
-				case queryVideo && queryAudio:
-					input = "-allowed_media_types video+audio "
-				case queryVideo:
-					input = "-allowed_media_types video "
-				case queryAudio:
-					input = "-allowed_media_types audio "
-				}
-
-				input += strings.Replace(tpl["rtsp"], "{input}", s, 1)
-			default:
-				input = "-i " + s
-			}
-		} else if streams.Get(s) != nil {
-			s = "rtsp://localhost:" + rtsp.Port + "/" + s
-			switch {
-			case queryVideo && !queryAudio:
-				s += "?video"
-			case queryAudio && !queryVideo:
-				s += "?audio"
-			}
-			input = strings.Replace(tpl["rtsp"], "{input}", s, 1)
-		} else if strings.HasPrefix(s, "device?") {
-			var err error
-			input, err = device.GetInput(s)
-			if err != nil {
-				return nil, err
-			}
-		} else {
-			input = strings.Replace(tpl["file"], "{input}", s, 1)
-		}
-
-		if _, ok := query["async"]; ok {
-			input = "-use_wallclock_as_timestamps 1 -async 1 " + input
-		}
-
-		s = cmd + input
-
-		if query != nil {
-			for _, raw := range query["raw"] {
-				s += " " + raw
-			}
-
-			for _, rotate := range query["rotate"] {
-				switch rotate {
-				case "90":
-					s += " -vf transpose=1" // 90 degrees clockwise
-				case "180":
-					s += " -vf transpose=1,transpose=1"
-				case "-90", "270":
-					s += " -vf transpose=2" // 90 degrees counterclockwise
-				}
-				break
-			}
-
-			switch len(query["video"]) {
-			case 0:
-				s += " -vn"
-			case 1:
-				if len(query["audio"]) > 1 {
-					s += " -map 0:v:0"
-				}
-				for _, video := range query["video"] {
-					if video == "copy" {
-						s += " -c:v copy"
-					} else {
-						s += " " + tpl[video]
-					}
-				}
-			default:
-				for i, video := range query["video"] {
-					if video == "copy" {
-						s += " -map 0:v:0 -c:v:" + strconv.Itoa(i) + " copy"
-					} else {
-						s += " -map 0:v:0 " + strings.ReplaceAll(tpl[video], ":v ", ":v:"+strconv.Itoa(i)+" ")
-					}
-				}
-			}
-
-			switch len(query["audio"]) {
-			case 0:
-				s += " -an"
-			case 1:
-				if len(query["video"]) > 1 {
-					s += " -map 0:a:0"
-				}
-				for _, audio := range query["audio"] {
-					if audio == "copy" {
-						s += " -c:a copy"
-					} else {
-						s += " " + tpl[audio]
-					}
-				}
-			default:
-				for i, audio := range query["audio"] {
-					if audio == "copy" {
-						s += " -map 0:a:0 -c:a:" + strconv.Itoa(i) + " copy"
-					} else {
-						s += " -map 0:a:0 " + strings.ReplaceAll(tpl[audio], ":a ", ":a:"+strconv.Itoa(i)+" ")
-					}
-				}
-			}
-		} else {
-			s += " -c copy"
-		}
-
-		s += " " + tpl["output"]
-
-		return exec.Handle(s)
+		return exec.Handle("exec:" + args.String())
 	})
 
-	device.Bin = cfg.Mod["bin"]
+	device.Bin = defaults["bin"]
 	device.Init()
 }
 
+var defaults = map[string]string{
+	"bin":    "ffmpeg",
+	"global": "-hide_banner",
+
+	// inputs
+	"file": "-re -i {input}",
+	"http": "-fflags nobuffer -flags low_delay -i {input}",
+	"rtsp": "-fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_transport tcp -i {input}",
+
+	"rtsp/udp": "-fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -i {input}",
+
+	// output
+	"output": "-user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}",
+
+	// `-preset superfast` - we can't use ultrafast because it doesn't support `-profile main -level 4.1`
+	// `-tune zerolatency` - for minimal latency
+	// `-profile high -level 4.1` - most used streaming profile
+	"h264":  "-c:v libx264 -g 50 -profile:v high -level:v 4.1 -preset:v superfast -tune:v zerolatency",
+	"h265":  "-c:v libx265 -g 50 -profile:v high -level:v 5.1 -preset:v superfast -tune:v zerolatency",
+	"mjpeg": "-c:v mjpeg -force_duplicated_matrix:v 1 -huffman:v 0 -pix_fmt:v yuvj420p",
+
+	"opus":       "-c:a libopus -ar:a 48000 -ac:a 2",
+	"pcmu":       "-c:a pcm_mulaw -ar:a 8000 -ac:a 1",
+	"pcmu/16000": "-c:a pcm_mulaw -ar:a 16000 -ac:a 1",
+	"pcmu/48000": "-c:a pcm_mulaw -ar:a 48000 -ac:a 1",
+	"pcma":       "-c:a pcm_alaw -ar:a 8000 -ac:a 1",
+	"pcma/16000": "-c:a pcm_alaw -ar:a 16000 -ac:a 1",
+	"pcma/48000": "-c:a pcm_alaw -ar:a 48000 -ac:a 1",
+	"aac":        "-c:a aac", // keep sample rate and channels
+	"aac/16000":  "-c:a aac -ar:a 16000 -ac:a 1",
+	"mp3":        "-c:a libmp3lame -q:a 8",
+
+	// hardware Intel and AMD on Linux
+	// better not to set `-async_depth:v 1` like for QSV, because framedrops
+	// `-bf 0` - disable B-frames is very important
+	"h264/vaapi":  "-c:v h264_vaapi -g 50 -bf 0 -profile:v high -level:v 4.1 -sei:v 0",
+	"h265/vaapi":  "-c:v hevc_vaapi -g 50 -bf 0 -profile:v high -level:v 5.1 -sei:v 0",
+	"mjpeg/vaapi": "-c:v mjpeg_vaapi",
+
+	// hardware Raspberry
+	"h264/v4l2m2m": "-c:v h264_v4l2m2m -g 50 -bf 0",
+	"h265/v4l2m2m": "-c:v hevc_v4l2m2m -g 50 -bf 0",
+
+	// hardware NVidia on Linux and Windows
+	// preset=p2 - faster, tune=ll - low latency
+	"h264/cuda": "-c:v h264_nvenc -g 50 -profile:v high -level:v auto -preset:v p2 -tune:v ll",
+	"h265/cuda": "-c:v hevc_nvenc -g 50 -profile:v high -level:v auto",
+
+	// hardware Intel on Windows
+	"h264/dxva2":  "-c:v h264_qsv -g 50 -bf 0 -profile:v high -level:v 4.1 -async_depth:v 1",
+	"h265/dxva2":  "-c:v hevc_qsv -g 50 -bf 0 -profile:v high -level:v 5.1 -async_depth:v 1",
+	"mjpeg/dxva2": "-c:v mjpeg_qsv -profile:v high -level:v 5.1",
+
+	// hardware macOS
+	"h264/videotoolbox": "-c:v h264_videotoolbox -g 50 -bf 0 -profile:v high -level:v 4.1",
+	"h265/videotoolbox": "-c:v hevc_videotoolbox -g 50 -bf 0 -profile:v high -level:v 5.1",
+}
+
+// inputTemplate - select input template from YAML config by template name
+// if query has input param - select another tempalte by this name
+// if there is no another template - use input param as template
+func inputTemplate(name, s string, query url.Values) string {
+	var template string
+	if input := query.Get("input"); input != "" {
+		if template = defaults[input]; template == "" {
+			template = input
+		}
+	} else {
+		template = defaults[name]
+	}
+	return strings.Replace(template, "{input}", s, 1)
+}
+
+func parseArgs(s string) *Args {
+	// init FFmpeg arguments
+	args := &Args{
+		bin:    defaults["bin"],
+		global: defaults["global"],
+		output: defaults["output"],
+	}
+
+	var query url.Values
+	if i := strings.IndexByte(s, '#'); i > 0 {
+		query = parseQuery(s[i+1:])
+		args.video = len(query["video"])
+		args.audio = len(query["audio"])
+		s = s[:i]
+	}
+
+	// Parse input:
+	//   1. Input as xxxx:// link (http or rtsp or any other)
+	//   2. Input as stream name
+	//   3. Input as FFmpeg device (local USB camera)
+	if i := strings.Index(s, "://"); i > 0 {
+		switch s[:i] {
+		case "http", "https", "rtmp":
+			args.input = inputTemplate("http", s, query)
+		case "rtsp", "rtsps":
+			// https://ffmpeg.org/ffmpeg-protocols.html#rtsp
+			// skip unnecessary input tracks
+			switch {
+			case (args.video > 0 && args.audio > 0) || (args.video == 0 && args.audio == 0):
+				args.input = "-allowed_media_types video+audio "
+			case args.video > 0:
+				args.input = "-allowed_media_types video "
+			case args.audio > 0:
+				args.input = "-allowed_media_types audio "
+			}
+
+			args.input += inputTemplate("rtsp", s, query)
+		default:
+			args.input = "-i " + s
+		}
+	} else if streams.Get(s) != nil {
+		s = "rtsp://localhost:" + rtsp.Port + "/" + s
+		switch {
+		case args.video > 0 && args.audio == 0:
+			s += "?video"
+		case args.audio > 0 && args.video == 0:
+			s += "?audio"
+		default:
+			s += "?video&audio"
+		}
+		args.input = inputTemplate("rtsp", s, query)
+	} else if strings.HasPrefix(s, "device?") {
+		var err error
+		args.input, err = device.GetInput(s)
+		if err != nil {
+			return nil
+		}
+	} else {
+		args.input = inputTemplate("file", s, query)
+	}
+
+	if query["async"] != nil {
+		args.input = "-use_wallclock_as_timestamps 1 -async 1 " + args.input
+	}
+
+	// Parse query params:
+	//   1. `width`/`height` params
+	//   2. `rotate` param
+	//   3. `video` params (support multiple)
+	//   4. `audio` params (support multiple)
+	//   5. `hardware` param
+	if query != nil {
+		// 1. Process raw params for FFmpeg
+		for _, raw := range query["raw"] {
+			args.AddCodec(raw)
+		}
+
+		// 2. Process video filters (resize and rotation)
+		if query["width"] != nil || query["height"] != nil {
+			filter := "scale="
+			if query["width"] != nil {
+				filter += query["width"][0]
+			} else {
+				filter += "-1"
+			}
+			filter += ":"
+			if query["height"] != nil {
+				filter += query["height"][0]
+			} else {
+				filter += "-1"
+			}
+			args.AddFilter(filter)
+		}
+
+		if query["rotate"] != nil {
+			var filter string
+			switch query["rotate"][0] {
+			case "90":
+				filter = "transpose=1" // 90 degrees clockwise
+			case "180":
+				filter = "transpose=1,transpose=1"
+			case "-90", "270":
+				filter = "transpose=2" // 90 degrees counterclockwise
+			}
+			if filter != "" {
+				args.AddFilter(filter)
+			}
+		}
+
+		// 3. Process video codecs
+		if args.video > 0 {
+			for _, video := range query["video"] {
+				if video != "copy" {
+					if codec := defaults[video]; codec != "" {
+						args.AddCodec(codec)
+					} else {
+						args.AddCodec(video)
+					}
+				} else {
+					args.AddCodec("-c:v copy")
+				}
+			}
+		} else {
+			args.AddCodec("-vn")
+		}
+
+		// 4. Process audio codecs
+		if args.audio > 0 {
+			for _, audio := range query["audio"] {
+				if audio != "copy" {
+					if codec := defaults[audio]; codec != "" {
+						args.AddCodec(codec)
+					} else {
+						args.AddCodec(audio)
+					}
+				} else {
+					args.AddCodec("-c:a copy")
+				}
+			}
+		} else {
+			args.AddCodec("-an")
+		}
+
+		if query["hardware"] != nil {
+			MakeHardware(args, query["hardware"][0])
+		}
+	}
+
+	if args.codecs == nil {
+		args.AddCodec("-c copy")
+	}
+
+	return args
+}
+
 func parseQuery(s string) map[string][]string {
 	query := map[string][]string{}
 	for _, key := range strings.Split(s, "#") {
@@ -213,3 +279,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/hls/hls.go

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

cmd/http/http.go

@@ -0,0 +1,65 @@
+package http
+
+import (
+	"errors"
+	"fmt"
+	"github.com/AlexxIT/go2rtc/cmd/streams"
+	"github.com/AlexxIT/go2rtc/pkg/mjpeg"
+	"github.com/AlexxIT/go2rtc/pkg/mpegts"
+	"github.com/AlexxIT/go2rtc/pkg/rtmp"
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/AlexxIT/go2rtc/pkg/tcp"
+	"net/http"
+	"strings"
+)
+
+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
+
+	case "video/mpeg":
+		client := mpegts.NewClient(res)
+		if err = client.Handle(); err != nil {
+			return nil, err
+		}
+		return client, nil
+	}
+
+	return nil, fmt.Errorf("unsupported Content-Type: %s", ct)
+}

cmd/mjpeg/mjpeg.go

@@ -1,10 +1,12 @@
 package mjpeg
 
 import (
+	"errors"
 	"github.com/AlexxIT/go2rtc/cmd/api"
 	"github.com/AlexxIT/go2rtc/cmd/streams"
 	"github.com/AlexxIT/go2rtc/pkg/mjpeg"
 	"github.com/rs/zerolog/log"
+	"io"
 	"net/http"
 	"strconv"
 )
@@ -12,18 +14,24 @@ 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
 	}
 
 	exit := make(chan []byte)
 
-	cons := &mjpeg.Consumer{}
+	cons := &mjpeg.Consumer{
+		RemoteAddr: r.RemoteAddr,
+		UserAgent:  r.UserAgent(),
+	}
 	cons.Listen(func(msg interface{}) {
 		switch msg := msg.(type) {
 		case []byte:
@@ -40,8 +48,12 @@ func handlerKeyframe(w http.ResponseWriter, r *http.Request) {
 
 	stream.RemoveConsumer(cons)
 
-	w.Header().Set("Content-Type", "image/jpeg")
-	w.Header().Set("Content-Length", strconv.Itoa(len(data)))
+	h := w.Header()
+	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()
@@ -51,26 +63,39 @@ func handlerKeyframe(w http.ResponseWriter, r *http.Request) {
 const header = "--frame\r\nContent-Type: image/jpeg\r\nContent-Length: "
 
 func handlerStream(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "POST" {
+		outputMjpeg(w, r)
+	} else {
+		inputMjpeg(w, r)
+	}
+}
+
+func outputMjpeg(w http.ResponseWriter, r *http.Request) {
 	src := r.URL.Query().Get("src")
 	stream := streams.GetOrNew(src)
 	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
 		return
 	}
 
-	exit := make(chan struct{})
+	flusher := w.(http.Flusher)
 
-	cons := &mjpeg.Consumer{}
+	cons := &mjpeg.Consumer{
+		RemoteAddr: r.RemoteAddr,
+		UserAgent:  r.UserAgent(),
+	}
 	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 {
-				exit <- struct{}{}
-			}
+			// Chrome bug: mjpeg image always shows the second to last image
+			// https://bugs.chromium.org/p/chromium/issues/detail?id=527446
+			_, _ = w.Write(data)
+			flusher.Flush()
 		}
 	})
 
@@ -79,11 +104,67 @@ 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 inputMjpeg(w http.ResponseWriter, r *http.Request) {
+	dst := r.URL.Query().Get("dst")
+	stream := streams.Get(dst)
+	if stream == nil {
+		http.Error(w, api.StreamNotFound, http.StatusNotFound)
+		return
+	}
+
+	res := &http.Response{Body: r.Body, Header: r.Header, Request: r}
+	res.Header.Set("Content-Type", "multipart/mixed;boundary=")
+
+	client := mjpeg.NewClient(res)
+	stream.AddProducer(client)
+
+	if err := client.Start(); err != nil && err != io.EOF {
+		log.Warn().Err(err).Caller().Send()
+	}
+
+	stream.RemoveProducer(client)
+}
+
+func handlerWS(tr *api.Transport, _ *api.Message) error {
+	src := tr.Request.URL.Query().Get("src")
+	stream := streams.GetOrNew(src)
+	if stream == nil {
+		return errors.New(api.StreamNotFound)
+	}
+
+	cons := &mjpeg.Consumer{
+		RemoteAddr: tr.Request.RemoteAddr,
+		UserAgent:  tr.Request.UserAgent(),
+	}
+	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

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

cmd/mp4/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,143 @@
+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{
+		RemoteAddr: tr.Request.RemoteAddr,
+		UserAgent:  tr.Request.UserAgent(),
+	}
+
+	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.Debug().Err(err).Msg("[mp4] add consumer")
+		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{
+		RemoteAddr:   tr.Request.RemoteAddr,
+		UserAgent:    tr.Request.UserAgent(),
+		OnlyKeyframe: true,
+	}
+
+	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 mp4.MimeH264:
+			codec := &streamer.Codec{Name: streamer.CodecH264}
+			videos = append(videos, codec)
+		case mp4.MimeH265:
+			codec := &streamer.Codec{Name: streamer.CodecH265}
+			videos = append(videos, codec)
+		case mp4.MimeAAC:
+			codec := &streamer.Codec{Name: streamer.CodecAAC}
+			audios = append(audios, codec)
+		case mp4.MimeOpus:
+			codec := &streamer.Codec{Name: streamer.CodecOpus}
+			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/mpegts/mpegts.go

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

cmd/rtmp/rtmp.go

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

cmd/rtsp/rtsp.go

@@ -3,25 +3,32 @@ package rtsp
 import (
 	"github.com/AlexxIT/go2rtc/cmd/app"
 	"github.com/AlexxIT/go2rtc/cmd/streams"
+	"github.com/AlexxIT/go2rtc/pkg/mp4"
 	"github.com/AlexxIT/go2rtc/pkg/rtsp"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/AlexxIT/go2rtc/pkg/tcp"
 	"github.com/rs/zerolog"
 	"net"
+	"net/url"
 	"strings"
 )
 
 func Init() {
 	var conf struct {
 		Mod struct {
-			Listen string `yaml:"listen"`
+			Listen       string `yaml:"listen" json:"listen"`
+			Username     string `yaml:"username" json:"-"`
+			Password     string `yaml:"password" json:"-"`
+			DefaultQuery string `yaml:"default_query" json:"default_query"`
 		} `yaml:"rtsp"`
 	}
 
 	// default config
 	conf.Mod.Listen = ":8554"
+	conf.Mod.DefaultQuery = "video&audio"
 
 	app.LoadConfig(&conf)
+	app.Info["rtsp"] = conf.Mod
 
 	log = app.GetLogger("rtsp")
 
@@ -46,13 +53,23 @@ func Init() {
 
 	log.Info().Str("addr", address).Msg("[rtsp] listen")
 
+	if query, err := url.ParseQuery(conf.Mod.DefaultQuery); err == nil {
+		defaultMedias = mp4.ParseQuery(query)
+	}
+
 	go func() {
 		for {
 			conn, err := ln.Accept()
 			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)
 		}
 	}()
 }
@@ -69,6 +86,7 @@ var Port string
 
 var log zerolog.Logger
 var handlers []Handler
+var defaultMedias []*streamer.Media
 
 func rtspHandler(url string) (streamer.Producer, error) {
 	backchannel := true
@@ -94,6 +112,8 @@ func rtspHandler(url string) (streamer.Producer, error) {
 				log.Trace().Msgf("[rtsp] client request:\n%s", msg)
 			case *tcp.Response:
 				log.Trace().Msgf("[rtsp] client response:\n%s", msg)
+			case string:
+				log.Trace().Msgf("[rtsp] client msg: %s", msg)
 			}
 		})
 	}
@@ -121,13 +141,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 +159,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)
@@ -149,7 +173,14 @@ func tcpHandler(c net.Conn) {
 
 			log.Debug().Str("stream", name).Msg("[rtsp] new consumer")
 
-			initMedias(conn)
+			conn.SessionName = app.UserAgent
+
+			conn.Medias = mp4.ParseQuery(conn.URL.Query())
+			if conn.Medias == nil {
+				for _, media := range defaultMedias {
+					conn.Medias = append(conn.Medias, media.Clone())
+				}
+			}
 
 			if err := stream.AddConsumer(conn); err != nil {
 				log.Warn().Err(err).Str("stream", name).Msg("[rtsp]")
@@ -161,6 +192,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)
@@ -183,6 +219,9 @@ func tcpHandler(c net.Conn) {
 
 	if err := conn.Accept(); err != nil {
 		log.Warn().Err(err).Caller().Send()
+		if closer != nil {
+			closer()
+		}
 		_ = conn.Close()
 		return
 	}
@@ -195,7 +234,7 @@ func tcpHandler(c net.Conn) {
 
 	if closer != nil {
 		if err := conn.Handle(); err != nil {
-			log.Debug().Err(err).Caller().Send()
+			log.Debug().Msgf("[rtsp] handle=%s", err)
 		}
 
 		closer()
@@ -205,45 +244,3 @@ func tcpHandler(c net.Conn) {
 
 	_ = conn.Close()
 }
-
-func initMedias(conn *rtsp.Conn) {
-	// set media candidates from query list
-	for key, value := range conn.URL.Query() {
-		switch key {
-		case streamer.KindVideo, streamer.KindAudio:
-			for _, name := range value {
-				name = strings.ToUpper(name)
-
-				// check aliases
-				switch name {
-				case "COPY":
-					name = "" // pass empty codecs list
-				case "MJPEG":
-					name = streamer.CodecJPEG
-				case "AAC":
-					name = streamer.CodecAAC
-				}
-
-				media := &streamer.Media{
-					Kind: key, Direction: streamer.DirectionRecvonly,
-				}
-
-				// empty codecs match all codecs
-				if name != "" {
-					// empty clock rate and channels match any values
-					media.Codecs = []*streamer.Codec{{Name: name}}
-				}
-
-				conn.Medias = append(conn.Medias, media)
-			}
-		}
-	}
-
-	// set default media candidates if query is empty
-	if conn.Medias == nil {
-		conn.Medias = []*streamer.Media{
-			{Kind: streamer.KindVideo, Direction: streamer.DirectionRecvonly},
-			{Kind: streamer.KindAudio, Direction: streamer.DirectionRecvonly},
-		}
-	}
-}

cmd/streams/consumer.go

@@ -0,0 +1,15 @@
+package streams
+
+import (
+	"encoding/json"
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+)
+
+type Consumer struct {
+	element streamer.Consumer
+	tracks  []*streamer.Track
+}
+
+func (c *Consumer) MarshalJSON() ([]byte, error) {
+	return json.Marshal(c.element)
+}

cmd/streams/play.go

@@ -0,0 +1,116 @@
+package streams
+
+import (
+	"errors"
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+)
+
+func (s *Stream) Play(source string) error {
+	s.mu.Lock()
+	for _, producer := range s.producers {
+		if producer.state == stateInternal && producer.element != nil {
+			_ = producer.element.Stop()
+		}
+	}
+	s.mu.Unlock()
+
+	if source == "" {
+		return nil
+	}
+
+	for _, producer := range s.producers {
+		// start new client
+		client, err := GetProducer(producer.url)
+		if err != nil {
+			return err
+		}
+
+		// check if client support consumer interface
+		cons, ok := client.(streamer.Consumer)
+		if !ok {
+			continue
+		}
+
+		// start new producer
+		prod, err := GetProducer(source)
+		if err != nil {
+			return err
+		}
+
+		if !matchMedia(prod, cons) {
+			return errors.New("can't match media")
+		}
+
+		s.AddInternalProducer(prod)
+		s.AddInternalConsumer(cons)
+
+		go func() {
+			_ = prod.Start()
+			_ = client.Stop()
+			s.RemoveProducer(prod)
+		}()
+
+		go func() {
+			_ = client.Start()
+			_ = prod.Stop()
+			s.RemoveInternalConsumer(cons)
+		}()
+
+		return nil
+	}
+
+	return errors.New("can't find consumer")
+}
+
+func (s *Stream) AddInternalProducer(prod streamer.Producer) {
+	producer := &Producer{element: prod, state: stateInternal}
+	s.mu.Lock()
+	s.producers = append(s.producers, producer)
+	s.mu.Unlock()
+}
+
+func (s *Stream) AddInternalConsumer(cons streamer.Consumer) {
+	consumer := &Consumer{element: cons}
+	s.mu.Lock()
+	s.consumers = append(s.consumers, consumer)
+	s.mu.Unlock()
+}
+
+func (s *Stream) RemoveInternalConsumer(cons streamer.Consumer) {
+	s.mu.Lock()
+	for i, consumer := range s.consumers {
+		if consumer.element == cons {
+			s.removeConsumer(i)
+			break
+		}
+	}
+	s.mu.Unlock()
+}
+
+func matchMedia(prod streamer.Producer, cons streamer.Consumer) bool {
+	for _, consMedia := range cons.GetMedias() {
+		for _, prodMedia := range prod.GetMedias() {
+			// codec negotiation
+			prodCodec := prodMedia.MatchMedia(consMedia)
+			if prodCodec == nil {
+				continue
+			}
+
+			// setup producer track
+			prodTrack := prod.GetTrack(prodMedia, prodCodec)
+			if prodTrack == nil {
+				return false
+			}
+
+			// setup consumer track
+			consTrack := cons.AddTrack(consMedia, prodTrack)
+			if consTrack == nil {
+				return false
+			}
+
+			return true
+		}
+	}
+
+	return false
+}

cmd/streams/producer.go

@@ -1,6 +1,7 @@
 package streams
 
 import (
+	"encoding/json"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"strings"
 	"sync"
@@ -15,6 +16,7 @@ const (
 	stateTracks
 	stateStart
 	stateExternal
+	stateInternal
 )
 
 type Producer struct {
@@ -24,11 +26,12 @@ type Producer struct {
 	template string
 
 	element streamer.Producer
+	lastErr error
 	tracks  []*streamer.Track
 
-	state   state
-	mu      sync.Mutex
-	restart *time.Timer
+	state    state
+	mu       sync.Mutex
+	workerID int
 }
 
 func (p *Producer) SetSource(s string) {
@@ -45,16 +48,20 @@ 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, err = GetProducer(p.url)
-		if err != nil || p.element == nil {
-			log.Error().Err(err).Caller().Send()
+		p.element, p.lastErr = GetProducer(p.url)
+		if p.lastErr != nil || p.element == nil {
+			log.Error().Err(p.lastErr).Str("url", p.url).Caller().Send()
 			return nil
 		}
 
 		p.state = stateMedias
 	}
 
+	// if element in reconnect state
+	if p.element == nil {
+		return nil
+	}
+
 	return p.element.GetMedias()
 }
 
@@ -86,6 +93,15 @@ func (p *Producer) GetTrack(media *streamer.Media, codec *streamer.Codec) *strea
 	return track
 }
 
+func (p *Producer) MarshalJSON() ([]byte, error) {
+	if p.element != nil {
+		return json.Marshal(p.element)
+	}
+
+	info := streamer.Info{URL: p.url}
+	return json.Marshal(info)
+}
+
 // internals
 
 func (p *Producer) start() {
@@ -99,32 +115,45 @@ func (p *Producer) start() {
 	log.Debug().Msgf("[streams] start producer url=%s", p.url)
 
 	p.state = stateStart
-	go func() {
-		// safe read element while mu locked
-		if err := p.element.Start(); err != nil {
-			log.Warn().Err(err).Caller().Send()
-		}
-		p.reconnect()
-	}()
+	p.workerID++
+
+	go p.worker(p.element, p.workerID)
 }
 
-func (p *Producer) reconnect() {
+func (p *Producer) worker(element streamer.Producer, workerID int) {
+	if err := element.Start(); err != nil {
+		p.mu.Lock()
+		closed := p.workerID != workerID
+		p.mu.Unlock()
+
+		if closed {
+			return
+		}
+
+		log.Warn().Err(err).Str("url", p.url).Caller().Send()
+	}
+
+	p.reconnect(workerID)
+}
+
+func (p *Producer) reconnect(workerID int) {
 	p.mu.Lock()
 	defer p.mu.Unlock()
 
-	if p.state != stateStart {
+	if p.workerID != workerID {
 		log.Trace().Msgf("[streams] stop reconnect url=%s", p.url)
 		return
 	}
 
 	log.Debug().Msgf("[streams] reconnect to url=%s", p.url)
 
-	var err error
-	p.element, err = GetProducer(p.url)
-	if err != nil || p.element == nil {
-		log.Debug().Err(err).Caller().Send()
+	p.element, p.lastErr = GetProducer(p.url)
+	if p.lastErr != nil || p.element == nil {
+		log.Debug().Msgf("[streams] producer=%s", p.lastErr)
 		// TODO: dynamic timeout
-		p.restart = time.AfterFunc(30*time.Second, p.reconnect)
+		time.AfterFunc(30*time.Second, func() {
+			p.reconnect(workerID)
+		})
 		return
 	}
 
@@ -148,12 +177,7 @@ func (p *Producer) reconnect() {
 		}
 	}
 
-	go func() {
-		if err = p.element.Start(); err != nil {
-			log.Debug().Err(err).Caller().Send()
-		}
-		p.reconnect()
-	}()
+	go p.worker(p.element, workerID)
 }
 
 func (p *Producer) stop() {
@@ -167,6 +191,8 @@ func (p *Producer) stop() {
 	case stateNone:
 		log.Debug().Msgf("[streams] can't stop none producer")
 		return
+	case stateStart:
+		p.workerID++
 	}
 
 	log.Debug().Msgf("[streams] stop producer url=%s", p.url)
@@ -175,10 +201,6 @@ func (p *Producer) stop() {
 		_ = p.element.Stop()
 		p.element = nil
 	}
-	if p.restart != nil {
-		p.restart.Stop()
-		p.restart = nil
-	}
 
 	p.state = stateNone
 	p.tracks = nil

cmd/streams/stream.go

@@ -3,19 +3,18 @@ package streams
 import (
 	"encoding/json"
 	"errors"
+	"fmt"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"strings"
 	"sync"
+	"sync/atomic"
 )
 
-type Consumer struct {
-	element streamer.Consumer
-	tracks  []*streamer.Track
-}
-
 type Stream struct {
 	producers []*Producer
 	consumers []*Consumer
 	mu        sync.Mutex
+	requests  int32
 }
 
 func NewStream(source interface{}) *Stream {
@@ -50,11 +49,16 @@ func (s *Stream) SetSource(source string) {
 }
 
 func (s *Stream) AddConsumer(cons streamer.Consumer) (err error) {
+	// support for multiple simultaneous requests from different consumers
+	atomic.AddInt32(&s.requests, 1)
+
 	ic := len(s.consumers)
 
 	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 {
@@ -76,7 +82,7 @@ func (s *Stream) AddConsumer(cons streamer.Consumer) (err error) {
 					// Step 4. Get producer track
 					prodTrack := prod.GetTrack(prodMedia, prodCodec)
 					if prodTrack == nil {
-						log.Warn().Msg("[stream] can't get track")
+						log.Warn().Str("url", prod.url).Msg("[streams] can't get track")
 						continue
 					}
 
@@ -85,15 +91,30 @@ func (s *Stream) AddConsumer(cons streamer.Consumer) (err error) {
 
 					consumer.tracks = append(consumer.tracks, consTrack)
 					producers = append(producers, prod)
-					break producers
+					if !consMedia.MatchAll() {
+						break producers
+					}
 				}
 			}
 		}
 	}
 
-	if len(producers) == 0 {
+	if atomic.AddInt32(&s.requests, -1) == 0 {
 		s.stopProducers()
-		return errors.New("couldn't find the matching tracks")
+	}
+
+	if len(producers) == 0 {
+		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()
@@ -173,22 +194,21 @@ producers:
 //}
 
 func (s *Stream) MarshalJSON() ([]byte, error) {
-	var v []interface{}
-	s.mu.Lock()
-	for _, prod := range s.producers {
-		if prod.element != nil {
-			v = append(v, prod.element)
-		}
+	if !s.mu.TryLock() {
+		log.Warn().Msgf("[streams] json locked")
+		return json.Marshal(nil)
 	}
-	for _, cons := range s.consumers {
-		// cons.element always not nil
-		v = append(v, cons.element)
+
+	var info struct {
+		Producers []*Producer `json:"producers"`
+		Consumers []*Consumer `json:"consumers"`
 	}
+	info.Producers = s.producers
+	info.Consumers = s.consumers
+
 	s.mu.Unlock()
-	if len(v) == 0 {
-		v = nil
-	}
-	return json.Marshal(v)
+
+	return json.Marshal(info)
 }
 
 func (s *Stream) removeConsumer(i int) {
@@ -216,3 +236,23 @@ func (s *Stream) removeProducer(i int) {
 		s.producers = append(s.producers[:i], s.producers[i+1:]...)
 	}
 }
+
+func collectCodecs(media *streamer.Media, codecs *string) {
+	if media.Direction == streamer.DirectionRecvonly {
+		return
+	}
+
+	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/streams/stream_test.go

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

cmd/streams/streams.go

@@ -1,9 +1,12 @@
 package streams
 
 import (
+	"encoding/json"
+	"github.com/AlexxIT/go2rtc/cmd/api"
 	"github.com/AlexxIT/go2rtc/cmd/app"
 	"github.com/AlexxIT/go2rtc/cmd/app/store"
 	"github.com/rs/zerolog"
+	"net/http"
 )
 
 func Init() {
@@ -22,6 +25,8 @@ func Init() {
 	for name, item := range store.GetDict("streams") {
 		streams[name] = NewStream(item)
 	}
+
+	api.HandleFunc("api/streams", streamsHandler)
 }
 
 func Get(name string) *Stream {
@@ -48,19 +53,63 @@ func GetOrNew(src string) *Stream {
 	return New(src, src)
 }
 
-func Delete(name string) {
-	delete(streams, name)
-}
+func streamsHandler(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+	src := query.Get("src")
 
-func All() map[string]interface{} {
-	all := map[string]interface{}{}
-	for name, stream := range streams {
-		all[name] = stream
-		//if stream.Active() {
-		//	all[name] = stream
-		//}
+	// without source - return all streams list
+	if src == "" && r.Method != "POST" {
+		_ = json.NewEncoder(w).Encode(streams)
+		return
+	}
+
+	// Not sure about all this API. Should be rewrited...
+	switch r.Method {
+	case "GET":
+		e := json.NewEncoder(w)
+		e.SetIndent("", "  ")
+		_ = e.Encode(streams[src])
+
+	case "PUT":
+		name := query.Get("name")
+		if name == "" {
+			name = src
+		}
+
+		New(name, src)
+
+	case "PATCH":
+		name := query.Get("name")
+		if name == "" {
+			http.Error(w, "", http.StatusBadRequest)
+			return
+		}
+
+		if stream := Get(name); stream != nil {
+			stream.SetSource(src)
+		} else {
+			New(name, src)
+		}
+
+	case "POST":
+		// with dst - redirect source to dst
+		if dst := query.Get("dst"); dst != "" {
+			if stream := Get(dst); stream != nil {
+				if err := stream.Play(src); err != nil {
+					http.Error(w, err.Error(), http.StatusInternalServerError)
+				} else {
+					_ = json.NewEncoder(w).Encode(stream)
+				}
+			} else {
+				http.Error(w, "", http.StatusNotFound)
+			}
+		} else {
+			http.Error(w, "", http.StatusBadRequest)
+		}
+
+	case "DELETE":
+		delete(streams, src)
 	}
-	return all
 }
 
 var log zerolog.Logger

cmd/tapo/tapo.go

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

cmd/webrtc/candidates.go

@@ -2,18 +2,40 @@ 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"
 )
 
 var candidates []string
+var networks = []string{"udp", "tcp"}
 
 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
+		}
+
+		for _, network := range networks {
+			cand, err := webrtc.NewCandidate(network, 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
 	}
@@ -38,13 +60,15 @@ func addCanditates(answer string) (string, error) {
 			continue
 		}
 
-		cand, err := webrtc.NewCandidate(address)
-		if err != nil {
-			log.Warn().Err(err).Msg("[webrtc] candidate")
-			continue
-		}
+		for _, network := range networks {
+			cand, err := webrtc.NewCandidate(network, address)
+			if err != nil {
+				log.Warn().Err(err).Msg("[webrtc] candidate")
+				continue
+			}
 
-		md.WithPropertyAttribute(cand)
+			md.WithPropertyAttribute(cand)
+		}
 	}
 
 	if end {
@@ -59,12 +83,14 @@ func addCanditates(answer string) (string, error) {
 	return string(data), nil
 }
 
-func candidateHandler(ctx *api.Context, msg *streamer.Message) {
-	if ctx.Consumer == nil {
-		return
+func candidateHandler(tr *api.Transport, msg *api.Message) error {
+	if tr.Consumer == nil {
+		return nil
 	}
-	if conn := ctx.Consumer.(*webrtc.Conn); conn != nil {
-		log.Trace().Str("candidate", msg.Value.(string)).Msg("[webrtc] remote")
-		conn.Push(msg)
+	if conn := tr.Consumer.(*webrtc.Conn); conn != nil {
+		s := msg.Value.(string)
+		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"
 )
@@ -22,6 +22,7 @@ func Init() {
 		} `yaml:"webrtc"`
 	}
 
+	cfg.Mod.Listen = ":8555"
 	cfg.Mod.IceServers = []pion.ICEServer{
 		{URLs: []string{"stun:stun.l.google.com:19302"}},
 	}
@@ -33,7 +34,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 +56,8 @@ func Init() {
 
 	candidates = cfg.Mod.Candidates
 
-	api.HandleWS(webrtc.MsgTypeOffer, offerHandler)
-	api.HandleWS(webrtc.MsgTypeCandidate, candidateHandler)
+	api.HandleWS("webrtc/offer", asyncHandler)
+	api.HandleWS("webrtc/candidate", candidateHandler)
 
 	api.HandleFunc("api/webrtc", syncHandler)
 }
@@ -66,11 +67,11 @@ var log zerolog.Logger
 
 var NewPConn func() (*pion.PeerConnection, error)
 
-func offerHandler(ctx *api.Context, msg *streamer.Message) {
-	src := ctx.Request.URL.Query().Get("src")
-	stream := streams.Get(src)
+func asyncHandler(tr *api.Transport, msg *api.Message) error {
+	src := tr.Request.URL.Query().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 +82,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")
-		return
+		log.Error().Err(err).Caller().Send()
+		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:
-			// subscribe on webrtc server candidates
-			log.Trace().Str("candidate", msg.Value.(string)).Msg("[webrtc] local")
-			ctx.Write(msg)
+		case *pion.ICECandidate:
+			if msg != nil {
+				s := msg.ToJSON().Candidate
+				log.Trace().Str("candidate", s).Msg("[webrtc] local")
+				tr.Write(&api.Message{Type: "webrtc/candidate", Value: s})
+			}
 		}
 	})
 
@@ -104,41 +107,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")
-		ctx.Error(err)
-		return
+		log.Warn().Err(err).Caller().Send()
+		return err
 	}
 
 	// 2. AddConsumer, so we get new tracks
 	if err = stream.AddConsumer(conn); err != nil {
-		log.Warn().Err(err).Msg("[api.webrtc] add consumer")
+		log.Debug().Err(err).Msg("[webrtc] add consumer")
 		_ = conn.Conn.Close()
-		ctx.Error(err)
-		return
+		return err
 	}
 
 	conn.Init()
 
-	// exchange sdp without waiting all candidates
-	//answer, err := conn.ExchangeSDP(offer, false)
-	//answer, err := conn.GetAnswer()
-	answer, err := conn.GetCompleteAnswer()
-	if err == nil {
-		answer, err = addCanditates(answer)
-	}
+	// 3. Exchange SDP without waiting all candidates
+	answer, err := conn.GetAnswer()
 	log.Trace().Msgf("[webrtc] answer\n%s", answer)
 
 	if err != nil {
-		log.Error().Err(err).Msg("[webrtc] get answer")
-		ctx.Error(err)
-		return
+		log.Error().Err(err).Caller().Send()
+		return err
 	}
 
-	ctx.Write(&streamer.Message{
-		Type: webrtc.MsgTypeAnswer, Value: answer,
-	})
+	tr.Consumer = conn
 
-	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 +146,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 +171,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 +189,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 +206,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/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
+	golang.org/x/tools v0.1.11 // 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

@@ -4,19 +4,24 @@ import (
 	"github.com/AlexxIT/go2rtc/cmd/api"
 	"github.com/AlexxIT/go2rtc/cmd/app"
 	"github.com/AlexxIT/go2rtc/cmd/debug"
+	"github.com/AlexxIT/go2rtc/cmd/dvrip"
 	"github.com/AlexxIT/go2rtc/cmd/echo"
 	"github.com/AlexxIT/go2rtc/cmd/exec"
 	"github.com/AlexxIT/go2rtc/cmd/ffmpeg"
 	"github.com/AlexxIT/go2rtc/cmd/hass"
+	"github.com/AlexxIT/go2rtc/cmd/hls"
 	"github.com/AlexxIT/go2rtc/cmd/homekit"
+	"github.com/AlexxIT/go2rtc/cmd/http"
 	"github.com/AlexxIT/go2rtc/cmd/ivideon"
 	"github.com/AlexxIT/go2rtc/cmd/mjpeg"
 	"github.com/AlexxIT/go2rtc/cmd/mp4"
+	"github.com/AlexxIT/go2rtc/cmd/mpegts"
 	"github.com/AlexxIT/go2rtc/cmd/ngrok"
 	"github.com/AlexxIT/go2rtc/cmd/rtmp"
 	"github.com/AlexxIT/go2rtc/cmd/rtsp"
 	"github.com/AlexxIT/go2rtc/cmd/srtp"
 	"github.com/AlexxIT/go2rtc/cmd/streams"
+	"github.com/AlexxIT/go2rtc/cmd/tapo"
 	"github.com/AlexxIT/go2rtc/cmd/webrtc"
 	"os"
 	"os/signal"
@@ -25,26 +30,28 @@ import (
 
 func main() {
 	app.Init()     // init config and logs
+	api.Init()     // init HTTP API server
 	streams.Init() // load streams list
 
-	api.Init() // init HTTP API server
-
-	echo.Init()
-
 	rtsp.Init()   // add support RTSP client and RTSP server
 	rtmp.Init()   // add support RTMP client
 	exec.Init()   // add support exec scheme (depends on RTSP server)
 	ffmpeg.Init() // add support ffmpeg scheme (depends on exec scheme)
 	hass.Init()   // add support hass scheme
-
-	webrtc.Init()
-	mp4.Init()
-	mjpeg.Init()
+	echo.Init()
+	ivideon.Init()
+	http.Init()
+	dvrip.Init()
+	tapo.Init()
+	mpegts.Init()
 
 	srtp.Init()
 	homekit.Init()
 
-	ivideon.Init()
+	webrtc.Init()
+	mp4.Init()
+	hls.Init()
+	mjpeg.Init()
 
 	ngrok.Init()
 	debug.Init()

pkg/aac/rtp.go

@@ -17,9 +17,14 @@ func RTPDepay(track *streamer.Track) streamer.WrapperFunc {
 
 			//log.Printf("[RTP/AAC] units: %d, size: %4d, ts: %10d, %t", headersSize/2, len(packet.Payload), packet.Timestamp, packet.Marker)
 
+			data := packet.Payload[2+headersSize:]
+			if IsADTS(data) {
+				data = data[7:]
+			}
+
 			clone := *packet
 			clone.Version = RTPPacketVersionAAC
-			clone.Payload = packet.Payload[2+headersSize:]
+			clone.Payload = data
 			return push(&clone)
 		}
 	}
@@ -55,3 +60,7 @@ func RTPPay(mtu uint16) streamer.WrapperFunc {
 		}
 	}
 }
+
+func IsADTS(b []byte) bool {
+	return len(b) > 7 && b[0] == 0xFF && b[1]&0xF0 == 0xF0
+}

pkg/dvrip/client.go

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

pkg/dvrip/producer.go

@@ -0,0 +1,25 @@
+package dvrip
+
+import "github.com/AlexxIT/go2rtc/pkg/streamer"
+
+func (c *Client) GetMedias() []*streamer.Media {
+	return c.medias
+}
+
+func (c *Client) GetTrack(media *streamer.Media, codec *streamer.Codec) *streamer.Track {
+	if c.videoTrack != nil && c.videoTrack.Codec == codec {
+		return c.videoTrack
+	}
+	if c.audioTrack != nil && c.audioTrack.Codec == codec {
+		return c.audioTrack
+	}
+	return nil
+}
+
+func (c *Client) Start() error {
+	return c.Handle()
+}
+
+func (c *Client) Stop() error {
+	return c.Close()
+}

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

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

pkg/h264/avc.go

@@ -1,11 +1,31 @@
 package h264
 
 import (
+	"bytes"
 	"encoding/binary"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/pion/rtp"
 )
 
+func AnnexB2AVC(b []byte) []byte {
+	for i := 0; i < len(b); {
+		if i+4 >= len(b) {
+			break
+		}
+
+		size := bytes.Index(b[i+4:], []byte{0, 0, 0, 1})
+		if size < 0 {
+			size = len(b) - (i + 4)
+		}
+
+		binary.BigEndian.PutUint32(b[i:], uint32(size))
+
+		i += size + 4
+	}
+
+	return b
+}
+
 func EncodeAVC(nals ...[]byte) (avc []byte) {
 	var i, n int
 

pkg/h264/helper.go

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

pkg/h264/payloader.go

@@ -31,7 +31,7 @@ const (
 
 //func annexbNALUStartCode() []byte { return []byte{0x00, 0x00, 0x00, 0x01} }
 
-func emitNalus(nals []byte, isAVC bool, emit func([]byte)) {
+func EmitNalus(nals []byte, isAVC bool, emit func([]byte)) {
 	if !isAVC {
 		nextInd := func(nalu []byte, start int) (indStart int, indLen int) {
 			zeroCount := 0
@@ -84,7 +84,7 @@ func (p *Payloader) Payload(mtu uint16, payload []byte) [][]byte {
 		return payloads
 	}
 
-	emitNalus(payload, p.IsAVC, func(nalu []byte) {
+	EmitNalus(payload, p.IsAVC, func(nalu []byte) {
 		if len(nalu) == 0 {
 			return
 		}

pkg/h264/rtp.go

@@ -9,6 +9,8 @@ import (
 
 const RTPPacketVersionAVC = 0
 
+const PSMaxSize = 128 // the biggest SPS I've seen is 48 (EZVIZ CS-CV210)
+
 func RTPDepay(track *streamer.Track) streamer.WrapperFunc {
 	depack := &codecs.H264Packet{IsAVC: true}
 
@@ -27,35 +29,40 @@ func RTPDepay(track *streamer.Track) streamer.WrapperFunc {
 			}
 
 			// Fix TP-Link Tapo TC70: sends SPS and PPS with packet.Marker = true
-			if packet.Marker {
+			// Reolink Duo 2: sends SPS with Marker and PPS without
+			if packet.Marker && len(payload) < PSMaxSize {
 				switch NALUType(payload) {
 				case NALUTypeSPS, NALUTypePPS:
 					buf = append(buf, payload...)
 					return nil
+				case NALUTypeSEI:
+					// RtspServer https://github.com/AlexxIT/go2rtc/issues/244
+					// sends, marked SPS, marked PPS, marked SEI, marked IFrame
+					return nil
 				}
 			}
 
 			if len(buf) == 0 {
-				// Amcrest IP4M-1051: 9, 7, 8, 6, 28...
-				// Amcrest IP4M-1051: 9, 6, 1
-				switch NALUType(payload) {
-				case NALUTypeIFrame:
-					// fix IFrame without SPS,PPS
-					buf = append(buf, ps...)
-				case NALUTypeSEI, NALUTypeAUD:
-					// fix ffmpeg with transcoding first frame
-					i := int(4 + binary.BigEndian.Uint32(payload))
-
-					// check if only one NAL (fix ffmpeg transcoding for Reolink RLC-510A)
-					if i == len(payload) {
-						return nil
-					}
-
-					payload = payload[i:]
-
-					if NALUType(payload) == NALUTypeIFrame {
+				for {
+					// Amcrest IP4M-1051: 9, 7, 8, 6, 28...
+					// Amcrest IP4M-1051: 9, 6, 1
+					switch NALUType(payload) {
+					case NALUTypeIFrame:
+						// fix IFrame without SPS,PPS
 						buf = append(buf, ps...)
+					case NALUTypeSEI, NALUTypeAUD:
+						// fix ffmpeg with transcoding first frame
+						i := int(4 + binary.BigEndian.Uint32(payload))
+
+						// check if only one NAL (fix ffmpeg transcoding for Reolink RLC-510A)
+						if i == len(payload) {
+							return nil
+						}
+
+						payload = payload[i:]
+						continue
 					}
+					break
 				}
 			}
 
@@ -70,7 +77,15 @@ func RTPDepay(track *streamer.Track) streamer.WrapperFunc {
 				buf = buf[:0]
 			}
 
-			//log.Printf("[AVC] %v, len: %d", Types(payload), len(payload))
+			// should not be that huge SPS
+			if NALUType(payload) == NALUTypeSPS && binary.BigEndian.Uint32(payload) >= PSMaxSize {
+				// some Chinese buggy cameras has single packet with SPS+PPS+IFrame separated by 00 00 00 01
+				// https://github.com/AlexxIT/WebRTC/issues/391
+				// https://github.com/AlexxIT/WebRTC/issues/392
+				AnnexB2AVC(payload)
+			}
+
+			//log.Printf("[AVC] %v, len: %d, ts: %10d, seq: %d", Types(payload), len(payload), packet.Timestamp, packet.SequenceNumber)
 
 			clone := *packet
 			clone.Version = RTPPacketVersionAVC

pkg/h265/README.md

@@ -1,3 +1,8 @@
+# H265
+
+Payloader code taken from [pion](https://github.com/pion/rtp) library branch [h265](https://github.com/pion/rtp/tree/h265). Because it's still not in release. Thanks to [@kevmo314](https://github.com/kevmo314).
+
 ## Useful links
 
 - https://datatracker.ietf.org/doc/html/rfc7798
+- [Add initial support for WebRTC HEVC](https://trac.webkit.org/changeset/259452/webkit)

pkg/h265/helper.go

@@ -2,19 +2,59 @@ 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
+	NALUTypePrefixSEI = 39
+	NALUTypeSuffixSEI = 40
+	NALUTypeFU        = 49
 )
 
-func NALUnitType(b []byte) byte {
-	return b[4] >> 1
+func NALUType(b []byte) byte {
+	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/payloader.go

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

pkg/h265/rtp.go

@@ -1,96 +1,86 @@
 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,
-			//)
+			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)
 
-			switch nut {
-			case h265parser.NAL_UNIT_UNSPECIFIED_49:
-				data := packet.Payload
+			// Fix for RtspServer https://github.com/AlexxIT/go2rtc/issues/244
+			if packet.Marker && len(data) < h264.PSMaxSize {
+				switch nuType {
+				case NALUTypeVPS, NALUTypeSPS, NALUTypePPS:
+					packet.Marker = false
+				case NALUTypePrefixSEI, NALUTypeSuffixSEI:
+					return nil
+				}
+			}
+
+			if nuType == NALUTypeFU {
 				switch data[2] >> 6 {
 				case 2: // begin
-					buffer = []byte{
-						(data[0] & 0x81) | (data[2] & 0x3f << 1), data[1],
-					}
-					buffer = append(buffer, data[3:]...)
+					nuType = data[2] & 0x3F
+
+					// push PS data before keyframe
+					//if len(buf) == 0 && nuType >= 19 && nuType <= 21 {
+					//	buf = append(buf, ps...)
+					//}
+
+					nuStart = len(buf)
+					buf = append(buf, 0, 0, 0, 0) // NAL unit size
+					buf = append(buf, (data[0]&0x81)|(nuType<<1), data[1])
+					buf = append(buf, data[3:]...)
 					return nil
 				case 0: // continue
-					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:
-				vps = packet.Payload
-				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")
+			} else {
+				nuStart = len(buf)
+				buf = append(buf, 0, 0, 0, 0) // NAL unit size
+				buf = append(buf, data...)
+				binary.BigEndian.PutUint32(buf[nuStart:], uint32(len(data)))
 			}
 
-			var clone rtp.Packet
-
-			nut = (packet.Payload[0] >> 1) & 0x3f
-			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)
-				if err := push(&clone); err != nil {
-					return err
-				}
-
-				clone = *packet
-				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
-				}
+			// collect all NAL Units for Access Unit
+			if !packet.Marker {
+				return nil
 			}
 
-			clone = *packet
+			//log.Printf("[HEVC] %v, len: %d", Types(buf), len(buf))
+
+			clone := *packet
 			clone.Version = h264.RTPPacketVersionAVC
-			clone.Payload = h264.EncodeAVC(packet.Payload)
+			clone.Payload = buf
+
+			buf = buf[:0]
 
 			return push(&clone)
 		}
 	}
 }
 
-// SafariPay - generate Safari friendly payload for H265
-func SafariPay(mtu uint16) streamer.WrapperFunc {
+func RTPPay(mtu uint16) streamer.WrapperFunc {
+	payloader := &Payloader{}
 	sequencer := rtp.NewRandomSequencer()
-	size := int(mtu - 12) // rtp.Header size
-
-	var buffer []byte
+	mtu -= 12 // rtp.Header size
 
 	return func(push streamer.WriterFunc) streamer.WriterFunc {
 		return func(packet *rtp.Packet) error {
@@ -98,56 +88,103 @@ func SafariPay(mtu uint16) streamer.WrapperFunc {
 				return push(packet)
 			}
 
-			data := packet.Payload
-			data[0] = 0
-			data[1] = 0
-			data[2] = 0
-			data[3] = 1
-
-			var start byte
-
-			nut := (data[4] >> 1) & 0b111111
-			//fmt.Printf("[H265] nut: %2d, size: %6d, data: %16x\n", nut, len(data), data[4:20])
-			switch {
-			case nut >= h265parser.NAL_UNIT_VPS && nut <= h265parser.NAL_UNIT_PPS:
-				buffer = append(buffer, data...)
-				return nil
-			case nut >= h265parser.NAL_UNIT_CODED_SLICE_BLA_W_LP && nut <= h265parser.NAL_UNIT_CODED_SLICE_CRA:
-				buffer = append([]byte{3}, buffer...)
-				data = append(buffer, data...)
-				start = 1
-			default:
-				data = append([]byte{2}, data...)
-				start = 0
-			}
-
-			for len(data) > size {
+			payloads := payloader.Payload(mtu, packet.Payload)
+			last := len(payloads) - 1
+			for i, payload := range payloads {
 				clone := rtp.Packet{
 					Header: rtp.Header{
 						Version:        2,
-						Marker:         false,
+						Marker:         i == last,
 						SequenceNumber: sequencer.NextSequenceNumber(),
 						Timestamp:      packet.Timestamp,
 					},
-					Payload: data[:size],
+					Payload: payload,
+				}
+				if err := push(&clone); err != nil {
+					return err
+				}
+			}
+
+			return nil
+		}
+	}
+}
+
+// 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
+
+	return func(push streamer.WriterFunc) streamer.WriterFunc {
+		return func(packet *rtp.Packet) error {
+			if packet.Version != h264.RTPPacketVersionAVC {
+				return push(packet)
+			}
+
+			// protect original packets from modification
+			au := make([]byte, len(packet.Payload))
+			copy(au, packet.Payload)
+
+			var start byte
+
+			for i := 0; i < len(au); {
+				size := int(binary.BigEndian.Uint32(au[i:])) + 4
+
+				// convert AVC to Annex-B
+				au[i] = 0
+				au[i+1] = 0
+				au[i+2] = 0
+				au[i+3] = 1
+
+				switch NALUType(au[i:]) {
+				case NALUTypeIFrame, NALUTypeIFrame2, NALUTypeIFrame3:
+					start = 3
+				default:
+					if start == 0 {
+						start = 2
+					}
+				}
+
+				i += size
+			}
+
+			// rtp.Packet payload
+			b := make([]byte, 1, size)
+			size-- // minus header byte
+
+			for au != nil {
+				b[0] = start
+
+				if start > 1 {
+					start -= 2
+				}
+
+				if len(au) > size {
+					b = append(b, au[:size]...)
+					au = au[size:]
+				} else {
+					b = append(b, au...)
+					au = nil
+				}
+
+				clone := rtp.Packet{
+					Header: rtp.Header{
+						Version:        2,
+						Marker:         au == nil,
+						SequenceNumber: sequencer.NextSequenceNumber(),
+						Timestamp:      packet.Timestamp,
+					},
+					Payload: b,
 				}
 				if err := push(&clone); err != nil {
 					return err
 				}
 
-				data = append([]byte{start}, data[size:]...)
+				b = b[:1] // clear buffer
 			}
 
-			clone := rtp.Packet{
-				Header: rtp.Header{
-					Version:        2,
-					Marker:         true,
-					SequenceNumber: sequencer.NextSequenceNumber(),
-					Timestamp:      packet.Timestamp,
-				},
-				Payload: data,
-			}
-			return push(&clone)
+			return nil
 		}
 	}
 }

pkg/homekit/client.go

@@ -1,6 +1,7 @@
 package homekit
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"github.com/AlexxIT/go2rtc/pkg/hap"
@@ -11,6 +12,7 @@ import (
 	"github.com/brutella/hap/rtp"
 	"net"
 	"net/url"
+	"sync/atomic"
 )
 
 type Client struct {
@@ -75,7 +77,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
 }
@@ -263,3 +265,19 @@ func (c *Client) getMedias() []*streamer.Media {
 
 	return medias
 }
+
+func (c *Client) MarshalJSON() ([]byte, error) {
+	var recv uint32
+	for _, session := range c.sessions {
+		recv += atomic.LoadUint32(&session.Recv)
+	}
+
+	info := &streamer.Info{
+		Type:   "HomeKit source",
+		URL:    c.conn.URL(),
+		Medias: c.medias,
+		Tracks: c.tracks,
+		Recv:   recv,
+	}
+	return json.Marshal(info)
+}

pkg/httpflv/amf0.go

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

pkg/httpflv/flvio.go

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

pkg/httpflv/httpflv.go

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

pkg/iso/atoms.go

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

pkg/iso/codecs.go

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

pkg/iso/iso.go

@@ -0,0 +1,91 @@
+package iso
+
+import (
+	"encoding/binary"
+	"math"
+)
+
+type Movie struct {
+	b     []byte
+	start []int
+}
+
+func NewMovie(size int) *Movie {
+	return &Movie{b: make([]byte, 0, size)}
+}
+
+func (m *Movie) Bytes() []byte {
+	return m.b
+}
+
+func (m *Movie) StartAtom(name string) {
+	m.start = append(m.start, len(m.b))
+	m.b = append(m.b, 0, 0, 0, 0)
+	m.b = append(m.b, name...)
+}
+
+func (m *Movie) EndAtom() {
+	n := len(m.start) - 1
+
+	i := m.start[n]
+	size := uint32(len(m.b) - i)
+	binary.BigEndian.PutUint32(m.b[i:], size)
+
+	m.start = m.start[:n]
+}
+
+func (m *Movie) Write(b []byte) {
+	m.b = append(m.b, b...)
+}
+
+func (m *Movie) WriteBytes(b ...byte) {
+	m.b = append(m.b, b...)
+}
+
+func (m *Movie) WriteString(s string) {
+	m.b = append(m.b, s...)
+}
+
+func (m *Movie) Skip(n int) {
+	m.b = append(m.b, make([]byte, n)...)
+}
+
+func (m *Movie) WriteUint16(v uint16) {
+	m.b = append(m.b, byte(v>>8), byte(v))
+}
+
+func (m *Movie) WriteUint24(v uint32) {
+	m.b = append(m.b, byte(v>>16), byte(v>>8), byte(v))
+}
+
+func (m *Movie) WriteUint32(v uint32) {
+	m.b = append(m.b, byte(v>>24), byte(v>>16), byte(v>>8), byte(v))
+}
+
+func (m *Movie) WriteUint64(v uint64) {
+	m.b = append(m.b, byte(v>>56), byte(v>>48), byte(v>>40), byte(v>>32), byte(v>>24), byte(v>>16), byte(v>>8), byte(v))
+}
+
+func (m *Movie) WriteFloat16(f float64) {
+	i, f := math.Modf(f)
+	f *= 256
+	m.b = append(m.b, byte(i), byte(f))
+}
+
+func (m *Movie) WriteFloat32(f float64) {
+	i, f := math.Modf(f)
+	f *= 65536
+	m.b = append(m.b, byte(uint16(i)>>8), byte(i), byte(uint16(f)>>8), byte(f))
+}
+
+func (m *Movie) WriteMatrix() {
+	m.WriteUint32(0x00010000)
+	m.Skip(4)
+	m.Skip(4)
+	m.Skip(4)
+	m.WriteUint32(0x00010000)
+	m.Skip(4)
+	m.Skip(4)
+	m.Skip(4)
+	m.WriteUint32(0x40000000)
+}

pkg/ivideon/client.go

@@ -14,9 +14,19 @@ import (
 	"io"
 	"net/http"
 	"strings"
+	"sync"
+	"sync/atomic"
 	"time"
 )
 
+type State byte
+
+const (
+	StateNone State = iota
+	StateConn
+	StateHandle
+)
+
 type Client struct {
 	streamer.Element
 
@@ -26,12 +36,14 @@ type Client struct {
 	medias []*streamer.Media
 	tracks map[byte]*streamer.Track
 
-	closed bool
-
 	msg *message
 	t0  time.Time
 
 	buffer chan []byte
+	state  State
+	mu     sync.Mutex
+
+	recv uint32
 }
 
 func NewClient(id string) *Client {
@@ -69,16 +81,26 @@ func (c *Client) Dial() (err error) {
 		return err
 	}
 
+	c.state = StateConn
+
 	return nil
 }
 
 func (c *Client) Handle() error {
-	c.buffer = make(chan []byte, 5)
 	// add delay to the stream for smooth playing (not a best solution)
 	c.t0 = time.Now().Add(time.Second)
 
-	// processing stream in separate thread for lower delay between packets
-	go c.worker()
+	c.mu.Lock()
+
+	if c.state == StateConn {
+		c.buffer = make(chan []byte, 5)
+		c.state = StateHandle
+
+		// processing stream in separate thread for lower delay between packets
+		go c.worker(c.buffer)
+	}
+
+	c.mu.Unlock()
 
 	_, data, err := c.conn.ReadMessage()
 	if err != nil {
@@ -87,7 +109,12 @@ func (c *Client) Handle() error {
 
 	track := c.tracks[c.msg.Track]
 	if track != nil {
-		c.buffer <- data
+		c.mu.Lock()
+		if c.state == StateHandle {
+			c.buffer <- data
+			atomic.AddUint32(&c.recv, uint32(len(data)))
+		}
+		c.mu.Unlock()
 	}
 
 	// we have one unprocessed msg after getTracks
@@ -114,7 +141,12 @@ func (c *Client) Handle() error {
 
 			track = c.tracks[msg.Track]
 			if track != nil {
-				c.buffer <- data
+				c.mu.Lock()
+				if c.state == StateHandle {
+					c.buffer <- data
+					atomic.AddUint32(&c.recv, uint32(len(data)))
+				}
+				c.mu.Unlock()
 			}
 
 		default:
@@ -124,11 +156,19 @@ func (c *Client) Handle() error {
 }
 
 func (c *Client) Close() error {
-	if c.conn == nil {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	switch c.state {
+	case StateNone:
 		return nil
+	case StateConn:
+	case StateHandle:
+		close(c.buffer)
 	}
-	close(c.buffer)
-	c.closed = true
+
+	c.state = StateNone
+
 	return c.conn.Close()
 }
 
@@ -165,7 +205,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 +232,7 @@ func (c *Client) getTracks() error {
 				}
 				c.medias = append(c.medias, media)
 
-				track := &streamer.Track{
-					Direction: streamer.DirectionSendonly,
-					Codec:     codec,
-				}
+				track := streamer.NewTrack(codec, streamer.DirectionSendonly)
 				c.tracks[msg.TrackID] = track
 
 			case "mp4a": // mp4a.40.2
@@ -211,13 +248,13 @@ func (c *Client) getTracks() error {
 	}
 }
 
-func (c *Client) worker() {
+func (c *Client) worker(buffer chan []byte) {
 	var track *streamer.Track
 	for _, track = range c.tracks {
 		break
 	}
 
-	for data := range c.buffer {
+	for data := range buffer {
 		moof := &fmp4io.MovieFrag{}
 		if _, err := moof.Unmarshal(data, 0); err != nil {
 			continue

pkg/ivideon/producer.go

@@ -0,0 +1,49 @@
+package ivideon
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"sync/atomic"
+)
+
+func (c *Client) GetMedias() []*streamer.Media {
+	return c.medias
+}
+
+func (c *Client) GetTrack(media *streamer.Media, codec *streamer.Codec) *streamer.Track {
+	for _, track := range c.tracks {
+		if track.Codec == codec {
+			return track
+		}
+	}
+	panic(fmt.Sprintf("wrong media/codec: %+v %+v", media, codec))
+}
+
+func (c *Client) Start() error {
+	err := c.Handle()
+	if c.buffer == nil {
+		return nil
+	}
+	return err
+}
+
+func (c *Client) Stop() error {
+	return c.Close()
+}
+
+func (c *Client) MarshalJSON() ([]byte, error) {
+	var tracks []*streamer.Track
+	for _, track := range c.tracks {
+		tracks = append(tracks, track)
+	}
+
+	info := &streamer.Info{
+		Type:   "Ivideon source",
+		URL:    c.ID,
+		Medias: c.medias,
+		Tracks: tracks,
+		Recv:   atomic.LoadUint32(&c.recv),
+	}
+	return json.Marshal(info)
+}

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,127 @@
+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"
+	"sync/atomic"
+	"time"
+)
+
+type Client struct {
+	streamer.Element
+
+	UserAgent  string
+	RemoteAddr string
+
+	closed bool
+	res    *http.Response
+
+	medias []*streamer.Media
+	track  *streamer.Track
+	recv   uint32
+}
+
+func NewClient(res *http.Response) *Client {
+	return &Client{res: res}
+}
+
+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)
+
+	atomic.AddUint32(&c.recv, uint32(len(buf)))
+
+	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)
+
+		atomic.AddUint32(&c.recv, uint32(len(buf)))
+	}
+
+	return nil
+}
+
+func (c *Client) startMJPEG(boundary string) error {
+	// some cameras add prefix to boundary header:
+	// https://github.com/TheTimeWalker/wallpanel-android
+	if !strings.HasPrefix(boundary, "--") {
+		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 !strings.HasPrefix(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)
+
+		atomic.AddUint32(&c.recv, uint32(len(buf)))
+
+		if _, err = r.Discard(2); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func now() uint32 {
+	return uint32(time.Now().UnixMilli() * 90)
+}

pkg/mjpeg/consumer.go

@@ -1,8 +1,10 @@
 package mjpeg
 
 import (
+	"encoding/json"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/pion/rtp"
+	"sync/atomic"
 )
 
 type Consumer struct {
@@ -14,7 +16,7 @@ type Consumer struct {
 	codecs []*streamer.Codec
 	start  bool
 
-	send int
+	send uint32
 }
 
 func (c *Consumer) GetMedias() []*streamer.Media {
@@ -26,70 +28,26 @@ 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(
-		//	"[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
-		}
-
+		c.Fire(packet.Payload)
+		atomic.AddUint32(&c.send, uint32(len(packet.Payload)))
 		return nil
 	}
+
+	if track.Codec.IsRTP() {
+		wrapper := RTPDepay(track)
+		push = wrapper(push)
+	}
+
 	return track.Bind(push)
 }
+
+func (c *Consumer) MarshalJSON() ([]byte, error) {
+	info := &streamer.Info{
+		Type:       "MJPEG client",
+		RemoteAddr: c.RemoteAddr,
+		UserAgent:  c.UserAgent,
+		Send:       atomic.LoadUint32(&c.send),
+	}
+	return json.Marshal(info)
+}

pkg/mjpeg/producer.go

@@ -0,0 +1,64 @@
+package mjpeg
+
+import (
+	"encoding/json"
+	"errors"
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"strings"
+	"sync/atomic"
+)
+
+func (c *Client) GetMedias() []*streamer.Media {
+	if c.medias == nil {
+		c.medias = []*streamer.Media{{
+			Kind:      streamer.KindVideo,
+			Direction: streamer.DirectionSendonly,
+			Codecs: []*streamer.Codec{
+				{
+					Name: streamer.CodecJPEG, ClockRate: 90000, PayloadType: streamer.PayloadTypeRAW,
+				},
+			},
+		}}
+	}
+	return c.medias
+}
+
+func (c *Client) GetTrack(media *streamer.Media, codec *streamer.Codec) *streamer.Track {
+	if c.track == nil {
+		c.track = streamer.NewTrack(codec, streamer.DirectionSendonly)
+	}
+	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 {
+	// important for close reader/writer gorutines
+	_ = c.res.Body.Close()
+	c.closed = true
+	return nil
+}
+
+func (c *Client) MarshalJSON() ([]byte, error) {
+	info := &streamer.Info{
+		Type:       "MJPEG source",
+		URL:        c.res.Request.URL.String(),
+		RemoteAddr: c.RemoteAddr,
+		UserAgent:  c.UserAgent,
+		Recv:       atomic.LoadUint32(&c.recv),
+	}
+	return json.Marshal(info)
+}

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,227 @@
+package mjpeg
+
+import (
+	"bytes"
+	"encoding/binary"
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/pion/rtp"
+	"image"
+	"image/jpeg"
+)
+
+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 sizes more than 2040
+				switch {
+				// 512x1920 512x1440
+				case w == cutSize(2560) && (h == 1920 || h == 1440):
+					w = 2560
+				// 1792x112
+				case w == cutSize(3840) && h == cutSize(2160):
+					w = 3840
+					h = 2160
+				// 256x1296
+				case w == cutSize(2304) && h == 1296:
+					w = 2304
+				}
+
+				//fmt.Printf("t: %d, q: %d, w: %d, h: %d\n", t, q, w, h)
+				buf = MakeHeaders(buf, t, w, h, lqt, cqt)
+			}
+
+			// 3.1.9.  JPEG Payload
+			buf = append(buf, b...)
+
+			if !packet.Marker {
+				return 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 cutSize(size uint16) uint16 {
+	return ((size >> 3) & 0xFF) << 3
+}
+
+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
+			p, err := Transcode(packet.Payload)
+			if 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
+			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
+		}
+	}
+}
+
+func Transcode(b []byte) ([]byte, error) {
+	img, err := jpeg.Decode(bytes.NewReader(b))
+	if err != nil {
+		return nil, err
+	}
+
+	wh := img.Bounds().Size()
+	w := wh.X
+	h := wh.Y
+
+	if w > 2040 {
+		w = 2040
+	} else if w&3 > 0 {
+		w &= 3
+	}
+	if h > 2040 {
+		h = 2040
+	} else if h&3 > 0 {
+		h &= 3
+	}
+
+	if w != wh.X || h != wh.Y {
+		x0 := (wh.X - w) / 2
+		y0 := (wh.Y - h) / 2
+		rect := image.Rect(x0, y0, x0+w, y0+h)
+		img = img.(*image.YCbCr).SubImage(rect)
+	}
+
+	buf := bytes.NewBuffer(nil)
+	if err = jpeg.Encode(buf, img, nil); err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}

pkg/mp4/README.md

@@ -1,19 +1,30 @@
+## Fragmented MP4
+
+```
+ffmpeg -i "rtsp://..." -movflags +frag_keyframe+separate_moof+default_base_moof+empty_moov -frag_duration 1 -c copy -t 5 sample.mp4
+```
+
+- movflags frag_keyframe 
+  Start a new fragment at each video keyframe.
+- frag_duration duration
+  Create fragments that are duration microseconds long.
+- movflags separate_moof
+  Write a separate moof (movie fragment) atom for each track.
+- movflags default_base_moof
+  Similarly to the omit_tfhd_offset, this flag avoids writing the absolute base_data_offset field in tfhd atoms, but does so by using the new default-base-is-moof flag instead.
+
+https://ffmpeg.org/ffmpeg-formats.html#Options-13
+
 ## HEVC
 
-Browser     | avc1 | hvc1 | hev1
-------------|------|------|---
-Mac Chrome  | +    | -    | +
-Mac Safari  | +    | +    | -
-iOS 15?     | +    | +    | -
-Mac Firefox | +    | -    | -
-iOS 12      | +    | -    | -
-Android 13  | +    | -    | -
-
-```
-ffmpeg -i input-hev1.mp4 -c:v copy -tag:v hvc1 -c:a copy output-hvc1.mp4
-Stream #0:0(eng): Video: hevc (Main) (hev1 / 0x31766568), yuv420p(tv, progressive), 720x404, 164 kb/s, 29.97 fps,
-Stream #0:0(eng): Video: hevc (Main) (hvc1 / 0x31637668), yuv420p(tv, progressive), 720x404, 164 kb/s, 29.97 fps,
-```
+| Browser     | avc1 | hvc1 | hev1 |
+|-------------|------|------|------|
+ | Mac Chrome  | +    | -    | +    |
+ | Mac Safari  | +    | +    | -    |
+ | iOS 15?     | +    | +    | -    |
+ | Mac Firefox | +    | -    | -    |
+ | iOS 12      | +    | -    | -    |
+ | Android 13  | +    | -    | -    |
 
 ## Useful links
 

pkg/mp4/consumer.go

@@ -7,22 +7,45 @@ import (
 	"github.com/AlexxIT/go2rtc/pkg/h265"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/pion/rtp"
+	"sync/atomic"
 )
 
 type Consumer struct {
 	streamer.Element
 
+	Medias     []*streamer.Media
 	UserAgent  string
 	RemoteAddr string
 
 	muxer  *Muxer
 	codecs []*streamer.Codec
-	start  bool
+	wait   byte
 
-	send int
+	send uint32
 }
 
+// ParseQuery - like usual parse, but with mp4 param handler
+func ParseQuery(query map[string][]string) []*streamer.Media {
+	if query["mp4"] != nil {
+		cons := Consumer{}
+		return cons.GetMedias()
+	}
+
+	return streamer.ParseQuery(query)
+}
+
+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,50 +72,60 @@ 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 {
-				return nil
+			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)
+			atomic.AddUint32(&c.send, uint32(len(buf)))
 			c.Fire(buf)
 
 			return nil
 		}
 
 		var wrapper streamer.WrapperFunc
-		if codec.IsMP4() {
-			wrapper = h264.RepairAVC(track)
-		} else {
+		if codec.IsRTP() {
 			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 {
-				return nil
+			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)
+			atomic.AddUint32(&c.send, uint32(len(buf)))
 			c.Fire(buf)
 
 			return nil
 		}
 
-		if !codec.IsMP4() {
+		if codec.IsRTP() {
 			wrapper := h265.RTPDepay(track)
 			push = wrapper(push)
 		}
@@ -101,30 +134,49 @@ 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
 			}
 
 			buf := c.muxer.Marshal(trackID, packet)
-			c.send += len(buf)
+			atomic.AddUint32(&c.send, uint32(len(buf)))
 			c.Fire(buf)
 
 			return nil
 		}
 
-		if !codec.IsMP4() {
+		if codec.IsRTP() {
 			wrapper := aac.RTPDepay(track)
 			push = wrapper(push)
 		}
 
+		return track.Bind(push)
+
+	case streamer.CodecOpus, streamer.CodecMP3, streamer.CodecPCMU, streamer.CodecPCMA:
+		push := func(packet *rtp.Packet) error {
+			if c.wait != waitNone {
+				return nil
+			}
+
+			buf := c.muxer.Marshal(trackID, packet)
+			atomic.AddUint32(&c.send, uint32(len(buf)))
+			c.Fire(buf)
+
+			return nil
+		}
+
 		return track.Bind(push)
 	}
 
 	panic("unsupported codec")
 }
 
+func (c *Consumer) MimeCodecs() string {
+	return c.muxer.MimeCodecs(c.codecs)
+}
+
 func (c *Consumer) MimeType() string {
-	return c.muxer.MimeType(c.codecs)
+	return `video/mp4; codecs="` + c.MimeCodecs() + `"`
 }
 
 func (c *Consumer) Init() ([]byte, error) {
@@ -133,18 +185,19 @@ func (c *Consumer) Init() ([]byte, error) {
 }
 
 func (c *Consumer) Start() {
-	c.start = true
+	if c.wait == waitInit {
+		c.wait = waitKeyframe
+	}
 }
 
 //
 
 func (c *Consumer) MarshalJSON() ([]byte, error) {
-	v := map[string]interface{}{
-		"type":        "MP4 server consumer",
-		"send":        c.send,
-		"remote_addr": c.RemoteAddr,
-		"user_agent":  c.UserAgent,
+	info := &streamer.Info{
+		Type:       "MP4 client",
+		RemoteAddr: c.RemoteAddr,
+		UserAgent:  c.UserAgent,
+		Send:       atomic.LoadUint32(&c.send),
 	}
-
-	return json.Marshal(v)
+	return json.Marshal(info)
 }

pkg/mp4/keyframe.go

@@ -1,85 +0,0 @@
-package mp4
-
-import (
-	"github.com/AlexxIT/go2rtc/pkg/h264"
-	"github.com/AlexxIT/go2rtc/pkg/h265"
-	"github.com/AlexxIT/go2rtc/pkg/streamer"
-	"github.com/pion/rtp"
-)
-
-type Keyframe struct {
-	streamer.Element
-
-	MimeType string
-}
-
-func (c *Keyframe) GetMedias() []*streamer.Media {
-	return []*streamer.Media{
-		{
-			Kind:      streamer.KindVideo,
-			Direction: streamer.DirectionRecvonly,
-			Codecs: []*streamer.Codec{
-				{Name: streamer.CodecH264},
-				{Name: streamer.CodecH265},
-			},
-		},
-	}
-}
-
-func (c *Keyframe) AddTrack(media *streamer.Media, track *streamer.Track) *streamer.Track {
-	muxer := &Muxer{}
-
-	codecs := []*streamer.Codec{track.Codec}
-
-	init, err := muxer.GetInit(codecs)
-	if err != nil {
-		return nil
-	}
-
-	c.MimeType = muxer.MimeType(codecs)
-
-	switch track.Codec.Name {
-	case streamer.CodecH264:
-		push := func(packet *rtp.Packet) error {
-			if !h264.IsKeyframe(packet.Payload) {
-				return nil
-			}
-
-			buf := muxer.Marshal(0, packet)
-			c.Fire(append(init, buf...))
-
-			return nil
-		}
-
-		var wrapper streamer.WrapperFunc
-		if track.Codec.IsMP4() {
-			wrapper = h264.RepairAVC(track)
-		} else {
-			wrapper = h264.RTPDepay(track)
-		}
-		push = wrapper(push)
-
-		return track.Bind(push)
-
-	case streamer.CodecH265:
-		push := func(packet *rtp.Packet) error {
-			if !h265.IsKeyframe(packet.Payload) {
-				return nil
-			}
-
-			buf := muxer.Marshal(0, packet)
-			c.Fire(append(init, buf...))
-
-			return nil
-		}
-
-		if !track.Codec.IsMP4() {
-			wrapper := h265.RTPDepay(track)
-			push = wrapper(push)
-		}
-
-		return track.Bind(push)
-	}
-
-	panic("unsupported codec")
-}

pkg/mp4/muxer.go

@@ -1,18 +1,13 @@
 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/iso"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
-	"github.com/deepch/vdk/av"
 	"github.com/deepch/vdk/codec/h264parser"
 	"github.com/deepch/vdk/codec/h265parser"
-	"github.com/deepch/vdk/format/fmp4/fmp4io"
-	"github.com/deepch/vdk/format/mp4/mp4io"
-	"github.com/deepch/vdk/format/mp4f/mp4fio"
 	"github.com/pion/rtp"
 )
 
@@ -20,12 +15,17 @@ type Muxer struct {
 	fragIndex uint32
 	dts       []uint64
 	pts       []uint32
-	//data      []byte
-	//total     int
 }
 
-func (m *Muxer) MimeType(codecs []*streamer.Codec) string {
-	s := `video/mp4; codecs="`
+const (
+	MimeH264 = "avc1.640029"
+	MimeH265 = "hvc1.1.6.L153.B0"
+	MimeAAC  = "mp4a.40.2"
+	MimeOpus = "opus"
+)
+
+func (m *Muxer) MimeCodecs(codecs []*streamer.Codec) string {
+	var s string
 
 	for i, codec := range codecs {
 		if i > 0 {
@@ -36,18 +36,25 @@ 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
-			s += "hvc1.1.6.L93.B0" // hev1.1.6.L93.B0
+			// H.265 profile=main level=5.1
+			// hvc1 - supported in Safari, hev1 - doesn't, both supported in Chrome
+			s += MimeH265
 		case streamer.CodecAAC:
-			s += "mp4a.40.2"
+			s += MimeAAC
+		case streamer.CodecOpus:
+			s += MimeOpus
 		}
 	}
 
-	return s + `"`
+	return s
 }
 
 func (m *Muxer) GetInit(codecs []*streamer.Codec) ([]byte, error) {
-	moov := MOOV()
+	mv := iso.NewMovie(1024)
+	mv.WriteFileType()
+
+	mv.StartAtom(iso.Moov)
+	mv.WriteMovieHeader()
 
 	for i, codec := range codecs {
 		switch codec.Name {
@@ -64,40 +71,19 @@ func (m *Muxer) GetInit(codecs []*streamer.Codec) ([]byte, error) {
 				return nil, err
 			}
 
-			width := codecData.Width()
-			height := codecData.Height()
-
-			trak := TRAK(i + 1)
-			trak.Header.TrackWidth = float64(width)
-			trak.Header.TrackHeight = float64(height)
-			trak.Media.Header.TimeScale = int32(codec.ClockRate)
-			trak.Media.Handler = &mp4io.HandlerRefer{
-				SubType: [4]byte{'v', 'i', 'd', 'e'},
-				Name:    []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 'm', 'a', 'i', 'n', 0},
-			}
-			trak.Media.Info.Video = &mp4io.VideoMediaInfo{
-				Flags: 0x000001,
-			}
-			trak.Media.Info.Sample.SampleDesc.AVC1Desc = &mp4io.AVC1Desc{
-				DataRefIdx:           1,
-				HorizontalResolution: 72,
-				VorizontalResolution: 72,
-				Width:                int16(width),
-				Height:               int16(height),
-				FrameCount:           1,
-				Depth:                24,
-				ColorTableId:         -1,
-				Conf: &mp4io.AVC1Conf{
-					Data: codecData.AVCDecoderConfRecordBytes(),
-				},
-			}
-
-			moov.Tracks = append(moov.Tracks, trak)
+			mv.WriteVideoTrack(
+				uint32(i+1), codec.Name, codec.ClockRate,
+				uint16(codecData.Width()), uint16(codecData.Height()),
+				codecData.AVCDecoderConfRecordBytes(),
+			)
 
 		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)
@@ -105,35 +91,11 @@ func (m *Muxer) GetInit(codecs []*streamer.Codec) ([]byte, error) {
 				return nil, err
 			}
 
-			width := codecData.Width()
-			height := codecData.Height()
-
-			trak := TRAK(i + 1)
-			trak.Header.TrackWidth = float64(width)
-			trak.Header.TrackHeight = float64(height)
-			trak.Media.Header.TimeScale = int32(codec.ClockRate)
-			trak.Media.Handler = &mp4io.HandlerRefer{
-				SubType: [4]byte{'v', 'i', 'd', 'e'},
-				Name:    []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 'm', 'a', 'i', 'n', 0},
-			}
-			trak.Media.Info.Video = &mp4io.VideoMediaInfo{
-				Flags: 0x000001,
-			}
-			trak.Media.Info.Sample.SampleDesc.HV1Desc = &mp4io.HV1Desc{
-				DataRefIdx:           1,
-				HorizontalResolution: 72,
-				VorizontalResolution: 72,
-				Width:                int16(width),
-				Height:               int16(height),
-				FrameCount:           1,
-				Depth:                24,
-				ColorTableId:         -1,
-				Conf: &mp4io.HV1Conf{
-					Data: codecData.AVCDecoderConfRecordBytes(),
-				},
-			}
-
-			moov.Tracks = append(moov.Tracks, trak)
+			mv.WriteVideoTrack(
+				uint32(i+1), codec.Name, codec.ClockRate,
+				uint16(codecData.Width()), uint16(codecData.Height()),
+				codecData.AVCDecoderConfRecordBytes(),
+			)
 
 		case streamer.CodecAAC:
 			s := streamer.Between(codec.FmtpLine, "config=", ";")
@@ -142,110 +104,62 @@ func (m *Muxer) GetInit(codecs []*streamer.Codec) ([]byte, error) {
 				return nil, err
 			}
 
-			trak := TRAK(i + 1)
-			trak.Header.AlternateGroup = 1
-			trak.Header.Duration = 0
-			trak.Header.Volume = 1
-			trak.Media.Header.TimeScale = int32(codec.ClockRate)
+			mv.WriteAudioTrack(
+				uint32(i+1), codec.Name, codec.ClockRate, codec.Channels, b,
+			)
 
-			trak.Media.Handler = &mp4io.HandlerRefer{
-				SubType: [4]byte{'s', 'o', 'u', 'n'},
-				Name:    []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 'm', 'a', 'i', 'n', 0},
-			}
-			trak.Media.Info.Sound = &mp4io.SoundMediaInfo{}
-
-			trak.Media.Info.Sample.SampleDesc.MP4ADesc = &mp4io.MP4ADesc{
-				DataRefIdx:       1,
-				NumberOfChannels: int16(codec.Channels),
-				SampleSize:       int16(av.FLTP.BytesPerSample() * 4),
-				SampleRate:       float64(codec.ClockRate),
-				Unknowns:         []mp4io.Atom{ESDS(b)},
-			}
-
-			moov.Tracks = append(moov.Tracks, trak)
+		case streamer.CodecOpus, streamer.CodecMP3, streamer.CodecPCMU, streamer.CodecPCMA:
+			mv.WriteAudioTrack(
+				uint32(i+1), codec.Name, codec.ClockRate, codec.Channels, nil,
+			)
 		}
 
-		trex := &mp4io.TrackExtend{
-			TrackId:               uint32(i + 1),
-			DefaultSampleDescIdx:  1,
-			DefaultSampleDuration: 0,
-		}
-		moov.MovieExtend.Tracks = append(moov.MovieExtend.Tracks, trex)
-
 		m.pts = append(m.pts, 0)
 		m.dts = append(m.dts, 0)
 	}
 
-	data := make([]byte, moov.Len())
-	moov.Marshal(data)
+	mv.StartAtom(iso.MoovMvex)
+	for i := range codecs {
+		mv.WriteTrackExtend(uint32(i + 1))
+	}
+	mv.EndAtom() // MVEX
 
-	return append(FTYP(), data...), nil
+	mv.EndAtom() // MOOV
+
+	return mv.Bytes(), nil
 }
 
-//func (m *Muxer) Rewind() {
-//	m.dts = 0
-//	m.pts = 0
-//}
+func (m *Muxer) Reset() {
+	m.fragIndex = 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{
-		Flags:            0x000b05,
-		FirstSampleFlags: uint32(fmp4io.SampleNoDependencies),
-		DataOffset:       0,
-		Entries:          []mp4io.TrackFragRunEntry{},
-	}
-
-	moof := &mp4fio.MovieFrag{
-		Header: &mp4fio.MovieFragHeader{
-			Seqnum: m.fragIndex + 1,
-		},
-		Tracks: []*mp4fio.TrackFrag{
-			{
-				Header: &mp4fio.TrackFragHeader{
-					Data: []byte{0x00, 0x02, 0x00, 0x20, 0x00, 0x00, 0x00, trackID + 1, 0x01, 0x01, 0x00, 0x00},
-				},
-				DecodeTime: &mp4fio.TrackFragDecodeTime{
-					Version: 1,
-					Flags:   0,
-					Time:    m.dts[trackID],
-				},
-				Run: run,
-			},
-		},
-	}
-
-	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)
-	}
-	m.pts[trackID] = newTime
-
-	// important before moof.Len()
-	run.Entries = append(run.Entries, entry)
-
-	moofLen := moof.Len()
-	mdatLen := 8 + len(packet.Payload)
-
-	// important after moof.Len()
-	run.DataOffset = uint32(moofLen + 8)
-
-	buf := make([]byte, moofLen+mdatLen)
-	moof.Marshal(buf)
-
-	binary.BigEndian.PutUint32(buf[moofLen:], uint32(mdatLen))
-	copy(buf[moofLen+4:], "mdat")
-	copy(buf[moofLen+8:], packet.Payload)
+	// important before increment
+	time := m.dts[trackID]
 
 	m.fragIndex++
 
-	//m.total += moofLen + mdatLen
+	var duration uint32
+	newTime := packet.Timestamp
+	if m.pts[trackID] > 0 {
+		duration = newTime - m.pts[trackID]
+		m.dts[trackID] += uint64(duration)
+	} else {
+		// important, or Safari will fail with first frame
+		duration = 1
+	}
+	m.pts[trackID] = newTime
 
-	return buf
+	mv := iso.NewMovie(1024 + len(packet.Payload))
+	mv.WriteMovieFragment(
+		m.fragIndex, uint32(trackID+1), duration,
+		uint32(len(packet.Payload)), time,
+	)
+	mv.WriteData(packet.Payload)
+
+	return mv.Bytes()
 }

pkg/mp4/segment.go

@@ -0,0 +1,143 @@
+package mp4
+
+import (
+	"encoding/json"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/h265"
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/pion/rtp"
+	"sync/atomic"
+)
+
+type Segment struct {
+	streamer.Element
+
+	Medias     []*streamer.Media
+	UserAgent  string
+	RemoteAddr string
+
+	MimeType     string
+	OnlyKeyframe bool
+
+	send uint32
+}
+
+func (c *Segment) GetMedias() []*streamer.Media {
+	if c.Medias != nil {
+		return c.Medias
+	}
+
+	// default medias
+	return []*streamer.Media{
+		{
+			Kind:      streamer.KindVideo,
+			Direction: streamer.DirectionRecvonly,
+			Codecs: []*streamer.Codec{
+				{Name: streamer.CodecH264},
+				{Name: streamer.CodecH265},
+			},
+		},
+	}
+}
+
+func (c *Segment) AddTrack(media *streamer.Media, track *streamer.Track) *streamer.Track {
+	muxer := &Muxer{}
+
+	codecs := []*streamer.Codec{track.Codec}
+
+	init, err := muxer.GetInit(codecs)
+	if err != nil {
+		return nil
+	}
+
+	c.MimeType = `video/mp4; codecs="` + muxer.MimeCodecs(codecs) + `"`
+
+	switch track.Codec.Name {
+	case streamer.CodecH264:
+		var push streamer.WriterFunc
+
+		if c.OnlyKeyframe {
+			push = func(packet *rtp.Packet) error {
+				if !h264.IsKeyframe(packet.Payload) {
+					return nil
+				}
+
+				buf := muxer.Marshal(0, packet)
+				atomic.AddUint32(&c.send, uint32(len(buf)))
+				c.Fire(append(init, buf...))
+
+				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...)
+					}
+
+					atomic.AddUint32(&c.send, uint32(len(buf)))
+					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.IsRTP() {
+			wrapper = h264.RTPDepay(track)
+		} else {
+			wrapper = h264.RepairAVC(track)
+		}
+		push = wrapper(push)
+
+		return track.Bind(push)
+
+	case streamer.CodecH265:
+		push := func(packet *rtp.Packet) error {
+			if !h265.IsKeyframe(packet.Payload) {
+				return nil
+			}
+
+			buf := muxer.Marshal(0, packet)
+			atomic.AddUint32(&c.send, uint32(len(buf)))
+			c.Fire(append(init, buf...))
+
+			return nil
+		}
+
+		if track.Codec.IsRTP() {
+			wrapper := h265.RTPDepay(track)
+			push = wrapper(push)
+		}
+
+		return track.Bind(push)
+	}
+
+	panic("unsupported codec")
+}
+
+func (c *Segment) MarshalJSON() ([]byte, error) {
+	info := &streamer.Info{
+		Type:       "WS/MP4 client",
+		RemoteAddr: c.RemoteAddr,
+		UserAgent:  c.UserAgent,
+		Send:       atomic.LoadUint32(&c.send),
+	}
+	return json.Marshal(info)
+}

pkg/mp4/v1/consumer.go

@@ -1,7 +1,8 @@
-package mp4f
+package mp4
 
 import (
-	"encoding/json"
+	"encoding/hex"
+	"github.com/AlexxIT/go2rtc/pkg/aac"
 	"github.com/AlexxIT/go2rtc/pkg/h264"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/deepch/vdk/av"
@@ -15,6 +16,7 @@ import (
 type Consumer struct {
 	streamer.Element
 
+	Medias     []*streamer.Media
 	UserAgent  string
 	RemoteAddr string
 
@@ -27,6 +29,10 @@ type Consumer struct {
 }
 
 func (c *Consumer) GetMedias() []*streamer.Media {
+	if c.Medias != nil {
+		return c.Medias
+	}
+
 	return []*streamer.Media{
 		{
 			Kind:      streamer.KindVideo,
@@ -89,7 +95,7 @@ func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 			return nil
 		}
 
-		if !codec.IsMP4() {
+		if codec.IsRTP() {
 			wrapper := h264.RTPDepay(track)
 			push = wrapper(push)
 		}
@@ -97,7 +103,17 @@ func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 		return track.Bind(push)
 
 	case streamer.CodecAAC:
-		stream, _ := aacparser.NewCodecDataFromMPEG4AudioConfigBytes([]byte{20, 8})
+		s := streamer.Between(codec.FmtpLine, "config=", ";")
+
+		b, err := hex.DecodeString(s)
+		if err != nil {
+			return nil
+		}
+
+		stream, err := aacparser.NewCodecDataFromMPEG4AudioConfigBytes(b)
+		if err != nil {
+			return nil
+		}
 
 		c.mimeType += ",mp4a.40.2"
 		c.streams = append(c.streams, stream)
@@ -127,6 +143,11 @@ func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *strea
 			return nil
 		}
 
+		if codec.IsRTP() {
+			wrapper := aac.RTPDepay(track)
+			push = wrapper(push)
+		}
+
 		return track.Bind(push)
 	}
 
@@ -146,19 +167,6 @@ func (c *Consumer) Init() ([]byte, error) {
 	return data, nil
 }
 
-func (c *Consumer) Start()  {
+func (c *Consumer) Start() {
 	c.start = true
 }
-
-//
-
-func (c *Consumer) MarshalJSON() ([]byte, error) {
-	v := map[string]interface{}{
-		"type":        "MSE server consumer",
-		"send":        c.send,
-		"remote_addr": c.RemoteAddr,
-		"user_agent":  c.UserAgent,
-	}
-
-	return json.Marshal(v)
-}

pkg/mp4/v2/consumer.go

@@ -0,0 +1,174 @@
+package mp4
+
+import (
+	"encoding/json"
+	"github.com/AlexxIT/go2rtc/pkg/aac"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/h265"
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/pion/rtp"
+	"sync/atomic"
+)
+
+type Consumer struct {
+	streamer.Element
+
+	Medias     []*streamer.Media
+	UserAgent  string
+	RemoteAddr string
+
+	muxer  *Muxer
+	codecs []*streamer.Codec
+	wait   byte
+
+	send uint32
+}
+
+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,
+			Direction: streamer.DirectionRecvonly,
+			Codecs: []*streamer.Codec{
+				{Name: streamer.CodecH264},
+				{Name: streamer.CodecH265},
+			},
+		},
+		{
+			Kind:      streamer.KindAudio,
+			Direction: streamer.DirectionRecvonly,
+			Codecs: []*streamer.Codec{
+				{Name: streamer.CodecAAC},
+			},
+		},
+	}
+}
+
+func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *streamer.Track {
+	trackID := byte(len(c.codecs))
+	c.codecs = append(c.codecs, track.Codec)
+
+	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.wait != waitNone {
+				if c.wait == waitInit || !h264.IsKeyframe(packet.Payload) {
+					return nil
+				}
+				c.wait = waitNone
+			}
+
+			buf := c.muxer.Marshal(trackID, packet)
+			atomic.AddUint32(&c.send, uint32(len(buf)))
+			c.Fire(buf)
+
+			return nil
+		}
+
+		var wrapper streamer.WrapperFunc
+		if codec.IsRTP() {
+			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.wait != waitNone {
+				if c.wait == waitInit || !h265.IsKeyframe(packet.Payload) {
+					return nil
+				}
+				c.wait = waitNone
+			}
+
+			buf := c.muxer.Marshal(trackID, packet)
+			atomic.AddUint32(&c.send, uint32(len(buf)))
+			c.Fire(buf)
+
+			return nil
+		}
+
+		if codec.IsRTP() {
+			wrapper := h265.RTPDepay(track)
+			push = wrapper(push)
+		}
+
+		return track.Bind(push)
+
+	case streamer.CodecAAC:
+		push := func(packet *rtp.Packet) error {
+			if c.wait != waitNone {
+				return nil
+			}
+
+			buf := c.muxer.Marshal(trackID, packet)
+			atomic.AddUint32(&c.send, uint32(len(buf)))
+			c.Fire(buf)
+
+			return nil
+		}
+
+		if codec.IsRTP() {
+			wrapper := aac.RTPDepay(track)
+			push = wrapper(push)
+		}
+
+		return track.Bind(push)
+	}
+
+	panic("unsupported codec")
+}
+
+func (c *Consumer) MimeType() string {
+	return c.muxer.MimeType(c.codecs)
+}
+
+func (c *Consumer) Init() ([]byte, error) {
+	c.muxer = &Muxer{}
+	return c.muxer.GetInit(c.codecs)
+}
+
+func (c *Consumer) Start() {
+	if c.wait == waitInit {
+		c.wait = waitKeyframe
+	}
+}
+
+//
+
+func (c *Consumer) MarshalJSON() ([]byte, error) {
+	info := &streamer.Info{
+		Type:       "MP4 client",
+		RemoteAddr: c.RemoteAddr,
+		UserAgent:  c.UserAgent,
+		Send:       atomic.LoadUint32(&c.send),
+	}
+	return json.Marshal(info)
+}

pkg/mp4/v2/muxer.go

@@ -0,0 +1,256 @@
+package mp4
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/h265"
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/deepch/vdk/av"
+	"github.com/deepch/vdk/codec/h264parser"
+	"github.com/deepch/vdk/codec/h265parser"
+	"github.com/deepch/vdk/format/fmp4/fmp4io"
+	"github.com/deepch/vdk/format/mp4/mp4io"
+	"github.com/deepch/vdk/format/mp4f/mp4fio"
+	"github.com/pion/rtp"
+)
+
+type Muxer struct {
+	fragIndex uint32
+	dts       []uint64
+	pts       []uint32
+}
+
+func (m *Muxer) MimeType(codecs []*streamer.Codec) string {
+	s := `video/mp4; codecs="`
+
+	for i, codec := range codecs {
+		if i > 0 {
+			s += ","
+		}
+
+		switch codec.Name {
+		case streamer.CodecH264:
+			s += "avc1." + h264.GetProfileLevelID(codec.FmtpLine)
+		case streamer.CodecH265:
+			// H.265 profile=main level=5.1
+			// hvc1 - supported in Safari, hev1 - doesn't, both supported in Chrome
+			s += "hvc1.1.6.L153.B0"
+		case streamer.CodecAAC:
+			s += "mp4a.40.2"
+		}
+	}
+
+	return s + `"`
+}
+
+func (m *Muxer) GetInit(codecs []*streamer.Codec) ([]byte, error) {
+	moov := MOOV()
+
+	for i, codec := range codecs {
+		switch codec.Name {
+		case streamer.CodecH264:
+			sps, pps := h264.GetParameterSet(codec.FmtpLine)
+			if sps == nil {
+				// some dummy SPS and PPS not a problem
+				sps = []byte{0x67, 0x42, 0x00, 0x0a, 0xf8, 0x41, 0xa2}
+				pps = []byte{0x68, 0xce, 0x38, 0x80}
+			}
+
+			codecData, err := h264parser.NewCodecDataFromSPSAndPPS(sps, pps)
+			if err != nil {
+				return nil, err
+			}
+
+			width := codecData.Width()
+			height := codecData.Height()
+
+			trak := TRAK(i + 1)
+			trak.Header.TrackWidth = float64(width)
+			trak.Header.TrackHeight = float64(height)
+			trak.Media.Header.TimeScale = int32(codec.ClockRate)
+			trak.Media.Handler = &mp4io.HandlerRefer{
+				SubType: [4]byte{'v', 'i', 'd', 'e'},
+				Name:    []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 'm', 'a', 'i', 'n', 0},
+			}
+			trak.Media.Info.Video = &mp4io.VideoMediaInfo{
+				Flags: 0x000001,
+			}
+			trak.Media.Info.Sample.SampleDesc.AVC1Desc = &mp4io.AVC1Desc{
+				DataRefIdx:           1,
+				HorizontalResolution: 72,
+				VorizontalResolution: 72,
+				Width:                int16(width),
+				Height:               int16(height),
+				FrameCount:           1,
+				Depth:                24,
+				ColorTableId:         -1,
+				Conf: &mp4io.AVC1Conf{
+					Data: codecData.AVCDecoderConfRecordBytes(),
+				},
+			}
+
+			moov.Tracks = append(moov.Tracks, trak)
+
+		case streamer.CodecH265:
+			vps, sps, pps := h265.GetParameterSet(codec.FmtpLine)
+			if sps == nil {
+				// 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)
+			if err != nil {
+				return nil, err
+			}
+
+			width := codecData.Width()
+			height := codecData.Height()
+
+			trak := TRAK(i + 1)
+			trak.Header.TrackWidth = float64(width)
+			trak.Header.TrackHeight = float64(height)
+			trak.Media.Header.TimeScale = int32(codec.ClockRate)
+			trak.Media.Handler = &mp4io.HandlerRefer{
+				SubType: [4]byte{'v', 'i', 'd', 'e'},
+				Name:    []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 'm', 'a', 'i', 'n', 0},
+			}
+			trak.Media.Info.Video = &mp4io.VideoMediaInfo{
+				Flags: 0x000001,
+			}
+			trak.Media.Info.Sample.SampleDesc.HV1Desc = &mp4io.HV1Desc{
+				DataRefIdx:           1,
+				HorizontalResolution: 72,
+				VorizontalResolution: 72,
+				Width:                int16(width),
+				Height:               int16(height),
+				FrameCount:           1,
+				Depth:                24,
+				ColorTableId:         -1,
+				Conf: &mp4io.HV1Conf{
+					Data: codecData.AVCDecoderConfRecordBytes(),
+				},
+			}
+
+			moov.Tracks = append(moov.Tracks, trak)
+
+		case streamer.CodecAAC:
+			s := streamer.Between(codec.FmtpLine, "config=", ";")
+			b, err := hex.DecodeString(s)
+			if err != nil {
+				return nil, err
+			}
+
+			trak := TRAK(i + 1)
+			trak.Header.AlternateGroup = 1
+			trak.Header.Duration = 0
+			trak.Header.Volume = 1
+			trak.Media.Header.TimeScale = int32(codec.ClockRate)
+
+			trak.Media.Handler = &mp4io.HandlerRefer{
+				SubType: [4]byte{'s', 'o', 'u', 'n'},
+				Name:    []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 'm', 'a', 'i', 'n', 0},
+			}
+			trak.Media.Info.Sound = &mp4io.SoundMediaInfo{}
+
+			trak.Media.Info.Sample.SampleDesc.MP4ADesc = &mp4io.MP4ADesc{
+				DataRefIdx:       1,
+				NumberOfChannels: int16(codec.Channels),
+				SampleSize:       int16(av.FLTP.BytesPerSample() * 4),
+				SampleRate:       float64(codec.ClockRate),
+				Unknowns:         []mp4io.Atom{ESDS(b)},
+			}
+
+			moov.Tracks = append(moov.Tracks, trak)
+		}
+
+		trex := &mp4io.TrackExtend{
+			TrackId:               uint32(i + 1),
+			DefaultSampleDescIdx:  1,
+			DefaultSampleDuration: 0,
+		}
+		moov.MovieExtend.Tracks = append(moov.MovieExtend.Tracks, trex)
+
+		m.pts = append(m.pts, 0)
+		m.dts = append(m.dts, 0)
+	}
+
+	data := make([]byte, moov.Len())
+	moov.Marshal(data)
+
+	return append(FTYP(), data...), nil
+}
+
+func (m *Muxer) Reset() {
+	m.fragIndex = 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{
+		Flags:            0x000b05,
+		FirstSampleFlags: uint32(fmp4io.SampleNoDependencies),
+		DataOffset:       0,
+		Entries:          []mp4io.TrackFragRunEntry{},
+	}
+
+	moof := &mp4fio.MovieFrag{
+		Header: &mp4fio.MovieFragHeader{
+			Seqnum: m.fragIndex + 1,
+		},
+		Tracks: []*mp4fio.TrackFrag{
+			{
+				Header: &mp4fio.TrackFragHeader{
+					Data: []byte{0x00, 0x02, 0x00, 0x20, 0x00, 0x00, 0x00, trackID + 1, 0x01, 0x01, 0x00, 0x00},
+				},
+				DecodeTime: &mp4fio.TrackFragDecodeTime{
+					Version: 1,
+					Flags:   0,
+					Time:    m.dts[trackID],
+				},
+				Run: run,
+			},
+		},
+	}
+
+	entry := mp4io.TrackFragRunEntry{
+		Size: uint32(len(packet.Payload)),
+	}
+
+	newTime := packet.Timestamp
+	if m.pts[trackID] > 0 {
+		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
+
+	// important before moof.Len()
+	run.Entries = append(run.Entries, entry)
+
+	moofLen := moof.Len()
+	mdatLen := 8 + len(packet.Payload)
+
+	// important after moof.Len()
+	run.DataOffset = uint32(moofLen + 8)
+
+	buf := make([]byte, moofLen+mdatLen)
+	moof.Marshal(buf)
+
+	binary.BigEndian.PutUint32(buf[moofLen:], uint32(mdatLen))
+	copy(buf[moofLen+4:], "mdat")
+	copy(buf[moofLen+8:], packet.Payload)
+
+	m.fragIndex++
+
+	//m.total += moofLen + mdatLen
+
+	return buf
+}

pkg/mp4/v2/segment.go

@@ -0,0 +1,143 @@
+package mp4
+
+import (
+	"encoding/json"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/h265"
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/pion/rtp"
+	"sync/atomic"
+)
+
+type Segment struct {
+	streamer.Element
+
+	Medias     []*streamer.Media
+	UserAgent  string
+	RemoteAddr string
+
+	MimeType     string
+	OnlyKeyframe bool
+
+	send uint32
+}
+
+func (c *Segment) GetMedias() []*streamer.Media {
+	if c.Medias != nil {
+		return c.Medias
+	}
+
+	// default medias
+	return []*streamer.Media{
+		{
+			Kind:      streamer.KindVideo,
+			Direction: streamer.DirectionRecvonly,
+			Codecs: []*streamer.Codec{
+				{Name: streamer.CodecH264},
+				{Name: streamer.CodecH265},
+			},
+		},
+	}
+}
+
+func (c *Segment) AddTrack(media *streamer.Media, track *streamer.Track) *streamer.Track {
+	muxer := &Muxer{}
+
+	codecs := []*streamer.Codec{track.Codec}
+
+	init, err := muxer.GetInit(codecs)
+	if err != nil {
+		return nil
+	}
+
+	c.MimeType = muxer.MimeType(codecs)
+
+	switch track.Codec.Name {
+	case streamer.CodecH264:
+		var push streamer.WriterFunc
+
+		if c.OnlyKeyframe {
+			push = func(packet *rtp.Packet) error {
+				if !h264.IsKeyframe(packet.Payload) {
+					return nil
+				}
+
+				buf := muxer.Marshal(0, packet)
+				atomic.AddUint32(&c.send, uint32(len(buf)))
+				c.Fire(append(init, buf...))
+
+				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...)
+					}
+
+					atomic.AddUint32(&c.send, uint32(len(buf)))
+					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.IsRTP() {
+			wrapper = h264.RTPDepay(track)
+		} else {
+			wrapper = h264.RepairAVC(track)
+		}
+		push = wrapper(push)
+
+		return track.Bind(push)
+
+	case streamer.CodecH265:
+		push := func(packet *rtp.Packet) error {
+			if !h265.IsKeyframe(packet.Payload) {
+				return nil
+			}
+
+			buf := muxer.Marshal(0, packet)
+			atomic.AddUint32(&c.send, uint32(len(buf)))
+			c.Fire(append(init, buf...))
+
+			return nil
+		}
+
+		if track.Codec.IsRTP() {
+			wrapper := h265.RTPDepay(track)
+			push = wrapper(push)
+		}
+
+		return track.Bind(push)
+	}
+
+	panic("unsupported codec")
+}
+
+func (c *Segment) MarshalJSON() ([]byte, error) {
+	info := &streamer.Info{
+		Type:       "WS/MP4 client",
+		RemoteAddr: c.RemoteAddr,
+		UserAgent:  c.UserAgent,
+		Send:       atomic.LoadUint32(&c.send),
+	}
+	return json.Marshal(info)
+}

pkg/mpegts/README.md

@@ -0,0 +1,5 @@
+## Useful links
+
+- https://github.com/theREDspace/video-onboarding/blob/main/MPEGTS%20Knowledge.md
+- https://en.wikipedia.org/wiki/MPEG_transport_stream
+- https://en.wikipedia.org/wiki/Program-specific_information

pkg/mpegts/checksum.go

@@ -0,0 +1,54 @@
+package mpegts
+
+var ieeeCrc32Tbl = []uint32{
+	0x00000000, 0xB71DC104, 0x6E3B8209, 0xD926430D, 0xDC760413, 0x6B6BC517,
+	0xB24D861A, 0x0550471E, 0xB8ED0826, 0x0FF0C922, 0xD6D68A2F, 0x61CB4B2B,
+	0x649B0C35, 0xD386CD31, 0x0AA08E3C, 0xBDBD4F38, 0x70DB114C, 0xC7C6D048,
+	0x1EE09345, 0xA9FD5241, 0xACAD155F, 0x1BB0D45B, 0xC2969756, 0x758B5652,
+	0xC836196A, 0x7F2BD86E, 0xA60D9B63, 0x11105A67, 0x14401D79, 0xA35DDC7D,
+	0x7A7B9F70, 0xCD665E74, 0xE0B62398, 0x57ABE29C, 0x8E8DA191, 0x39906095,
+	0x3CC0278B, 0x8BDDE68F, 0x52FBA582, 0xE5E66486, 0x585B2BBE, 0xEF46EABA,
+	0x3660A9B7, 0x817D68B3, 0x842D2FAD, 0x3330EEA9, 0xEA16ADA4, 0x5D0B6CA0,
+	0x906D32D4, 0x2770F3D0, 0xFE56B0DD, 0x494B71D9, 0x4C1B36C7, 0xFB06F7C3,
+	0x2220B4CE, 0x953D75CA, 0x28803AF2, 0x9F9DFBF6, 0x46BBB8FB, 0xF1A679FF,
+	0xF4F63EE1, 0x43EBFFE5, 0x9ACDBCE8, 0x2DD07DEC, 0x77708634, 0xC06D4730,
+	0x194B043D, 0xAE56C539, 0xAB068227, 0x1C1B4323, 0xC53D002E, 0x7220C12A,
+	0xCF9D8E12, 0x78804F16, 0xA1A60C1B, 0x16BBCD1F, 0x13EB8A01, 0xA4F64B05,
+	0x7DD00808, 0xCACDC90C, 0x07AB9778, 0xB0B6567C, 0x69901571, 0xDE8DD475,
+	0xDBDD936B, 0x6CC0526F, 0xB5E61162, 0x02FBD066, 0xBF469F5E, 0x085B5E5A,
+	0xD17D1D57, 0x6660DC53, 0x63309B4D, 0xD42D5A49, 0x0D0B1944, 0xBA16D840,
+	0x97C6A5AC, 0x20DB64A8, 0xF9FD27A5, 0x4EE0E6A1, 0x4BB0A1BF, 0xFCAD60BB,
+	0x258B23B6, 0x9296E2B2, 0x2F2BAD8A, 0x98366C8E, 0x41102F83, 0xF60DEE87,
+	0xF35DA999, 0x4440689D, 0x9D662B90, 0x2A7BEA94, 0xE71DB4E0, 0x500075E4,
+	0x892636E9, 0x3E3BF7ED, 0x3B6BB0F3, 0x8C7671F7, 0x555032FA, 0xE24DF3FE,
+	0x5FF0BCC6, 0xE8ED7DC2, 0x31CB3ECF, 0x86D6FFCB, 0x8386B8D5, 0x349B79D1,
+	0xEDBD3ADC, 0x5AA0FBD8, 0xEEE00C69, 0x59FDCD6D, 0x80DB8E60, 0x37C64F64,
+	0x3296087A, 0x858BC97E, 0x5CAD8A73, 0xEBB04B77, 0x560D044F, 0xE110C54B,
+	0x38368646, 0x8F2B4742, 0x8A7B005C, 0x3D66C158, 0xE4408255, 0x535D4351,
+	0x9E3B1D25, 0x2926DC21, 0xF0009F2C, 0x471D5E28, 0x424D1936, 0xF550D832,
+	0x2C769B3F, 0x9B6B5A3B, 0x26D61503, 0x91CBD407, 0x48ED970A, 0xFFF0560E,
+	0xFAA01110, 0x4DBDD014, 0x949B9319, 0x2386521D, 0x0E562FF1, 0xB94BEEF5,
+	0x606DADF8, 0xD7706CFC, 0xD2202BE2, 0x653DEAE6, 0xBC1BA9EB, 0x0B0668EF,
+	0xB6BB27D7, 0x01A6E6D3, 0xD880A5DE, 0x6F9D64DA, 0x6ACD23C4, 0xDDD0E2C0,
+	0x04F6A1CD, 0xB3EB60C9, 0x7E8D3EBD, 0xC990FFB9, 0x10B6BCB4, 0xA7AB7DB0,
+	0xA2FB3AAE, 0x15E6FBAA, 0xCCC0B8A7, 0x7BDD79A3, 0xC660369B, 0x717DF79F,
+	0xA85BB492, 0x1F467596, 0x1A163288, 0xAD0BF38C, 0x742DB081, 0xC3307185,
+	0x99908A5D, 0x2E8D4B59, 0xF7AB0854, 0x40B6C950, 0x45E68E4E, 0xF2FB4F4A,
+	0x2BDD0C47, 0x9CC0CD43, 0x217D827B, 0x9660437F, 0x4F460072, 0xF85BC176,
+	0xFD0B8668, 0x4A16476C, 0x93300461, 0x242DC565, 0xE94B9B11, 0x5E565A15,
+	0x87701918, 0x306DD81C, 0x353D9F02, 0x82205E06, 0x5B061D0B, 0xEC1BDC0F,
+	0x51A69337, 0xE6BB5233, 0x3F9D113E, 0x8880D03A, 0x8DD09724, 0x3ACD5620,
+	0xE3EB152D, 0x54F6D429, 0x7926A9C5, 0xCE3B68C1, 0x171D2BCC, 0xA000EAC8,
+	0xA550ADD6, 0x124D6CD2, 0xCB6B2FDF, 0x7C76EEDB, 0xC1CBA1E3, 0x76D660E7,
+	0xAFF023EA, 0x18EDE2EE, 0x1DBDA5F0, 0xAAA064F4, 0x738627F9, 0xC49BE6FD,
+	0x09FDB889, 0xBEE0798D, 0x67C63A80, 0xD0DBFB84, 0xD58BBC9A, 0x62967D9E,
+	0xBBB03E93, 0x0CADFF97, 0xB110B0AF, 0x060D71AB, 0xDF2B32A6, 0x6836F3A2,
+	0x6D66B4BC, 0xDA7B75B8, 0x035D36B5, 0xB440F7B1, 0x00000001,
+}
+
+func calcCRC32(crc uint32, data []byte) uint32 {
+	for _, b := range data {
+		crc = ieeeCrc32Tbl[b^byte(crc)] ^ (crc >> 8)
+	}
+	return crc
+}

pkg/mpegts/client.go

@@ -0,0 +1,73 @@
+package mpegts
+
+import (
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"net/http"
+)
+
+type Client struct {
+	streamer.Element
+
+	medias []*streamer.Media
+	tracks map[byte]*streamer.Track
+
+	res *http.Response
+}
+
+func NewClient(res *http.Response) *Client {
+	return &Client{res: res}
+}
+
+func (c *Client) Handle() error {
+	if c.tracks == nil {
+		c.tracks = map[byte]*streamer.Track{}
+	}
+
+	reader := NewReader()
+
+	b := make([]byte, 1024*1024*256) // 256K
+
+	probe := streamer.NewProbe(c.medias == nil)
+	for probe == nil || probe.Active() {
+		n, err := c.res.Body.Read(b)
+		if err != nil {
+			return err
+		}
+
+		reader.AppendBuffer(b[:n])
+
+		for {
+			packet := reader.GetPacket()
+			if packet == nil {
+				break
+			}
+
+			track := c.tracks[packet.PayloadType]
+			if track == nil {
+				// count track on probe state even if not support it
+				probe.Append(packet.PayloadType)
+
+				media := GetMedia(packet)
+				if media == nil {
+					continue // unsupported codec
+				}
+
+				track = streamer.NewTrack2(media, nil)
+
+				c.medias = append(c.medias, media)
+				c.tracks[packet.PayloadType] = track
+			}
+
+			_ = track.WriteRTP(packet)
+
+			//log.Printf("[AVC] %v, len: %d, pts: %d ts: %10d", h264.Types(packet.Payload), len(packet.Payload), pkt.PTS, packet.Timestamp)
+		}
+	}
+
+	return nil
+}
+
+func (c *Client) Close() error {
+	_ = c.res.Body.Close()
+	return nil
+}

pkg/mpegts/helpers.go

@@ -0,0 +1,251 @@
+package mpegts
+
+import (
+	"bytes"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/pion/rtp"
+	"time"
+)
+
+const (
+	PacketSize = 188
+	SyncByte   = 0x47
+)
+
+const (
+	StreamTypePrivate  = 0x06 // PCMU or PCMA from FFmpeg
+	StreamTypeAAC      = 0x0F
+	StreamTypeH264     = 0x1B
+	StreamTypePCMATapo = 0x90
+)
+
+type Packet struct {
+	StreamType byte
+	PTS        time.Duration
+	DTS        time.Duration
+	Payload    []byte
+}
+
+// PES - Packetized Elementary Stream
+type PES struct {
+	StreamType byte
+	StreamID   byte
+	Payload    []byte
+	Mode       byte
+	Size       int
+
+	Sequence  uint16
+	Timestamp uint32
+}
+
+const (
+	ModeUnknown = iota
+	ModeSize
+	ModeStream
+)
+
+// parse Optional PES header
+const minHeaderSize = 3
+
+func (p *PES) SetBuffer(size uint16, b []byte) {
+	if size == 0 {
+		optSize := b[2] // optional fields
+		b = b[minHeaderSize+optSize:]
+
+		if p.StreamType == StreamTypeH264 {
+			if bytes.HasPrefix(b, []byte{0, 0, 0, 1, h264.NALUTypeAUD}) {
+				p.Mode = ModeStream
+				b = b[5:]
+			}
+		}
+
+		if p.Mode == ModeUnknown {
+			println("WARNING: mpegts: unknown zero-size stream")
+		}
+	} else {
+		p.Mode = ModeSize
+		p.Size = int(size)
+	}
+
+	p.Payload = make([]byte, 0, size)
+	p.Payload = append(p.Payload, b...)
+}
+
+func (p *PES) AppendBuffer(b []byte) {
+	p.Payload = append(p.Payload, b...)
+}
+
+func (p *PES) GetPacket() (pkt *rtp.Packet) {
+	switch p.Mode {
+	case ModeSize:
+		left := p.Size - len(p.Payload)
+		if left > 0 {
+			return
+		}
+
+		if left < 0 {
+			println("WARNING: mpegts: buffer overflow")
+			p.Payload = nil
+			return
+		}
+
+		// fist byte also flags
+		flags := p.Payload[1]
+		optSize := p.Payload[2] // optional fields
+
+		payload := p.Payload[minHeaderSize+optSize:]
+
+		switch p.StreamType {
+		case StreamTypeH264:
+			var ts uint32
+
+			const hasPTS = 0b1000_0000
+			if flags&hasPTS != 0 {
+				ts = ParseTime(p.Payload[minHeaderSize:])
+			}
+
+			pkt = &rtp.Packet{
+				Header: rtp.Header{
+					PayloadType: p.StreamType,
+					Timestamp:   ts,
+				},
+				Payload: h264.AnnexB2AVC(payload),
+			}
+
+		case StreamTypePCMATapo:
+			p.Sequence++
+			p.Timestamp += uint32(len(payload))
+
+			pkt = &rtp.Packet{
+				Header: rtp.Header{
+					Version:        2,
+					PayloadType:    p.StreamType,
+					SequenceNumber: p.Sequence,
+					Timestamp:      p.Timestamp,
+				},
+				Payload: payload,
+			}
+		}
+
+		p.Payload = nil
+
+	case ModeStream:
+		i := bytes.Index(p.Payload, []byte{0, 0, 0, 1, h264.NALUTypeAUD})
+		if i < 0 {
+			return
+		}
+		if i2 := IndexFrom(p.Payload, []byte{0, 0, 1}, i); i2 < 0 && i2 > 9 {
+			return
+		}
+
+		pkt = &rtp.Packet{
+			Header: rtp.Header{
+				PayloadType: p.StreamType,
+				Timestamp:   uint32(time.Duration(time.Now().UnixNano()) * 90000 / time.Second),
+			},
+			Payload: DecodeAnnex3B(p.Payload[:i]),
+		}
+
+		p.Payload = p.Payload[i+5:]
+
+	default:
+		p.Payload = nil
+	}
+
+	return
+}
+
+func ParseTime(b []byte) uint32 {
+	return (uint32(b[0]&0x0E) << 29) | (uint32(b[1]) << 22) | (uint32(b[2]&0xFE) << 14) | (uint32(b[3]) << 7) | (uint32(b[4]) >> 1)
+}
+
+func GetMedia(pkt *rtp.Packet) *streamer.Media {
+	var codec *streamer.Codec
+	var kind string
+
+	switch pkt.PayloadType {
+	case StreamTypeH264:
+		codec = &streamer.Codec{
+			Name:        streamer.CodecH264,
+			ClockRate:   90000,
+			PayloadType: streamer.PayloadTypeRAW,
+			FmtpLine:    h264.GetFmtpLine(pkt.Payload),
+		}
+		kind = streamer.KindVideo
+
+	case StreamTypePCMATapo:
+		codec = &streamer.Codec{
+			Name:      streamer.CodecPCMA,
+			ClockRate: 8000,
+		}
+		kind = streamer.KindAudio
+
+	default:
+		return nil
+	}
+
+	return &streamer.Media{
+		Kind:      kind,
+		Direction: streamer.DirectionSendonly,
+		Codecs:    []*streamer.Codec{codec},
+	}
+}
+
+func DecodeAnnex3B(annexb []byte) (avc []byte) {
+	// depends on AU delimeter size
+	i0 := bytes.Index(annexb, []byte{0, 0, 1})
+	if i0 < 0 || i0 > 9 {
+		return nil
+	}
+
+	annexb = annexb[i0+3:] // skip first separator
+	i0 = 0
+
+	for {
+		// search next separato
+		iN := IndexFrom(annexb, []byte{0, 0, 1}, i0)
+		if iN < 0 {
+			break
+		}
+
+		// move i0 to next AU
+		if i0 = iN + 3; i0 >= len(annexb) {
+			break
+		}
+
+		// check if AU type valid
+		octet := annexb[i0]
+		const forbiddenZeroBit = 0x80
+		if octet&forbiddenZeroBit == 0 {
+			const nalUnitType = 0x1F
+			switch octet & nalUnitType {
+			case h264.NALUTypePFrame, h264.NALUTypeIFrame, h264.NALUTypeSPS, h264.NALUTypePPS:
+				// add AU in AVC format
+				avc = append(avc, byte(iN>>24), byte(iN>>16), byte(iN>>8), byte(iN))
+				avc = append(avc, annexb[:iN]...)
+
+				// cut search to next AU start
+				annexb = annexb[i0:]
+				i0 = 0
+			}
+		}
+	}
+
+	size := len(annexb)
+	avc = append(avc, byte(size>>24), byte(size>>16), byte(size>>8), byte(size))
+	return append(avc, annexb...)
+}
+
+func IndexFrom(b []byte, sep []byte, from int) int {
+	if from > 0 {
+		if from < len(b) {
+			if i := bytes.Index(b[from:], sep); i >= 0 {
+				return from + i
+			}
+		}
+		return -1
+	}
+
+	return bytes.Index(b, sep)
+}

pkg/mpegts/mpegts_test.go

@@ -0,0 +1,14 @@
+package mpegts
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestTime(t *testing.T) {
+	w := NewWriter()
+	w.WriteTime(0xFFFFFFFF)
+	assert.Equal(t, []byte{0x27, 0xFF, 0xFF, 0xFF, 0xFF}, w.Bytes())
+	ts := ParseTime(w.Bytes())
+	assert.Equal(t, uint32(0xFFFFFFFF), ts)
+}

pkg/mpegts/producer.go

@@ -1,7 +1,6 @@
-package ivideon
+package mpegts
 
 import (
-	"fmt"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
 )
 
@@ -15,15 +14,11 @@ func (c *Client) GetTrack(media *streamer.Media, codec *streamer.Codec) *streame
 			return track
 		}
 	}
-	panic(fmt.Sprintf("wrong media/codec: %+v %+v", media, codec))
+	return nil
 }
 
 func (c *Client) Start() error {
-	err := c.Handle()
-	if c.closed {
-		return nil
-	}
-	return err
+	return c.Handle()
 }
 
 func (c *Client) Stop() error {

pkg/mpegts/reader.go

@@ -0,0 +1,201 @@
+package mpegts
+
+import "github.com/pion/rtp"
+
+type Reader struct {
+	b []byte // packets buffer
+	i byte   // read position
+	s byte   // end position
+
+	pmt uint16 // Program Map Table (PMT) PID
+	pes map[uint16]*PES
+}
+
+func NewReader() *Reader {
+	return &Reader{}
+}
+
+func (r *Reader) SetBuffer(b []byte) {
+	r.b = b
+	r.i = 0
+	r.s = PacketSize
+}
+
+func (r *Reader) AppendBuffer(b []byte) {
+	r.b = append(r.b, b...)
+}
+
+func (r *Reader) GetPacket() *rtp.Packet {
+	for r.Sync() {
+		r.Skip(1) // Sync byte
+
+		pid := r.ReadUint16() & 0x1FFF // PID
+		flag := r.ReadByte()           // flags...
+
+		const pidNullPacket = 0x1FFF
+		if pid == pidNullPacket {
+			continue
+		}
+
+		const hasAdaptionField = 0b0010_0000
+		if flag&hasAdaptionField != 0 {
+			adSize := r.ReadByte() // Adaptation field length
+			if adSize > PacketSize-6 {
+				println("WARNING: mpegts: wrong adaptation size")
+				continue
+			}
+			r.Skip(adSize)
+		}
+
+		// PAT: Program Association Table
+		const pidPAT = 0
+		if pid == pidPAT {
+			// already processed
+			if r.pmt != 0 {
+				continue
+			}
+
+			r.ReadPSIHeader()
+
+			const CRCSize = 4
+			for r.Left() > CRCSize {
+				pNum := r.ReadUint16()
+				pPID := r.ReadUint16() & 0x1FFF
+				if pNum != 0 {
+					r.pmt = pPID
+				}
+			}
+
+			r.Skip(4) // CRC32
+			continue
+		}
+
+		// PMT : Program Map Table
+		if pid == r.pmt {
+			// already processed
+			if r.pes != nil {
+				continue
+			}
+
+			r.ReadPSIHeader()
+
+			pesPID := r.ReadUint16() & 0x1FFF // ? PCR PID
+			pSize := r.ReadUint16() & 0x03FF  // ? 0x0FFF
+			r.Skip(byte(pSize))
+
+			r.pes = map[uint16]*PES{}
+
+			const CRCSize = 4
+			for r.Left() > CRCSize {
+				streamType := r.ReadByte()
+				pesPID = r.ReadUint16() & 0x1FFF // Elementary PID
+				iSize := r.ReadUint16() & 0x03FF // ? 0x0FFF
+				r.Skip(byte(iSize))
+
+				r.pes[pesPID] = &PES{StreamType: streamType}
+			}
+
+			r.Skip(4) // ? CRC32
+			continue
+		}
+
+		if r.pes == nil {
+			continue
+		}
+
+		pes := r.pes[pid]
+		if pes == nil {
+			continue // unknown PID
+		}
+
+		if pes.Payload == nil {
+			// PES Packet start code prefix
+			if r.ReadByte() != 0 || r.ReadByte() != 0 || r.ReadByte() != 1 {
+				continue
+			}
+
+			// read stream ID and total payload size
+			pes.StreamID = r.ReadByte()
+			pes.SetBuffer(r.ReadUint16(), r.Bytes())
+		} else {
+			pes.AppendBuffer(r.Bytes())
+		}
+
+		if pkt := pes.GetPacket(); pkt != nil {
+			return pkt
+		}
+	}
+
+	return nil
+}
+
+// Sync - search sync byte
+func (r *Reader) Sync() bool {
+	// drop previous readed packet
+	if r.i != 0 {
+		r.b = r.b[PacketSize:]
+		r.i = 0
+		r.s = PacketSize
+	}
+
+	// if packet available
+	if len(r.b) < PacketSize {
+		return false
+	}
+
+	// if data starts from sync byte
+	if r.b[0] == SyncByte {
+		return true
+	}
+
+	for len(r.b) >= PacketSize {
+		if r.b[0] == SyncByte {
+			return true
+		}
+		r.b = r.b[1:]
+	}
+
+	return false
+}
+
+func (r *Reader) ReadPSIHeader() {
+	pointer := r.ReadByte() // Pointer field
+	r.Skip(pointer)         // Pointer filler bytes
+
+	r.Skip(1)                       // Table ID
+	size := r.ReadUint16() & 0x03FF // Section length
+	r.SetSize(byte(size))
+
+	r.Skip(2) // Table ID extension
+	r.Skip(1) // flags...
+	r.Skip(1) // Section number
+	r.Skip(1) // Last section number
+}
+
+func (r *Reader) Skip(i byte) {
+	r.i += i
+}
+
+func (r *Reader) ReadByte() byte {
+	b := r.b[r.i]
+	r.i++
+	return b
+}
+
+func (r *Reader) ReadUint16() uint16 {
+	i := (uint16(r.b[r.i]) << 8) | uint16(r.b[r.i+1])
+	r.i += 2
+	return i
+}
+
+func (r *Reader) Bytes() []byte {
+	return r.b[r.i:PacketSize]
+}
+
+func (r *Reader) Left() byte {
+	return r.s - r.i
+}
+
+func (r *Reader) SetSize(size byte) {
+	r.s = r.i + size
+}

pkg/mpegts/ts.go

@@ -0,0 +1,194 @@
+package mpegts
+
+import (
+	"bytes"
+	"encoding/hex"
+	"github.com/AlexxIT/go2rtc/pkg/aac"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/deepch/vdk/av"
+	"github.com/deepch/vdk/codec/aacparser"
+	"github.com/deepch/vdk/codec/h264parser"
+	"github.com/deepch/vdk/format/ts"
+	"github.com/pion/rtp"
+	"sync/atomic"
+	"time"
+)
+
+type Consumer struct {
+	streamer.Element
+
+	UserAgent  string
+	RemoteAddr string
+
+	buf      *bytes.Buffer
+	muxer    *ts.Muxer
+	mimeType string
+	streams  []av.CodecData
+	start    bool
+	init     []byte
+
+	send uint32
+}
+
+func (c *Consumer) GetMedias() []*streamer.Media {
+	return []*streamer.Media{
+		{
+			Kind:      streamer.KindVideo,
+			Direction: streamer.DirectionRecvonly,
+			Codecs: []*streamer.Codec{
+				{Name: streamer.CodecH264},
+			},
+		},
+		//{
+		//	Kind:      streamer.KindAudio,
+		//	Direction: streamer.DirectionRecvonly,
+		//	Codecs: []*streamer.Codec{
+		//		{Name: streamer.CodecAAC},
+		//	},
+		//},
+	}
+}
+
+func (c *Consumer) AddTrack(media *streamer.Media, track *streamer.Track) *streamer.Track {
+	codec := track.Codec
+	trackID := int8(len(c.streams))
+
+	switch codec.Name {
+	case streamer.CodecH264:
+		sps, pps := h264.GetParameterSet(codec.FmtpLine)
+		stream, err := h264parser.NewCodecDataFromSPSAndPPS(sps, pps)
+		if err != nil {
+			return nil
+		}
+
+		if len(c.mimeType) > 0 {
+			c.mimeType += ","
+		}
+
+		c.mimeType += "avc1." + h264.GetProfileLevelID(codec.FmtpLine)
+
+		c.streams = append(c.streams, stream)
+
+		pkt := av.Packet{Idx: trackID, CompositionTime: time.Millisecond}
+
+		ts2time := time.Second / time.Duration(codec.ClockRate)
+
+		push := func(packet *rtp.Packet) error {
+			if packet.Version != h264.RTPPacketVersionAVC {
+				return nil
+			}
+
+			if !c.start {
+				return nil
+			}
+
+			pkt.Data = packet.Payload
+			newTime := time.Duration(packet.Timestamp) * ts2time
+			if pkt.Time > 0 {
+				pkt.Duration = newTime - pkt.Time
+			}
+			pkt.Time = newTime
+
+			if err = c.muxer.WritePacket(pkt); err != nil {
+				return err
+			}
+
+			// clone bytes from buffer, so next packet won't overwrite it
+			buf := append([]byte{}, c.buf.Bytes()...)
+			atomic.AddUint32(&c.send, uint32(len(buf)))
+			c.Fire(buf)
+
+			c.buf.Reset()
+
+			return nil
+		}
+
+		if codec.IsRTP() {
+			wrapper := h264.RTPDepay(track)
+			push = wrapper(push)
+		}
+
+		return track.Bind(push)
+
+	case streamer.CodecAAC:
+		s := streamer.Between(codec.FmtpLine, "config=", ";")
+
+		b, err := hex.DecodeString(s)
+		if err != nil {
+			return nil
+		}
+
+		stream, err := aacparser.NewCodecDataFromMPEG4AudioConfigBytes(b)
+		if err != nil {
+			return nil
+		}
+
+		if len(c.mimeType) > 0 {
+			c.mimeType += ","
+		}
+
+		c.mimeType += "mp4a.40.2"
+		c.streams = append(c.streams, stream)
+
+		pkt := av.Packet{Idx: trackID, CompositionTime: time.Millisecond}
+
+		ts2time := time.Second / time.Duration(codec.ClockRate)
+
+		push := func(packet *rtp.Packet) error {
+			if !c.start {
+				return nil
+			}
+
+			pkt.Data = packet.Payload
+			newTime := time.Duration(packet.Timestamp) * ts2time
+			if pkt.Time > 0 {
+				pkt.Duration = newTime - pkt.Time
+			}
+			pkt.Time = newTime
+
+			if err := c.muxer.WritePacket(pkt); err != nil {
+				return err
+			}
+
+			// clone bytes from buffer, so next packet won't overwrite it
+			buf := append([]byte{}, c.buf.Bytes()...)
+			atomic.AddUint32(&c.send, uint32(len(buf)))
+			c.Fire(buf)
+
+			c.buf.Reset()
+
+			return nil
+		}
+
+		if codec.IsRTP() {
+			wrapper := aac.RTPDepay(track)
+			push = wrapper(push)
+		}
+
+		return track.Bind(push)
+	}
+
+	panic("unsupported codec")
+}
+
+func (c *Consumer) MimeCodecs() string {
+	return c.mimeType
+}
+
+func (c *Consumer) Init() ([]byte, error) {
+	c.buf = bytes.NewBuffer(nil)
+	c.muxer = ts.NewMuxer(c.buf)
+
+	// first packet will be with header, it's ok
+	if err := c.muxer.WriteHeader(c.streams); err != nil {
+		return nil, err
+	}
+	data := append([]byte{}, c.buf.Bytes()...)
+
+	return data, nil
+}
+
+func (c *Consumer) Start() {
+	c.start = true
+}

pkg/mpegts/writer.go

@@ -0,0 +1,219 @@
+package mpegts
+
+type Writer struct {
+	b []byte // packets buffer
+	m int    // crc start
+
+	pid        []uint16
+	counter    []byte
+	streamType []byte
+	timestamp  []uint32
+}
+
+func NewWriter() *Writer {
+	return &Writer{}
+}
+
+func (w *Writer) AddPES(pid uint16, streamType byte) {
+	w.pid = append(w.pid, pid)
+	w.streamType = append(w.streamType, streamType)
+	w.counter = append(w.counter, 0)
+	w.timestamp = append(w.timestamp, 0)
+}
+
+func (w *Writer) WriteByte(b byte) {
+	w.b = append(w.b, b)
+}
+
+func (w *Writer) WriteUint16(i uint16) {
+	w.b = append(w.b, byte(i>>8), byte(i))
+}
+
+func (w *Writer) WriteTime(t uint32) {
+	const onlyPTS = 0x20
+	// [>>32 <<3] [>>24 <<2] [>>16 <<2] [>>8 <<1] [<<1]
+	w.b = append(w.b, onlyPTS|byte(t>>29)|1, byte(t>>22), byte(t>>14)|1, byte(t>>7), byte(t<<1)|1)
+}
+
+func (w *Writer) WriteBytes(b []byte) {
+	w.b = append(w.b, b...)
+}
+
+func (w *Writer) MarkChecksum() {
+	w.m = len(w.b)
+}
+
+func (w *Writer) WriteChecksum() {
+	crc := calcCRC32(0xFFFFFFFF, w.b[w.m:])
+	w.b = append(w.b, byte(crc), byte(crc>>8), byte(crc>>16), byte(crc>>24))
+}
+
+func (w *Writer) FinishPacket() {
+	if n := len(w.b) % PacketSize; n != 0 {
+		w.b = append(w.b, make([]byte, PacketSize-n)...)
+	}
+}
+
+func (w *Writer) Bytes() []byte {
+	if len(w.b)%PacketSize != 0 {
+		panic("wrong packet size")
+	}
+	return w.b
+}
+
+func (w *Writer) Reset() {
+	w.b = nil
+}
+
+const isUnitStart = 0x4000
+const flagHasAdaptation = 0x20
+const flagHasPayload = 0x10
+const lenIsProgramTable = 0xB000
+const tableFlags = 0xC1
+const tableHeader = 0xE000
+const tableLength = 0xF000
+
+const patPID = 0
+const patTableID = 0
+const patTableExtID = 1
+
+func (w *Writer) WritePAT() {
+	w.WriteByte(SyncByte)
+	w.WriteUint16(isUnitStart | patPID) // PAT PID
+	w.WriteByte(flagHasPayload)         // flags...
+
+	w.WriteByte(0) // Pointer field
+
+	w.MarkChecksum()
+	w.WriteByte(patTableID)               // Table ID
+	w.WriteUint16(lenIsProgramTable | 13) // Section length
+	w.WriteUint16(patTableExtID)          // Table ID extension
+	w.WriteByte(tableFlags)               // flags...
+	w.WriteByte(0)                        // Section number
+	w.WriteByte(0)                        // Last section number
+
+	w.WriteUint16(1) // Program num (usual 1)
+	w.WriteUint16(tableHeader + pmtPID)
+
+	w.WriteChecksum()
+
+	w.FinishPacket()
+}
+
+const pmtPID = 18
+const pmtTableID = 2
+const pmtTableExtID = 1
+
+func (w *Writer) WritePMT() {
+	w.WriteByte(SyncByte)
+	w.WriteUint16(isUnitStart | pmtPID) // PMT PID
+	w.WriteByte(flagHasPayload)         // flags...
+
+	w.WriteByte(0) // Pointer field
+
+	tableLen := 13 + uint16(len(w.pid))*5
+
+	w.MarkChecksum()
+	w.WriteByte(pmtTableID)                     // Table ID
+	w.WriteUint16(lenIsProgramTable | tableLen) // Section length
+	w.WriteUint16(pmtTableExtID)                // Table ID extension
+	w.WriteByte(tableFlags)                     // flags...
+	w.WriteByte(0)                              // Section number
+	w.WriteByte(0)                              // Last section number
+
+	w.WriteUint16(tableHeader | w.pid[0]) // PID
+	w.WriteUint16(tableLength | 0)        // Info length
+
+	for i, pid := range w.pid {
+		w.WriteByte(w.streamType[i])
+		w.WriteUint16(tableHeader | pid) // PID
+		w.WriteUint16(tableLength | 0)   // Info len
+	}
+
+	w.WriteChecksum()
+
+	w.FinishPacket()
+}
+
+const pesHeaderSize = PacketSize - 18
+
+func (w *Writer) WritePES(pid uint16, streamID byte, payload []byte) {
+	w.WriteByte(SyncByte)
+	w.WriteUint16(isUnitStart | pid)
+
+	// check if payload lower then max first packet size
+	if len(payload) < PacketSize-18 {
+		w.WriteByte(flagHasAdaptation | flagHasPayload)
+
+		// for 183 payload will be zero
+		adSize := PacketSize - 18 - 1 - byte(len(payload))
+		w.WriteByte(adSize)
+		w.WriteBytes(make([]byte, adSize))
+	} else {
+		w.WriteByte(flagHasPayload)
+	}
+
+	w.WriteByte(0)
+	w.WriteByte(0)
+	w.WriteByte(1)
+
+	w.WriteByte(streamID)
+	w.WriteUint16(uint16(8 + len(payload)))
+
+	w.WriteByte(0x80)
+	w.WriteByte(0x80) // only PTS
+	w.WriteByte(5)    // optional size
+
+	switch w.streamType[0] {
+	case StreamTypePCMATapo:
+		w.timestamp[0] += uint32(len(payload) * 45 / 8)
+	}
+
+	w.WriteTime(w.timestamp[0])
+
+	if len(payload) < PacketSize-18 {
+		w.WriteBytes(payload)
+		return
+	}
+
+	w.WriteBytes(payload[:pesHeaderSize])
+
+	payload = payload[pesHeaderSize:]
+	var counter byte
+
+	for {
+		counter++
+
+		if len(payload) > PacketSize-4 {
+			// payload more then maximum size
+			w.WriteByte(SyncByte)
+			w.WriteUint16(pid)
+			w.WriteByte(flagHasPayload | counter&0xF)
+			w.WriteBytes(payload[:PacketSize-4])
+
+			payload = payload[PacketSize-4:]
+		} else if len(payload) == PacketSize-4 {
+			// payload equal maximum size (last packet)
+			w.WriteByte(SyncByte)
+			w.WriteUint16(pid)
+			w.WriteByte(flagHasPayload | counter&0xF)
+			w.WriteBytes(payload)
+
+			break
+		} else {
+			// payload lower than maximum size (last packet)
+			w.WriteByte(SyncByte)
+			w.WriteUint16(pid)
+			w.WriteByte(flagHasAdaptation | flagHasPayload | counter&0xF)
+
+			// for 183 payload will be zero
+			adSize := PacketSize - 4 - 1 - byte(len(payload))
+			w.WriteByte(adSize)
+			w.WriteBytes(make([]byte, adSize))
+
+			w.WriteBytes(payload)
+
+			break
+		}
+	}
+}

pkg/rtmp/client.go

@@ -11,7 +11,8 @@ import (
 	"github.com/deepch/vdk/codec/h264parser"
 	"github.com/deepch/vdk/format/rtmp"
 	"github.com/pion/rtp"
-	"strings"
+	"net/http"
+	"sync/atomic"
 	"time"
 )
 
@@ -33,7 +34,7 @@ type Client struct {
 	conn   Conn
 	closed bool
 
-	receive int
+	recv uint32
 }
 
 func NewClient(uri string) *Client {
@@ -41,16 +42,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)
-	}
+	c.conn, err = rtmp.Dial(c.URI)
+	return
+}
 
+// Accept - convert http.Response to Client
+func Accept(res *http.Response) (*Client, error) {
+	conn, err := httpflv.Accept(res)
 	if err != nil {
-		return
+		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 +78,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 +88,7 @@ func (c *Client) Dial() (err error) {
 			}
 			c.medias = append(c.medias, media)
 
-			track := &streamer.Track{
-				Codec: codec, Direction: media.Direction,
-			}
+			track := streamer.NewTrack(codec, media.Direction)
 			c.tracks = append(c.tracks, track)
 
 		case av.AAC:
@@ -98,7 +101,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 +111,7 @@ func (c *Client) Dial() (err error) {
 			}
 			c.medias = append(c.medias, media)
 
-			track := &streamer.Track{
-				Codec: codec, Direction: media.Direction,
-			}
+			track := streamer.NewTrack(codec, media.Direction)
 			c.tracks = append(c.tracks, track)
 
 		default:
@@ -138,7 +139,7 @@ func (c *Client) Handle() (err error) {
 			return
 		}
 
-		c.receive += len(pkt.Data)
+		atomic.AddUint32(&c.recv, uint32(len(pkt.Data)))
 
 		track := c.tracks[int(pkt.Idx)]
 

pkg/rtmp/streamer.go

@@ -4,7 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
-	"strconv"
+	"sync/atomic"
 )
 
 func (c *Client) GetMedias() []*streamer.Media {
@@ -29,19 +29,12 @@ func (c *Client) Stop() error {
 }
 
 func (c *Client) MarshalJSON() ([]byte, error) {
-	v := map[string]interface{}{
-		streamer.JSONReceive:    c.receive,
-		streamer.JSONType:       "RTMP client producer",
-		//streamer.JSONRemoteAddr: c.conn.NetConn().RemoteAddr().String(),
-		"url":                   c.URI,
+	info := &streamer.Info{
+		Type:   "RTMP source",
+		URL:    c.URI,
+		Medias: c.medias,
+		Tracks: c.tracks,
+		Recv:   atomic.LoadUint32(&c.recv),
 	}
-	for i, media := range c.medias {
-		k := "media:" + strconv.Itoa(i)
-		v[k] = media.String()
-	}
-	for i, track := range c.tracks {
-		k := "track:" + strconv.Itoa(i)
-		v[k] = track.String()
-	}
-	return json.Marshal(v)
+	return json.Marshal(info)
 }

pkg/rtsp/client.go

@@ -2,13 +2,10 @@ package rtsp
 
 import (
 	"bufio"
-	"bytes"
 	"crypto/tls"
 	"encoding/binary"
 	"errors"
 	"fmt"
-	"github.com/AlexxIT/go2rtc/pkg/aac"
-	"github.com/AlexxIT/go2rtc/pkg/h264"
 	"github.com/AlexxIT/go2rtc/pkg/streamer"
 	"github.com/AlexxIT/go2rtc/pkg/tcp"
 	"github.com/pion/rtcp"
@@ -19,6 +16,7 @@ import (
 	"net/url"
 	"strconv"
 	"strings"
+	"sync"
 	"time"
 )
 
@@ -37,20 +35,37 @@ const (
 type Mode byte
 
 const (
-	ModeUnknown Mode = iota
-	ModeClientProducer
+	ModeUnknown        Mode = iota
+	ModeClientProducer      // conn act as RTSP client that receive data from RTSP server (ex. camera)
 	ModeServerUnknown
-	ModeServerProducer
-	ModeServerConsumer
+	ModeServerProducer // conn act as RTSP server that reseive data from RTSP client (ex. ffmpeg output)
+	ModeServerConsumer // conn act as RTSP server that send data to RTSP client (ex. ffmpeg input)
 )
 
 type State byte
 
+func (s State) String() string {
+	switch s {
+	case StateNone:
+		return "NONE"
+	case StateConn:
+		return "CONN"
+	case StateSetup:
+		return "SETUP"
+	case StatePlay:
+		return "PLAY"
+	case StateHandle:
+		return "HANDLE"
+	}
+	return strconv.Itoa(int(s))
+}
+
 const (
 	StateNone State = iota
 	StateConn
 	StateSetup
 	StatePlay
+	StateHandle
 )
 
 type Conn struct {
@@ -59,6 +74,7 @@ type Conn struct {
 	// public
 
 	Backchannel bool
+	SessionName string
 
 	Medias    []*streamer.Media
 	Session   string
@@ -71,6 +87,7 @@ type Conn struct {
 	conn     net.Conn
 	mode     Mode
 	state    State
+	stateMu  sync.Mutex
 	reader   *bufio.Reader
 	sequence int
 	uri      string
@@ -91,14 +108,6 @@ func NewClient(uri string) (*Conn, error) {
 	return c, c.parseURI()
 }
 
-func NewServer(conn net.Conn) *Conn {
-	c := new(Conn)
-	c.conn = conn
-	c.mode = ModeServerUnknown
-	c.reader = bufio.NewReader(conn)
-	return c
-}
-
 func (c *Conn) parseURI() (err error) {
 	c.URL, err = url.Parse(c.uri)
 	if err != nil {
@@ -195,12 +204,15 @@ func (c *Conn) Do(req *tcp.Request) (*tcp.Response, error) {
 	if res.StatusCode == http.StatusUnauthorized {
 		switch c.auth.Method {
 		case tcp.AuthNone:
+			if c.auth.ReadNone(res) {
+				return c.Do(req)
+			}
 			return nil, errors.New("user/pass not provided")
 		case tcp.AuthUnknown:
 			if c.auth.Read(res) {
 				return c.Do(req)
 			}
-		case tcp.AuthBasic, tcp.AuthDigest:
+		default:
 			return nil, errors.New("wrong user/pass")
 		}
 	}
@@ -255,7 +267,7 @@ func (c *Conn) Options() error {
 	}
 
 	if val := res.Header.Get("Content-Base"); val != "" {
-		c.URL, err = url.Parse(val)
+		c.URL, err = urlParse(val)
 		if err != nil {
 			return err
 		}
@@ -279,13 +291,19 @@ func (c *Conn) Describe() error {
 		req.Header.Set("Require", "www.onvif.org/ver20/backchannel")
 	}
 
+	if c.UserAgent != "" {
+		// this camera will answer with 401 on DESCRIBE without User-Agent
+		// https://github.com/AlexxIT/go2rtc/issues/235
+		req.Header.Set("User-Agent", c.UserAgent)
+	}
+
 	res, err := c.Do(req)
 	if err != nil {
 		return err
 	}
 
 	if val := res.Header.Get("Content-Base"); val != "" {
-		c.URL, err = url.Parse(val)
+		c.URL, err = urlParse(val)
 		if err != nil {
 			return err
 		}
@@ -301,28 +319,30 @@ func (c *Conn) Describe() error {
 	return nil
 }
 
-//func (c *Conn) Announce() (err error) {
-//	req := &tcp.Request{
-//		Method: MethodAnnounce,
-//		URL:    c.URL,
-//		Header: map[string][]string{
-//			"Content-Type": {"application/sdp"},
-//		},
-//	}
-//
-//	//req.Body, err = c.sdp.Marshal()
-//	if err != nil {
-//		return
-//	}
-//
-//	_, err = c.Do(req)
-//
-//	return
-//}
+func (c *Conn) Announce() (err error) {
+	req := &tcp.Request{
+		Method: MethodAnnounce,
+		URL:    c.URL,
+		Header: map[string][]string{
+			"Content-Type": {"application/sdp"},
+		},
+	}
+
+	req.Body, err = streamer.MarshalSDP(c.SessionName, c.Medias)
+	if err != nil {
+		return err
+	}
+
+	res, err := c.Do(req)
+
+	_ = res
+
+	return
+}
 
 func (c *Conn) Setup() error {
 	for _, media := range c.Medias {
-		_, err := c.SetupMedia(media, media.Codecs[0])
+		_, err := c.SetupMedia(media, media.Codecs[0], true)
 		if err != nil {
 			return err
 		}
@@ -331,9 +351,17 @@ func (c *Conn) Setup() error {
 	return nil
 }
 
-func (c *Conn) SetupMedia(
-	media *streamer.Media, codec *streamer.Codec,
-) (*streamer.Track, error) {
+func (c *Conn) SetupMedia(media *streamer.Media, codec *streamer.Codec, first bool) (*streamer.Track, error) {
+	// TODO: rewrite recoonection and first flag
+	if first {
+		c.stateMu.Lock()
+		defer c.stateMu.Unlock()
+	}
+
+	if c.state != StateConn && c.state != StateSetup {
+		return nil, fmt.Errorf("RTSP SETUP from wrong state: %s", c.state)
+	}
+
 	ch := c.GetChannel(media)
 	if ch < 0 {
 		return nil, fmt.Errorf("wrong media: %v", media)
@@ -347,7 +375,7 @@ func (c *Conn) SetupMedia(
 		}
 		rawURL += media.Control
 	}
-	trackURL, err := url.Parse(rawURL)
+	trackURL, err := urlParse(rawURL)
 	if err != nil {
 		return nil, err
 	}
@@ -380,7 +408,7 @@ func (c *Conn) SetupMedia(
 
 			for _, newMedia := range c.Medias {
 				if newMedia.Control == media.Control {
-					return c.SetupMedia(newMedia, newMedia.Codecs[0])
+					return c.SetupMedia(newMedia, newMedia.Codecs[0], false)
 				}
 			}
 		}
@@ -398,6 +426,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 +463,7 @@ func (c *Conn) SetupMedia(
 		return nil, err
 	}
 
-	track := &streamer.Track{
-		Codec: codec, Direction: media.Direction,
-	}
+	track := streamer.NewTrack(codec, media.Direction)
 
 	switch track.Direction {
 	case streamer.DirectionSendonly:
@@ -451,12 +483,19 @@ func (c *Conn) SetupMedia(
 }
 
 func (c *Conn) Play() (err error) {
+	c.stateMu.Lock()
+	defer c.stateMu.Unlock()
+
 	if c.state != StateSetup {
 		return fmt.Errorf("RTSP PLAY from wrong state: %s", c.state)
 	}
 
 	req := &tcp.Request{Method: MethodPlay, URL: c.URL}
-	return c.Request(req)
+	if err = c.Request(req); err == nil {
+		c.state = StatePlay
+	}
+
+	return
 }
 
 func (c *Conn) Teardown() (err error) {
@@ -466,151 +505,44 @@ func (c *Conn) Teardown() (err error) {
 }
 
 func (c *Conn) Close() error {
+	c.stateMu.Lock()
+	defer c.stateMu.Unlock()
+
 	if c.state == StateNone {
 		return nil
 	}
-	if err := c.Teardown(); err != nil {
-		return err
-	}
+
+	_ = c.Teardown()
 	c.state = StateNone
 	return c.conn.Close()
 }
 
-const transport = "RTP/AVP/TCP;unicast;interleaved="
-
-func (c *Conn) Accept() error {
-	for {
-		req, err := tcp.ReadRequest(c.reader)
-		if err != nil {
-			return err
-		}
-
-		if c.URL == nil {
-			c.URL = req.URL
-			c.UserAgent = req.Header.Get("User-Agent")
-		}
-
-		c.Fire(req)
-
-		// Receiver: OPTIONS > DESCRIBE > SETUP... > PLAY > TEARDOWN
-		// Sender: OPTIONS > ANNOUNCE > SETUP... > RECORD > TEARDOWN
-		switch req.Method {
-		case MethodOptions:
-			res := &tcp.Response{
-				Header: map[string][]string{
-					"Public": {"OPTIONS, SETUP, TEARDOWN, DESCRIBE, PLAY, PAUSE, ANNOUNCE, RECORD"},
-				},
-				Request: req,
-			}
-			if err = c.Response(res); err != nil {
-				return err
-			}
-
-		case MethodAnnounce:
-			if req.Header.Get("Content-Type") != "application/sdp" {
-				return errors.New("wrong content type")
-			}
-
-			c.Medias, err = UnmarshalSDP(req.Body)
-			if err != nil {
-				return err
-			}
-
-			// TODO: fix someday...
-			c.channels = map[byte]*streamer.Track{}
-			for i, media := range c.Medias {
-				track := &streamer.Track{
-					Codec: media.Codecs[0], Direction: media.Direction,
-				}
-				c.tracks = append(c.tracks, track)
-				c.channels[byte(i<<1)] = track
-			}
-
-			c.mode = ModeServerProducer
-			c.Fire(MethodAnnounce)
-
-			res := &tcp.Response{Request: req}
-			if err = c.Response(res); err != nil {
-				return err
-			}
-
-		case MethodDescribe:
-			c.mode = ModeServerConsumer
-			c.Fire(MethodDescribe)
-
-			if c.tracks == nil {
-				res := &tcp.Response{
-					Status:  "404 Not Found",
-					Request: req,
-				}
-				return c.Response(res)
-			}
-
-			res := &tcp.Response{
-				Header: map[string][]string{
-					"Content-Type": {"application/sdp"},
-				},
-				Request: req,
-			}
-
-			// convert tracks to real output medias medias
-			var medias []*streamer.Media
-			for _, track := range c.tracks {
-				media := &streamer.Media{
-					Kind:      streamer.GetKind(track.Codec.Name),
-					Direction: streamer.DirectionSendonly,
-					Codecs:    []*streamer.Codec{track.Codec},
-				}
-				medias = append(medias, media)
-			}
-
-			res.Body, err = streamer.MarshalSDP(medias)
-			if err != nil {
-				return err
-			}
-
-			if err = c.Response(res); err != nil {
-				return err
-			}
-
-		case MethodSetup:
-			tr := req.Header.Get("Transport")
-
-			res := &tcp.Response{
-				Header:  map[string][]string{},
-				Request: req,
-			}
-
-			if strings.HasPrefix(tr, transport) {
-				c.Session = "1" // TODO: fixme
-				c.state = StateSetup
-				res.Header.Set("Transport", tr[:len(transport)+3])
-			} else {
-				res.Status = "461 Unsupported transport"
-			}
-
-			if err = c.Response(res); err != nil {
-				return err
-			}
-
-		case MethodRecord, MethodPlay:
-			res := &tcp.Response{Request: req}
-			return c.Response(res)
-
-		default:
-			return fmt.Errorf("unsupported method: %s", req.Method)
-		}
-	}
-}
-
 func (c *Conn) Handle() (err error) {
-	if c.state != StateSetup {
-		return fmt.Errorf("RTSP Handle from wrong state: %d", c.state)
+	c.stateMu.Lock()
+
+	switch c.state {
+	case StateNone: // Close after PLAY and before Handle is OK (because SETUP after PLAY)
+	case StatePlay:
+		c.state = StateHandle
+	default:
+		err = fmt.Errorf("RTSP HANDLE from wrong state: %s", c.state)
+
+		c.state = StateNone
+		_ = c.conn.Close()
 	}
 
-	c.state = StatePlay
+	ok := c.state == StateHandle
+
+	c.stateMu.Unlock()
+
+	if !ok {
+		return
+	}
 
 	defer func() {
+		c.stateMu.Lock()
+		defer c.stateMu.Unlock()
+
 		if c.state == StateNone {
 			err = nil
 			return
@@ -627,9 +559,16 @@ func (c *Conn) Handle() (err error) {
 	switch c.mode {
 	case ModeClientProducer:
 		// polling frames from remote RTSP Server (ex Camera)
-		timeout = time.Second * 5
 		go c.keepalive()
 
+		if c.HasSendTracks() {
+			// if we receiving video/audio from camera
+			timeout = time.Second * 5
+		} else {
+			// if we only send audio to camera
+			timeout = time.Second * 30
+		}
+
 	case ModeServerProducer:
 		// polling frames from remote RTSP Client (ex FFmpeg)
 		timeout = time.Second * 15
@@ -661,6 +600,9 @@ func (c *Conn) Handle() (err error) {
 			return
 		}
 
+		var channelID byte
+		var size uint16
+
 		if buf4[0] != '$' {
 			switch string(buf4) {
 			case "RTSP":
@@ -669,26 +611,62 @@ func (c *Conn) Handle() (err error) {
 					return
 				}
 				c.Fire(res)
+				continue
+
 			case "OPTI", "TEAR", "DESC", "SETU", "PLAY", "PAUS", "RECO", "ANNO", "GET_", "SET_":
 				var req *tcp.Request
 				if req, err = tcp.ReadRequest(c.reader); err != nil {
 					return
 				}
 				c.Fire(req)
+				continue
+
 			default:
-				return fmt.Errorf("RTSP wrong input")
+				for i := 0; ; i++ {
+					// search next start symbol
+					if _, err = c.reader.ReadBytes('$'); err != nil {
+						return err
+					}
+
+					if channelID, err = c.reader.ReadByte(); err != nil {
+						return err
+					}
+
+					// check if channel ID exists
+					if c.channels[channelID] == nil {
+						continue
+					}
+
+					buf4 = make([]byte, 2)
+					if _, err = io.ReadFull(c.reader, buf4); err != nil {
+						return err
+					}
+
+					// check if size good for RTP
+					size = binary.BigEndian.Uint16(buf4)
+					if size <= 1500 {
+						break
+					}
+
+					// 10 tries to find good packet
+					if i >= 10 {
+						return fmt.Errorf("RTSP wrong input")
+					}
+				}
+
+				c.Fire("RTSP wrong input")
 			}
-			continue
-		}
+		} else {
+			// hope that the odd channels are always RTCP
+			channelID = buf4[1]
 
-		// hope that the odd channels are always RTCP
-		channelID := buf4[1]
+			// get data size
+			size = binary.BigEndian.Uint16(buf4[2:])
 
-		// get data size
-		size := int(binary.BigEndian.Uint16(buf4[2:]))
-
-		if _, err = c.reader.Discard(4); err != nil {
-			return
+			// skip 4 bytes from c.reader.Peek
+			if _, err = c.reader.Discard(4); err != nil {
+				return
+			}
 		}
 
 		// init memory for data
@@ -697,7 +675,7 @@ func (c *Conn) Handle() (err error) {
 			return
 		}
 
-		c.receive += size
+		c.receive += int(size)
 
 		if channelID&1 == 0 {
 			packet := &rtp.Packet{}
@@ -708,21 +686,19 @@ func (c *Conn) Handle() (err error) {
 			track := c.channels[channelID]
 			if track != nil {
 				_ = track.WriteRTP(packet)
-				//return fmt.Errorf("wrong channelID: %d", channelID)
 			} else {
-				continue // TODO: maybe fix this
-				//panic("wrong channelID")
+				//c.Fire("wrong channelID: " + strconv.Itoa(int(channelID)))
 			}
 		} else {
 			msg := &RTCP{Channel: channelID}
 
 			if err = msg.Header.Unmarshal(buf); err != nil {
-				return
+				continue
 			}
 
 			msg.Packets, err = rtcp.Unmarshal(buf)
 			if err != nil {
-				return
+				continue
 			}
 
 			c.Fire(msg)
@@ -753,84 +729,11 @@ func (c *Conn) GetChannel(media *streamer.Media) int {
 	return -1
 }
 
-func (c *Conn) bindTrack(
-	track *streamer.Track, channel uint8, payloadType uint8,
-) *streamer.Track {
-	push := func(packet *rtp.Packet) error {
-		if c.state == StateNone {
-			return nil
-		}
-		packet.Header.PayloadType = payloadType
-
-		size := packet.MarshalSize()
-
-		data := make([]byte, 4+size)
-		data[0] = '$'
-		data[1] = channel
-		binary.BigEndian.PutUint16(data[2:], uint16(size))
-
-		if _, err := packet.MarshalTo(data[4:]); err != nil {
-			return nil
-		}
-
-		if _, err := c.conn.Write(data); err != nil {
-			return err
-		}
-
-		c.send += size
-
-		return nil
-	}
-
-	if track.Codec.IsMP4() {
-		switch track.Codec.Name {
-		case streamer.CodecH264:
-			wrapper := h264.RTPPay(1500)
-			push = wrapper(push)
-		case streamer.CodecAAC:
-			wrapper := aac.RTPPay(1500)
-			push = wrapper(push)
+func (c *Conn) HasSendTracks() bool {
+	for _, track := range c.tracks {
+		if track.Direction == streamer.DirectionSendonly {
+			return true
 		}
 	}
-
-	return track.Bind(push)
-}
-
-type RTCP struct {
-	Channel byte
-	Header  rtcp.Header
-	Packets []rtcp.Packet
-}
-
-const sdpHeader = `v=0
-o=- 0 0 IN IP4 0.0.0.0
-s=-
-t=0 0`
-
-func UnmarshalSDP(rawSDP []byte) ([]*streamer.Media, error) {
-	medias, err := streamer.UnmarshalSDP(rawSDP)
-	if err != nil {
-		// fix SDP header for some cameras
-		i := bytes.Index(rawSDP, []byte("\nm="))
-		if i > 0 {
-			rawSDP = append([]byte(sdpHeader), rawSDP[i:]...)
-			medias, err = streamer.UnmarshalSDP(rawSDP)
-		}
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	// fix bug in ONVIF spec
-	// https://www.onvif.org/specs/stream/ONVIF-Streaming-Spec-v241.pdf
-	for _, media := range medias {
-		switch media.Direction {
-		case streamer.DirectionRecvonly, "":
-			media.Direction = streamer.DirectionSendonly
-		case streamer.DirectionSendonly:
-			media.Direction = streamer.DirectionRecvonly
-		}
-	}
-
-	return medias, nil
+	return false
 }

pkg/rtsp/consumer.go

@@ -0,0 +1,112 @@
+package rtsp
+
+import (
+	"encoding/binary"
+	"github.com/AlexxIT/go2rtc/pkg/aac"
+	"github.com/AlexxIT/go2rtc/pkg/h264"
+	"github.com/AlexxIT/go2rtc/pkg/h265"
+	"github.com/AlexxIT/go2rtc/pkg/mjpeg"
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/pion/rtp"
+)
+
+func (c *Conn) AddTrack(media *streamer.Media, track *streamer.Track) *streamer.Track {
+	switch c.mode {
+	// send our track to RTSP consumer (ex. FFmpeg)
+	case ModeServerConsumer:
+		i := len(c.tracks)
+		channelID := byte(i << 1)
+
+		codec := track.Codec.Clone()
+		codec.PayloadType = uint8(96 + i)
+
+		if media.MatchAll() {
+			// fill consumer medias list
+			c.Medias = append(c.Medias, &streamer.Media{
+				Kind: media.Kind, Direction: media.Direction,
+				Codecs: []*streamer.Codec{codec},
+			})
+		} else {
+			// find consumer media and replace codec with right one
+			for i, m := range c.Medias {
+				if m == media {
+					media.Codecs = []*streamer.Codec{codec}
+					c.Medias[i] = media
+					break
+				}
+			}
+		}
+
+		track = c.bindTrack(track, channelID, codec.PayloadType)
+		track.Codec = codec
+		c.tracks = append(c.tracks, track)
+
+		return track
+
+	// camera with backchannel support
+	case ModeClientProducer:
+		consCodec := media.MatchCodec(track.Codec)
+		consTrack := c.GetTrack(media, consCodec)
+		if consTrack == nil {
+			return nil
+		}
+
+		return track.Bind(func(packet *rtp.Packet) error {
+			return consTrack.WriteRTP(packet)
+		})
+	}
+
+	println("WARNING: rtsp: AddTrack to wrong mode")
+	return nil
+}
+
+func (c *Conn) bindTrack(
+	track *streamer.Track, channel uint8, payloadType uint8,
+) *streamer.Track {
+	push := func(packet *rtp.Packet) error {
+		if c.state == StateNone {
+			return nil
+		}
+		packet.Header.PayloadType = payloadType
+
+		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
+		binary.BigEndian.PutUint16(data[2:], uint16(size))
+
+		if _, err := packet.MarshalTo(data[4:]); err != nil {
+			return nil
+		}
+
+		if _, err := c.conn.Write(data); err != nil {
+			return err
+		}
+
+		c.send += size
+
+		return nil
+	}
+
+	if !track.Codec.IsRTP() {
+		switch track.Codec.Name {
+		case streamer.CodecH264:
+			wrapper := h264.RTPPay(1500)
+			push = wrapper(push)
+		case streamer.CodecH265:
+			wrapper := h265.RTPPay(1500)
+			push = wrapper(push)
+		case streamer.CodecAAC:
+			wrapper := aac.RTPPay(1500)
+			push = wrapper(push)
+		case streamer.CodecJPEG:
+			wrapper := mjpeg.RTPPay()
+			push = wrapper(push)
+		}
+	}
+
+	return track.Bind(push)
+}

pkg/rtsp/helpers.go

@@ -0,0 +1,108 @@
+package rtsp
+
+import (
+	"bytes"
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+	"github.com/pion/rtcp"
+	"github.com/pion/sdp/v3"
+	"net/url"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+type RTCP struct {
+	Channel byte
+	Header  rtcp.Header
+	Packets []rtcp.Packet
+}
+
+const sdpHeader = `v=0
+o=- 0 0 IN IP4 0.0.0.0
+s=-
+t=0 0`
+
+func UnmarshalSDP(rawSDP []byte) ([]*streamer.Media, error) {
+	// fix bug from Reolink Doorbell
+	if i := bytes.Index(rawSDP, []byte("a=sendonlym=")); i > 0 {
+		rawSDP = append(rawSDP[:i+11], rawSDP[i+10:]...)
+		rawSDP[i+10] = '\n'
+	}
+
+	// fix bug from Ezviz C6N
+	if i := bytes.Index(rawSDP, []byte("H265/90000\r\na=fmtp:96 profile-level-id=420029;")); i > 0 {
+		rawSDP[i+3] = '4'
+	}
+
+	sd := &sdp.SessionDescription{}
+	if err := sd.Unmarshal(rawSDP); err != nil {
+		// fix multiple `s=` https://github.com/AlexxIT/WebRTC/issues/417
+		re, _ := regexp.Compile("\ns=[^\n]+")
+		rawSDP = re.ReplaceAll(rawSDP, nil)
+
+		// fix SDP header for some cameras
+		if i := bytes.Index(rawSDP, []byte("\nm=")); i > 0 {
+			rawSDP = append([]byte(sdpHeader), rawSDP[i:]...)
+			sd = &sdp.SessionDescription{}
+			err = sd.Unmarshal(rawSDP)
+		}
+
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	medias := streamer.UnmarshalMedias(sd.MediaDescriptions)
+
+	for _, media := range medias {
+		// Check buggy SDP with fmtp for H264 on another track
+		// https://github.com/AlexxIT/WebRTC/issues/419
+		for _, codec := range media.Codecs {
+			if codec.Name == streamer.CodecH264 && codec.FmtpLine == "" {
+				codec.FmtpLine = findFmtpLine(codec.PayloadType, sd.MediaDescriptions)
+			}
+		}
+
+		// fix bug in ONVIF spec
+		// https://www.onvif.org/specs/stream/ONVIF-Streaming-Spec-v241.pdf
+		switch media.Direction {
+		case streamer.DirectionRecvonly, "":
+			media.Direction = streamer.DirectionSendonly
+		case streamer.DirectionSendonly:
+			media.Direction = streamer.DirectionRecvonly
+		}
+	}
+
+	return medias, nil
+}
+
+func findFmtpLine(payloadType uint8, descriptions []*sdp.MediaDescription) string {
+	s := strconv.Itoa(int(payloadType))
+	for _, md := range descriptions {
+		codec := streamer.UnmarshalCodec(md, s)
+		if codec.FmtpLine != "" {
+			return codec.FmtpLine
+		}
+	}
+	return ""
+}
+
+// urlParse fix bugs:
+// 1. Content-Base: rtsp://::ffff:192.168.1.123/onvif/profile.1/
+// 2. Content-Base: rtsp://rtsp://turret2-cam.lan:554/stream1/
+func urlParse(rawURL string) (*url.URL, error) {
+	if strings.HasPrefix(rawURL, "rtsp://rtsp://") {
+		rawURL = rawURL[7:]
+	}
+
+	u, err := url.Parse(rawURL)
+	if err != nil && strings.HasSuffix(err.Error(), "after host") {
+		if i1 := strings.Index(rawURL, "://"); i1 > 0 {
+			if i2 := strings.IndexByte(rawURL[i1+3:], '/'); i2 > 0 {
+				return urlParse(rawURL[:i1+3+i2] + ":" + rawURL[i1+3+i2:])
+			}
+		}
+	}
+
+	return u, err
+}

pkg/rtsp/producer.go

@@ -0,0 +1,106 @@
+package rtsp
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/AlexxIT/go2rtc/pkg/streamer"
+)
+
+func (c *Conn) GetMedias() []*streamer.Media {
+	if c.Medias != nil {
+		return c.Medias
+	}
+
+	return []*streamer.Media{
+		{
+			Kind:      streamer.KindVideo,
+			Direction: streamer.DirectionRecvonly,
+			Codecs: []*streamer.Codec{
+				{Name: streamer.CodecAll},
+			},
+		},
+		{
+			Kind:      streamer.KindAudio,
+			Direction: streamer.DirectionRecvonly,
+			Codecs: []*streamer.Codec{
+				{Name: streamer.CodecAll},
+			},
+		},
+	}
+}
+
+func (c *Conn) GetTrack(media *streamer.Media, codec *streamer.Codec) *streamer.Track {
+	for _, track := range c.tracks {
+		if track.Codec == codec {
+			return track
+		}
+	}
+
+	// can't setup new tracks from play state - forcing a reconnection feature
+	switch c.state {
+	case StatePlay, StateHandle:
+		go c.Close()
+		return streamer.NewTrack(codec, media.Direction)
+	}
+
+	track, err := c.SetupMedia(media, codec, true)
+	if err != nil {
+		return nil
+	}
+	return track
+}
+
+func (c *Conn) Start() error {
+	switch c.mode {
+	case ModeClientProducer:
+		if err := c.Play(); err != nil {
+			return err
+		}
+	case ModeServerProducer:
+	default:
+		return fmt.Errorf("start wrong mode: %d", c.mode)
+	}
+
+	return c.Handle()
+}
+
+func (c *Conn) Stop() error {
+	return c.Close()
+}
+
+func (c *Conn) MarshalJSON() ([]byte, error) {
+	info := &streamer.Info{
+		UserAgent: c.UserAgent,
+		Medias:    c.Medias,
+		Tracks:    c.tracks,
+		Recv:      uint32(c.receive),
+		Send:      uint32(c.send),
+	}
+
+	switch c.mode {
+	case ModeUnknown:
+		info.Type = "RTSP unknown"
+	case ModeClientProducer, ModeServerProducer:
+		info.Type = "RTSP source"
+	case ModeServerConsumer:
+		info.Type = "RTSP client"
+	}
+
+	if c.URL != nil {
+		info.URL = c.URL.String()
+	}
+	if c.conn != nil {
+		info.RemoteAddr = c.conn.RemoteAddr().String()
+	}
+
+	//for i, track := range c.tracks {
+	//	k := "track:" + strconv.Itoa(i+1)
+	//	if track.MimeType() == streamer.MimeTypeH264 {
+	//		v[k] = h264.Describe(track.Caps())
+	//	} else {
+	//		v[k] = track.MimeType()
+	//	}
+	//}
+
+	return json.Marshal(info)
+}