Bump version: 6.54 → 6.55

According to N2176 of ISO/IEC 9899:2017 §5.1.2.2.1 ¶2:

> - argv[argc] shall be a null pointer.

Possibly fixes openwrt/packages#28472.

.bumpversion.cfg

@@ -1,16 +1,39 @@
 [bumpversion]
 commit = True
 tag = True
-current_version = 0.33
-parse = (?P<major>\d+)\.(?P<minor>\d+)(\.(?P<patch>\d+)(\-(?P<release>[a-z]+))?)?
+current_version = 6.55
+parse = (?P<major>\d+)\.(?P<minor>\d+)
 serialize = 
 	{major}.{minor}
 
-[bumpversion:file:src/config.h]
-search = VERSION "{current_version}"
-replace = VERSION "{new_version}"
+[bumpversion:file:src/libs/const.h]
+parse = (?P<major>\d+)
+serialize = {major}
+search = VERSION_MAJOR {current_version}
+replace = VERSION_MAJOR {new_version}
 
-[bumpversion:file:PKGBUILD]
+[bumpversion:file:./src/libs/const.h]
+parse = <major>\d+\.(?P<minor>\d+)
+serialize = {minor}
+search = VERSION_MINOR {current_version}
+replace = VERSION_MINOR {new_version}
+
+[bumpversion:file:python/setup.py]
+search = version="{current_version}"
+replace = version="{new_version}"
+
+[bumpversion:file:pkg/arch/PKGBUILD]
 search = pkgver={current_version}
 replace = pkgver={new_version}
 
+[bumpversion:file:pkg/openwrt/Makefile]
+search = PKG_VERSION:={current_version}
+replace = PKG_VERSION:={new_version}
+
+[bumpversion:file:man/ustreamer.1]
+search = "version {current_version}"
+replace = "version {new_version}"
+
+[bumpversion:file:man/ustreamer-dump.1]
+search = "version {current_version}"
+replace = "version {new_version}"

.dockerignore

@@ -0,0 +1,10 @@
+# Ignore everything
+*
+
+# Allow source code
+!Makefile
+!src/**
+!python/**
+!janus/**
+!man/**
+!pkg/docker/entry.sh

.editorconfig

@@ -0,0 +1,10 @@
+root = true
+
+[*]
+end_of_file = lf
+indent_style = tab
+indent_size = 4
+
+[*.{py,yaml}]
+indent_style = space
+indent_size = 4

.gitattributes

@@ -0,0 +1,5 @@
+/.github/ export-ignore
+/.bumpversion.cfg export-ignore
+/.dockerignore export-ignore
+/.gitattributes export-ignore
+/.gitignore export-ignore

.github/FUNDING.yml

@@ -0,0 +1,4 @@
+# These are supported funding model platforms
+
+patreon: pikvm
+custom: https://paypal.me/pikvm

.github/workflows/docker-alpine-image.yaml

@@ -0,0 +1,81 @@
+name: Build Alpine
+
+on:
+    push:
+        branches: [master, build_*]
+        tags: [v*]
+    pull_request:
+        branches: [master]
+
+jobs:
+  buildx:
+    runs-on: ubuntu-latest
+    steps:
+      -
+        name: Checkout
+        uses: actions/checkout@v3
+      -
+        name: Login to GitHub Container Registry
+        if: github.event_name != 'pull_request'
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      -
+        name: Login to DockerHub Container Registry
+        if: startsWith(github.ref, 'refs/tags/v')
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      -
+        name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v4
+        with:
+          images: |
+            ${{ secrets.DOCKERHUB_REPO }}/ustreamer,enable=${{ startsWith(github.ref, 'refs/tags/v') }}
+            ghcr.io/${{ github.repository }},enable=${{ github.event_name != 'pull_request' }}
+          tags: |
+            type=ref,event=tag
+            type=sha,format=long
+      -
+        name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+      -
+        name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+        with:
+          driver-opts: image=moby/buildkit:master
+      -
+        name: Build and export to Docker
+        uses: docker/build-push-action@v3
+        with:
+          context: .
+          load: true
+          tags: ustreamer
+          file: pkg/docker/Dockerfile.alpine
+      -
+        name: Test
+        run: |
+          echo version: $(docker run --rm -t ustreamer --version)
+          echo -e "features:\n$(docker run --rm -t ustreamer --features)"
+      -
+        name: Build multi arch
+        uses: docker/build-push-action@v3
+        with:
+          context: .
+          platforms: linux/arm64,linux/amd64,linux/arm/v6,linux/arm/v7
+          file: pkg/docker/Dockerfile.alpine
+      -
+        name: Push
+        if: steps.meta.outputs.tags != ''
+        uses: docker/build-push-action@v3
+        with:
+          context: .
+          platforms: linux/arm64,linux/amd64,linux/arm/v7
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          file: pkg/docker/Dockerfile.alpine

.github/workflows/dockerimage.yml

@@ -0,0 +1,20 @@
+name: CI
+
+on:
+    push:
+        branches: [master]
+    pull_request:
+        branches: [master]
+
+jobs:
+    build:
+        runs-on: ubuntu-latest
+
+        steps:
+          - uses: actions/checkout@v2
+
+          - name: Building linters image ...
+            run: make linters
+
+          - name: Running linters ...
+            run: make tox

.gitignore

@@ -1,8 +1,19 @@
-/pkg/
-/src/ustreamer-*/
-/src/v*.tar.gz
-/v*.tar.gz
-/ustreamer-*.pkg.tar.xz
-/vgcore.*
+/linters/.tox/
+/linters/.mypy_cache/
+/pkg/arch/pkg/
+/pkg/arch/src/
+/src/build/
+/python/dist/
+/python/ustreamer.egg-info/
+/python/root/
+/janus/build/
 /ustreamer
-*.o
+/ustreamer-*
+/config.mk
+vgcore.*
+*.sock
+*.so
+*.bin
+*.pkg.tar.xz
+*.pkg.tar.zst
+*.tar.gz

Makefile

@@ -1,63 +1,157 @@
-DESTDIR ?=
-PREFIX ?= /usr/local
-CFLAGS ?= -O3
-LDFLAGS ?=
+-include config.mk
 
 
 # =====
-CC = gcc
-LIBS = -lm -ljpeg -pthread -levent -levent_pthreads -luuid
-override CFLAGS += -c -std=c99 -Wall -Wextra -D_GNU_SOURCE
-SOURCES = $(shell ls src/*.c src/jpeg/*.c)
-OBJECTS = $(SOURCES:.c=.o)
-PROG = ustreamer
+DESTDIR ?=
+PREFIX ?= /usr/local
+MANPREFIX ?= $(PREFIX)/share/man
+
+CC ?= gcc
+PY ?= python3
+PKG_CONFIG ?= pkg-config
+CFLAGS ?= -O3
+LDFLAGS ?=
+
+R_DESTDIR = $(if $(DESTDIR),$(shell realpath "$(DESTDIR)"),)
+
+WITH_PYTHON ?= 0
+WITH_JANUS ?= 0
+WITH_V4P ?= 0
+WITH_GPIO ?= 0
+WITH_SYSTEMD ?= 0
+WITH_PTHREAD_NP ?= 1
+WITH_SETPROCTITLE ?= 1
+WITH_PDEATHSIG ?= 1
+
+define optbool
+$(filter $(shell echo $(1) | tr A-Z a-z), yes on 1)
+endef
+MK_WITH_PYTHON = $(call optbool,$(WITH_PYTHON))
+MK_WITH_JANUS = $(call optbool,$(WITH_JANUS))
+MK_WITH_V4P = $(call optbool,$(WITH_V4P))
+MK_WITH_GPIO = $(call optbool,$(WITH_GPIO))
+MK_WITH_SYSTEMD = $(call optbool,$(WITH_SYSTEMD))
+MK_WITH_PTHREAD_NP = $(call optbool,$(WITH_PTHREAD_NP))
+MK_WITH_SETPROCTITLE = $(call optbool,$(WITH_SETPROCTITLE))
+MK_WITH_PDEATHSIG = $(call optbool,$(WITH_PDEATHSIG))
+
+export
+
+_LINTERS_IMAGE ?= ustreamer-linters
 
 
-ifeq ($(shell ls -d /opt/vc/include 2>/dev/null), /opt/vc/include)
-SOURCES += $(shell ls src/omx/*.c)
-LIBS += -lbcm_host -lvcos -lopenmaxil -L/opt/vc/lib
-override CFLAGS += -DOMX_ENCODER -DOMX_SKIP64BIT -I/opt/vc/include
+# =====
+ifeq (__not_found__,$(shell which $(PKG_CONFIG) 2>/dev/null || echo "__not_found__"))
+$(error "No $(PKG_CONFIG) found in $(PATH)")
 endif
 
 
 # =====
-all: $(SOURCES) $(PROG)
+ifeq ($(V),)
+	ECHO = @
+endif
 
 
-install: $(PROG)
-	install -Dm755 $(PROG) $(DESTDIR)$(PREFIX)/bin/$(PROG)
+# =====
+all:
+	+ $(MAKE) apps
+ifneq ($(MK_WITH_PYTHON),)
+	+ $(MAKE) python
+endif
+ifneq ($(MK_WITH_JANUS),)
+	+ $(MAKE) janus
+endif
+
+
+apps:
+	$(MAKE) -C src
+	for i in src/*.bin; do \
+		test ! -x $$i || ln -sf $$i `basename $$i .bin`; \
+	done
+
+
+python:
+	$(MAKE) -C python
+	$(ECHO) ln -sf python/root/usr/lib/python*/site-packages/*.so .
+
+
+janus:
+	$(MAKE) -C janus
+	$(ECHO) ln -sf janus/*.so .
+
+
+install: all
+	$(MAKE) -C src install
+ifneq ($(MK_WITH_PYTHON),)
+	$(MAKE) -C python install
+endif
+ifneq ($(MK_WITH_JANUS),)
+	$(MAKE) -C janus install
+endif
+	mkdir -p $(R_DESTDIR)$(MANPREFIX)/man1
+	for man in $(shell ls man); do \
+		install -m644 man/$$man $(R_DESTDIR)$(MANPREFIX)/man1/$$man; \
+		gzip -f $(R_DESTDIR)$(MANPREFIX)/man1/$$man; \
+	done
+
+
+install-strip: install
+	$(MAKE) -C src install-strip
 
 
 regen:
-	tools/make-jpeg-h.py src/data/blank.jpeg src/data/blank_jpeg.h BLANK 640 480
-	tools/make-html-h.py src/data/index.html src/data/index_html.h HTML_INDEX_PAGE
-
-
-$(PROG): $(OBJECTS)
-	$(CC) $(LIBS) $(LDFLAGS) $(OBJECTS) -o $@
-
-
-.c.o:
-	$(CC) $(LIBS) $(CFLAGS) $< -o $@
+	tools/make-ico-h.py src/ustreamer/data/favicon.ico src/ustreamer/data/favicon_ico.c FAVICON
+	tools/make-html-h.py src/ustreamer/data/index.html src/ustreamer/data/index_html.c INDEX
 
 
 release:
-	make clean
-	make push
-	make bump
-	make push
-	make clean
+	$(MAKE) clean
+	$(MAKE) tox
+	$(MAKE) push
+	$(MAKE) bump V=$(V)
+	$(MAKE) push
+	$(MAKE) clean
+
+
+tox: linters
+	time docker run --rm \
+			--volume `pwd`:/src:ro \
+			--volume `pwd`/linters:/src/linters:rw \
+		-t $(_LINTERS_IMAGE) bash -c " \
+			cd /src \
+			&& tox -q -c linters/tox.ini $(if $(E),-e $(E),-p auto) \
+		"
+
+
+linters:
+	docker build \
+			$(if $(call optbool,$(NC)),--no-cache,) \
+			--rm \
+			--tag $(_LINTERS_IMAGE) \
+		-f linters/Dockerfile linters
 
 
 bump:
-	bumpversion minor
+	bumpversion $(if $(V),$(V),minor)
 
 
 push:
 	git push
 	git push --tags
 
-clean-all: clean
+
+clean-all: linters clean
+	- docker run --rm \
+			--volume `pwd`:/src \
+		-it $(_LINTERS_IMAGE) bash -c "cd src && rm -rf linters/{.tox,.mypy_cache}"
+
+
 clean:
-	rm -f src/*.o src/{jpeg,omx}/*.o vgcore.* $(PROG)
-	rm -rf pkg src/$(PROG)-* src/v*.tar.gz v*.tar.gz $(PROG)-*.pkg.tar.xz
+	rm -rf pkg/arch/pkg pkg/arch/src pkg/arch/v*.tar.gz pkg/arch/ustreamer-*.pkg.tar.{xz,zst}
+	rm -f ustreamer ustreamer-* *.so
+	$(MAKE) -C src clean
+	$(MAKE) -C python clean
+	$(MAKE) -C janus clean
+
+
+.PHONY: python janus linters

PKGBUILD

@@ -1,30 +0,0 @@
-# Contributor: Maxim Devaev <mdevaev@gmail.com>
-# Author: Maxim Devaev <mdevaev@gmail.com>
-
-
-pkgname=ustreamer
-pkgver=0.33
-pkgrel=1
-pkgdesc="Lightweight and fast MJPG-HTTP streamer"
-url="https://github.com/pi-kvm/ustreamer"
-license=(GPL)
-arch=(i686 x86_64 armv6h armv7h)
-depends=(libjpeg libevent libutil-linux)
-# optional: raspberrypi-firmware for OMX JPEG compressor
-makedepends=(gcc make)
-source=("$url/archive/v$pkgver.tar.gz")
-md5sums=(SKIP)
-
-
-build() {
-	cd $srcdir
-	rm -rf $pkgname-build
-	cp -r ustreamer-$pkgver $pkgname-build
-	cd $pkgname-build
-	make CFLAGS="$CFLAGS" LDFLAGS="$LDFLAGS" $MAKEFLAGS
-}
-
-package() {
-	cd $srcdir/$pkgname-build
-	make DESTDIR="$pkgdir" PREFIX=/usr install
-}

README.md

@@ -1,73 +1,216 @@
 # µStreamer
-[[Русская версия]](README.ru.md)
+[![CI](https://github.com/pikvm/ustreamer/workflows/CI/badge.svg)](https://github.com/pikvm/ustreamer/actions?query=workflow%3ACI)
+[![Discord](https://img.shields.io/discord/580094191938437144?logo=discord)](https://discord.gg/bpmXfz5)
 
-µStreamer is a lightweight and very quick server to broadcast [MJPG](https://en.wikipedia.org/wiki/Motion_JPEG) video from any V4L2 device to the net. All new browsers have native support of this video format, as well as most video players such as mplayer, VLC etc.
-µStreamer is a part of the [Pi-KVM](https://github.com/pi-kvm) project designed to stream [VGA](https://www.amazon.com/dp/B0126O0RDC) and [HDMI](https://auvidea.com/b101-hdmi-to-csi-2-bridge-15-pin-fpc/) screencast hardware data with the highest resolution and FPS possible.
+µStreamer is a lightweight and very quick server to stream [MJPEG](https://en.wikipedia.org/wiki/Motion_JPEG) video from any V4L2 device to the net. All new browsers have native support of this video format, as well as most video players such as mplayer, VLC etc.
+µStreamer is a part of the [PiKVM](https://github.com/pikvm/pikvm) project designed to stream [VGA](https://www.amazon.com/dp/B0126O0RDC) and [HDMI](https://auvidea.com/b101-hdmi-to-csi-2-bridge-15-pin-fpc/) screencast hardware data with the highest resolution and FPS possible.
 
 µStreamer is very similar to [mjpg-streamer](https://github.com/jacksonliam/mjpg-streamer) with ```input_uvc.so``` and ```output_http.so``` plugins, however, there are some major differences. The key ones are:
 
 | **Feature** | **µStreamer** | **mjpg-streamer** |
 |----------|---------------|-------------------|
-| Multithreaded JPEG encoding | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) No |
-| [OpenMAX IL](https://www.khronos.org/openmaxil) hardware acceleration<br>on Raspberry Pi | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) No |
-| Behavior when the device<br>is disconnected while streaming | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Shows a black screen<br>with ```NO SIGNAL``` on it<br>until reconnected | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Stops the broadcast<sup>1</sup> |
-| [DV-timings](https://linuxtv.org/downloads/v4l-dvb-apis/uapi/v4l/dv-timings.html) support -<br>the ability to change resolution<br>on the fly by source signal | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes | ![#ffaa00](https://placehold.it/15/ffaa00/000000?text=+) Partially yes <sup>1</sup> |
-| Option to skip frames when streaming<br>static images by HTTP to save traffic | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes <sup>2</sup> | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) No |
-| Debug logs without recompiling,<br>performance statistics log,<br>access to HTTP broadcast parameters | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) No |
-| Supported input devices | ![#ffaa00](https://placehold.it/15/ffaa00/000000?text=+) YUYV, UYVY,<br>RGB565, ~~MJPG~~ <sup>3</sup> | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) YUYV, UYVY,<br>RGB565, MJPG |
-| Access to webcam controls (focus, servos)<br>and settings such as brightness via HTTP | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) No | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes |
-| Option to serve files<br>with a built-in HTTP server, auth settings | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) No <sup>4</sup> | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes |
+| Multithreaded JPEG encoding | ✔ | ✘ |
+| Hardware image encoding<br>on Raspberry Pi | ✔ | ✘ |
+| Behavior when the device<br>is disconnected while streaming | ✔ Shows a black screen<br>with ```NO LIVE VIDEO``` on it<br>until reconnected | ✘ Stops the streaming <sup>1</sup> |
+| [DV-timings](https://linuxtv.org/downloads/v4l-dvb-apis-new/userspace-api/v4l/dv-timings.html) support -<br>the ability to change resolution<br>on the fly by source signal | ✔ | ☹ Partially yes <sup>1</sup> |
+| Option to skip frames when streaming<br>static images by HTTP to save the traffic | ✔ <sup>2</sup> | ✘ |
+| Streaming via UNIX domain socket | ✔ | ✘ |
+| Systemd socket activation | ✔ | ✘ |
+| Debug logs without recompiling,<br>performance statistics log,<br>access to HTTP streaming parameters | ✔ | ✘ |
+| Option to serve files<br>with a built-in HTTP server | ✔ | ☹ Regular files only |
+| Signaling about the stream state<br>on GPIO using [libgpiod](https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git/about) | ✔ | ✘ |
+| Access to webcam controls (focus, servos)<br>and settings such as brightness via HTTP | ✘ | ✔ |
+| Compatibility with mjpg-streamer's API | ✔ | :) |
 
 Footnotes:
-  * ```1``` Long before µStreamer, I made a [patch](https://github.com/jacksonliam/mjpg-streamer/pull/164) to add DV-timings support to mjpg-streamer and to keep it from hanging up no device disconnection. Alas, the patch is far from perfect and I can't guarantee it will work every time - mjpg-streamer's source code is very complicated and its structure is hard to understand. With this in mind, along with needing multithreading and JPEG hardware acceleration in the future, I decided to make my own stream server from scratch instead of supporting legacy code.
-  
-  * ```2``` This feature allows to cut down outgoing traffic several-fold when broadcasting HDMI, but it increases CPU usage a little bit. The idea is that HDMI is a fully digital interface and each captured frame can be identical to the previous one byte-wise. There's no need to broadcast the same image over the net several times a second. With the `--drop-same-frames=20` option enabled, µStreamer will drop all the matching frames (with a limit of 20 in a row). Each new frame is matched with the previous one first by length, then using ```memcmp()```.
+  * ```1``` Long before µStreamer, I made a [patch](https://github.com/jacksonliam/mjpg-streamer/pull/164) to add DV-timings support to mjpg-streamer and to keep it from hanging up on device disconnection. Alas, the patch is far from perfect and I can't guarantee it will work every time - mjpg-streamer's source code is very complicated and its structure is hard to understand. With this in mind, along with needing multithreading and JPEG hardware acceleration in the future, I decided to make my own stream server from scratch instead of supporting legacy code.
 
-  * ```3``` As µStreamer was made mainly to be used with screencast hardware it supports video formats they usually need. MJPG input means that the screencast device can compress images to JPEG and feed it to the software, which allows to cut down CPU usage and avoid software image encoding. This video format is supported by most webcams, but I've never seen it supported by screencast hardware: neither [Auvidea B101](https://auvidea.com/b101-hdmi-to-csi-2-bridge-15-pin-fpc/), nor [EasyCap UTV 007](https://www.amazon.com/dp/B0126O0RDC) offer such support. It's not hard to add hardware MJPG sources support, it's just not done yet.
-
-  * ```4``` ...and there'll never be. µStreamer is designed UNIX-way, so if you need a small website with your broadcast, install NGINX.
+  * ```2``` This feature allows to cut down outgoing traffic several-fold when streaming HDMI, but it increases CPU usage a little bit. The idea is that HDMI is a fully digital interface and each captured frame can be identical to the previous one byte-wise. There's no need to stream the same image over the net several times a second. With the `--drop-same-frames=20` option enabled, µStreamer will drop all the matching frames (with a limit of 20 in a row). Each new frame is matched with the previous one first by length, then using ```memcmp()```.
 
 -----
 # TL;DR
 If you're going to live-stream from your backyard webcam and need to control it, use mjpg-streamer. If you need a high-quality image with high FPS - µStreamer for the win.
 
 -----
-# Building
-You'll need  ```make```, ```gcc```, ```libevent``` with ```pthreads``` support, ```libjpeg8```/```libjpeg-turbo``` and ```libuuid```.
+# Installation
 
-It should compile automatically with OpenMAX IL on Raspberry Pi, if the corresponding headers are present in ```/opt/vc/include```.
+## Building
+You need to download the µStreamer onto your system and build it from the sources, or use a package:
+
+* Arch Linux: https://aur.archlinux.org/packages/ustreamer
+* Fedora: https://src.fedoraproject.org/rpms/ustreamer
+* Ubuntu: https://packages.ubuntu.com/jammy/ustreamer
+* Debian: https://packages.debian.org/sid/ustreamer
+* OpenWRT: https://github.com/openwrt/packages/tree/master/multimedia/ustreamer
+* FreeBSD port: https://www.freshports.org/multimedia/ustreamer
+
+### Preconditions
+You'll need  ```make```, ```gcc```, ```pkg-config```, ```libevent``` with ```pthreads``` support, ```libjpeg9```/```libjpeg-turbo``` and ```libbsd``` (only for Linux).
+
+* Arch: `sudo pacman -S libevent libjpeg-turbo libutil-linux libbsd`.
+* Raspberry OS Bullseye: `sudo apt install libevent-dev libjpeg62-turbo libbsd-dev`. Add `libgpiod-dev` for `WITH_GPIO=1` and `libsystemd-dev` for `WITH_SYSTEMD=1` and `libasound2-dev libspeex-dev libspeexdsp-dev libopus-dev` for `WITH_JANUS=1`.
+* Raspberry OS Bookworm: same as previous but replace `libjpeg62-turbo` to `libjpeg62-turbo-dev`.
+* Debian/Ubuntu: `sudo apt install build-essential libevent-dev libjpeg-dev libbsd-dev`.
+* Alpine: `sudo apk add libevent-dev libbsd-dev libjpeg-turbo-dev musl-dev`. Build with `WITH_PTHREAD_NP=0`.
+
+To enable GPIO support install [libgpiod](https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git/about) and pass option ```WITH_GPIO=1```. If the compiler reports about a missing function ```pthread_get_name_np()``` (or similar), add option ```WITH_PTHREAD_NP=0``` (it's enabled by default). For the similar error with ```setproctitle()``` add option ```WITH_SETPROCTITLE=0```.
+
+### Make
+The most convenient process is to clone the µStreamer Git repository onto your system. If you don't have Git installed and don't want to install it either, you can download and unzip the sources from GitHub using `wget https://github.com/pikvm/ustreamer/archive/refs/heads/master.zip`.
 
 ```
-$ git clone --depth=1 https://github.com/pi-kvm/ustreamer
+$ git clone --depth=1 https://github.com/pikvm/ustreamer
 $ cd ustreamer
 $ make
 $ ./ustreamer --help
 ```
 
-AUR has a package for Arch Linux: https://aur.archlinux.org/packages/ustreamer
+## Update
+Assuming you have a µStreamer clone as discussed above you can update µStreamer as follows.
+
+```
+$ cd ustreamer
+$ git pull
+$ make clean
+$ make
+```
 
 -----
 # Usage
-Without arguments, ```ustreamer``` will try to open ```/dev/video0``` with 640x480 resolution and start broadcasting on  ```http://127.0.0.1:8080```. You can override this behavior using parameters ```--device```, ```--host``` and ```--port```. For example, to broadcast to the world, run:
+**For M2M hardware encoding on Raspberry Pi, you need at least 5.15.32 kernel. OpenMAX and MMAL support on older kernels is deprecated and removed.**
+
+Without arguments, ```ustreamer``` will try to open ```/dev/video0``` with 640x480 resolution and start streaming on  ```http://127.0.0.1:8080```. You can override this behavior using parameters ```--device```, ```--host``` and ```--port```. For example, to stream to the world, run:
 ```
 # ./ustreamer --device=/dev/video1 --host=0.0.0.0 --port=80
 ```
 
-The recommended way of running µStreamer with [Auvidea B101](https://www.raspberrypi.org/forums/viewtopic.php?f=38&t=120702&start=400#p1339178) on Raspberry Pi:
-```bash
+:exclamation: Please note that since µStreamer v2.0 cross-domain requests were disabled by default for [security reasons](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS). To enable the old behavior, use the option `--allow-origin=\*`.
+
+The recommended way of running µStreamer with [TC358743-based capture device](https://www.raspberrypi.org/forums/viewtopic.php?f=38&t=120702&start=400#p1339178) on Raspberry Pi:
+```
 $ ./ustreamer \
     --format=uyvy \ # Device input format
-    --encoder=omx \ # Hardware encoding with OpenMAX
-    --dv-timings \ # use DV-timings
-    --quality=20 \ # OpenMAX has a non-linear quality scale
-    --drop-same-frames=30 # Save that traffic
+    --encoder=m2m-image \ # Hardware encoding on V4L2 M2M driver
+    --workers=3 \ # Workers number
+    --persistent \ # Suppress repetitive signal source errors (for example when HDMI cable was disconnected)
+    --dv-timings \ # Use DV-timings
+    --drop-same-frames=30 # Save the traffic
 ```
 
+:exclamation: Please note that to use `--drop-same-frames` for different browsers you need to use some specific URL `/stream` parameters (see URL `/` for details).
+
 You can always view the full list of options with ```ustreamer --help```.
 
+-----
+# Docker (Raspberry Pi 4 HDMI)
+
+## Preparations
+Add following lines to /boot/firmware/usercfg.txt:
+
+```
+gpu_mem=128
+dtoverlay=tc358743
+```
+
+Check size of CMA:
+
+```
+$ dmesg | grep cma-reserved
+[    0.000000] Memory: 7700524K/8244224K available (11772K kernel code, 1278K rwdata, 4320K rodata, 4096K init, 1077K bss, 281556K reserved, 262144K cma-reserved)
+```
+
+If it is smaller than 128M add following to /boot/firmware/cmdline.txt:
+
+```
+cma=128M
+```
+
+Save changes and reboot.
+
+## Launch
+Start container:
+
+```
+$ docker run --device /dev/video0:/dev/video0 -e EDID=1 -p 8080:8080 pikvm/ustreamer:latest
+```
+
+Then access the web interface at port 8080 (e.g. http://raspberrypi.local:8080).
+
+## Custom config
+```
+$ docker run --rm pikvm/ustreamer:latest \
+    --format=uyvy \
+    --workers=3 \
+    --persistent \
+    --dv-timings \
+    --drop-same-frames=30
+```
+
+## EDID
+Add `-e EDID=1` to set HDMI EDID before starting ustreamer. Use together with `-e EDID_HEX=xx` to specify custom EDID data.
+
+-----
+# Raspberry Pi Camera Example
+
+Example usage for the Raspberry Pi v3 camera (required `libcamerify` which is located in `libcamera-tools` and `libcamera-v4l2` (install both) on Raspbian):
+```
+$ sudo modprobe bcm2835-v4l2
+$ libcamerify ./ustreamer --host :: --encoder=m2m-image
+```
+
+For v2 camera you can use the same trick with `libcamerify` but enable legacy camera mode in `raspi-config`.
+
+Example usage for the Raspberry Pi v1 camera:
+```
+$ sudo modprobe bcm2835-v4l2
+$ ./ustreamer --host :: -m jpeg --device-timeout=5 --buffers=3 -r 2592x1944
+```
+
+:exclamation: Please note that newer camera models have a different maximum resolution. You can see the supported resolutions at the [PiCamera documentation](https://picamera.readthedocs.io/en/release-1.13/fov.html#sensor-modes).
+
+:exclamation: If you get a poor framerate, it could be that the camera is switched to photo mode, which produces a low framerate (but a higher quality picture). This is because `bcm2835-v4l2` switches to photo mode at resolutions higher than `1280x720`. To work around this, pass the `max_video_width` and `max_video_height` module parameters like so:
+
+```
+$ modprobe bcm2835-v4l2 max_video_width=2592 max_video_height=1944
+```
+
+-----
+# Integrations
+
+## Janus
+µStreamer supports bandwidth-efficient streaming using [H.264 compression](https://en.wikipedia.org/wiki/Advanced_Video_Coding) and the Janus WebRTC server. See the [Janus integration guide](docs/h264.md) for full details.
+
+## Nginx
+When uStreamer is behind an Nginx proxy, its buffering behavior introduces latency into the video stream. It's possible to disable Nginx's buffering to eliminate the additional latency:
+
+```nginx
+location /stream {
+    postpone_output 0;
+    proxy_buffering off;
+    proxy_ignore_headers X-Accel-Buffering;
+    proxy_pass http://ustreamer;
+}
+```
+
+-----
+# Tips & tricks for v4l2
+v4l2 utilities provide the tools to manage USB webcam setting and information. Scripts can be use to make adjustments and run manually or with cron. Running in cron for example to change the exposure settings at certain times of day. The package is available in all Linux distributions and is usually called `v4l-utils`.
+
+* List of available video devices: `v4l2-ctl --list-devices`.
+* List available control settings: `v4l2-ctl -d /dev/video0 --list-ctrls`.
+* List available video formats: `v4l2-ctl -d /dev/video0 --list-formats-ext`.
+* Read the current setting: `v4l2-ctl -d /dev/video0 --get-ctrl=exposure_auto`.
+* Change the setting value: `v4l2-ctl -d /dev/video0 --set-ctrl=exposure_auto=1`.
+
+[Here](https://www.kurokesu.com/main/2016/01/16/manual-usb-camera-settings-in-linux/) you can find more examples. Documentation is available in [`man v4l2-ctl`](https://www.mankier.com/1/v4l2-ctl).
+
+-----
+# See also
+* [Running uStreamer via systemd service](https://github.com/pikvm/ustreamer/issues/16).
+
 -----
 # License
-Copyright (C) 2018 by Maxim Devaev mdevaev@gmail.com
+Copyright (C) 2018-2024 by Maxim Devaev mdevaev@gmail.com
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by

README.ru.md

@@ -1,83 +0,0 @@
-# µStreamer 
-[[English version]](README.md)
-
-
-µStreamer - это маленький и очень быстрый сервер, который позволяет организовать трансляцию видео в формате [MJPG](https://en.wikipedia.org/wiki/Motion_JPEG) с любого устройства V4L2 в сеть. Этот формат нативно поддерживается всеми современными браузерами и большинством приложений для просмотра видео (mplayer, VLC и так далее). µStreamer был разработан в рамках проекта [Pi-KVM](https://github.com/pi-kvm) специально для стриминга с устройств видеозахвата [VGA](https://www.amazon.com/dp/B0126O0RDC) и [HDMI](https://auvidea.com/b101-hdmi-to-csi-2-bridge-15-pin-fpc/) с максимально возможным разрешением и FPS, которые только позволяет железо.
-
-Функционально µStreamer очень похож на [mjpg-streamer](https://github.com/jacksonliam/mjpg-streamer) при использовании им плагинов ```input_uvc.so``` и ```output_http.so```, однако имеет ряд серьезных отличий. Основные приведены в этой таблице:
-
-| **Фича** | **µStreamer** | **mjpg-streamer** |
-|----------|---------------|-------------------|
-| Многопоточное кодирование JPEG | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Нет |
-| Аппаратное кодирование с помощью [OpenMAX IL](https://www.khronos.org/openmaxil) на Raspberry Pi | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Нет |
-| Поведение при физическом отключении устройства<br>от сервера во время работы | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Транслирует черный экран<br>с надписью ```NO SIGNAL```,<br>пока устройство не будет подключено снова | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Прерывает трансляцию <sup>1</sup> |
-| Поддержка [DV-таймингов](https://linuxtv.org/downloads/v4l-dvb-apis/uapi/v4l/dv-timings.html) - возможности изменения <br>параметров разрешения трансляции на лету<br>по сигналу источника (устройства видеозахвата) | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть | ![#ffaa00](https://placehold.it/15/ffaa00/000000?text=+) Условно есть <sup>1</sup> |
-| Возможность пропуска фреймов при передаче<br>статического изображения по HTTP<br>для экономии трафика | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть <sup>2</sup> | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Нет |
-| Дебаг-логи без перекомпиляции,<br>логгирование статистики производительности,<br>возможность получения параметров<br>трансляции по HTTP | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Нет |
-| Поддерживаемые входные форматы устройств | ![#ffaa00](https://placehold.it/15/ffaa00/000000?text=+) YUYV, UYVY,<br>RGB565, ~~MJPG~~ <sup>3</sup> | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) YUYV, UYVY,<br>RGB565, MJPG |
-| Поддержка контролов веб-камер (фокус,<br> движение сервами) и всяких настроек,<br> типа яркости, через HTTP | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Нет | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть |
-| Возможность сервить файлы встроенным<br>HTTP-сервером, настройки авторизации | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Нет <sup>4</sup> | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть |
-
-Сносочки:
-  * ```1``` Еще до написания µStreamer, я запилил [патч](https://github.com/jacksonliam/mjpg-streamer/pull/164), добавляющий в mjpg-streamer поддержку DV-таймингов и предотвращающий его зависание при отключении устройства. Однако патч, увы, далек от совершенства и я не гарантирую его стопроцентную работоспособность, поскольку код mjpg-streamer чрезвычайно запутан и очень плохо структурирован. Учитывая это, а также то, что в дальнейшем мне потребовались многопоточность и аппаратное кодирование JPEG, было принято решение написать свой стрим-сервер с нуля, чтобы не тратить силы на поддержку лишнего легаси.
-  
-  * ```2``` Это фича позволяет в несколько раз снизить объем исходящего трафика при трансляции HDMI, однако немного увеличивает загрузку процессора. Суть в том, что HDMI - полностью цифровой интерфейс, и новый захваченный фрейм может быть идентичен предыдущему в точности до байта. В этом случае нет нужды передавать одну и ту же картинку по сети несколько раз в секунду. При использовании опции `--drop-same-frames=20`, µStreamer будет дропать все одинаковые фреймы, но не более 20 подряд. Новый фрейм сравнивается с предыдущим сначала по длине, а затем помощью ```memcmp()```.
-
-  * ```3``` Поскольку µStreamer писался в первую очередь для устройств видеозахвата, в нем реализованы только те форматы, которые для них были нужны. MJPG в контексте входных данных означает, что устройство умеет самостоятельно сжимать картинку в JPEG и отдавать ее программе, что позволяет значительно снизить загрузку процессора и избавить его от необходимости кодировать картинку софтом. Этот формат поддерживается большинством веб-камер, но не поддерживается ни одним из встреченных мной устройств видеозахвата; его не умеет ни [Auvidea B101](https://auvidea.com/b101-hdmi-to-csi-2-bridge-15-pin-fpc/), ни [EasyCap UTV 007](https://www.amazon.com/dp/B0126O0RDC). Нет никаких технических сложностей добавить поддержку аппаратного MJPG источника, но у меня просто пока не дошли до этого руки.
-
-  * ```4``` ... и не будет. µStreamer придерживается концепции UNIX-way, так что если вам нужно нарисовать маленький сайтик со встроенной трансляцией - просто поставьте NGINX.
-
------
-# TL;DR
-Если вам нужно вещать стрим с уличной камеры и управлять ее параметрами - возьмите mjpg-streamer. Если же вам нужно очень качественное изображение с высоким FPS - µStreamer ваш бро.
-
------
-# Сборка
-Для сборки вам понадобятся ```make```, ```gcc```, ```libevent``` с поддержкой ```pthreads```, ```libjpeg8```/```libjpeg-turbo``` и ```libuuid```.
-
-На Raspberry Pi програма автоматически собирается с поддержкой OpenMAX IL, если обнаружит нужные хедеры в ```/opt/vc/include```.
-
-```
-$ git clone --depth=1 https://github.com/pi-kvm/ustreamer
-$ cd ustreamer
-$ make
-$ ./ustreamer --help
-```
-
-Для Arch Linux в AUR есть готовый пакет: https://aur.archlinux.org/packages/ustreamer
-
------
-# Использование
-Будучи запущенным без аргументов, ```ustreamer``` попробует открыть устройство ```/dev/video0``` с разрешением 640x480 и начать трансляцию на ```http://127.0.0.1:8080```. Это поведение может быть изменено с помощью опций ```--device```, ```--host``` и ```--port```. Пример вещания на всю сеть по 80-м порту:
-```
-# ./ustreamer --device=/dev/video1 --host=0.0.0.0 --port=80
-```
-
-Рекомендуемый способ запуска µStreamer для работы с [Auvidea B101](https://www.raspberrypi.org/forums/viewtopic.php?f=38&t=120702&start=400#p1339178) на Raspberry Pi:
-```bash
-$ ./ustreamer \
-    --format=uyvy \ # Настройка входного формата устройства
-    --encoder=omx \ # Использование аппаратного кодирования с помощью OpenMAX
-    --dv-timings \ # Включение DV-таймингов
-    --quality=20 \ # У OpenMAX нелинейная шкала качества
-    --drop-same-frames=30 # Экономим трафик
-```
-
-За полным списком опций обращайтесь ко встроенной справке: ```ustreamer --help```.
-
------
-# Лицензия
-Copyright (C) 2018 by Maxim Devaev mdevaev@gmail.com
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program.  If not, see https://www.gnu.org/licenses/.

docs/h264.md

@@ -0,0 +1,237 @@
+# Streaming H.264 Video over WebRTC with Janus
+
+µStreamer supports bandwidth-efficient streaming using [H.264 compression](https://en.wikipedia.org/wiki/Advanced_Video_Coding) and the Janus WebRTC server.
+
+This guide explains how to configure µStreamer to provide an H.264 video stream and consume it within a web application using WebRTC.
+
+## Components
+
+In addition to µStreamer, H.264 streaming involves the following components:
+
+- [**Janus**](https://janus.conf.meetecho.com/): A general-purpose WebRTC server.
+- [**µStreamer Janus Plugin**](https://github.com/pikvm/ustreamer/tree/master/janus): A Janus plugin that allows Janus to consume a video stream from µStreamer via shared memory.
+- [**Janus JavaScript Client**](https://janus.conf.meetecho.com/docs/JS.html): A frontend library that communicates with the Janus server and the µStreamer Janus plugin.
+
+## Control Flow
+
+To connect to a µStreamer video stream over WebRTC, an application must establish the following control flow:
+
+1. The backend server starts the µStreamer service.
+1. The backend server starts the Janus WebRTC server with the µStreamer Janus plugin.
+1. The client-side JavaScript application establishes a connection to the Janus server.
+1. The client-side JavaScript application instructs the Janus server to attach the µStreamer Janus plugin and start the video stream.
+1. The client-side JavaScript application renders the video stream in the web browser.
+
+## Server Setup
+
+### Prerequisites
+
+To integrate with Janus, µStreamer has the following prerequisites:
+
+- The system packages that µStreamer depends on (see the [main build instructions](../README.md#building)).
+- The Janus WebRTC server with WebSockets transport enabled (see the [Janus documentation](https://github.com/meetecho/janus-gateway)).
+
+### Fixing Janus C Headers
+
+To compile µStreamer with the Janus option, (see [“Installation”](#installation)), you need to make the Janus header files available within µStreamer's build context.
+
+First, create a symbolic link from `/usr/include` to the Janus install directory. By default, Janus installs to `/opt/janus`.
+
+```sh
+ln -s /opt/janus/include/janus /usr/include/janus
+```
+
+Janus uses `#include` paths that make it difficult for third-party libraries to build against its headers. To fix this, modify the `#include` directive in `janus/plugins/plugin.h` to prepend a `../` to the included file name (`#include "refcount.h"` → `#include "../refcount.h"`).
+
+```sh
+sed \
+  --in-place \
+  --expression 's|^#include "refcount.h"$|#include "../refcount.h"|g' \
+  /usr/include/janus/plugins/plugin.h
+```
+
+### Installation
+
+First, compile µStreamer with the Janus plugin option (`WITH_JANUS`).
+
+```sh
+git clone --depth=1 https://github.com/pikvm/ustreamer
+cd ustreamer
+make WITH_JANUS=1
+```
+
+The `WITH_JANUS` option compiles the µStreamer Janus plugin and outputs it to `janus/libjanus_ustreamer.so`. Move this file to the plugin directory of your Janus installation.
+
+```sh
+mv \
+  janus/libjanus_ustreamer.so \
+  /opt/janus/lib/janus/plugins/libjanus_ustreamer.so
+```
+
+Finally, specify a qualifier for the shared memory object so that the µStreamer Janus plugin can read  µStreamer's video data.
+
+```sh
+cat > /opt/janus/lib/janus/configs/janus.plugin.ustreamer.jcfg <<EOF
+memsink: {
+  object = "demo::ustreamer::h264"
+}
+EOF
+```
+
+If you're using a TC358743-based video capture device that supports audio capture, run the following command to enable audio streaming:
+
+```sh
+cat << EOF >> /opt/janus/lib/janus/configs/janus.plugin.ustreamer.jcfg
+audio: {
+    device = "hw:1"
+    tc358743 = "/dev/video0"
+}
+EOF
+```
+
+### Start µStreamer and the Janus WebRTC Server
+
+For µStreamer to share the video stream with the µStreamer Janus plugin, µStreamer must run with the following command-line flags:
+
+- `--h264-sink` with the qualifier of the shared memory object you specified above (`demo::ustreamer::h264`)
+- `--h264-sink-mode` with the permissions bitmask for the shared memory object (e.g., `660`)
+- `--h264-sink-rm` to clean up the shared memory object when the µStreamer process exits
+
+To load the µStreamer Janus plugin and configuration, the Janus WebRTC server must run with the following command-line flags:
+
+- `--configs-folder` with the path to the Janus configuration directory (e.g., `/opt/janus/lib/janus/configs/`)
+- `--plugins-folder` with the path to the Janus plugin directory (e.g., `/opt/janus/lib/janus/plugins/`)
+
+## Client Setup
+
+Once an application's backend server is running µStreamer and Janus, a browser-based JavaScript application can consume the server's video stream.
+
+### Prerequisites
+
+The client needs to load the following JavaScript libraries:
+
+- [WebRTC Adapter library](https://webrtc.github.io/adapter/adapter-8.1.0.js) (`webrtc-adapter.js`, version `8.1.0`)
+- [Janus Gateway JavaScript library](https://raw.githubusercontent.com/meetecho/janus-gateway/v1.0.0/html/janus.js) (`janus.js`, version `1.0.0`)
+
+### Control Flow
+
+The client-side JavaScript application uses the following control flow:
+
+1. The client loads and initializes the Janus client library.
+1. The client establishes a WebSockets connection to the Janus server.
+1. The client instructs the Janus server to attach the µStreamer Janus plugin.
+1. On success, the client obtains a plugin handle through which it can send requests directly to the µStreamer Janus plugin. The client processes responses via the `attach` callbacks:
+   - `onmessage` for general messages
+   - `onremotetrack` for the H.264 video stream and (optionally) an Opus audio stream
+1. The client issues a `watch` request to the µStreamer Janus plugin, which initiates the H.264 stream in the plugin itself.
+   - It takes a few seconds for uStreamer's video stream to become available to Janus. The first `watch` request may fail, so the client must retry the `watch` request.
+1. The client and server negotiate the underlying parameters of the WebRTC session. This procedure is called JavaScript Session Establishment Protocol (JSEP). The server makes a `jsepOffer` to the client, and the client responds with a `jsepAnswer`.
+1. The client issues a `start` request to the µStreamer Janus plugin to indicate that the client wants to begin consuming the video stream.
+1. The µStreamer Janus plugin delivers the H.264 video stream and (optionally) an Opus audio stream to the client via WebRTC.
+1. The Janus client library invokes the `onremotetrack` callback with the video stream. The client attaches the video stream to the `<video>` element, rendering the video stream in the browser window.
+1. (if an audio track is available) The Janus client library invokes the `onremotetrack` callback with the Opus audio stream. The client adds the audio stream to the `<video>` element, rendering the audio in the browser window.
+
+### Sample Code
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>µStreamer H.264 demo</title>
+  <script src="https://webrtc.github.io/adapter/adapter-8.1.0.js"></script>
+  <!-- janus.js is the JavaScript client library of Janus, as specified above in
+       the prerequisites section of the client setup. You might need to change
+       the `src` path, depending on where you serve this file from. -->
+  <script src="janus.js"></script>
+  <style>
+    video {
+      height: 100%;
+      width: 100%;
+      object-fit: contain;
+    }
+  </style>
+</head>
+<body>
+  <video id="webrtc-output" autoplay playsinline muted></video>
+  <script type="text/javascript">
+    // Initialize Janus library.
+    Janus.init({
+      // Turn on debug logs in the browser console.
+      debug: true,
+
+      // Configure Janus to use standard browser APIs internally.
+      dependencies: Janus.useDefaultDependencies(),
+    });
+
+    // Establish a WebSockets connection to the server.
+    const janus = new Janus({
+      // Specify the URL of the Janus server’s WebSockets endpoint.
+      server: `ws://${window.location.hostname}:8188/`,
+
+      // Callback function if the client connects successfully.
+      success: attachUStreamerPlugin,
+
+      // Callback function if the client fails to connect.
+      error: console.error,
+    });
+
+    let uStreamerPluginHandle = null;
+
+    function attachUStreamerPlugin() {
+      // Instruct the server to attach the µStreamer Janus plugin.
+      janus.attach({
+        // Qualifier of the plugin.
+        plugin: "janus.plugin.ustreamer",
+
+        // Callback function, for when the server attached the plugin
+        // successfully.
+        success: function (pluginHandle) {
+          uStreamerPluginHandle = pluginHandle;
+          // Instruct the µStreamer Janus plugin to initiate streaming.
+          uStreamerPluginHandle.send({ message: { request: "watch", params: {audio: true} } });
+        },
+
+        // Callback function if the server fails to attach the plugin.
+        error: console.error,
+
+        // Callback function for processing messages from the Janus server.
+        onmessage: function (msg, jsepOffer) {
+          // If there is a JSEP offer, respond to it. This starts the WebRTC
+          // connection.
+          if (jsepOffer) {
+            uStreamerPluginHandle.createAnswer({
+              jsep: jsepOffer,
+              // Prevent the client from sending audio and video, as this would
+              // trigger a permission dialog in the browser.
+              media: { audioSend: false, videoSend: false },
+              success: function (jsepAnswer) {
+                uStreamerPluginHandle.send({
+                  message: { request: "start" },
+                  jsep: jsepAnswer,
+                });
+              },
+              error: console.error,
+            });
+          }
+        },
+
+        // Callback function, for when a media stream arrives.
+        onremotetrack: function (mediaStreamTrack, mediaId, isAdded) {
+          if (isAdded) {
+            // Attach the received media track to the video element. Cloning the
+            // mediaStreamTrack creates a new object with a distinct, globally
+            // unique stream identifier.
+            const videoElement = document.getElementById("webrtc-output");
+            if (videoElement.srcObject === null) {
+              videoElement.srcObject = new MediaStream();
+            }
+            videoElement.srcObject.addTrack(mediaStreamTrack.clone());
+          }
+        },
+      });
+    }
+  </script>
+</body>
+</html>
+```

docs/ssl/README.md

@@ -0,0 +1,50 @@
+# Adding SSL
+These days, browsers are not happy if you have HTTP content on an HTTPS page.
+The browser will not show an HTTP stream on a page if the parent page is from a site which is using HTTPS.
+
+The files in this folder configure an Nginx proxy in front of the µStreamer stream.
+Using certbot, an SSL cert is created from Let's Encrypt and installed.
+These scripts can be modified to add SSL to just about any HTTP server.
+
+The scripts are not fire and forget.
+They will require some pre-configuration and are interactive (you'll be asked questions while they're running).
+They have been tested using the following setup.
+1. A Raspberry Pi 4
+1. µStreamer set up and running as a service
+    1. Internally on port 8080
+    1. Public port will be 5101
+1. Verizon home Wi-Fi router
+1. Domain registration from GoDaddy
+
+## The Script
+Below is an overview of the steps performed by `ssl-config.sh` (for Raspberry OS):
+1. Install snapd - certbot uses this for installation
+1. Install certbot
+1. Get a free cert from Let's Encrypt using certbot
+1. Install nginx
+1. Configures nginx to proxy for µStreamer
+
+## Steps
+1. Create a public DNS entry.
+    1. Pointing to the Pi itself or the public IP of the router behind which the Pi sits.
+    1. This would be managed in the domain registrar, such as GoDaddy.
+    1. Use a subdomain, such as `webcam.domain.com`
+1. Port Forwarding
+    1. If using a Wi-Fi router, create a port forwarding rule which passes traffic from port 80 to the Pi. This is needed for certbot to ensure your DNS entry reaches the Pi, even if your final port will be something else.
+    1. Create a second rule for your final setup. For example, forward traffic from the router on port 5101 to the Pi's IP port 8080.
+1. Update the ustreamer-proxy file in this folder
+    1. Replace `your.domain.com` with a fully qualified domain, it's three places in the proxy file.
+    1. Modify the line `listen 5101 ssl` port if needed. This is the public port, not the port on which the µStreamer service is running
+    1. Modify `proxy_pass http://127.0.0.1:8080;` with the working address of the internal µStreamer service.
+1. Run the script
+    1. Stand buy, certbot asks some basic questions, such as email, domain, agree to terms, etc.
+    1. `bash ssl-config.sh`
+1. Test your URL!
+
+## Down the Road
+Two important points to keep in mind for the future:
+1. Dynamic IP - Most routers do not have a static IP address on the WAN side. So, if you reboot your router or if your internet provider gives you a new IP, you'll have to update the DNS entry.
+    1. Many routers have some sort of dynamic DNS feature. This would automatically update the DNS entry for you. That functionality is outside the scope of this document.
+1. SSL Renewals - certbot automatically creates a task to renew the SSL cert before it expires. Assuming the Pi is running all the time, this shouldn't be an issue.
+
+## Enjoy!

docs/ssl/ssl-config.sh

@@ -0,0 +1,20 @@
+#!/bin/sh
+
+echo -e "\e[32mInstalling snapd...\e[0m"
+sudo apt install snapd -y
+sudo snap install core
+
+
+echo -e "\e[32mInstalling certbot, don't leave, it's going to ask questions...\e[0m"
+sudo snap install --classic certbot
+sudo ln -s /snap/bin/certbot /usr/bin/certbot
+sudo certbot certonly --standalone
+sudo certbot renew --dry-run
+
+
+echo -e "\e[32mInstalling nginx...\e[0m"
+sudo apt-get install nginx -y
+sudo cp ustreamer-proxy /etc/nginx/sites-available/ustreamer-proxy
+sudo ln -s /etc/nginx/sites-available/ustreamer-proxy /etc/nginx/sites-enabled/
+sudo nginx -t
+sudo systemctl reload nginx

docs/ssl/ustreamer-proxy

@@ -0,0 +1,13 @@
+server {
+    listen 5101 ssl;
+    server_name your.domain.com;
+
+    ssl_certificate /etc/letsencrypt/live/your.domain.com/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/your.domain.com/privkey.pem;
+
+    location / {
+        proxy_pass http://127.0.0.1:8080;  # Change this to the uStreamer server address
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+    }
+}

docs/youtube.md

@@ -0,0 +1,97 @@
+## Streaming to third party services
+
+This method provides the ability of streaming a USB Webcam and include audio to large audiences.
+It uses to two machines. One is a Raspberry Pi and the other a more capable machine to performance
+the encoding of the video and audio that is streamed to the third party service such as YouTube.
+
+Another benefit of using a browser (http stream) is the video can have overlays add in the custom ustreamer webpage.
+For example a cron process that retrieves weather information and updates a file to include on the page, announcements,
+or other creative ideas. The audio stream can also be something other than the webcam mic (music, voice files, etc.)
+and easily changed on the second machine setup. In the following example filtering is applied in ffmpeg to
+improve the sound of the webcam mic making vocals clearer and more intelligible.
+
+* Machine 1:
+    * USB webcam on the machine (Pi for example) running ustreamer (video) and VLC (audio). Remember to make any needed firewall changes if machine 2 is on a separate network so it can reach the ports for the video and audio.
+    * To stream audio from the Pi.
+        ```
+        /usr/bin/vlc -I dummy -vvv alsa://hw:2,0 --sout #transcode{acodec=mp3,ab=128}:standard{access=http,mux=ts,dst=:[PickAPort}
+        ```
+
+* Machine 2:
+    * On a more capable box run the video stream in a browser using ffmpeg to combine the video (browser) and audio and stream to YouTube or other services. In this example a VM with two virtual monitors running the browser full screen one of the monitors is used.
+
+Script to stream the combination to YouTube:
+```bash
+#!/bin/bash
+KEY=$1
+echo
+echo Cleanup -------------------------------------------------
+source live-yt.key
+killall -9 ffmpeg
+killall -9 chromium
+sleep 3
+
+echo Setup General--------------------------------------------
+cd /home/[USER]
+rm -f nohup.out
+export DISPLAY=:0.0
+export $(dbus-launch)
+
+echo Setup Chromium-------------------------------------------
+CHROMIUM_TEMP=/home/{USER]/tmp/chromium
+rm -rf $CHROMIUM_TEMP.bak
+mv $CHROMIUM_TEMP $CHROMIUM_TEMP.bak
+mkdir -p $CHROMIUM_TEMP
+
+echo Start Chromium ------------------------------------------
+nohup /usr/lib/chromium/chromium \
+    --new-window "http://[ustreamerURL]" \
+    --start-fullscreen \
+    --disable \
+    --disable-translate \
+    --disable-infobars \
+    --disable-suggestions-service \
+    --disable-save-password-bubble \
+    --disable-new-tab-first-run \
+    --disable-session-crashed-bubble \
+    --disable-bundled-ppapi-flash  \
+    --disable-gpu \
+    --enable-javascript \
+    --enable-user-scripts \
+    --disk-cache-dir=$CHROMIUM_TEMP/cache/ustreamer/ \
+    --user-data-dir=$CHROMIUM_TEMP/user_data/ustreamer/ \
+    --window-position=1440,12 \
+     >/dev/null 2>&1 &
+sleep 5
+
+echo Start FFMpeg---------------------------------------------
+nohup /usr/bin/ffmpeg \
+    -loglevel level+warning \
+    -thread_queue_size 512 \
+    -framerate 30 \
+    -f x11grab \
+    -s 1920x1080 \
+    -probesize 42M \
+    -i :0.0+1024,0 \
+    -i http://[VLCaudioURL] \
+    -filter:a "volume=10, highpass=f=300, lowpass=f=2800" \
+    -c:v libx264 \
+    -pix_fmt yuv420p \
+    -g 60 \
+    -b:v 2500k \
+    -c:a libmp3lame \
+    -ar 44100 \
+    -b:a 32k \
+    -preset ultrafast \
+    -maxrate 5000k \
+    -bufsize 2500k \
+    -preset ultrafast \
+    -flvflags no_duration_filesize  \
+    -f flv "rtmp://a.rtmp.youtube.com/live2/$KEY" \
+     >/home/{USER]/ff-audio.log 2>&1 &
+
+echo Done ----------------------------------------------------
+echo
+```
+
+*PS: Recipe by David Klippel*

janus/Makefile

@@ -0,0 +1,54 @@
+R_DESTDIR ?=
+PREFIX ?= /usr/local
+
+CC ?= gcc
+PKG_CONFIG ?= pkg-config
+CFLAGS ?= -O3
+LDFLAGS ?=
+
+
+# =====
+_PLUGIN = libjanus_ustreamer.so
+
+_CFLAGS = -fPIC -MD -c -std=c17 -Wall -Wextra -D_GNU_SOURCE $(shell $(PKG_CONFIG) --cflags janus-gateway) $(CFLAGS)
+_LDFLAGS = -shared -lm -pthread -lrt -ljansson -lopus -lasound -lspeexdsp $(shell $(PKG_CONFIG) --libs janus-gateway) $(LDFLAGS)
+
+_SRCS = $(shell ls src/uslibs/*.c src/*.c)
+
+_BUILD = build
+
+
+# =====
+ifeq ($(findstring bsd,$(shell $(CC) -dumpmachine)),)
+override _LDFLAGS += -latomic
+endif
+
+ifneq ($(MK_WITH_PTHREAD_NP),)
+override _CFLAGS += -DWITH_PTHREAD_NP
+endif
+
+
+# =====
+$(_PLUGIN): $(_SRCS:%.c=$(_BUILD)/%.o)
+	$(info == SO $@)
+	$(ECHO) $(CC) $^ -o $@ $(_LDFLAGS)
+
+
+$(_BUILD)/%.o: %.c
+	$(info -- CC $<)
+	$(ECHO) mkdir -p $(dir $@) || true
+	$(ECHO) $(CC) $< -o $@ $(_CFLAGS)
+
+
+
+install: $(_PLUGIN)
+	mkdir -p $(R_DESTDIR)$(PREFIX)/lib/ustreamer/janus
+	install -m755 $(_PLUGIN) $(R_DESTDIR)$(PREFIX)/lib/ustreamer/janus/$(PLUGIN)
+
+
+clean:
+	rm -rf $(_PLUGIN) $(_BUILD)
+
+
+_OBJS = $(_SRCS:%.c=$(_BUILD)/%.o)
+-include $(_OBJS:%.o=%.d)

janus/src/acap.c

@@ -0,0 +1,243 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "acap.h"
+
+#include <stdlib.h>
+#include <stdatomic.h>
+#include <assert.h>
+
+#include <pthread.h>
+#include <alsa/asoundlib.h>
+#include <speex/speex_resampler.h>
+#include <opus/opus.h>
+
+#include "uslibs/types.h"
+#include "uslibs/errors.h"
+#include "uslibs/tools.h"
+#include "uslibs/array.h"
+#include "uslibs/ring.h"
+#include "uslibs/threading.h"
+
+#include "rtp.h"
+#include "au.h"
+#include "logging.h"
+
+
+static void *_pcm_thread(void *v_acap);
+static void *_encoder_thread(void *v_acap);
+
+
+us_acap_s *us_acap_init(const char *name, uint pcm_hz) {
+	us_acap_s *acap;
+	US_CALLOC(acap, 1);
+	acap->pcm_hz = pcm_hz;
+	US_RING_INIT_WITH_ITEMS(acap->pcm_ring, 8, us_au_pcm_init);
+	US_RING_INIT_WITH_ITEMS(acap->enc_ring, 8, us_au_encoded_init);
+	atomic_init(&acap->stop, false);
+
+	int err;
+
+	{
+		if ((err = snd_pcm_open(&acap->dev, name, SND_PCM_STREAM_CAPTURE, 0)) < 0) {
+			acap->dev = NULL;
+			US_JLOG_PERROR_ALSA(err, "acap", "Can't open PCM capture");
+			goto error;
+		}
+		assert(!snd_pcm_hw_params_malloc(&acap->dev_params));
+
+#		define SET_PARAM(_msg, _func, ...) { \
+				if ((err = _func(acap->dev, acap->dev_params, ##__VA_ARGS__)) < 0) { \
+					US_JLOG_PERROR_ALSA(err, "acap", _msg); \
+					goto error; \
+				} \
+			}
+
+		SET_PARAM("Can't initialize PCM params",	snd_pcm_hw_params_any);
+		SET_PARAM("Can't set PCM access type",		snd_pcm_hw_params_set_access, SND_PCM_ACCESS_RW_INTERLEAVED);
+		SET_PARAM("Can't set PCM channels number",	snd_pcm_hw_params_set_channels, US_RTP_OPUS_CH);
+		SET_PARAM("Can't set PCM sampling format",	snd_pcm_hw_params_set_format, SND_PCM_FORMAT_S16_LE);
+		SET_PARAM("Can't set PCM sampling rate",	snd_pcm_hw_params_set_rate_near, &acap->pcm_hz, 0);
+		if (acap->pcm_hz < US_AU_MIN_PCM_HZ || acap->pcm_hz > US_AU_MAX_PCM_HZ) {
+			US_JLOG_ERROR("acap", "Unsupported PCM freq: %u; should be: %u <= F <= %u",
+				acap->pcm_hz, US_AU_MIN_PCM_HZ, US_AU_MAX_PCM_HZ);
+			goto error;
+		}
+		acap->pcm_frames = US_AU_HZ_TO_FRAMES(acap->pcm_hz);
+		acap->pcm_size = US_AU_HZ_TO_BUF8(acap->pcm_hz);
+		SET_PARAM("Can't apply PCM params", snd_pcm_hw_params);
+
+#		undef SET_PARAM
+	}
+
+	if (acap->pcm_hz != US_RTP_OPUS_HZ) {
+		acap->res = speex_resampler_init(US_RTP_OPUS_CH, acap->pcm_hz, US_RTP_OPUS_HZ, SPEEX_RESAMPLER_QUALITY_DESKTOP, &err);
+		if (err < 0) {
+			acap->res = NULL;
+			US_JLOG_PERROR_RES(err, "acap", "Can't create resampler");
+			goto error;
+		}
+	}
+
+	{
+		// OPUS_APPLICATION_VOIP, OPUS_APPLICATION_RESTRICTED_LOWDELAY
+		acap->enc = opus_encoder_create(US_RTP_OPUS_HZ, US_RTP_OPUS_CH, OPUS_APPLICATION_AUDIO, &err);
+		assert(err == 0);
+		// https://github.com/meetecho/janus-gateway/blob/3cdd6ff/src/plugins/janus_audiobridge.c#L2272
+		// https://datatracker.ietf.org/doc/html/rfc7587#section-3.1.1
+		assert(!opus_encoder_ctl(acap->enc, OPUS_SET_BITRATE(128000)));
+		assert(!opus_encoder_ctl(acap->enc, OPUS_SET_MAX_BANDWIDTH(OPUS_BANDWIDTH_FULLBAND)));
+		assert(!opus_encoder_ctl(acap->enc, OPUS_SET_SIGNAL(OPUS_SIGNAL_MUSIC)));
+		// OPUS_SET_INBAND_FEC(1), OPUS_SET_PACKET_LOSS_PERC(10): see rtpa.c
+	}
+
+	US_JLOG_INFO("acap", "Capture configured on %uHz; capturing ...", acap->pcm_hz);
+	acap->tids_created = true;
+	US_THREAD_CREATE(acap->enc_tid, _encoder_thread, acap);
+	US_THREAD_CREATE(acap->pcm_tid, _pcm_thread, acap);
+
+	return acap;
+
+	error:
+		us_acap_destroy(acap);
+		return NULL;
+}
+
+void us_acap_destroy(us_acap_s *acap) {
+	if (acap->tids_created) {
+		atomic_store(&acap->stop, true);
+		US_THREAD_JOIN(acap->pcm_tid);
+		US_THREAD_JOIN(acap->enc_tid);
+	}
+	US_DELETE(acap->enc, opus_encoder_destroy);
+	US_DELETE(acap->res, speex_resampler_destroy);
+	US_DELETE(acap->dev, snd_pcm_close);
+	US_DELETE(acap->dev_params, snd_pcm_hw_params_free);
+	US_RING_DELETE_WITH_ITEMS(acap->enc_ring, us_au_encoded_destroy);
+	US_RING_DELETE_WITH_ITEMS(acap->pcm_ring, us_au_pcm_destroy);
+	if (acap->tids_created) {
+		US_JLOG_INFO("acap", "Capture closed");
+	}
+	free(acap);
+}
+
+int us_acap_get_encoded(us_acap_s *acap, u8 *data, uz *size, u64 *pts) {
+	if (atomic_load(&acap->stop)) {
+		return -1;
+	}
+	const int ri = us_ring_consumer_acquire(acap->enc_ring, 0.1);
+	if (ri < 0) {
+		return US_ERROR_NO_DATA;
+	}
+	const us_au_encoded_s *const buf = acap->enc_ring->items[ri];
+	if (buf->used == 0 || *size < buf->used) {
+		us_ring_consumer_release(acap->enc_ring, ri);
+		return US_ERROR_NO_DATA;
+	}
+	memcpy(data, buf->data, buf->used);
+	*size = buf->used;
+	*pts = buf->pts;
+	us_ring_consumer_release(acap->enc_ring, ri);
+	return 0;
+}
+
+static void *_pcm_thread(void *v_acap) {
+	US_THREAD_SETTLE("us_ac_pcm");
+
+	us_acap_s *const acap = v_acap;
+	u8 in[US_AU_MAX_BUF8];
+
+	while (!atomic_load(&acap->stop)) {
+		const int frames = snd_pcm_readi(acap->dev, in, acap->pcm_frames);
+		if (frames < 0) {
+			US_JLOG_PERROR_ALSA(frames, "acap", "Fatal: Can't capture PCM frames");
+			break;
+		} else if (frames < (int)acap->pcm_frames) {
+			US_JLOG_ERROR("acap", "Fatal: Too few PCM frames captured");
+			break;
+		}
+
+		const int ri = us_ring_producer_acquire(acap->pcm_ring, 0);
+		if (ri >= 0) {
+			us_au_pcm_s *const out = acap->pcm_ring->items[ri];
+			memcpy(out->data, in, acap->pcm_size);
+			us_ring_producer_release(acap->pcm_ring, ri);
+		} else {
+			US_JLOG_ERROR("acap", "PCM ring is full");
+		}
+	}
+
+	atomic_store(&acap->stop, true);
+	return NULL;
+}
+
+static void *_encoder_thread(void *v_acap) {
+	US_THREAD_SETTLE("us_ac_enc");
+
+	us_acap_s *const acap = v_acap;
+	s16 in_res[US_AU_MAX_BUF16];
+
+	while (!atomic_load(&acap->stop)) {
+		const int in_ri = us_ring_consumer_acquire(acap->pcm_ring, 0.1);
+		if (in_ri < 0) {
+			continue;
+		}
+		us_au_pcm_s *const in = acap->pcm_ring->items[in_ri];
+
+		s16 *in_ptr;
+		if (acap->res != NULL) {
+			assert(acap->pcm_hz != US_RTP_OPUS_HZ);
+			u32 in_count = acap->pcm_frames;
+			u32 out_count = US_AU_HZ_TO_FRAMES(US_RTP_OPUS_HZ);
+			speex_resampler_process_interleaved_int(acap->res, in->data, &in_count, in_res, &out_count);
+			in_ptr = in_res;
+		} else {
+			assert(acap->pcm_hz == US_RTP_OPUS_HZ);
+			in_ptr = in->data;
+		}
+
+		const int out_ri = us_ring_producer_acquire(acap->enc_ring, 0);
+		if (out_ri < 0) {
+			US_JLOG_ERROR("acap", "OPUS encoder queue is full");
+			us_ring_consumer_release(acap->pcm_ring, in_ri);
+			continue;
+		}
+		us_au_encoded_s *const out = acap->enc_ring->items[out_ri];
+
+		const int size = opus_encode(acap->enc, in_ptr, US_AU_HZ_TO_FRAMES(US_RTP_OPUS_HZ), out->data, US_ARRAY_LEN(out->data));
+		us_ring_consumer_release(acap->pcm_ring, in_ri);
+
+		if (size > 0) {
+			out->used = size;
+			out->pts = acap->pts;
+			// https://datatracker.ietf.org/doc/html/rfc7587#section-4.2
+			acap->pts += US_AU_HZ_TO_FRAMES(US_RTP_OPUS_HZ);
+		} else {
+			out->used = 0;
+			US_JLOG_PERROR_OPUS(size, "acap", "Fatal: Can't encode PCM frame to OPUS");
+		}
+		us_ring_producer_release(acap->enc_ring, out_ri);
+	}
+
+	atomic_store(&acap->stop, true);
+	return NULL;
+}

janus/src/acap.h

@@ -0,0 +1,59 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#include <stdatomic.h>
+
+#include <pthread.h>
+#include <alsa/asoundlib.h>
+#include <speex/speex_resampler.h>
+#include <opus/opus.h>
+
+#include "uslibs/types.h"
+#include "uslibs/ring.h"
+
+
+typedef struct {
+	snd_pcm_t			*dev;
+	uint				pcm_hz;
+	uint				pcm_frames;
+	uz					pcm_size;
+	snd_pcm_hw_params_t	*dev_params;
+	SpeexResamplerState	*res;
+	OpusEncoder			*enc;
+
+	us_ring_s		*pcm_ring;
+	us_ring_s		*enc_ring;
+	u32				pts;
+
+	pthread_t		pcm_tid;
+	pthread_t		enc_tid;
+	bool			tids_created;
+	atomic_bool		stop;
+} us_acap_s;
+
+
+us_acap_s *us_acap_init(const char *name, uint pcm_hz);
+void us_acap_destroy(us_acap_s *acap);
+
+int us_acap_get_encoded(us_acap_s *acap, u8 *data, uz *size, u64 *pts);

janus/src/au.c

@@ -0,0 +1,151 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "au.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include <sys/stat.h>
+
+#include "uslibs/tools.h"
+
+
+bool us_au_probe(const char *name) {
+	// This function is very limited. It takes something like:
+	//   hw:0,0 or hw:tc358743,0 or plughw:UAC2Gadget,0
+	// parses card name (0, tc358743, UAC2Gadget) and checks
+	// the existence of it in /proc/asound/.
+	// It's enough for our case.
+
+	if (name == NULL) {
+		return false;
+	}
+
+	if (strchr(name, '/') || strchr(name, '.')) {
+		return false;
+	}
+
+	const char *begin = strchr(name, ':');
+	if (begin == NULL) {
+		return false;
+	}
+	begin += 1;
+	if (*begin == '\0') {
+		return false;
+	}
+
+	const char *end = strchr(begin, ',');
+	if (end == NULL) {
+		return false;
+	}
+	if (end - begin < 1) {
+		return false;
+	}
+
+	char *card = us_strdup(begin);
+	card[end - begin] = '\0';
+
+	bool numeric = true;
+	for (uz index = 0; card[index] != '\0'; ++index) {
+		if (!isdigit(card[index])) {
+			numeric = false;
+			break;
+		}
+	}
+
+	char *path;
+	if (numeric) {
+		US_ASPRINTF(path, "/proc/asound/card%s", card);
+	} else {
+		US_ASPRINTF(path, "/proc/asound/%s", card);
+	}
+
+	bool ok = false;
+	struct stat st;
+	if (lstat(path, &st) == 0) {
+		if (numeric && S_ISDIR(st.st_mode)) {
+			ok = true;
+		} else if (!numeric && S_ISLNK(st.st_mode)) {
+			ok = true;
+		}
+	}
+	free(path);
+	free(card);
+	return ok;
+}
+
+us_au_pcm_s *us_au_pcm_init(void) {
+	us_au_pcm_s *pcm;
+	US_CALLOC(pcm, 1);
+	return pcm;
+}
+
+void us_au_pcm_destroy(us_au_pcm_s *pcm) {
+	free(pcm);
+}
+
+void us_au_pcm_mix(us_au_pcm_s *dest, us_au_pcm_s *src) {
+	const uz size = src->frames * US_RTP_OPUS_CH * 2; // 2 for 16 bit
+
+	if (src->frames == 0) {
+		return;
+
+	} else if (dest->frames == 0) {
+		memcpy(dest->data, src->data, size);
+		dest->frames = src->frames;
+
+	} else if (dest->frames == src->frames) {
+		// https://stackoverflow.com/questions/12089662
+		for (uz index = 0; index < size; ++index) {
+			int a = dest->data[index];
+			int b = src->data[index];
+			int m;
+
+			a += 32768;
+			b += 32768;
+
+			if ((a < 32768) && (b < 32768)) {
+				m = a * b / 32768;
+			} else {
+				m = 2 * (a + b) - (a * b) / 32768 - 65536;
+			}
+			if (m == 65536) {
+				m = 65535;
+			}
+			m -= 32768;
+
+			dest->data[index] = m;
+		}
+	}
+}
+
+us_au_encoded_s *us_au_encoded_init(void) {
+	us_au_encoded_s *enc;
+	US_CALLOC(enc, 1);
+	return enc;
+}
+
+void us_au_encoded_destroy(us_au_encoded_s *enc) {
+	free(enc);
+}

janus/src/au.h

@@ -0,0 +1,61 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#include "uslibs/types.h"
+
+#include "rtp.h"
+
+// A number of frames per 1 channel:
+//   - https://github.com/xiph/opus/blob/7b05f44/src/opus_demo.c#L368
+#define US_AU_FRAME_MS			20
+// #define _HZ_TO_FRAMES(_hz)	(6 * (_hz) / 50) // 120ms
+#define US_AU_HZ_TO_FRAMES(_hz)	((_hz) / 50) // 20ms
+#define US_AU_HZ_TO_BUF16(_hz)	(US_AU_HZ_TO_FRAMES(_hz) * US_RTP_OPUS_CH) // ... * 2: One stereo frame = (16bit L) + (16bit R)
+#define US_AU_HZ_TO_BUF8(_hz)	(US_AU_HZ_TO_BUF16(_hz) * sizeof(s16))
+
+#define US_AU_MIN_PCM_HZ		8000
+#define US_AU_MAX_PCM_HZ		192000
+#define US_AU_MAX_BUF16			US_AU_HZ_TO_BUF16(US_AU_MAX_PCM_HZ)
+#define US_AU_MAX_BUF8			US_AU_HZ_TO_BUF8(US_AU_MAX_PCM_HZ)
+
+
+typedef struct {
+	s16		data[US_AU_MAX_BUF16];
+	uz		frames;
+} us_au_pcm_s;
+
+typedef struct {
+	u8		data[US_RTP_PAYLOAD_SIZE];
+	uz		used;
+	u64		pts;
+} us_au_encoded_s;
+
+bool us_au_probe(const char *name);
+
+us_au_pcm_s *us_au_pcm_init(void);
+void us_au_pcm_destroy(us_au_pcm_s *pcm);
+void us_au_pcm_mix(us_au_pcm_s *a, us_au_pcm_s *b);
+
+us_au_encoded_s *us_au_encoded_init(void);
+void us_au_encoded_destroy(us_au_encoded_s *enc);

janus/src/client.c

@@ -0,0 +1,276 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "client.h"
+
+#include <stdlib.h>
+#include <stdatomic.h>
+#include <string.h>
+#include <assert.h>
+
+#include <pthread.h>
+#include <janus/plugins/plugin.h>
+#include <janus/rtp.h>
+#include <opus/opus.h>
+
+#include "uslibs/types.h"
+#include "uslibs/tools.h"
+#include "uslibs/threading.h"
+#include "uslibs/array.h"
+#include "uslibs/list.h"
+#include "uslibs/ring.h"
+
+#include "logging.h"
+#include "au.h"
+#include "rtp.h"
+
+
+static void *_video_thread(void *v_client);
+static void *_acap_thread(void *v_client);
+static void *_video_or_acap_thread(void *v_client, bool video);
+static void *_aplay_thread(void *v_client);
+
+
+us_janus_client_s *us_janus_client_init(janus_callbacks *gw, janus_plugin_session *session) {
+	us_janus_client_s *client;
+	US_CALLOC(client, 1);
+	client->gw = gw;
+	client->session = session;
+	atomic_init(&client->transmit, false);
+	atomic_init(&client->transmit_acap, false);
+	atomic_init(&client->transmit_aplay, false);
+	atomic_init(&client->video_orient, 0);
+
+	atomic_init(&client->stop, false);
+
+	US_RING_INIT_WITH_ITEMS(client->video_ring, 2048, us_rtp_init);
+	US_THREAD_CREATE(client->video_tid, _video_thread, client);
+
+	US_RING_INIT_WITH_ITEMS(client->acap_ring, 64, us_rtp_init);
+	US_THREAD_CREATE(client->acap_tid, _acap_thread, client);
+
+	US_RING_INIT_WITH_ITEMS(client->aplay_enc_ring, 64, us_au_encoded_init);
+	US_RING_INIT_WITH_ITEMS(client->aplay_pcm_ring, 64, us_au_pcm_init);
+	US_THREAD_CREATE(client->aplay_tid, _aplay_thread, client);
+
+	return client;
+}
+
+void us_janus_client_destroy(us_janus_client_s *client) {
+	atomic_store(&client->stop, true);
+
+	US_THREAD_JOIN(client->video_tid);
+	US_RING_DELETE_WITH_ITEMS(client->video_ring, us_rtp_destroy);
+
+	US_THREAD_JOIN(client->acap_tid);
+	US_RING_DELETE_WITH_ITEMS(client->acap_ring, us_rtp_destroy);
+
+	US_THREAD_JOIN(client->aplay_tid);
+	US_RING_DELETE_WITH_ITEMS(client->aplay_enc_ring, us_au_encoded_destroy);
+	US_RING_DELETE_WITH_ITEMS(client->aplay_pcm_ring, us_au_pcm_destroy);
+
+	free(client);
+}
+
+void us_janus_client_send(us_janus_client_s *client, const us_rtp_s *rtp) {
+	if (
+		atomic_load(&client->transmit)
+		&& (rtp->video || atomic_load(&client->transmit_acap))
+	) {
+		us_ring_s *const ring = (rtp->video ? client->video_ring : client->acap_ring);
+		const int ri = us_ring_producer_acquire(ring, 0);
+		if (ri < 0) {
+			US_JLOG_ERROR("client", "Session %p %s ring is full",
+				client->session, (rtp->video ? "video" : "acap"));
+			return;
+		}
+		memcpy(ring->items[ri], rtp, sizeof(us_rtp_s));
+		us_ring_producer_release(ring, ri);
+	}
+}
+
+void us_janus_client_recv(us_janus_client_s *client, janus_plugin_rtp *packet) {
+	if (
+		packet->video
+		|| packet->length < sizeof(janus_rtp_header)
+		|| !atomic_load(&client->transmit)
+		|| !atomic_load(&client->transmit_aplay)
+	) {
+		return;
+	}
+
+	const janus_rtp_header *const header = (janus_rtp_header*)packet->buffer;
+	if (header->type != US_RTP_OPUS_PAYLOAD) {
+		return;
+	}
+
+	const u16 seq = ntohs(header->seq_number);
+	if (
+		seq >= client->aplay_seq_next // In order or missing
+		|| (client->aplay_seq_next - seq) > 50 // In late sequence or sequence wrapped
+	) {
+		client->aplay_seq_next = seq + 1;
+
+		int size = 0;
+		const char *const data = janus_rtp_payload(packet->buffer, packet->length, &size);
+		if (data == NULL || size <= 0) {
+			return;
+		}
+
+		us_ring_s *const ring = client->aplay_enc_ring;
+		const int ri = us_ring_producer_acquire(ring, 0);
+		if (ri < 0) {
+			// US_JLOG_ERROR("client", "Session %p aplay ring is full", client->session);
+			return;
+		}
+		us_au_encoded_s *enc = ring->items[ri];
+		if ((uz)size < US_ARRAY_LEN(enc->data)) {
+			memcpy(enc->data, data, size);
+			enc->used = size;
+		} else {
+			enc->used = 0;
+		}
+		us_ring_producer_release(ring, ri);
+	}
+}
+
+static void *_video_thread(void *v_client) {
+	US_THREAD_SETTLE("us_cx_vid");
+	return _video_or_acap_thread(v_client, true);
+}
+
+static void *_acap_thread(void *v_client) {
+	US_THREAD_SETTLE("us_cx_ac");
+	return _video_or_acap_thread(v_client, false);
+}
+
+static void *_video_or_acap_thread(void *v_client, bool video) {
+	us_janus_client_s *const client = v_client;
+	us_ring_s *const ring = (video ? client->video_ring : client->acap_ring);
+	assert(ring != NULL);
+
+	while (!atomic_load(&client->stop)) {
+		const int ri = us_ring_consumer_acquire(ring, 0.1);
+		if (ri < 0) {
+			continue;
+		}
+		us_rtp_s rtp;
+		memcpy(&rtp, ring->items[ri], sizeof(us_rtp_s));
+		us_ring_consumer_release(ring, ri);
+
+		if (
+			atomic_load(&client->transmit)
+			&& (video || atomic_load(&client->transmit_acap))
+		) {
+			janus_plugin_rtp packet = {
+				.video = rtp.video,
+				.buffer = (char*)rtp.datagram,
+				.length = rtp.used,
+#				if JANUS_PLUGIN_API_VERSION >= 100
+				// The uStreamer Janus plugin places video in stream index 0 and audio
+				// (if available) in stream index 1.
+				.mindex = (rtp.video ? 0 : 1),
+#				endif
+			};
+			janus_plugin_rtp_extensions_reset(&packet.extensions);
+
+			if (rtp.first_of_frame) {
+				if (rtp.zero_playout_delay) {
+					// https://github.com/pikvm/pikvm/issues/784
+					packet.extensions.min_delay = 0;
+					packet.extensions.max_delay = 0;
+				} else {
+					// Эти дефолты используются в Chrome/Safari/Firefox.
+					// Работает всё одинаково, потому что у них общая кодовая база WebRTC.
+					packet.extensions.min_delay = 0;
+					packet.extensions.max_delay = 1000; // == 10s, i.e. 10ms granularity
+				}
+			}
+
+			if (rtp.video && rtp.first_of_frame) {
+				packet.extensions.abs_capture_ts = rtp.grab_ntp_ts;
+			}
+
+			if (rtp.video && rtp.last_of_frame) {
+				uint video_orient = atomic_load(&client->video_orient);
+				if (video_orient != 0) {
+					// The extension rotates the video clockwise, but want it counterclockwise.
+					// It's more intuitive for people who have seen a protractor at least once in their life.
+					if (video_orient == 90) {
+						video_orient = 270;
+					} else if (video_orient == 270) {
+						video_orient = 90;
+					}
+					packet.extensions.video_rotation = video_orient;
+				}
+			}
+
+			client->gw->relay_rtp(client->session, &packet);
+		}
+	}
+	return NULL;
+}
+
+static void *_aplay_thread(void *v_client) {
+	US_THREAD_SETTLE("us_cx_ap");
+
+	us_janus_client_s *const client = v_client;
+
+	int err;
+	OpusDecoder *dec = opus_decoder_create(US_RTP_OPUS_HZ, US_RTP_OPUS_CH, &err);
+	assert(err == 0);
+
+	while (!atomic_load(&client->stop)) {
+		const int in_ri = us_ring_consumer_acquire(client->aplay_enc_ring, 0.1);
+		if (in_ri < 0) {
+			continue;
+		}
+		us_au_encoded_s *in = client->aplay_enc_ring->items[in_ri];
+
+		if (in->used == 0) {
+			us_ring_consumer_release(client->aplay_enc_ring, in_ri);
+			continue;
+		}
+
+		const int out_ri = us_ring_producer_acquire(client->aplay_pcm_ring, 0);
+		if (out_ri < 0) {
+			US_JLOG_ERROR("aplay", "OPUS decoder queue is full");
+			us_ring_consumer_release(client->aplay_enc_ring, in_ri);
+			continue;
+		}
+		us_au_pcm_s *out = client->aplay_pcm_ring->items[out_ri];
+
+		const int frames = opus_decode(dec, in->data, in->used, out->data, US_AU_HZ_TO_FRAMES(US_RTP_OPUS_HZ), 0);
+		us_ring_consumer_release(client->aplay_enc_ring, in_ri);
+
+		if (frames > 0) {
+			out->frames = frames;
+		} else {
+			out->frames = 0;
+			US_JLOG_PERROR_OPUS(frames, "aplay", "Fatal: Can't decode OPUS to PCM frame");
+		}
+		us_ring_producer_release(client->aplay_pcm_ring, out_ri);
+	}
+
+	opus_decoder_destroy(dec);
+	return NULL;
+}

janus/src/client.h

@@ -0,0 +1,65 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#include <stdatomic.h>
+
+#include <pthread.h>
+#include <janus/plugins/plugin.h>
+
+#include "uslibs/types.h"
+#include "uslibs/list.h"
+#include "uslibs/ring.h"
+
+#include "rtp.h"
+
+
+typedef struct {
+	janus_callbacks			*gw;
+	janus_plugin_session	*session;
+	atomic_bool				transmit;
+	atomic_bool				transmit_acap;
+	atomic_bool				transmit_aplay;
+	atomic_uint				video_orient;
+
+	pthread_t				video_tid;
+	pthread_t				acap_tid;
+	pthread_t				aplay_tid;
+	atomic_bool				stop;
+
+	us_ring_s				*video_ring;
+	us_ring_s				*acap_ring;
+
+	us_ring_s				*aplay_enc_ring;
+	u16						aplay_seq_next;
+	us_ring_s				*aplay_pcm_ring;
+
+    US_LIST_DECLARE;
+} us_janus_client_s;
+
+
+us_janus_client_s *us_janus_client_init(janus_callbacks *gw, janus_plugin_session *session);
+void us_janus_client_destroy(us_janus_client_s *client);
+
+void us_janus_client_send(us_janus_client_s *client, const us_rtp_s *rtp);
+void us_janus_client_recv(us_janus_client_s *client, janus_plugin_rtp *packet);

janus/src/config.c

@@ -0,0 +1,124 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <janus/config.h>
+#include <janus/plugins/plugin.h>
+
+#include "uslibs/types.h"
+#include "uslibs/tools.h"
+
+#include "const.h"
+#include "logging.h"
+
+
+static char *_get_value(janus_config *jcfg, const char *section, const char *option);
+static uint _get_uint(janus_config *jcfg, const char *section, const char *option, uint def);
+// static bool _get_bool(janus_config *jcfg, const char *section, const char *option, bool def);
+
+
+us_config_s *us_config_init(const char *config_dir_path) {
+	us_config_s *config;
+	US_CALLOC(config, 1);
+
+	char *config_file_path;
+	janus_config *jcfg = NULL;
+
+	US_ASPRINTF(config_file_path, "%s/%s.jcfg", config_dir_path, US_PLUGIN_PACKAGE);
+	US_JLOG_INFO("config", "Reading config file '%s' ...", config_file_path);
+
+	jcfg = janus_config_parse(config_file_path);
+	if (jcfg == NULL) {
+		US_JLOG_ERROR("config", "Can't read config");
+		goto error;
+	}
+	janus_config_print(jcfg);
+
+	if ((config->video_sink_name = _get_value(jcfg, "video", "sink")) == NULL) {
+		US_JLOG_ERROR("config", "Missing config value: video.sink");
+		goto error;
+	}
+	if ((config->acap_dev_name = _get_value(jcfg, "acap", "device")) != NULL) {
+		config->acap_hz = _get_uint(jcfg, "acap", "sampling_rate", 0);
+		config->tc358743_dev_path = _get_value(jcfg, "acap", "tc358743");
+		if (config->acap_hz == 0 && config->tc358743_dev_path == NULL) {
+			US_JLOG_ERROR("config", "Either acap.sampling_rate or acap.tc358743 required");
+			goto error;
+		}
+		config->aplay_dev_name = _get_value(jcfg, "aplay", "device");
+	}
+
+	goto ok;
+
+error:
+	US_DELETE(config, us_config_destroy);
+
+ok:
+	US_DELETE(jcfg, janus_config_destroy);
+	free(config_file_path);
+	return config;
+}
+
+void us_config_destroy(us_config_s *config) {
+	US_DELETE(config->video_sink_name, free);
+	US_DELETE(config->acap_dev_name, free);
+	US_DELETE(config->tc358743_dev_path, free);
+	US_DELETE(config->aplay_dev_name, free);
+	free(config);
+}
+
+static char *_get_value(janus_config *jcfg, const char *section, const char *option) {
+	janus_config_category *section_obj = janus_config_get_create(jcfg, NULL, janus_config_type_category, section);
+	janus_config_item *option_obj = janus_config_get(jcfg, section_obj, janus_config_type_item, option);
+	if (option_obj == NULL || option_obj->value == NULL || option_obj->value[0] == '\0') {
+		return NULL;
+	}
+	return us_strdup(option_obj->value);
+}
+
+static uint _get_uint(janus_config *jcfg, const char *section, const char *option, uint def) {
+	char *const tmp = _get_value(jcfg, section, option);
+	uint value = def;
+	if (tmp != NULL) {
+		errno = 0;
+		value = (uint)strtoul(tmp, NULL, 10);
+		if (errno != 0) {
+			value = def;
+		}
+		free(tmp);
+	}
+	return value;
+}
+
+/*static bool _get_bool(janus_config *jcfg, const char *section, const char *option, bool def) {
+	char *const tmp = _get_value(jcfg, section, option);
+	bool value = def;
+	if (tmp != NULL) {
+		value = (!strcasecmp(tmp, "1") || !strcasecmp(tmp, "true") || !strcasecmp(tmp, "yes"));
+		free(tmp);
+	}
+	return value;
+}*/

janus/src/config.h

@@ -0,0 +1,41 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+
+#include "uslibs/types.h"
+
+
+typedef struct {
+	char	*video_sink_name;
+
+	char	*acap_dev_name;
+	uint	acap_hz;
+	char	*tc358743_dev_path;
+
+	char	*aplay_dev_name;
+} us_config_s;
+
+
+us_config_s *us_config_init(const char *config_dir_path);
+void us_config_destroy(us_config_s *config);

janus/src/const.h

@@ -0,0 +1,26 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#define US_PLUGIN_NAME		"ustreamer"
+#define US_PLUGIN_PACKAGE	"janus.plugin.ustreamer"

janus/src/logging.h

@@ -0,0 +1,43 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include <janus/plugins/plugin.h>
+
+#include "uslibs/tools.h"
+
+#include "const.h"
+
+
+#define US_JLOG_INFO(x_prefix, x_msg, ...)	JANUS_LOG(LOG_INFO, "== %s/%-9s -- " x_msg "\n", US_PLUGIN_NAME, x_prefix, ##__VA_ARGS__)
+#define US_JLOG_WARN(x_prefix, x_msg, ...)	JANUS_LOG(LOG_WARN, "== %s/%-9s -- " x_msg "\n", US_PLUGIN_NAME, x_prefix, ##__VA_ARGS__)
+#define US_JLOG_ERROR(x_prefix, x_msg, ...)	JANUS_LOG(LOG_ERR, "== %s/%-9s -- " x_msg "\n", US_PLUGIN_NAME, x_prefix, ##__VA_ARGS__)
+
+#define US_JLOG_PERROR(x_prefix, x_msg, ...) { \
+		char *const m_perror_str = us_errno_to_string(errno); \
+		JANUS_LOG(LOG_ERR, "[%s/%-9s] " x_msg ": %s\n", US_PLUGIN_NAME, x_prefix, ##__VA_ARGS__, m_perror_str); \
+		free(m_perror_str); \
+	}
+
+// We don't include alsa, speex and opus headers here
+#define US_JLOG_PERROR_ALSA(_err, _prefix, _msg, ...)	US_JLOG_ERROR(_prefix, _msg ": %s", ##__VA_ARGS__, snd_strerror(_err))
+#define US_JLOG_PERROR_RES(_err, _prefix, _msg, ...)	US_JLOG_ERROR(_prefix, _msg ": %s", ##__VA_ARGS__, speex_resampler_strerror(_err))
+#define US_JLOG_PERROR_OPUS(_err, _prefix, _msg, ...)	US_JLOG_ERROR(_prefix, _msg ": %s", ##__VA_ARGS__, opus_strerror(_err))

janus/src/memsinkfd.c

@@ -0,0 +1,80 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "memsinkfd.h"
+
+#include <unistd.h>
+
+#include <linux/videodev2.h>
+
+#include "uslibs/types.h"
+#include "uslibs/errors.h"
+#include "uslibs/tools.h"
+#include "uslibs/frame.h"
+#include "uslibs/memsinksh.h"
+
+#include "logging.h"
+
+
+int us_memsink_fd_wait_frame(int fd, us_memsink_shared_s *mem, u64 last_id) {
+	const ldf deadline_ts = us_get_now_monotonic() + 1; // wait_timeout
+	ldf now_ts;
+	do {
+		const int result = us_flock_timedwait_monotonic(fd, 1); // lock_timeout
+		now_ts = us_get_now_monotonic();
+		if (result < 0 && errno != EWOULDBLOCK) {
+			US_JLOG_PERROR("video", "Can't lock memsink");
+			return -1;
+		} else if (result == 0) {
+			if (mem->magic == US_MEMSINK_MAGIC && mem->version == US_MEMSINK_VERSION && mem->id != last_id) {
+				return 0;
+			}
+			if (flock(fd, LOCK_UN) < 0) {
+				US_JLOG_PERROR("video", "Can't unlock memsink");
+				return -1;
+			}
+		}
+		usleep(1000); // lock_polling
+	} while (now_ts < deadline_ts);
+	return US_ERROR_NO_DATA;
+}
+
+int us_memsink_fd_get_frame(int fd, us_memsink_shared_s *mem, us_frame_s *frame, u64 *frame_id, bool key_required) {
+	us_frame_set_data(frame, us_memsink_get_data(mem), mem->used);
+	US_FRAME_COPY_META(mem, frame);
+	*frame_id = mem->id;
+	mem->last_client_ts = us_get_now_monotonic();
+	if (key_required) {
+		mem->key_requested = true;
+	}
+
+	bool retval = 0;
+	if (frame->format != V4L2_PIX_FMT_H264) {
+		US_JLOG_ERROR("video", "Got non-H264 frame from memsink");
+		retval = -1;
+	}
+	if (flock(fd, LOCK_UN) < 0) {
+		US_JLOG_PERROR("video", "Can't unlock memsink");
+		retval = -1;
+	}
+	return retval;
+}

janus/src/memsinkfd.h

@@ -0,0 +1,31 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#include "uslibs/types.h"
+#include "uslibs/frame.h"
+#include "uslibs/memsinksh.h"
+
+
+int us_memsink_fd_wait_frame(int fd, us_memsink_shared_s *mem, u64 last_id);
+int us_memsink_fd_get_frame(int fd, us_memsink_shared_s *mem, us_frame_s *frame, u64 *frame_id, bool key_required);

janus/src/plugin.c

@@ -0,0 +1,771 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include <stdatomic.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <assert.h>
+
+#include <sys/mman.h>
+#include <sys/stat.h>
+
+#include <pthread.h>
+#include <jansson.h>
+#include <janus/plugins/plugin.h>
+#include <janus/rtp.h>
+#include <janus/rtcp.h>
+#include <alsa/asoundlib.h>
+
+#include "uslibs/types.h"
+#include "uslibs/const.h"
+#include "uslibs/errors.h"
+#include "uslibs/tools.h"
+#include "uslibs/threading.h"
+#include "uslibs/list.h"
+#include "uslibs/ring.h"
+#include "uslibs/memsinksh.h"
+#include "uslibs/tc358743.h"
+
+#include "const.h"
+#include "logging.h"
+#include "client.h"
+#include "au.h"
+#include "acap.h"
+#include "rtp.h"
+#include "rtpv.h"
+#include "rtpa.h"
+#include "sdp.h"
+#include "memsinkfd.h"
+#include "config.h"
+
+
+static const char *const	default_ice_url = "stun:stun.l.google.com:19302";
+
+static us_config_s		*_g_config = NULL;
+static const useconds_t	_g_watchers_polling = 100000;
+
+static us_janus_client_s	*_g_clients = NULL;
+static janus_callbacks		*_g_gw = NULL;
+static us_ring_s			*_g_video_ring = NULL;
+static us_rtpv_s			*_g_rtpv = NULL;
+static us_rtpa_s			*_g_rtpa = NULL;
+
+static pthread_t		_g_video_rtp_tid;
+static atomic_bool		_g_video_rtp_tid_created = false;
+static pthread_t		_g_video_sink_tid;
+static atomic_bool		_g_video_sink_tid_created = false;
+static pthread_t		_g_acap_tid;
+static atomic_bool		_g_acap_tid_created = false;
+static pthread_t		_g_aplay_tid;
+static atomic_bool		_g_aplay_tid_created = false;
+
+static pthread_mutex_t	_g_video_lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t	_g_acap_lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t	_g_aplay_lock = PTHREAD_MUTEX_INITIALIZER;
+static atomic_bool		_g_ready = false;
+static atomic_bool		_g_stop = false;
+static atomic_bool		_g_has_watchers = false;
+static atomic_bool		_g_has_listeners = false;
+static atomic_bool		_g_has_speakers = false;
+static atomic_bool		_g_key_required = false;
+
+
+#define _LOCK_VIDEO		US_MUTEX_LOCK(_g_video_lock)
+#define _UNLOCK_VIDEO	US_MUTEX_UNLOCK(_g_video_lock)
+
+#define _LOCK_ACAP		US_MUTEX_LOCK(_g_acap_lock)
+#define _UNLOCK_ACAP	US_MUTEX_UNLOCK(_g_acap_lock)
+
+#define _LOCK_APLAY		US_MUTEX_LOCK(_g_aplay_lock)
+#define _UNLOCK_APLAY	US_MUTEX_UNLOCK(_g_aplay_lock)
+
+#define _LOCK_ALL		{ _LOCK_VIDEO; _LOCK_ACAP; _LOCK_APLAY; }
+#define _UNLOCK_ALL		{ _UNLOCK_APLAY; _UNLOCK_ACAP; _UNLOCK_VIDEO; }
+
+#define _READY			atomic_load(&_g_ready)
+#define _STOP			atomic_load(&_g_stop)
+#define _HAS_WATCHERS	atomic_load(&_g_has_watchers)
+#define _HAS_LISTENERS	atomic_load(&_g_has_listeners)
+#define _HAS_SPEAKERS	atomic_load(&_g_has_speakers)
+
+#define _IF_DISABLED(...) { if (!_READY || _STOP) { __VA_ARGS__ } }
+
+
+janus_plugin *create(void);
+
+
+static void *_video_rtp_thread(void *arg) {
+	(void)arg;
+	US_THREAD_SETTLE("us_p_rtpv");
+	atomic_store(&_g_video_rtp_tid_created, true);
+
+	while (!_STOP) {
+		const int ri = us_ring_consumer_acquire(_g_video_ring, 0.1);
+		if (ri >= 0) {
+			const us_frame_s *const frame = _g_video_ring->items[ri];
+			_LOCK_VIDEO;
+			const bool zero_playout_delay = (frame->gop == 0);
+			us_rtpv_wrap(_g_rtpv, frame, zero_playout_delay);
+			_UNLOCK_VIDEO;
+			us_ring_consumer_release(_g_video_ring, ri);
+		}
+	}
+	return NULL;
+}
+
+static void *_video_sink_thread(void *arg) {
+	(void)arg;
+	US_THREAD_SETTLE("us_p_vsink");
+	atomic_store(&_g_video_sink_tid_created, true);
+
+	us_frame_s *drop = us_frame_init();
+	u64 frame_id = 0;
+	int once = 0;
+
+	while (!_STOP) {
+		if (!_HAS_WATCHERS) {
+			US_ONCE({ US_JLOG_INFO("video", "No active watchers, memsink disconnected"); });
+			usleep(_g_watchers_polling);
+			continue;
+		}
+
+		int fd = -1;
+		us_memsink_shared_s *mem = NULL;
+
+		const uz data_size = us_memsink_calculate_size(_g_config->video_sink_name);
+		if (data_size == 0) {
+			US_ONCE({ US_JLOG_ERROR("video", "Invalid memsink object suffix"); });
+			goto close_memsink;
+		}
+
+		if ((fd = shm_open(_g_config->video_sink_name, O_RDWR, 0)) <= 0) {
+			US_ONCE({ US_JLOG_PERROR("video", "Can't open memsink"); });
+			goto close_memsink;
+		}
+
+		if ((mem = us_memsink_shared_map(fd, data_size)) == NULL) {
+			US_ONCE({ US_JLOG_PERROR("video", "Can't map memsink"); });
+			goto close_memsink;
+		}
+
+		once = 0;
+
+		US_JLOG_INFO("video", "Memsink opened; reading frames ...");
+		while (!_STOP && _HAS_WATCHERS) {
+			const int waited = us_memsink_fd_wait_frame(fd, mem, frame_id);
+			if (waited == 0) {
+				const int ri = us_ring_producer_acquire(_g_video_ring, 0);
+				us_frame_s *frame;
+				if (ri >= 0) {
+					frame = _g_video_ring->items[ri];
+				} else {
+					US_ONCE({ US_JLOG_PERROR("video", "Video ring is full"); });
+					frame = drop;
+				}
+
+				const int got = us_memsink_fd_get_frame(fd, mem, frame, &frame_id, atomic_load(&_g_key_required));
+				if (ri >= 0) {
+					us_ring_producer_release(_g_video_ring, ri);
+				}
+				if (got < 0) {
+					goto close_memsink;
+				}
+
+				if (ri >= 0 && frame->key) {
+					atomic_store(&_g_key_required, false);
+				}
+			} else if (waited != US_ERROR_NO_DATA) {
+				goto close_memsink;
+			}
+		}
+
+	close_memsink:
+		if (mem != NULL) {
+			us_memsink_shared_unmap(mem, data_size);
+			mem = NULL;
+		}
+		US_CLOSE_FD(fd);
+		US_JLOG_INFO("video", "Memsink closed");
+		sleep(1); // error_delay
+	}
+
+	us_frame_destroy(drop);
+	return NULL;
+}
+
+static int _get_acap_hz(uint *hz) {
+	if (_g_config->acap_hz != 0) {
+		*hz = _g_config->acap_hz;
+		return 0;
+	}
+	if (_g_config->tc358743_dev_path == NULL) {
+		US_JLOG_ERROR("acap", "No configured sampling rate");
+		return -1;
+	}
+	int fd;
+	if ((fd = open(_g_config->tc358743_dev_path, O_RDWR)) < 0) {
+		US_JLOG_PERROR("acap", "Can't open TC358743 V4L2 device");
+		return -1;
+	}
+	const int checked = us_tc358743_xioctl_get_audio_hz(fd, hz);
+	if (checked < 0) {
+		US_JLOG_PERROR("acap", "Can't check TC358743 audio state (%d)", checked);
+		close(fd);
+		return -1;
+	}
+	close(fd);
+	return 0;
+}
+
+static void *_acap_thread(void *arg) {
+	(void)arg;
+	US_THREAD_SETTLE("us_p_ac");
+	atomic_store(&_g_acap_tid_created, true);
+
+	assert(_g_config->acap_dev_name != NULL);
+	assert(_g_rtpa != NULL);
+
+	int once = 0;
+
+	while (!_STOP) {
+		if (!_HAS_WATCHERS || !_HAS_LISTENERS) {
+			usleep(_g_watchers_polling);
+			continue;
+		}
+
+		uint hz = 0;
+		us_acap_s *acap = NULL;
+
+		if (!us_au_probe(_g_config->acap_dev_name)) {
+			US_ONCE({ US_JLOG_ERROR("acap", "No PCM capture device"); });
+			goto close_acap;
+		}
+		if (_get_acap_hz(&hz) < 0) {
+			goto close_acap;
+		}
+		if (hz == 0) {
+			US_ONCE({ US_JLOG_INFO("acap", "No audio presented from the host"); });
+			goto close_acap;
+		}
+		US_ONCE({ US_JLOG_INFO("acap", "Detected host audio"); });
+		if ((acap = us_acap_init(_g_config->acap_dev_name, hz)) == NULL) {
+			goto close_acap;
+		}
+
+		once = 0;
+
+		while (!_STOP && _HAS_WATCHERS && _HAS_LISTENERS) {
+			if (_get_acap_hz(&hz) < 0 || acap->pcm_hz != hz) {
+				goto close_acap;
+			}
+			uz size = US_RTP_TOTAL_SIZE - US_RTP_HEADER_SIZE;
+			u8 data[size];
+			u64 pts;
+			const int result = us_acap_get_encoded(acap, data, &size, &pts);
+			if (result == 0) {
+				_LOCK_ACAP;
+				us_rtpa_wrap(_g_rtpa, data, size, pts);
+				_UNLOCK_ACAP;
+			} else if (result == -1) {
+				goto close_acap;
+			}
+		}
+
+	close_acap:
+		US_DELETE(acap, us_acap_destroy);
+		sleep(1); // error_delay
+	}
+	return NULL;
+}
+
+static void *_aplay_thread(void *arg) {
+	(void)arg;
+	US_THREAD_SETTLE("us_p_ap");
+	atomic_store(&_g_aplay_tid_created, true);
+
+	assert(_g_config->aplay_dev_name != NULL);
+
+	int once = 0;
+
+	while (!_STOP) {
+		snd_pcm_t *dev = NULL;
+		bool skip = true;
+
+		while (!_STOP) {
+			usleep((US_AU_FRAME_MS / 4) * 1000);
+
+			us_au_pcm_s mixed = {0};
+			_LOCK_APLAY;
+			US_LIST_ITERATE(_g_clients, client, {
+				us_au_pcm_s last = {0};
+				do {
+					const int ri = us_ring_consumer_acquire(client->aplay_pcm_ring, 0);
+					if (ri >= 0) {
+						const us_au_pcm_s *pcm = client->aplay_pcm_ring->items[ri];
+						memcpy(&last, pcm, sizeof(us_au_pcm_s));
+						us_ring_consumer_release(client->aplay_pcm_ring, ri);
+					} else {
+						break;
+					}
+				} while (skip && !_STOP);
+				us_au_pcm_mix(&mixed, &last);
+				// US_JLOG_INFO("++++++", "mixed %p", client);
+			});
+			_UNLOCK_APLAY;
+			// US_JLOG_INFO("++++++", "--------------");
+
+			if (skip) {
+				static uint skipped = 0;
+				if (skipped < (1000 / (US_AU_FRAME_MS / 4))) {
+					++skipped;
+					continue;
+				} else {
+					skipped = 0;
+				}
+			}
+
+			if (!_HAS_WATCHERS || !_HAS_LISTENERS || !_HAS_SPEAKERS) {
+				goto close_aplay;
+			}
+
+			if (dev == NULL) {
+				if (!us_au_probe(_g_config->aplay_dev_name)) {
+					US_ONCE({ US_JLOG_ERROR("aplay", "No PCM playback device"); });
+					goto close_aplay;
+				}
+
+				int err = snd_pcm_open(&dev, _g_config->aplay_dev_name, SND_PCM_STREAM_PLAYBACK, 0);
+				if (err < 0) {
+					US_ONCE({ US_JLOG_PERROR_ALSA(err, "aplay", "Can't open PCM playback"); });
+					goto close_aplay;
+				}
+
+				err = snd_pcm_set_params(dev, SND_PCM_FORMAT_S16_LE, SND_PCM_ACCESS_RW_INTERLEAVED,
+					US_RTP_OPUS_CH, US_RTP_OPUS_HZ, 1 /* soft resample */, 50000 /* 50000 = 0.05sec */
+				);
+				if (err < 0) {
+					US_ONCE({ US_JLOG_PERROR_ALSA(err, "aplay", "Can't configure PCM playback"); });
+					goto close_aplay;
+				}
+
+				US_JLOG_INFO("aplay", "Playback opened, playing ...");
+				once = 0;
+			}
+
+			if (dev != NULL && mixed.frames > 0) {
+				snd_pcm_sframes_t frames = snd_pcm_writei(dev, mixed.data, mixed.frames);
+				if (frames < 0) {
+					frames = snd_pcm_recover(dev, frames, 1);
+				} else {
+					if (once != 0) {
+						US_JLOG_INFO("aplay", "Playing resumed (snd_pcm_writei) ...");
+					}
+					once = 0;
+					skip = false;
+				}
+				if (frames < 0) {
+					US_ONCE({ US_JLOG_PERROR_ALSA(frames, "aplay", "Can't play to PCM playback"); });
+					if (frames == -ENODEV) {
+						goto close_aplay;
+					}
+					skip = true;
+				} else {
+					if (once != 0) {
+						US_JLOG_INFO("aplay", "Playing resumed (snd_pcm_recover) ...");
+					}
+					once = 0;
+					skip = false;
+				}
+			}
+		}
+
+	close_aplay:
+		if (dev != NULL) {
+			US_DELETE(dev, snd_pcm_close);
+			US_JLOG_INFO("aplay", "Playback closed");
+		}
+	}
+	return NULL;
+}
+
+static void _relay_rtp_clients(const us_rtp_s *rtp) {
+	US_LIST_ITERATE(_g_clients, client, {
+		us_janus_client_send(client, rtp);
+	});
+}
+
+static void _alsa_quiet(const char *file, int line, const char *func, int err, const char *fmt, ...) {
+	(void)file;
+	(void)line;
+	(void)func;
+	(void)err;
+	(void)fmt;
+}
+
+static int _plugin_init(janus_callbacks *gw, const char *config_dir_path) {
+	// https://groups.google.com/g/meetecho-janus/c/xoWIQfaoJm8
+	// sysctl -w net.core.rmem_default=500000 
+	// sysctl -w net.core.wmem_default=500000 
+	// sysctl -w net.core.rmem_max=1000000 
+	// sysctl -w net.core.wmem_max=1000000
+
+	US_JLOG_INFO("main", "Initializing PiKVM uStreamer plugin %s ...", US_VERSION);
+	if (gw == NULL || config_dir_path == NULL || ((_g_config = us_config_init(config_dir_path)) == NULL)) {
+		return -1;
+	}
+	_g_gw = gw;
+
+	snd_lib_error_set_handler(_alsa_quiet);
+
+	US_RING_INIT_WITH_ITEMS(_g_video_ring, 64, us_frame_init);
+	_g_rtpv = us_rtpv_init(_relay_rtp_clients);
+	if (_g_config->acap_dev_name != NULL) {
+		_g_rtpa = us_rtpa_init(_relay_rtp_clients);
+		US_THREAD_CREATE(_g_acap_tid, _acap_thread, NULL);
+		if (_g_config->aplay_dev_name != NULL) {
+			US_THREAD_CREATE(_g_aplay_tid, _aplay_thread, NULL);
+		}
+	}
+	US_THREAD_CREATE(_g_video_rtp_tid, _video_rtp_thread, NULL);
+	US_THREAD_CREATE(_g_video_sink_tid, _video_sink_thread, NULL);
+
+	atomic_store(&_g_ready, true);
+	return 0;
+}
+
+static void _plugin_destroy(void) {
+	US_JLOG_INFO("main", "Destroying plugin ...");
+
+	atomic_store(&_g_stop, true);
+#	define JOIN(_tid) { if (atomic_load(&_tid##_created)) { US_THREAD_JOIN(_tid); } }
+	JOIN(_g_video_sink_tid);
+	JOIN(_g_video_rtp_tid);
+	JOIN(_g_acap_tid);
+	JOIN(_g_aplay_tid);
+#	undef JOIN
+
+	US_LIST_ITERATE(_g_clients, client, {
+		US_LIST_REMOVE(_g_clients, client);
+		us_janus_client_destroy(client);
+	});
+
+	US_RING_DELETE_WITH_ITEMS(_g_video_ring, us_frame_destroy);
+
+	US_DELETE(_g_rtpa, us_rtpa_destroy);
+	US_DELETE(_g_rtpv, us_rtpv_destroy);
+	US_DELETE(_g_config, us_config_destroy);
+}
+
+static void _plugin_create_session(janus_plugin_session *session, int *err) {
+	_IF_DISABLED({ *err = -1; return; });
+	_LOCK_ALL;
+	US_JLOG_INFO("main", "Creating session %p ...", session);
+	us_janus_client_s *const client = us_janus_client_init(_g_gw, session);
+	US_LIST_APPEND(_g_clients, client);
+	atomic_store(&_g_has_watchers, true);
+	_UNLOCK_ALL;
+}
+
+static void _plugin_destroy_session(janus_plugin_session* session, int *err) {
+	_IF_DISABLED({ *err = -1; return; });
+	_LOCK_ALL;
+	bool found = false;
+	bool has_watchers = false;
+	bool has_listeners = false;
+	bool has_speakers = false;
+	US_LIST_ITERATE(_g_clients, client, {
+		if (client->session == session) {
+			US_JLOG_INFO("main", "Removing session %p ...", session);
+			US_LIST_REMOVE(_g_clients, client);
+			us_janus_client_destroy(client);
+			found = true;
+		} else {
+			has_watchers = (has_watchers || atomic_load(&client->transmit));
+			has_listeners = (has_listeners || atomic_load(&client->transmit_acap));
+			has_speakers = (has_speakers || atomic_load(&client->transmit_aplay));
+		}
+	});
+	if (!found) {
+		US_JLOG_WARN("main", "No session %p", session);
+		*err = -2;
+	}
+	atomic_store(&_g_has_watchers, has_watchers);
+	atomic_store(&_g_has_listeners, has_listeners);
+	atomic_store(&_g_has_speakers, has_speakers);
+	_UNLOCK_ALL;
+}
+
+static json_t *_plugin_query_session(janus_plugin_session *session) {
+	_IF_DISABLED({ return NULL; });
+	json_t *info = NULL;
+	_LOCK_ALL;
+	US_LIST_ITERATE(_g_clients, client, {
+		if (client->session == session) {
+			info = json_string("session_found");
+			break;
+		}
+	});
+	_UNLOCK_ALL;
+	return info;
+}
+
+static void _set_transmit(janus_plugin_session *session, const char *msg, bool transmit) {
+	(void)msg;
+	_IF_DISABLED({ return; });
+	_LOCK_ALL;
+	bool found = false;
+	bool has_watchers = false;
+	US_LIST_ITERATE(_g_clients, client, {
+		if (client->session == session) {
+			atomic_store(&client->transmit, transmit);
+			// US_JLOG_INFO("main", "%s session %p", msg, session);
+			found = true;
+		}
+		has_watchers = (has_watchers || atomic_load(&client->transmit));
+	});
+	if (!found) {
+		US_JLOG_WARN("main", "No session %p", session);
+	}
+	atomic_store(&_g_has_watchers, has_watchers);
+	_UNLOCK_ALL;
+}
+
+static void _plugin_setup_media(janus_plugin_session *session) { _set_transmit(session, "Unmuted", true); }
+static void _plugin_hangup_media(janus_plugin_session *session) { _set_transmit(session, "Muted", false); }
+
+static struct janus_plugin_result *_plugin_handle_message(
+	janus_plugin_session *session, char *transaction, json_t *msg, json_t *jsep) {
+
+	janus_plugin_result_type result_type = JANUS_PLUGIN_OK;
+	char *result_msg = NULL;
+
+	if (session == NULL || msg == NULL) {
+		result_type = JANUS_PLUGIN_ERROR;
+		result_msg = (msg ? "No session" : "No message");
+		goto done;
+	}
+
+#	define PUSH_ERROR(x_error, x_reason) { \
+			/*US_JLOG_ERROR("main", "Message error in session %p: %s", session, x_reason);*/ \
+			json_t *m_event = json_object(); \
+			json_object_set_new(m_event, "ustreamer", json_string("event")); \
+			json_object_set_new(m_event, "error_code", json_integer(x_error)); \
+			json_object_set_new(m_event, "error", json_string(x_reason)); \
+			_g_gw->push_event(session, create(), NULL, m_event, NULL); \
+			json_decref(m_event); \
+		}
+
+	json_t *const request = json_object_get(msg, "request");
+	if (request == NULL) {
+		PUSH_ERROR(400, "Request missing");
+		goto done;
+	}
+
+	const char *const request_str = json_string_value(request);
+	if (request_str == NULL) {
+		PUSH_ERROR(400, "Request not a string");
+		goto done;
+	}
+	// US_JLOG_INFO("main", "Message: %s", request_str);
+
+#	define PUSH_STATUS(x_status, x_payload, x_jsep) { \
+			json_t *const m_event = json_object(); \
+			json_object_set_new(m_event, "ustreamer", json_string("event")); \
+			json_t *const m_result = json_object(); \
+			json_object_set_new(m_result, "status", json_string(x_status)); \
+			if (x_payload != NULL) { \
+				json_object_set(m_result, x_status, x_payload); \
+			} \
+			json_object_set_new(m_event, "result", m_result); \
+			_g_gw->push_event(session, create(), NULL, m_event, x_jsep); \
+			json_decref(m_event); \
+		}
+
+	if (!strcmp(request_str, "start")) {
+		PUSH_STATUS("started", NULL, NULL);
+
+	} else if (!strcmp(request_str, "stop")) {
+		PUSH_STATUS("stopped", NULL, NULL);
+
+	} else if (!strcmp(request_str, "watch")) {
+		uint video_orient = 0;
+		bool with_acap = false;
+		bool with_aplay = false;
+		{
+			json_t *const params = json_object_get(msg, "params");
+			if (params != NULL) {
+				{
+					json_t *const obj = json_object_get(params, "audio");
+					if (obj != NULL && json_is_boolean(obj)) {
+						with_acap = (us_au_probe(_g_config->acap_dev_name) && json_boolean_value(obj));
+					}
+				}
+				{
+					json_t *const obj = json_object_get(params, "mic");
+					if (obj != NULL && json_is_boolean(obj)) {
+						with_aplay = (us_au_probe(_g_config->aplay_dev_name) && json_boolean_value(obj));
+					}
+				}
+				{
+					json_t *const obj = json_object_get(params, "orientation");
+					if (obj != NULL && json_is_integer(obj)) {
+						video_orient = json_integer_value(obj);
+						switch (video_orient) {
+							case 90: case 180: case 270: break;
+							default: video_orient = 0; break;
+						}
+					}
+				}
+			}
+		}
+
+		{
+			char *const sdp = us_sdp_create(
+				_g_rtpv,
+				(with_acap ? _g_rtpa : NULL),
+				(with_acap && with_aplay));
+			json_t *const offer_jsep = json_pack("{ssss}", "type", "offer", "sdp", sdp);
+			PUSH_STATUS("started", NULL, offer_jsep);
+			json_decref(offer_jsep);
+			free(sdp);
+		}
+
+		{
+			_LOCK_ALL;
+			bool has_listeners = false;
+			bool has_speakers = false;
+			US_LIST_ITERATE(_g_clients, client, {
+				if (client->session == session) {
+					atomic_store(&client->transmit_acap, with_acap);
+					atomic_store(&client->transmit_aplay, with_aplay);
+					atomic_store(&client->video_orient, video_orient);
+				}
+				has_listeners = (has_listeners || atomic_load(&client->transmit_acap));
+				has_speakers = (has_speakers || atomic_load(&client->transmit_aplay));
+			});
+			atomic_store(&_g_has_listeners, has_listeners);
+			atomic_store(&_g_has_speakers, has_speakers);
+			_UNLOCK_ALL;
+		}
+
+	} else if (!strcmp(request_str, "features")) {
+		const char *const ice_url = getenv("JANUS_USTREAMER_WEB_ICE_URL");
+		const bool acap_avail = us_au_probe(_g_config->acap_dev_name);
+		json_t *const features = json_pack(
+			"{s:b, s:b, s:{s:s?}}",
+			"audio", acap_avail,
+			"mic", (acap_avail && us_au_probe(_g_config->aplay_dev_name)),
+			"ice", "url", (ice_url != NULL ? ice_url : default_ice_url)
+		);
+		PUSH_STATUS("features", features, NULL);
+		json_decref(features);
+
+	} else if (!strcmp(request_str, "key_required")) {
+		// US_JLOG_INFO("main", "Got key_required message");
+		atomic_store(&_g_key_required, true);
+
+	} else {
+		PUSH_ERROR(405, "Not implemented");
+	}
+
+done:
+	US_DELETE(transaction, free);
+	US_DELETE(msg, json_decref);
+	US_DELETE(jsep, json_decref);
+
+	return janus_plugin_result_new(
+		result_type, result_msg,
+		(result_type == JANUS_PLUGIN_OK ? json_pack("{sb}", "ok", 1) : NULL));
+
+#	undef PUSH_STATUS
+#	undef PUSH_ERROR
+}
+
+static void _plugin_incoming_rtp(janus_plugin_session *session, janus_plugin_rtp *packet) {
+	_IF_DISABLED({ return; });
+	if (session == NULL || packet == NULL || packet->video) {
+		return; // Accept only valid audio
+	}
+	_LOCK_APLAY;
+	US_LIST_ITERATE(_g_clients, client, {
+		if (client->session == session) {
+			us_janus_client_recv(client, packet);
+			break;
+		}
+	});
+	_UNLOCK_APLAY;
+}
+
+static void _plugin_incoming_rtcp(janus_plugin_session *session, janus_plugin_rtcp *packet) {
+	_IF_DISABLED({ return; });
+	if (session == NULL || packet == NULL || !packet->video) {
+		return; // Accept only valid video
+	}
+	if (janus_rtcp_has_pli(packet->buffer, packet->length)) {
+		// US_JLOG_INFO("main", "Got video PLI");
+		atomic_store(&_g_key_required, true);
+	}
+}
+
+
+// ***** Plugin *****
+
+static int _plugin_get_api_compatibility(void)		{ return JANUS_PLUGIN_API_VERSION; }
+static int _plugin_get_version(void)				{ return US_VERSION_U; }
+static const char *_plugin_get_version_string(void)	{ return US_VERSION; }
+static const char *_plugin_get_description(void)	{ return "PiKVM uStreamer Janus plugin for H.264 video"; }
+static const char *_plugin_get_name(void)			{ return US_PLUGIN_NAME; }
+static const char *_plugin_get_author(void)			{ return "Maxim Devaev <mdevaev@gmail.com>"; }
+static const char *_plugin_get_package(void)		{ return US_PLUGIN_PACKAGE; }
+
+janus_plugin *create(void) {
+#	pragma GCC diagnostic push
+#	pragma GCC diagnostic ignored "-Woverride-init"
+	static janus_plugin plugin = JANUS_PLUGIN_INIT(
+		.init = _plugin_init,
+		.destroy = _plugin_destroy,
+
+		.create_session = _plugin_create_session,
+		.destroy_session = _plugin_destroy_session,
+		.query_session = _plugin_query_session,
+
+		.setup_media = _plugin_setup_media,
+		.hangup_media = _plugin_hangup_media,
+
+		.handle_message = _plugin_handle_message,
+
+		.get_api_compatibility = _plugin_get_api_compatibility,
+		.get_version = _plugin_get_version,
+		.get_version_string = _plugin_get_version_string,
+		.get_description = _plugin_get_description,
+		.get_name = _plugin_get_name,
+		.get_author = _plugin_get_author,
+		.get_package = _plugin_get_package,
+
+		.incoming_rtp = _plugin_incoming_rtp,
+		.incoming_rtcp = _plugin_incoming_rtcp,
+	);
+#	pragma GCC diagnostic pop
+	return &plugin;
+}

janus/src/rtp.c

@@ -0,0 +1,65 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    This source file is partially based on this code:                       #
+#      - https://github.com/catid/kvm/blob/master/kvm_pipeline/src           #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "rtp.h"
+
+#include <stdlib.h>
+
+#include "uslibs/types.h"
+#include "uslibs/tools.h"
+
+
+us_rtp_s *us_rtp_init(void) {
+	us_rtp_s *rtp;
+	US_CALLOC(rtp, 1);
+	return rtp;
+}
+
+void us_rtp_destroy(us_rtp_s *rtp) {
+	free(rtp);
+}
+
+void us_rtp_assign(us_rtp_s *rtp, uint payload, bool video) {
+	rtp->payload = payload;
+	rtp->video = video;
+	rtp->ssrc = us_triple_u32(us_get_now_monotonic_u64());
+}
+
+void us_rtp_write_header(us_rtp_s *rtp, u32 pts, bool marked) {
+	u32 word0 = 0x80000000;
+	if (marked) {
+		word0 |= 1 << 23;
+	}
+	word0 |= (rtp->payload & 0x7F) << 16;
+	word0 |= rtp->seq;
+	++rtp->seq;
+
+#	define WRITE_BE_U32(x_offset, x_value) \
+		*((u32*)(rtp->datagram + x_offset)) = __builtin_bswap32(x_value)
+	WRITE_BE_U32(0, word0);
+	WRITE_BE_U32(4, pts);
+	WRITE_BE_U32(8, rtp->ssrc);
+#	undef WRITE_BE_U32
+}

janus/src/rtp.h

@@ -0,0 +1,69 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#include "uslibs/types.h"
+
+
+// Max RTP size for WebRTC is 1200 bytes:
+//   - https://stackoverflow.com/questions/47635545/why-webrtc-chose-rtp-max-packet-size-to-1200-bytes
+// But(!) Tailscale has 1200 MTU. So to fit it required to substract:
+// 1. possible RTP extensions (see sdp.c)
+// 2. additional SRTP fields (>= 10 bytes)
+// 3. UDP header (8 bytes)
+// 4. IPv6 header (40 bytes)
+// Finally it looks like 100 bytes for all above should be enough
+#define US_RTP_TOTAL_SIZE		(1200 - 100)
+#define US_RTP_HEADER_SIZE		12
+#define US_RTP_PAYLOAD_SIZE		(US_RTP_TOTAL_SIZE - US_RTP_HEADER_SIZE)
+
+#define US_RTP_H264_PAYLOAD		96
+#define US_RTP_OPUS_PAYLOAD		111
+
+#define US_RTP_OPUS_HZ			48000
+#define US_RTP_OPUS_CH			2
+
+
+typedef struct {
+	uint	payload;
+	bool	video;
+	u32		ssrc;
+
+	u16		seq;
+	u8		datagram[US_RTP_TOTAL_SIZE];
+	uz		used;
+
+	bool	first_of_frame;
+	bool	last_of_frame;
+	bool	zero_playout_delay;
+	u64		grab_ntp_ts;
+} us_rtp_s;
+
+typedef void (*us_rtp_callback_f)(const us_rtp_s *rtp);
+
+
+us_rtp_s *us_rtp_init(void);
+void us_rtp_destroy(us_rtp_s *rtp);
+
+void us_rtp_assign(us_rtp_s *rtp, uint payload, bool video);
+void us_rtp_write_header(us_rtp_s *rtp, u32 pts, bool marked);

janus/src/rtpa.c

@@ -0,0 +1,54 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "rtpa.h"
+
+#include <stdlib.h>
+
+#include "uslibs/types.h"
+#include "uslibs/tools.h"
+
+#include "rtp.h"
+
+
+us_rtpa_s *us_rtpa_init(us_rtp_callback_f callback) {
+	us_rtpa_s *rtpa;
+	US_CALLOC(rtpa, 1);
+	rtpa->rtp = us_rtp_init();
+	us_rtp_assign(rtpa->rtp, US_RTP_OPUS_PAYLOAD, false);
+	rtpa->callback = callback;
+	return rtpa;
+}
+
+void us_rtpa_destroy(us_rtpa_s *rtpa) {
+	us_rtp_destroy(rtpa->rtp);
+	free(rtpa);
+}
+
+void us_rtpa_wrap(us_rtpa_s *rtpa, const u8 *data, uz size, u32 pts) {
+    if (size + US_RTP_HEADER_SIZE <= US_RTP_TOTAL_SIZE) {
+        us_rtp_write_header(rtpa->rtp, pts, false);
+        memcpy(rtpa->rtp->datagram + US_RTP_HEADER_SIZE, data, size);
+		rtpa->rtp->used = size + US_RTP_HEADER_SIZE;
+        rtpa->callback(rtpa->rtp);
+	}
+}

janus/src/rtpa.h

@@ -0,0 +1,39 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#include "uslibs/types.h"
+
+#include "rtp.h"
+
+
+typedef struct {
+	us_rtp_s			*rtp;
+	us_rtp_callback_f	callback;
+} us_rtpa_s;
+
+
+us_rtpa_s *us_rtpa_init(us_rtp_callback_f callback);
+void us_rtpa_destroy(us_rtpa_s *rtpa);
+
+void us_rtpa_wrap(us_rtpa_s *rtpa, const u8 *data, uz size, u32 pts);

janus/src/rtpv.c

@@ -0,0 +1,191 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    This source file is partially based on this code:                       #
+#      - https://github.com/catid/kvm/blob/master/kvm_pipeline/src           #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "rtpv.h"
+
+#include <stdlib.h>
+#include <inttypes.h>
+#include <assert.h>
+
+#include <linux/videodev2.h>
+
+#include "uslibs/types.h"
+#include "uslibs/tools.h"
+#include "uslibs/frame.h"
+
+#include "rtp.h"
+
+
+void _rtpv_process_nalu(us_rtpv_s *rtpv, const u8 *data, uz size, u32 pts, bool marked);
+
+static sz _find_annexb(const u8 *data, uz size);
+
+
+us_rtpv_s *us_rtpv_init(us_rtp_callback_f callback) {
+	us_rtpv_s *rtpv;
+	US_CALLOC(rtpv, 1);
+	rtpv->rtp = us_rtp_init();
+	us_rtp_assign(rtpv->rtp, US_RTP_H264_PAYLOAD, true);
+	rtpv->callback = callback;
+	return rtpv;
+}
+
+void us_rtpv_destroy(us_rtpv_s *rtpv) {
+	us_rtp_destroy(rtpv->rtp);
+	free(rtpv);
+}
+
+#define _PRE 3 // Annex B prefix length
+
+void us_rtpv_wrap(us_rtpv_s *rtpv, const us_frame_s *frame, bool zero_playout_delay) {
+	// There is a complicated logic here but everything works as it should:
+	//   - https://github.com/pikvm/ustreamer/issues/115#issuecomment-893071775
+
+	assert(frame->format == V4L2_PIX_FMT_H264);
+
+	rtpv->rtp->first_of_frame = true;
+	rtpv->rtp->last_of_frame = false;
+	rtpv->rtp->zero_playout_delay = zero_playout_delay;
+	rtpv->rtp->grab_ntp_ts = us_get_now_ntp() - us_ld_to_ntp(us_get_now_monotonic() - frame->grab_begin_ts);
+
+	const u32 pts = us_get_now_monotonic_u64() * 9 / 100; // PTS units are in 90 kHz
+	sz last_offset = -_PRE;
+
+	while (true) { // Find and iterate by nalus
+		const uz next_start = last_offset + _PRE;
+		sz offset = _find_annexb(frame->data + next_start, frame->used - next_start);
+		if (offset < 0) {
+			break;
+		}
+		offset += next_start;
+
+		if (last_offset >= 0) {
+			const u8 *const data = frame->data + last_offset + _PRE;
+			uz size = offset - last_offset - _PRE;
+			if (data[size - 1] == 0) { // Check for extra 00
+				--size;
+			}
+			_rtpv_process_nalu(rtpv, data, size, pts, false);
+		}
+
+		last_offset = offset;
+	}
+
+	if (last_offset >= 0) {
+		const u8 *const data = frame->data + last_offset + _PRE;
+		uz size = frame->used - last_offset - _PRE;
+		_rtpv_process_nalu(rtpv, data, size, pts, true);
+	}
+}
+
+void _rtpv_process_nalu(us_rtpv_s *rtpv, const u8 *data, uz size, u32 pts, bool marked) {
+	const uint ref_idc = (data[0] >> 5) & 3;
+	const uint type = data[0] & 0x1F;
+	u8 *dg = rtpv->rtp->datagram;
+
+	// Set *_of_frame flags only for non-SPS/PPS packages
+/*
+#	define CALL_FOR_SERVICE { \
+			const bool m_fof = rtpv->rtp->first_of_frame; \
+			const bool m_lof = rtpv->rtp->last_of_frame; \
+			rtpv->rtp->first_of_frame = false; \
+			rtpv->rtp->last_of_frame = false; \
+			rtpv->callback(rtpv->rtp); \
+			rtpv->rtp->first_of_frame = m_fof; \
+			rtpv->rtp->last_of_frame = m_lof; \
+		}
+*/
+
+	if (size + US_RTP_HEADER_SIZE <= US_RTP_TOTAL_SIZE) {
+		us_rtp_write_header(rtpv->rtp, pts, marked);
+		memcpy(dg + US_RTP_HEADER_SIZE, data, size);
+		rtpv->rtp->used = size + US_RTP_HEADER_SIZE;
+//		if (type == 7 || type == 8) {
+//			CALL_FOR_SERVICE;
+//		} else {*/
+			rtpv->rtp->last_of_frame = true;
+			rtpv->callback(rtpv->rtp);
+			rtpv->rtp->first_of_frame = false;
+//		}
+		return;
+	}
+
+	const uz fu_overhead = US_RTP_HEADER_SIZE + 2; // FU-A overhead
+
+	const u8 *src = data + 1;
+	sz remaining = size - 1;
+
+	bool first = true;
+	while (remaining > 0) {
+		sz frag_size = US_RTP_TOTAL_SIZE - fu_overhead;
+		const bool last = (remaining <= frag_size);
+		if (last) {
+			frag_size = remaining;
+		}
+
+		us_rtp_write_header(rtpv->rtp, pts, (marked && last));
+
+		dg[US_RTP_HEADER_SIZE] = 28 | (ref_idc << 5);
+
+		u8 fu = type;
+		if (first) {
+			fu |= 0x80;
+		}
+		if (last) {
+			fu |= 0x40;
+		}
+		dg[US_RTP_HEADER_SIZE + 1] = fu;
+
+		memcpy(dg + fu_overhead, src, frag_size);
+		rtpv->rtp->used = fu_overhead + frag_size;
+//		if (type == 7 || type == 8) {
+//			CALL_FOR_SERVICE;
+//		} else {
+			rtpv->rtp->last_of_frame = last;
+			rtpv->callback(rtpv->rtp);
+			rtpv->rtp->first_of_frame = false;
+//		}
+
+		src += frag_size;
+		remaining -= frag_size;
+		first = false;
+	}
+
+#	undef CALL_FOR_SERVICE
+}
+
+static sz _find_annexb(const u8 *data, uz size) {
+	// Parses buffer for 00 00 01 start codes
+	if (size >= _PRE) {
+		for (uz index = 0; index <= size - _PRE; ++index) {
+			if (data[index] == 0 && data[index + 1] == 0 && data[index + 2] == 1) {
+				return index;
+			}
+		}
+	}
+	return -1;
+}
+
+#undef _PRE

janus/src/rtpv.h

@@ -0,0 +1,40 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#include "uslibs/types.h"
+#include "uslibs/frame.h"
+
+#include "rtp.h"
+
+
+typedef struct {
+	us_rtp_s			*rtp;
+	us_rtp_callback_f	callback;
+} us_rtpv_s;
+
+
+us_rtpv_s *us_rtpv_init(us_rtp_callback_f callback);
+void us_rtpv_destroy(us_rtpv_s *rtpv);
+
+void us_rtpv_wrap(us_rtpv_s *rtpv, const us_frame_s *frame, bool zero_playout_delay);

janus/src/sdp.c

@@ -0,0 +1,110 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "sdp.h"
+
+#include <inttypes.h>
+
+#include <janus/plugins/plugin.h>
+
+#include "uslibs/types.h"
+#include "uslibs/tools.h"
+
+#include "rtp.h"
+#include "rtpv.h"
+#include "rtpa.h"
+
+
+char *us_sdp_create(us_rtpv_s *rtpv, us_rtpa_s *rtpa, bool mic) {
+	char *video_sdp;
+	{
+		// https://tools.ietf.org/html/rfc6184
+		// https://github.com/meetecho/janus-gateway/issues/2443
+		const uint pl = rtpv->rtp->payload;
+		US_ASPRINTF(
+			video_sdp,
+			"m=video 1 RTP/SAVPF %u" RN
+			"c=IN IP4 0.0.0.0" RN
+			"a=rtpmap:%u H264/90000" RN
+			"a=fmtp:%u profile-level-id=42E01F;packetization-mode=1" RN
+			"a=rtcp-fb:%u nack" RN
+			"a=rtcp-fb:%u nack pli" RN
+			"a=rtcp-fb:%u goog-remb" RN
+			"a=mid:v" RN
+			"a=msid:video v" RN
+			"a=ssrc:%" PRIu32 " cname:ustreamer" RN
+			"a=extmap:1/sendonly urn:3gpp:video-orientation" RN
+			"a=extmap:2/sendonly http://www.webrtc.org/experiments/rtp-hdrext/playout-delay" RN
+			"a=extmap:3/sendonly http://www.webrtc.org/experiments/rtp-hdrext/abs-capture-time" RN
+			"a=sendonly" RN,
+			pl, pl, pl, pl, pl, pl,
+			rtpv->rtp->ssrc);
+	}
+
+	char *audio_sdp;
+	if (rtpa == NULL) {
+		audio_sdp = us_strdup("");
+	} else {
+		const uint pl = rtpa->rtp->payload;
+		US_ASPRINTF(
+			audio_sdp,
+			"m=audio 1 RTP/SAVPF %u" RN
+			"c=IN IP4 0.0.0.0" RN
+			"a=rtpmap:%u OPUS/%u/%u" RN
+			"a=fmtp:%u sprop-stereo=1" RN // useinbandfec=1
+			"a=rtcp-fb:%u nack" RN
+			"a=rtcp-fb:%u nack pli" RN
+			"a=rtcp-fb:%u goog-remb" RN
+			"a=mid:a" RN
+			"a=msid:audio a" RN
+			"a=ssrc:%" PRIu32 " cname:ustreamer" RN
+			"a=%s" RN,
+			pl, pl,
+			US_RTP_OPUS_HZ, US_RTP_OPUS_CH,
+			pl, pl, pl, pl,
+			rtpa->rtp->ssrc,
+			(mic ? "sendrecv" : "sendonly"));
+	}
+
+	char *sdp;
+	US_ASPRINTF(sdp,
+		"v=0" RN
+		"o=- %" PRIu64 " 1 IN IP4 0.0.0.0" RN
+		"s=PiKVM uStreamer" RN
+		"t=0 0" RN
+		"%s%s",
+		us_get_now_id() >> 1,
+#		if JANUS_PLUGIN_API_VERSION >= 100
+		// Place video SDP before audio SDP so that the video and audio streams
+		// have predictable indices, even if audio is not available.
+		// See also client.c.
+		video_sdp, audio_sdp
+#		else
+		// For versions of Janus prior to 1.x, place the audio SDP first.
+		audio_sdp, video_sdp
+#		endif
+	);
+
+	free(audio_sdp);
+	free(video_sdp);
+	return sdp;
+}

janus/src/sdp.h

@@ -0,0 +1,31 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#include "uslibs/types.h"
+
+#include "rtpv.h"
+#include "rtpa.h"
+
+
+char *us_sdp_create(us_rtpv_s *rtpv, us_rtpa_s *rtpa, bool mic);

janus/src/uslibs/array.h

@@ -0,0 +1 @@
+../../../src/libs/array.h

janus/src/uslibs/const.h

@@ -0,0 +1 @@
+../../../src/libs/const.h

janus/src/uslibs/errors.h

@@ -0,0 +1 @@
+../../../src/libs/errors.h

janus/src/uslibs/frame.c

@@ -0,0 +1 @@
+../../../src/libs/frame.c

janus/src/uslibs/frame.h

@@ -0,0 +1 @@
+../../../src/libs/frame.h

janus/src/uslibs/list.h

@@ -0,0 +1 @@
+../../../src/libs/list.h

janus/src/uslibs/memsinksh.c

@@ -0,0 +1 @@
+../../../src/libs/memsinksh.c

janus/src/uslibs/memsinksh.h

@@ -0,0 +1 @@
+../../../src/libs/memsinksh.h

janus/src/uslibs/queue.c

@@ -0,0 +1 @@
+../../../src/libs/queue.c

janus/src/uslibs/queue.h

@@ -0,0 +1 @@
+../../../src/libs/queue.h

janus/src/uslibs/ring.c

@@ -0,0 +1 @@
+../../../src/libs/ring.c

janus/src/uslibs/ring.h

@@ -0,0 +1 @@
+../../../src/libs/ring.h

janus/src/uslibs/tc358743.c

@@ -0,0 +1 @@
+../../../src/libs/tc358743.c

janus/src/uslibs/tc358743.h

@@ -0,0 +1 @@
+../../../src/libs/tc358743.h

janus/src/uslibs/threading.h

@@ -0,0 +1 @@
+../../../src/libs/threading.h

janus/src/uslibs/tools.h

@@ -0,0 +1 @@
+../../../src/libs/tools.h

janus/src/uslibs/types.h

@@ -0,0 +1 @@
+../../../src/libs/types.h

janus/src/uslibs/xioctl.h

@@ -0,0 +1 @@
+../../../src/libs/xioctl.h

linters/.dockerignore

@@ -0,0 +1,2 @@
+/.tox/
+/.mypy_cache/

linters/Dockerfile

@@ -0,0 +1,26 @@
+FROM archlinux/archlinux:base
+
+RUN mkdir -p /etc/pacman.d/hooks \
+	&& ln -s /dev/null /etc/pacman.d/hooks/30-systemd-tmpfiles.hook
+
+RUN echo 'Server = https://mirror.rackspace.com/archlinux/$repo/os/$arch' > /etc/pacman.d/mirrorlist
+
+RUN pacman -Syu --noconfirm \
+	&& pacman -S --needed --noconfirm \
+		vim \
+		git \
+		libjpeg \
+		libevent \
+		libutil-linux \
+		libbsd \
+		python \
+		python-pip \
+		python-tox \
+		cppcheck \
+		npm \
+	&& (pacman -Sc --noconfirm || true) \
+	&& rm -rf /var/cache/pacman/pkg/*
+
+RUN npm install htmlhint -g
+
+CMD /bin/bash

linters/cppcheck.h

@@ -0,0 +1,4 @@
+#define CHAR_BIT 8
+#define WITH_GPIO
+#define JANUS_PLUGIN_INIT(...) { __VA_ARGS__ }
+#define EVTHREAD_USE_PTHREADS_IMPLEMENTED 1

linters/flake8.ini

@@ -0,0 +1,9 @@
+[flake8]
+inline-quotes = double
+max-line-length = 160
+ignore = W503, E227, E241, E252, Q003
+# W503 line break before binary operator
+# E227 missing whitespace around bitwise or shift operator
+# E241 multiple spaces after
+# E252 missing whitespace around parameter equals
+# Q003 Change outer quotes to avoid escaping inner quotes

linters/mypy.ini

@@ -0,0 +1,5 @@
+[mypy]
+python_version = 3.14
+ignore_missing_imports = true
+disallow_untyped_defs = true
+strict_optional = true

linters/pylint.ini

@@ -0,0 +1,54 @@
+[MASTER]
+ignore = .git
+
+[DESIGN]
+min-public-methods = 0
+max-args = 10
+
+[TYPECHECK]
+ignored-classes=
+	AioQueue,
+
+[MESSAGES CONTROL]
+disable =
+	file-ignored,
+	locally-disabled,
+	fixme,
+	missing-docstring,
+	superfluous-parens,
+	duplicate-code,
+	broad-except,
+	redundant-keyword-arg,
+	wrong-import-order,
+	too-many-ancestors,
+	no-else-return,
+	len-as-condition,
+	unspecified-encoding,
+
+[REPORTS]
+msg-template = {symbol} -- {path}:{line}({obj}): {msg}
+
+[FORMAT]
+max-line-length = 160
+
+[BASIC]
+# Good variable names which should always be accepted, separated by a comma
+good-names = _, __, i, x, y, ws, make-html-h, make-ico-h
+
+# Regular expression matching correct method names
+method-rgx = [a-z_][a-z0-9_]{2,50}$
+
+# Regular expression matching correct function names
+function-rgx = [a-z_][a-z0-9_]{2,50}$
+
+# Regular expression which should only match correct module level names
+const-rgx = ([a-zA-Z_][a-zA-Z0-9_]*)$
+
+# Regular expression which should only match correct argument names
+argument-rgx = [a-z_][a-z0-9_]{1,30}$
+
+# Regular expression which should only match correct variable names
+variable-rgx = [a-z_][a-z0-9_]{1,30}$
+
+# Regular expression which should only match correct instance attribute names
+attr-rgx = [a-z_][a-z0-9_]{1,30}$

linters/tox.ini

@@ -0,0 +1,52 @@
+[tox]
+envlist = cppcheck, flake8, pylint, mypy, vulture, htmlhint
+skipsdist = true
+
+[testenv]
+basepython = python3.14
+changedir = /src
+
+[testenv:cppcheck]
+allowlist_externals = cppcheck
+commands = cppcheck \
+			--force \
+			--std=c17 \
+			--error-exitcode=1 \
+			--quiet \
+			--check-level=exhaustive \
+			--enable=warning,portability,performance,style \
+			--suppress=variableScope \
+			--inline-suppr \
+			--library=python \
+			--include=linters/cppcheck.h \
+		src python/src/*.? janus/src/*.?
+
+[testenv:flake8]
+allowlist_externals = bash
+commands = bash -c 'flake8 --config=linters/flake8.ini tools/*.py' python/*.py
+deps =
+	flake8
+	flake8-quotes
+
+[testenv:pylint]
+allowlist_externals = bash
+commands = bash -c 'pylint --rcfile=linters/pylint.ini --output-format=colorized --reports=no tools/*.py python/*.py'
+deps =
+	pylint
+	setuptools
+
+[testenv:mypy]
+allowlist_externals = bash
+commands = bash -c 'mypy --config-file=linters/mypy.ini tools/*.py python/*.py'
+deps =
+	mypy
+
+[testenv:vulture]
+allowlist_externals = bash
+commands = bash -c 'vulture tools/*.py python/*.py'
+deps =
+	vulture
+
+[testenv:htmlhint]
+allowlist_externals = htmlhint
+commands = htmlhint src/ustreamer/http/data/*.html

man/ustreamer-dump.1

@@ -0,0 +1,94 @@
+.\" Manpage for ustreamer-dump.
+.\" Open an issue or pull request to https://github.com/pikvm/ustreamer to correct errors or typos
+.TH USTREAMER-DUMP 1 "version 6.55" "January 2021"
+
+.SH NAME
+ustreamer-dump \- Dump uStreamer's memory sink to file
+
+.SH SYNOPSIS
+.B ustreamer-dump
+.RI [OPTIONS]
+
+.SH DESCRIPTION
+µStreamer-dump (\fBustreamer-dump\fP) writes a local stream from ustreamer to a file or redirect it to other utilities (such as \fBffmpeg\fR).
+
+.SH USAGE
+\fBustreamer\fR requires at least the \fB\-\-sink\fR option to operate.
+
+To output ustreamers sink "test" to ffmpeg, and into a file called test.mp4:
+
+\fBustreamer-dump \e\fR
+.RS
+\fB\-\-sink=test \e\fR # Use ustreamer sink "test"
+.nf
+\fB\-\-output\ \- \e\fR # Output to stdout
+\fB|\ ffmpeg\ \-use_wallclock_as_timestamps\ 1\ \-i\ pipe:\ \-c:v\ libx264\ test\.mp4\fR
+
+.SH OPTIONS
+.SS "Sink options"
+.TP
+.BR \-s ", " \-\-sink\ \fIname
+Memory sink ID. No default.
+.TP
+.BR \-t ", " \-\-sink\-timeout\ \fIsec
+Timeout for the upcoming frame. Default: 1.
+.TP
+.BR \-o ", " \-\-output\ \fIfilename
+Filename to dump output to. Use '-' for stdout. Default: just consume the sink.
+.TP
+.BR \-j ", " \-\-output-json
+Format output as JSON. Required option --output. Default: disabled.
+.TP
+.BR \-c ", " \-\-count\ \fIN
+Limit the number of frames. Default: 0 (infinite).
+.TP
+.BR \-i ", "\-\-interval\ \fIsec
+Delay between reading frames (float). Default: 0.
+.TP
+.BR \-k ", " \-\-key\-required
+Request keyframe from the sink. Default: disabled.
+
+.SS "Logging options"
+.TP
+.BR \-\-log\-level\ \fIN
+Verbosity level of messages from 0 (info) to 3 (debug). Enabling debugging messages can slow down the program.
+Available levels: 0 (info), 1 (performance), 2 (verbose), 3 (debug).
+Default: 0.
+.TP
+.BR \-\-perf
+Enable performance messages (same as \-\-log\-level=1). Default: disabled.
+.TP
+.BR \-\-verbose
+Enable verbose messages and lower (same as \-\-log\-level=2). Default: disabled.
+.TP
+.BR \-\-debug
+Enable debug messages and lower (same as \-\-log\-level=3). Default: disabled.
+.TP
+.BR \-\-force\-log\-colors
+Force color logging. Default: colored if stderr is a TTY.
+.TP
+.BR \-\-no\-log\-colors
+Disable color logging. Default: ditto.
+
+.SS "Help options"
+.TP
+.BR \-h ", " \-\-help
+Print this text and exit.
+.TP
+.BR \-v ", " \-\-version
+Print version and exit.
+
+.SH "SEE ALSO"
+.BR ustreamer (1)
+
+.SH BUGS
+Please file any bugs and issues at \fIhttps://github.com/pikvm/ustreamer/issues\fR
+
+.SH AUTHOR
+Maxim Devaev <mdevaev@gmail.com>
+
+.SH HOMEPAGE
+\fIhttps://pikvm.org/\fR
+
+.SH COPYRIGHT
+GNU General Public License v3.0

man/ustreamer.1

@@ -0,0 +1,359 @@
+.\" Manpage for ustreamer.
+.\" Open an issue or pull request to https://github.com/pikvm/ustreamer to correct errors or typos
+.TH USTREAMER 1 "version 6.55" "November 2020"
+
+.SH NAME
+ustreamer \- stream MJPEG video from any V4L2 device to the network
+
+.SH SYNOPSIS
+.B ustreamer
+.RI [OPTIONS]
+
+.SH DESCRIPTION
+µStreamer (\fBustreamer\fP) is a lightweight and very quick server to stream MJPEG video from any V4L2 device to the network. All new browsers have native support of this video format, as well as most video players such as mplayer, VLC etc. µStreamer is a part of the PiKVM project designed to stream VGA and HDMI screencast hardware data with the highest resolution and FPS possible.
+
+.SH USAGE
+Without arguments, \fBustreamer\fR will try to open \fB/dev/video0\fR with 640x480 resolution and start streaming on \fBhttp://127\.0\.0\.1:8080\fR\. You can override this behavior using parameters \fB\-\-device\fR, \fB\-\-host\fR and \fB\-\-port\fR\. For example, to stream to the world, run: \fBustreamer --device=/dev/video1 --host=0.0.0.0 --port=80\fR
+
+Please note that since µStreamer v2\.0 cross\-domain requests were disabled by default for security reasons\. To enable the old behavior, use the option \fB\-\-allow\-origin=\e*\fR\.
+
+For example, the recommended way of running µStreamer with TC358743-based capture device on a Raspberry Pi is:
+
+\fBustreamer \e\fR
+.RS
+\fB\-\-format=uyvy \e\fR # Device input format
+.nf
+\fB\-\-encoder=m2m-image \e\fR # Hardware encoding with V4L2 M2M interface
+.nf
+\fB\-\-workers=3 \e\fR # Maximum workers for V4L2 encoder
+.nf
+\fB\-\-persistent \e\fR # Suppress repetitive signal source errors (for example when HDMI cable was disconnected)
+.nf
+\fB\-\-dv\-timings \e\fR # Use DV\-timings
+.nf
+\fB\-\-drop\-same\-frames=30\fR # Save the traffic\fR
+.RE
+.P
+Please note that to use \fB\-\-drop\-same\-frames\fR for different browsers you need to use some specific URL \fB/stream\fR parameters (see URL \fB/\fR for details)\.
+.P
+You can always view the full list of options with \fBustreamer \-\-help\fR\. Some features may not be available on your platform. To find out which features are enabled, use \fBustreamer \-\-features\fR.
+
+.SH OPTIONS
+.SS "Capturing options"
+.TP
+.BR \-d\ \fI/dev/path ", " \-\-device\ \fI/dev/path
+Path to V4L2 device. Default: /dev/video0.
+.TP
+.BR \-i\ \fIN ", " \-\-input\ \fIN
+Input channel. Default: 0.
+.TP
+.BR \-r\ \fIWxH ", " \-\-resolution\ \fIWxH
+Initial image resolution. Default: 640x480.
+.TP
+.BR \-m\ \fIfmt ", " \-\-format\ \fIfmt
+Image format.
+Available: YUYV, YVYU, UYVY, YUV420, YVU420, RGB565, RGB24, GREY, MJPEG, JPEG; default: YUYV.
+.TP
+.BR \-a\ \fIstd ", " \-\-tv\-standard\ \fIstd
+Force TV standard.
+Available: PAL, NTSC, SECAM; default: disabled.
+.TP
+.BR \-I\ \fImethod ", " \-\-io\-method\ \fImethod
+Set V4L2 IO method (see kernel documentation). Changing of this parameter may increase the performance. Or not.
+Available: MMAP, USERPTR; default: MMAP.
+.TP
+.BR \-f\ \fIN ", " \-\-desired\-fps\ \fIN
+Desired FPS. Default: maximum possible.
+.TP
+.BR \-z\ \fIN ", " \-\-min\-frame\-size\ \fIN
+Drop frames smaller than this limit. Useful if the device produces small\-sized garbage frames. Default: 128 bytes.
+.TP
+.BR \-T ", " \-\-allow\-truncated\-frames
+Allows to handle truncated frames. Useful if the device produces incorrect but still acceptable frames. Default: disabled.
+.TP
+.BR \-n ", " \-\-persistent
+Suppress repetitive signal source errors. Default: disabled.
+.TP
+.BR \-t ", " \-\-dv\-timings
+Enable DV-timings querying and events processing to automatic resolution change. Default: disabled.
+.TP
+.BR \-b\ \fIN ", " \-\-buffers\ \fIN
+The number of buffers to receive data from the device. Each buffer may be processed using an independent thread.
+Default: 2 (the number of CPU cores (but not more than 4) + 1).
+.TP
+.BR \-w\ \fIN ", " \-\-workers\ \fIN
+The number of worker threads but not more than buffers.
+Default: 1 (the number of CPU cores (but not more than 4)).
+.TP
+.BR \-q\ \fIN ", " \-\-quality\ \fIN
+Set quality of JPEG encoding from 1 to 100 (best). Default: 80.
+Note: If HW encoding is used (JPEG source format selected), this parameter attempts to configure the camera or capture device hardware's internal encoder. It does not re\-encode MJPEG to MJPEG to change the quality level for sources that already output MJPEG.
+.TP
+.BR \-c\ \fItype ", " \-\-encoder\ \fItype
+Use specified encoder. It may affect the number of workers.
+
+CPU ─ Software MJPEG encoding (default).
+
+HW ─ Use pre-encoded MJPEG frames directly from camera hardware.
+
+M2M-VIDEO ─ GPU-accelerated MJPEG encoding.
+
+M2M-IMAGE ─ GPU-accelerated JPEG encoding.
+.TP
+.BR \-g\ \fIWxH,... ", " \-\-glitched\-resolutions\ \fIWxH,...
+It doesn't do anything. Still here for compatibility.
+.TP
+.BR \-k\ \fIpath ", " \-\-blank\ \fIpath
+It doesn't do anything. Still here for compatibility.
+.TP
+.BR \-K\ \fIsec ", " \-\-last\-as\-blank\ \fIsec
+It doesn't do anything. Still here for compatibility.
+.TP
+.BR \-l ", " \-\-slowdown
+Slowdown capturing to 1 FPS or less when no stream or sink clients are connected. Useful to reduce CPU consumption. Default: disabled.
+.TP
+.BR \-\-device\-timeout\ \fIsec
+Timeout for device querying. Default: 1.
+.TP
+.BR \-\-device\-error\-delay\ \fIsec
+Delay before trying to connect to the device again after an error (timeout for example). Default: 1.
+.TP
+.BR \-\-m2m\-device\ \fI/dev/path
+Path to V4L2 mem-to-mem encoder device. Default: auto-select.
+
+.SS "Image control options"
+.TP
+.BR \-\-image\-default
+Reset all image settings below to default. Default: no change.
+.TP
+.BR \-\-brightness\ \fIN ", " \fIauto ", " \fIdefault
+Set brightness. Default: no change.
+.TP
+.BR \-\-contrast\ \fIN ", " \fIdefault
+Set contrast. Default: no change.
+.TP
+.BR \-\-saturation\ \fIN ", " \fIdefault
+Set saturation. Default: no change.
+.TP
+.BR \-\-hue\ \fIN ", " \fIauto ", " \fIdefault
+Set hue. Default: no change.
+.TP
+.BR \-\-gamma\ \fIN ", " \fIdefault
+Set gamma. Default: no change.
+.TP
+.BR \-\-sharpness\ \fIN ", " \fIdefault
+Set sharpness. Default: no change.
+.TP
+.BR \-\-backlight\-compensation\ \fIN ", " \fIdefault
+Set backlight compensation. Default: no change.
+.TP
+.BR \-\-white\-balance\ \fIN ", " \fIauto ", " \fIdefault
+Set white balance. Default: no change.
+.TP
+.BR \-\-gain\ \fIN ", " \fIauto ", " \fIdefault
+Set gain. Default: no change.
+.TP
+.BR \-\-color\-effect\ \fIN ", " \fIdefault
+Set color effect. Default: no change.
+.TP
+.BR \-\-flip\-vertical\ \fI1 ", " \fI0 ", " \fIdefault
+Set vertical flip. Default: no change.
+.TP
+.BR \-\-flip\-horizontal\ \fI1 ", " \fI0 ", " \fIdefault
+Set horizontal flip. Default: no change.
+
+.SS "HTTP server options"
+.TP
+.BR \-s\ \fIaddress ", " \-\-host\ \fIaddress
+Listen on Hostname or IP. Default: 127.0.0.1.
+.TP
+.BR \-p\ \fIN ", " \-\-port\ \fIN
+Bind to this TCP port. Default: 8080.
+.TP
+.BR \-U\ \fIpath ", " \-\-unix\ \fIpath
+Bind to UNIX domain socket. Default: disabled.
+.TP
+.BR \-D ", " \-\-unix\-rm
+Try to remove old unix socket file before binding. default: disabled.
+.TP
+.BR \-M\ \fImode ", " \-\-unix\-mode\ \fImode
+Set UNIX socket file permissions (like 777). Default: disabled.
+.TP
+.BR \-S ", " \-\-systemd
+Bind to systemd socket for socket activation. Required \fBWITH_SYSTEMD\fR feature. Default: disabled.
+.TP
+.BR \-\-user\ \fIname
+HTTP basic auth user. Default: disabled.
+.TP
+.BR \-\-passwd\ \fIstr
+HTTP basic auth passwd. Default: empty.
+.TP
+.BR \-\-static\ \fIpath
+Path to dir with static files instead of embedded root index page. Symlinks are not supported for security reasons. Default: disabled.
+.TP
+.BR \-e\ \fIN ", " \-\-drop\-same\-frames\ \fIN
+Don't send identical frames to clients, but no more than specified number. It can significantly reduce the outgoing traffic, but will increase the CPU loading. Don't use this option with analog signal sources or webcams, it's useless. Default: disabled.
+.TP
+.BR \-R\ \fIWxH ", " \-\-fake\-resolution\ \fIWxH
+Override image resolution for the /state. Default: disabled.
+.TP
+.BR \-\-tcp\-nodelay
+Set TCP_NODELAY flag to the client /stream socket. Only for TCP socket.
+Default: disabled.
+.TP
+.BR \-\-allow\-origin\ \fIstr
+Set Access\-Control\-Allow\-Origin header. Default: disabled.
+.TP
+.BR \-\-instance\-id\ \fIstr
+A short string identifier to be displayed in the /state handle. It must satisfy regexp ^[a-zA-Z0-9\./+_-]*$. Default: an empty string.
+.TP
+.BR \-\-server\-timeout\ \fIsec
+Timeout for client connections. Default: 10.
+
+.SS "JPEG sink options"
+With shared memory sink you can write a stream to a file. See \fBustreamer-dump\fR(1) for more info.
+.TP
+.BR \-\-jpeg\-sink\ \fIname
+Use the specified shared memory object to sink JPEG frames. The name should end with a suffix ".jpeg" or ":jpeg". Default: disabled.
+.TP
+.BR \-\-jpeg\-sink\-mode\ \fImode
+Set JPEG sink permissions (like 777). Default: 660.
+.TP
+.BR \-\-jpeg\-sink\-rm
+Remove shared memory on stop. Default: disabled.
+.TP
+.BR \-\-jpeg\-sink\-client\-ttl\ \fIsec
+Client TTL. Default: 10.
+.TP
+.BR \-\-jpeg\-sink\-timeout\ \fIsec
+Timeout for lock. Default: 1.
+
+.SS "H264 sink options"
+.TP
+.BR \-\-h264\-sink\ \fIname
+Use the specified shared memory object to sink H264 frames. The name should end with a suffix ".h264" or ":h264". Default: disabled.
+.TP
+.BR \-\-h264\-sink\-mode\ \fImode
+Set H264 sink permissions (like 777). Default: 660.
+.TP
+.BR \-\-h264\-sink\-rm
+Remove shared memory on stop. Default: disabled.
+.TP
+.BR \-\-h264\-sink\-client\-ttl\ \fIsec
+Client TTL. Default: 10.
+.TP
+.BR \-\-h264\-sink\-timeout\ \fIsec
+Timeout for lock. Default: 1.
+.TP
+.BR \-\-h264\-bitrate\ \fIkbps
+H264 bitrate in Kbps. Default: 5000.
+.TP
+.BR \-\-h264\-gop\ \fIN
+Interval between keyframes. Default: 30.
+.TP
+.BR \-\-h264\-m2m\-device\ \fI/dev/path
+Path to V4L2 mem-to-mem encoder device. Default: auto-select.
+.TP
+.BR \-\-h264\-boost\-device
+Increase encoder performance on PiKVM V4. Default: disabled.
+
+.SS "RAW sink options"
+.TP
+.BR \-\-raw\-sink\ \fIname
+Use the specified shared memory object to sink RAW frames. The name should end with a suffix ".raw" or ":raw". Default: disabled.
+.TP
+.BR \-\-raw\-sink\-mode\ \fImode
+Set RAW sink permissions (like 777). Default: 660.
+.TP
+.BR \-\-raw\-sink\-rm
+Remove shared memory on stop. Default: disabled.
+.TP
+.BR \-\-raw\-sink\-client\-ttl\ \fIsec
+Client TTL. Default: 10.
+.TP
+.BR \-\-raw\-sink\-timeout\ \fIsec
+Timeout for lock. Default: 1.
+
+.SS "Process options"
+.TP
+.BR \-\-exit\-on\-parent\-death
+Exit the program if the parent process is dead. Required \fBWITH_PDEATHSIG\fR feature. Default: disabled.
+.TP
+.BR \-\-exit\-on\-device\-error
+Exit on any device error instead of polling until success. Default: disabled.
+.TP
+.BR \-\-exit\-on\-no\-clients \fIsec
+Exit the program if there have been no stream or sink clients or any HTTP requests in the last N seconds. Default: 0 (disabled).
+.TP
+.BR \-\-process\-name\-prefix\ \fIstr
+Set process name prefix which will be displayed in the process list like '\fIstr: ustreamer \-\-blah\-blah\-blah'\fR. Required \fBWITH_SETPROCTITLE\fR feature. Default: disabled.
+.TP
+.BR \-\-notify\-parent
+Send SIGUSR2 to the parent process when the stream parameters are changed. Checking changes is performed for the online flag and image resolution. Required \fBWITH_SETPROCTITLE\fR feature.
+
+.SS "GPIO options"
+Available only if \fBWITH_GPIO\fR feature enabled.
+.TP
+.BR \-\-gpio\-device\ \fI/dev/path
+Path to GPIO character device. Default: /dev/gpiochip0.
+.TP
+.BR \-\-gpio\-consumer\-prefix\ \fIstr
+Consumer prefix for GPIO outputs. Default: ustreamer.
+.TP
+.BR \-\-gpio\-prog\-running\ \fIpin
+Set 1 on GPIO pin while µStreamer is running. Default: disabled.
+.TP
+.BR \-\-gpio\-stream\-online\ \fIpin
+Set 1 while streaming. Default: disabled.
+.TP
+.BR \-\-gpio\-has\-http\-clients\ \fIpin
+Set 1 while stream has at least one client. Default: disabled.
+
+.SS "Logging options"
+.TP
+.BR \-\-log\-level\ \fIN
+Verbosity level of messages from 0 (info) to 3 (debug). Enabling debugging messages can slow down the program.
+Available levels: 0 (info), 1 (performance), 2 (verbose), 3 (debug).
+Default: 0.
+.TP
+.BR \-\-perf
+Enable performance messages (same as \-\-log\-level=1). Default: disabled.
+.TP
+.BR \-\-verbose
+Enable verbose messages and lower (same as \-\-log\-level=2). Default: disabled.
+.TP
+.BR \-\-debug
+Enable debug messages and lower (same as \-\-log\-level=3). Default: disabled.
+.TP
+.BR \-\-force\-log\-colors
+Force color logging. Default: colored if stderr is a TTY.
+.TP
+.BR \-\-no\-log\-colors
+Disable color logging. Default: ditto.
+
+.SS "Help options"
+.TP
+.BR \-h ", " \-\-help
+Print this text and exit.
+.TP
+.BR \-v ", " \-\-version
+Print version and exit.
+.TP
+.BR \-\-features
+Print list of supported features.
+
+.SH "SEE ALSO"
+.BR ustreamer-dump (1)
+
+.SH BUGS
+Please file any bugs and issues at \fIhttps://github.com/pikvm/ustreamer/issues\fR
+
+.SH AUTHOR
+Maxim Devaev <mdevaev@gmail.com>
+
+.SH HOMEPAGE
+\fIhttps://pikvm.org/\fR
+
+.SH COPYRIGHT
+GNU General Public License v3.0
+

pkg/arch/PKGBUILD

@@ -0,0 +1,42 @@
+# Contributor: Maxim Devaev <mdevaev@gmail.com>
+# Author: Maxim Devaev <mdevaev@gmail.com>
+
+
+pkgname=ustreamer
+pkgver=6.55
+pkgrel=1
+pkgdesc="Lightweight and fast MJPEG-HTTP streamer"
+url="https://github.com/pikvm/ustreamer"
+license=(GPL)
+arch=(i686 x86_64 armv6h armv7h aarch64)
+depends=(libjpeg libevent libbsd libgpiod systemd)
+makedepends=(gcc make pkgconf systemd)
+source=(${pkgname}::"git+https://github.com/pikvm/ustreamer#commit=v${pkgver}")
+md5sums=(SKIP)
+
+
+_options="WITH_GPIO=1 WITH_SYSTEMD=1"
+if [ -e /usr/bin/python3 ]; then
+	_options="$_options WITH_PYTHON=1"
+	depends+=("python>=3.14" "python<3.15")
+	makedepends+=(python-setuptools python-pip python-build python-wheel)
+fi
+if [ -e /usr/include/janus/plugins/plugin.h ];then
+	depends+=(janus-gateway alsa-lib opus)
+	makedepends+=(janus-gateway alsa-lib opus)
+	_options="$_options WITH_JANUS=1"
+fi
+
+
+build() {
+	cd "$srcdir"
+	rm -rf $pkgname-build
+	cp -r $pkgname $pkgname-build
+	cd $pkgname-build
+	make $_options CFLAGS="$CFLAGS" LDFLAGS="$LDFLAGS" $MAKEFLAGS
+}
+
+package() {
+	cd "$srcdir/$pkgname-build"
+	make $_options CFLAGS="$CFLAGS" LDFLAGS="$LDFLAGS" DESTDIR="$pkgdir" PREFIX=/usr install
+}

pkg/docker/Dockerfile.alpine

@@ -0,0 +1,34 @@
+FROM alpine:3.16 as build
+RUN apk add --no-cache \
+		alpine-sdk \
+		linux-headers \
+		libjpeg-turbo-dev \
+		libevent-dev \
+		libbsd-dev \
+		libgpiod-dev
+
+WORKDIR /build/ustreamer/
+COPY . .
+RUN make -j5 WITH_GPIO=1
+
+FROM alpine:3.16 as run
+
+RUN apk add --no-cache \
+		libevent \
+		libjpeg-turbo \
+		libevent \
+		libgpiod \
+		libbsd \
+		v4l-utils
+
+WORKDIR /ustreamer
+COPY --from=build /build/ustreamer/src/ustreamer.bin ustreamer
+
+RUN wget https://raw.githubusercontent.com/pikvm/kvmd/master/configs/kvmd/edid/v2.hex -O /edid.hex
+COPY pkg/docker/entry.sh /
+
+EXPOSE 8080
+ENTRYPOINT ["/entry.sh"]
+CMD ["--dv-timings", "--format", "UYVY"]
+
+# vim: syntax=dockerfile

pkg/docker/Dockerfile.arm.cross

@@ -0,0 +1,39 @@
+FROM balenalib/raspberrypi3-debian:build as build
+
+RUN ["cross-build-start"]
+
+RUN apt-get update \
+	&& apt-get install -y --no-install-recommends \
+		gcc \
+		libjpeg8-dev \
+		libbsd-dev \
+		libgpiod-dev \
+	&& rm -rf /var/lib/apt/lists/*
+
+WORKDIR /build/ustreamer/
+COPY . .
+RUN make -j5 WITH_GPIO=1
+RUN ["cross-build-end"]
+
+FROM balenalib/raspberrypi3-debian:run as RUN
+
+RUN ["cross-build-start"]
+
+RUN apt-get update \
+	&& apt-get install -y --no-install-recommends \
+		libevent-2.1 \
+		libevent-pthreads-2.1-6 \
+		libjpeg8 \
+		libbsd0 \
+		libgpiod2 \
+	&& rm -rf /var/lib/apt/lists/*
+
+RUN ["cross-build-end"]
+
+WORKDIR /ustreamer
+COPY --from=build /build/ustreamer/ustreamer .
+
+EXPOSE 8080
+ENTRYPOINT ["./ustreamer", "--host=::"]
+
+# vim: syntax=dockerfile

pkg/docker/Dockerfile.arm.native

@@ -0,0 +1,32 @@
+FROM balenalib/raspberrypi3-debian:build as build
+
+RUN apt-get update \
+	&& apt-get install -y --no-install-recommends \
+		gcc \
+		libjpeg8-dev \
+		libbsd-dev \
+		libgpiod-dev \
+	&& rm -rf /var/lib/apt/lists/*
+
+WORKDIR /build/ustreamer/
+COPY . .
+RUN make -j5 WITH_GPIO=1
+
+FROM balenalib/raspberrypi3-debian:run as RUN
+
+RUN apt-get update \
+	&& apt-get install -y --no-install-recommends \
+		libevent-2.1 \
+		libevent-pthreads-2.1-6 \
+		libjpeg8 \
+		libbsd0 \
+		libgpiod2 \
+	&& rm -rf /var/lib/apt/lists/*
+
+WORKDIR /ustreamer
+COPY --from=build /build/ustreamer/ustreamer .
+
+EXPOSE 8080
+ENTRYPOINT ["./ustreamer", "--host=::"]
+
+# vim: syntax=dockerfile

pkg/docker/Dockerfile.x64.native

@@ -0,0 +1,38 @@
+FROM debian:buster-slim as build
+
+RUN apt-get update \
+	&& apt-get install -y \
+		ca-certificates \
+		make \
+		gcc \
+		git \
+		libevent-dev \
+		libjpeg62-turbo-dev \
+		libbsd-dev \
+		libgpiod-dev \
+	&& rm -rf /var/lib/apt/lists/*
+
+WORKDIR /build/ustreamer/
+COPY . .
+RUN make -j5 WITH_GPIO=1
+
+FROM debian:buster-slim as run
+
+RUN apt-get update \
+	&& apt-get install -y \
+		ca-certificates \
+		libevent-2.1 \
+		libevent-pthreads-2.1-6 \
+		libjpeg62-turbo \
+		libbsd0 \
+		libgpiod2 \
+	&& rm -rf /var/lib/apt/lists/*
+
+WORKDIR /ustreamer
+COPY --from=build /build/ustreamer/ustreamer .
+
+#ENV LD_LIBRARY_PATH=/opt/vc/lib
+EXPOSE 8080
+ENTRYPOINT ["./ustreamer", "--host=0.0.0.0"]
+
+# vim: syntax=dockerfile

pkg/docker/entry.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+
+set -e
+
+[ -n "$EDID" ] && {
+	[ -n "$EDID_HEX" ] && echo "$EDID_HEX" > /edid.hex
+	while true; do
+		v4l2-ctl --device=/dev/video0 --set-edid=file=/edid.hex --fix-edid-checksums --info-edid && break
+		echo 'Failed to set EDID. Reetrying...'
+		sleep 1
+	done
+}
+
+./ustreamer --host=0.0.0.0 $@

pkg/gentoo/ustreamer-9999.ebuild

@@ -0,0 +1,30 @@
+# Copyright 2019 Gentoo Authors
+# Distributed under the terms of the GNU General Public License v2
+
+EAPI=7
+
+inherit git-r3
+
+DESCRIPTION="uStreamer - Lightweight and fast MJPEG-HTTP streamer"
+HOMEPAGE="https://github.com/pikvm/ustreamer"
+EGIT_REPO_URI="https://github.com/pikvm/ustreamer.git"
+
+LICENSE="GPL-3"
+SLOT="0"
+KEYWORDS="~amd64"
+IUSE=""
+
+DEPEND="
+	>=dev-libs/libevent-2.1.8
+	>=media-libs/libjpeg-turbo-1.5.3
+	>=dev-libs/libbsd-0.9.1
+"
+RDEPEND="${DEPEND}"
+BDEPEND=""
+
+src_install() {
+	dobin ustreamer
+	dobin ustreamer-dump
+	doman man/ustreamer.1
+	doman man/ustreamer-dump.1
+}

pkg/openwrt/Makefile

@@ -0,0 +1,49 @@
+#
+# This is free software, licensed under the GNU General Public License v2.
+# See /LICENSE for more information.
+#
+# This package is just an example. For OpenWRT it is recommended to use upstream package:
+#   - https://github.com/openwrt/packages/tree/master/multimedia/ustreamer
+#
+
+include $(TOPDIR)/rules.mk
+
+PKG_NAME:=ustreamer
+PKG_VERSION:=6.55
+PKG_RELEASE:=1
+PKG_MAINTAINER:=Maxim Devaev <mdevaev@gmail.com>
+
+PKG_SOURCE_PROTO:=git
+PKG_SOURCE_URL:=https://github.com/pikvm/ustreamer.git
+PKG_SOURCE_VERSION:=v$(PKG_VERSION)
+PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.xz
+PKG_SOURCE_SUBDIR:=$(PKG_NAME)-$(PKG_VERSION)
+
+PKG_LICENSE:=GPL-3.0
+PKG_LICENSE_FILES:=LICENSE
+
+include $(INCLUDE_DIR)/package.mk
+
+define Package/ustreamer
+  SECTION:=multimedia
+  CATEGORY:=Multimedia
+  TITLE:=uStreamer
+  DEPENDS:=+libatomic +libpthread +libjpeg +libv4l +libbsd +libevent2 +libevent2-core +libevent2-extra +libevent2-pthreads
+  URL:=https://github.com/pikvm/ustreamer
+endef
+
+define Package/ustreamer/description
+ µStreamer - Lightweight and fast MJPEG-HTTP streamer
+endef
+
+define Package/ustreamer/install
+	$(INSTALL_DIR) $(1)/usr/bin
+	$(INSTALL_BIN) $(PKG_BUILD_DIR)/ustreamer $(1)/usr/bin/
+	$(INSTALL_BIN) $(PKG_BUILD_DIR)/ustreamer-dump $(1)/usr/bin/
+	$(INSTALL_DIR) $(1)/etc/config
+	$(CP) ./files/ustreamer.config $(1)/etc/config/ustreamer
+	$(INSTALL_DIR) $(1)/etc/init.d
+	$(INSTALL_BIN) ./files/ustreamer.init $(1)/etc/init.d/ustreamer
+endef
+
+$(eval $(call BuildPackage,ustreamer))

pkg/openwrt/files/ustreamer.config

@@ -0,0 +1,19 @@
+
+config ustreamer
+	option enabled '0'
+
+	option device '/dev/video0'
+	option device_timeout '5'
+	option input '0'
+
+	option resolution '640x480'
+	option format 'YUYV'
+	option quality '80'
+	option desired_fps '0'
+	option encoder 'CPU'
+
+	option host '::'
+	option port '8080'
+	option static ''
+	option user ''
+	option password ''

pkg/openwrt/files/ustreamer.init

@@ -0,0 +1,54 @@
+#!/bin/sh /etc/rc.common
+# Copyright (C) 2009-2019 OpenWrt.org
+
+START=90
+STOP=10
+
+USE_PROCD=1
+PROG=/usr/bin/ustreamer
+
+getcfg() {
+	config_get value ustreamer $1 $2
+	return "$value"
+}
+
+start_instance() {
+	config_get_bool enabled ustreamer enabled 0
+	[ "$enabled" -eq 0 ] && return
+
+	local options=""
+
+	options="$options --device='`getcfg device /dev/video0`'"
+	options="$options --device-timeout='`getcfg device_timeout 5`'"
+	options="$options --input='`getcfg input 0`'"
+
+	options="$options --resolution='`getcfg resolution 640x480`'"
+	options="$options --format='`getcfg format YUYV`'"
+	options="$options --quality='`getcfg quality 80`'"
+	options="$options --desired-fps='`getcfg desired_fps 0`'"
+	options="$options --encoder='`getcfg encoder CPU`'"
+
+	options="$options --host='`getcfg host '::'`'"
+	local port=`getcfg port 8080`
+	options="$options --port='$port'"
+	options="$options --static='`getcfg static ''`'"
+	options="$options --user='`getcfg user ''`'"
+	options="$options --passwd='`getcfg password ''`'"
+
+	config-get-bool opt_slowdown ustreamer slowdown 1
+	[ "$slowdown" -eq 1 ] && options="$options --slowdown"
+
+	procd_open_instance
+	procd_set_param command "$PROG" $options
+	procd_add_mdns http tcp "$port" daemon=ustreamer
+	procd_close_instance
+}
+
+start_service() {
+	config_load ustreamer
+	config_foreach start_instance ustreamer
+}
+
+service_triggers() {
+	procd_add_reload_trigger ustreamer
+}

python/MANIFEST.in

@@ -0,0 +1,2 @@
+include setup.py
+recursive-include src *.c *h

python/Makefile

@@ -0,0 +1,21 @@
+R_DESTDIR ?=
+PREFIX ?= /usr/local
+
+PY ?= python3
+
+
+# =====
+all: root
+root: $(shell find src -type f,l) setup.py
+	$(info == PY_BUILD ustreamer-*.so)
+	rm -rf root
+	$(ECHO) $(PY) -m build --skip-dependency-check --no-isolation
+	$(ECHO) $(PY) -m pip install dist/*.whl --ignore-installed --root=./root
+
+
+install:
+	$(PY) -m pip install dist/*.whl --ignore-installed --prefix=$(PREFIX) --root=$(if $(R_DESTDIR),$(R_DESTDIR),/)
+
+
+clean:
+	rm -rf root dist ustreamer.egg-info

python/setup.py

@@ -0,0 +1,58 @@
+import os
+
+from setuptools import Extension
+from setuptools import setup
+
+
+# =====
+def _find_sources() -> list[str]:
+    sources: list[str] = []
+    for (root_path, _, names) in os.walk("src"):
+        for name in names:
+            if name.endswith(".c"):
+                sources.append(os.path.join(root_path, name))
+    return sources
+
+
+def _find_flags() -> dict[str, bool]:
+    return {
+        key[3:]: (value.strip().lower() in ["true", "on", "1"])
+        for (key, value) in sorted(os.environ.items())
+        if key.startswith("MK_WITH_")
+    }
+
+
+def _make_d_features(flags: dict[str, bool]) -> str:
+    features = " ".join([
+        f"{key}={int(value)}"
+        for (key, value) in flags.items()
+    ])
+    return f"-DUS_FEATURES=\"{features}\""
+
+
+def main() -> None:
+    flags = _find_flags()
+    setup(
+        name="ustreamer",
+        version="6.55",
+        description="uStreamer tools",
+        author="Maxim Devaev",
+        author_email="mdevaev@gmail.com",
+        url="https://github.com/pikvm/ustreamer",
+        ext_modules=[
+            Extension(
+                "ustreamer",
+                libraries=["rt", "m", "pthread"],
+                extra_compile_args=[
+                    "-std=c17", "-D_GNU_SOURCE",
+                    _make_d_features(flags),
+                ],
+                undef_macros=["NDEBUG"],
+                sources=_find_sources(),
+            ),
+        ],
+    )
+
+
+if __name__ == "__main__":
+    main()

python/src/uslibs/const.h

@@ -0,0 +1 @@
+../../../src/libs/const.h

python/src/uslibs/errors.h

@@ -0,0 +1 @@
+../../../src/libs/errors.h

python/src/uslibs/frame.c

@@ -0,0 +1 @@
+../../../src/libs/frame.c

python/src/uslibs/frame.h

@@ -0,0 +1 @@
+../../../src/libs/frame.h

python/src/uslibs/memsinksh.c

@@ -0,0 +1 @@
+../../../src/libs/memsinksh.c

python/src/uslibs/memsinksh.h

@@ -0,0 +1 @@
+../../../src/libs/memsinksh.h

python/src/uslibs/tools.h

@@ -0,0 +1 @@
+../../../src/libs/tools.h

python/src/uslibs/types.h

@@ -0,0 +1 @@
+../../../src/libs/types.h

python/src/ustreamer.c

@@ -0,0 +1,361 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#include <sys/types.h>
+#include <sys/file.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+
+#include <Python.h>
+
+#include "uslibs/const.h"
+#include "uslibs/types.h"
+#include "uslibs/errors.h"
+#include "uslibs/tools.h"
+#include "uslibs/frame.h"
+#include "uslibs/memsinksh.h"
+
+
+typedef struct {
+	PyObject_HEAD
+
+	char	*obj;
+	double	lock_timeout;
+	double	wait_timeout;
+	double	drop_same_frames;
+	uz		data_size;
+
+	int					fd;
+	us_memsink_shared_s	*mem;
+
+	u64				frame_id;
+	ldf				frame_ts;
+	us_frame_s		*frame;
+} _MemsinkObject;
+
+
+static void _MemsinkObject_destroy_internals(_MemsinkObject *self) {
+	if (self->mem != NULL) {
+		us_memsink_shared_unmap(self->mem, self->data_size);
+		self->mem = NULL;
+	}
+	US_CLOSE_FD(self->fd);
+	US_DELETE(self->frame, us_frame_destroy);
+}
+
+static int _MemsinkObject_init(_MemsinkObject *self, PyObject *args, PyObject *kwargs) {
+	self->fd = -1;
+
+	self->lock_timeout = 1;
+	self->wait_timeout = 1;
+
+	static char *kws[] = {"obj", "lock_timeout", "wait_timeout", "drop_same_frames", NULL};
+	if (!PyArg_ParseTupleAndKeywords(
+		args, kwargs, "s|ddd", kws,
+		&self->obj, &self->lock_timeout, &self->wait_timeout, &self->drop_same_frames)) {
+		return -1;
+	}
+
+#	define SET_DOUBLE(x_field, x_cond) { \
+			if (!(self->x_field x_cond)) { \
+				PyErr_SetString(PyExc_ValueError, #x_field " must be " #x_cond); \
+				return -1; \
+			} \
+		}
+	SET_DOUBLE(lock_timeout, > 0);
+	SET_DOUBLE(wait_timeout, > 0);
+	SET_DOUBLE(drop_same_frames, >= 0);
+#	undef SET_DOUBLE
+
+	if ((self->data_size = us_memsink_calculate_size(self->obj)) == 0) {
+		PyErr_SetString(PyExc_ValueError, "Invalid memsink object suffix");
+		return -1;
+	}
+
+	self->frame = us_frame_init();
+
+	if ((self->fd = shm_open(self->obj, O_RDWR, 0)) == -1) {
+		PyErr_SetFromErrno(PyExc_OSError);
+		goto error;
+	}
+	if ((self->mem = us_memsink_shared_map(self->fd, self->data_size)) == NULL) {
+		PyErr_SetFromErrno(PyExc_OSError);
+		goto error;
+	}
+	return 0;
+
+error:
+	_MemsinkObject_destroy_internals(self);
+	return -1;
+}
+
+static PyObject *_MemsinkObject_repr(_MemsinkObject *self) {
+	char repr[1024];
+	US_SNPRINTF(repr, 1023, "<Memsink(%s)>", self->obj);
+	return Py_BuildValue("s", repr);
+}
+
+static void _MemsinkObject_dealloc(_MemsinkObject *self) {
+	_MemsinkObject_destroy_internals(self);
+	PyObject_Del(self);
+}
+
+static PyObject *_MemsinkObject_close(_MemsinkObject *self, PyObject *Py_UNUSED(ignored)) {
+	_MemsinkObject_destroy_internals(self);
+	Py_RETURN_NONE;
+}
+
+static PyObject *_MemsinkObject_enter(_MemsinkObject *self, PyObject *Py_UNUSED(ignored)) {
+	Py_INCREF(self);
+	return (PyObject*)self;
+}
+
+static PyObject *_MemsinkObject_exit(_MemsinkObject *self, PyObject *Py_UNUSED(ignored)) {
+	return PyObject_CallMethod((PyObject*)self, "close", "");
+}
+
+static int _wait_frame(_MemsinkObject *self) {
+	const ldf deadline_ts = us_get_now_monotonic() + self->wait_timeout;
+
+	int locked = -1;
+	ldf now_ts;
+	do {
+		Py_BEGIN_ALLOW_THREADS
+
+		locked = us_flock_timedwait_monotonic(self->fd, self->lock_timeout);
+		now_ts = us_get_now_monotonic();
+		if (locked < 0) {
+			if (errno == EWOULDBLOCK) {
+				goto retry;
+			}
+			goto os_error;
+		}
+
+		us_memsink_shared_s *mem = self->mem;
+		if (mem->magic != US_MEMSINK_MAGIC || mem->version != US_MEMSINK_VERSION) {
+			goto retry;
+		}
+
+		// Let the sink know that the client is alive
+		mem->last_client_ts = now_ts;
+
+		if (mem->id == self->frame_id) {
+			goto retry;
+		}
+
+		if (self->drop_same_frames > 0) {
+			if (
+				US_FRAME_COMPARE_GEOMETRY(self->mem, self->frame)
+				&& (self->frame_ts + self->drop_same_frames > now_ts)
+				&& !memcmp(self->frame->data, us_memsink_get_data(mem), mem->used)
+			) {
+				self->frame_id = mem->id;
+				goto retry;
+			}
+		}
+
+		// New frame found
+		Py_BLOCK_THREADS
+		return 0;
+
+	os_error:
+		Py_BLOCK_THREADS
+		PyErr_SetFromErrno(PyExc_OSError);
+		return -1;
+
+	retry:
+		if (locked >= 0 && flock(self->fd, LOCK_UN) < 0) {
+			goto os_error;
+		}
+		if (usleep(1000) < 0) {
+			goto os_error;
+		}
+		Py_END_ALLOW_THREADS
+		if (PyErr_CheckSignals() < 0) {
+			return -1;
+		}
+	} while (now_ts < deadline_ts);
+
+	return US_ERROR_NO_DATA;
+}
+
+static PyObject *_MemsinkObject_wait_frame(_MemsinkObject *self, PyObject *args, PyObject *kwargs) {
+	if (self->mem == NULL || self->fd <= 0) {
+		PyErr_SetString(PyExc_RuntimeError, "Closed");
+		return NULL;
+	}
+
+	bool key_required = false;
+	static char *kws[] = {"key_required", NULL};
+	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|p", kws, &key_required)) {
+		return NULL;
+	}
+
+	switch (_wait_frame(self)) {
+		case 0: break;
+		case US_ERROR_NO_DATA: Py_RETURN_NONE;
+		default: return NULL;
+	}
+
+	us_memsink_shared_s *mem = self->mem;
+	us_frame_set_data(self->frame, us_memsink_get_data(mem), mem->used);
+	US_FRAME_COPY_META(self->mem, self->frame);
+	self->frame_id = mem->id;
+	self->frame_ts = us_get_now_monotonic();
+	if (key_required) {
+		mem->key_requested = true;
+	}
+
+	if (flock(self->fd, LOCK_UN) < 0) {
+		return PyErr_SetFromErrno(PyExc_OSError);
+	}
+
+	PyObject *dict_frame = PyDict_New();
+	if (dict_frame  == NULL) {
+		return NULL;
+	}
+
+#	define SET_VALUE(x_key, x_maker) { \
+			PyObject *m_tmp = x_maker; \
+			if (m_tmp == NULL) { \
+				return NULL; \
+			} \
+			if (PyDict_SetItemString(dict_frame, x_key, m_tmp) < 0) { \
+				Py_DECREF(m_tmp); \
+				return NULL; \
+			} \
+			Py_DECREF(m_tmp); \
+		}
+#	define SET_NUMBER(x_key, x_from, x_to) \
+		SET_VALUE(#x_key, Py##x_to##_From##x_from(self->frame->x_key))
+
+	SET_NUMBER(width, Long, Long);
+	SET_NUMBER(height, Long, Long);
+	SET_NUMBER(format, Long, Long);
+	SET_NUMBER(stride, Long, Long);
+	SET_NUMBER(online, Long, Bool);
+	SET_NUMBER(key, Long, Bool);
+	SET_NUMBER(gop, Long, Long);
+	SET_NUMBER(grab_begin_ts, Double, Float);
+	SET_NUMBER(grab_end_ts, Double, Float);
+	SET_NUMBER(encode_begin_ts, Double, Float);
+	SET_NUMBER(encode_end_ts, Double, Float);
+	SET_VALUE("data", PyBytes_FromStringAndSize((const char*)self->frame->data, self->frame->used));
+
+#	undef SET_NUMBER
+#	undef SET_VALUE
+
+	return dict_frame;
+}
+
+static PyObject *_MemsinkObject_is_opened(_MemsinkObject *self, PyObject *Py_UNUSED(ignored)) {
+	return PyBool_FromLong(self->mem != NULL && self->fd > 0);
+}
+
+#define FIELD_GETTER(x_field, x_from, x_to) \
+	static PyObject *_MemsinkObject_getter_##x_field(_MemsinkObject *self, void *Py_UNUSED(closure)) { \
+		return Py##x_to##_From##x_from(self->x_field); \
+	}
+FIELD_GETTER(obj, String, Unicode)
+FIELD_GETTER(lock_timeout, Double, Float)
+FIELD_GETTER(wait_timeout, Double, Float)
+FIELD_GETTER(drop_same_frames, Double, Float)
+#undef FIELD_GETTER
+
+static PyMethodDef _MemsinkObject_methods[] = {
+#	define ADD_METHOD(x_name, x_method, x_flags) \
+		{.ml_name = x_name, .ml_meth = (PyCFunction)_MemsinkObject_##x_method, .ml_flags = (x_flags)}
+	ADD_METHOD("close", close, METH_NOARGS),
+	ADD_METHOD("__enter__", enter, METH_NOARGS),
+	ADD_METHOD("__exit__", exit, METH_VARARGS),
+	ADD_METHOD("wait_frame", wait_frame, METH_VARARGS | METH_KEYWORDS),
+	ADD_METHOD("is_opened", is_opened, METH_NOARGS),
+	{},
+#	undef ADD_METHOD
+};
+
+static PyGetSetDef _MemsinkObject_getsets[] = {
+#	define ADD_GETTER(x_field) \
+		{.name = #x_field, .get = (getter)_MemsinkObject_getter_##x_field}
+	ADD_GETTER(obj),
+	ADD_GETTER(lock_timeout),
+	ADD_GETTER(wait_timeout),
+	ADD_GETTER(drop_same_frames),
+	{},
+#	undef ADD_GETTER
+};
+
+static PyTypeObject _MemsinkType = {
+	PyVarObject_HEAD_INIT(NULL, 0)
+	.tp_name		= "ustreamer.Memsink",
+	.tp_basicsize	= sizeof(_MemsinkObject),
+	.tp_flags		= Py_TPFLAGS_DEFAULT,
+	.tp_new			= PyType_GenericNew,
+	.tp_init		= (initproc)_MemsinkObject_init,
+	.tp_dealloc		= (destructor)_MemsinkObject_dealloc,
+	.tp_repr		= (reprfunc)_MemsinkObject_repr,
+	.tp_methods		= _MemsinkObject_methods,
+	.tp_getset		= _MemsinkObject_getsets,
+};
+
+static PyModuleDef _Module = {
+	PyModuleDef_HEAD_INIT,
+	.m_name = "ustreamer",
+	.m_size = -1,
+};
+
+PyMODINIT_FUNC PyInit_ustreamer(void) {
+	PyObject *module = NULL;
+
+	if (PyType_Ready(&_MemsinkType) < 0) {
+		goto error;
+	}
+
+	if ((module = PyModule_Create(&_Module)) == NULL) {
+		goto error;
+	}
+
+#	define ADD(x_what, x_key, x_value) \
+		{ if (PyModule_Add##x_what(module, x_key, x_value) < 0) { goto error; } }
+	ADD(StringConstant, "__version__", US_VERSION);
+	ADD(StringConstant, "VERSION", US_VERSION);
+	ADD(IntConstant, "VERSION_MAJOR", US_VERSION_MAJOR);
+	ADD(IntConstant, "VERSION_MINOR", US_VERSION_MINOR);
+	ADD(StringConstant, "FEATURES", US_FEATURES); // Defined in setup.py
+	ADD(ObjectRef, "Memsink", (PyObject*)&_MemsinkType);
+#	undef ADD
+	return module;
+
+error:
+	if (module != NULL) {
+		Py_DECREF(module);
+	}
+	return NULL;
+}

src/Makefile

@@ -0,0 +1,142 @@
+R_DESTDIR ?=
+PREFIX ?= /usr/local
+
+CC ?= gcc
+PKG_CONFIG ?= pkg-config
+CFLAGS ?= -O3
+LDFLAGS ?=
+
+
+# =====
+_USTR = ustreamer.bin
+_DUMP = ustreamer-dump.bin
+_V4P = ustreamer-v4p.bin
+
+_CFLAGS = -MD -c -std=c17 -Wall -Wextra -D_GNU_SOURCE $(CFLAGS)
+
+_USTR_LDFLAGS = $(LDFLAGS) -lm -ljpeg -pthread -lrt -levent -levent_pthreads
+_DUMP_LDFLAGS = $(LDFLAGS) -lm -ljpeg -pthread -lrt
+_V4P_LDFLAGS = $(LDFLAGS) -lm -ljpeg -pthread -lrt
+
+_USTR_SRCS = $(shell ls \
+	libs/*.c \
+	ustreamer/*.c \
+	ustreamer/http/*.c \
+	ustreamer/data/*.c \
+	ustreamer/encoders/cpu/*.c \
+	ustreamer/encoders/hw/*.c \
+	ustreamer/*.c \
+)
+
+_DUMP_SRCS = $(shell ls \
+	libs/*.c \
+	dump/*.c \
+)
+
+_V4P_SRCS = $(shell ls \
+	libs/*.c \
+	libs/drm/*.c \
+	v4p/*.c \
+)
+
+_BUILD = build
+
+_TARGETS = $(_USTR) $(_DUMP)
+_OBJS = $(_USTR_SRCS:%.c=$(_BUILD)/%.o) $(_DUMP_SRCS:%.c=$(_BUILD)/%.o)
+
+
+# =====
+ifeq ($(findstring bsd,$(shell $(CC) -dumpmachine)),)
+override _USTR_LDFLAGS += -latomic
+override _DUMP_LDFLAGS += -latomic
+override _V4P_LDFLAGS += -latomic
+endif
+
+ifneq ($(MK_WITH_PYTHON),)
+override _CFLAGS += -DMK_WITH_PYTHON
+endif
+
+ifneq ($(MK_WITH_JANUS),)
+override _CFLAGS += -DMK_WITH_JANUS
+endif
+
+ifneq ($(MK_WITH_GPIO),)
+override _CFLAGS += -DMK_WITH_GPIO -DWITH_GPIO $(shell $(PKG_CONFIG) --atleast-version=2 libgpiod 2> /dev/null && echo -DHAVE_GPIOD2)
+override _USTR_LDFLAGS += -lgpiod
+override _USTR_SRCS += $(shell ls ustreamer/gpio/*.c)
+endif
+
+ifneq ($(MK_WITH_SYSTEMD),)
+override _CFLAGS += -DMK_WITH_SYSTEMD -DWITH_SYSTEMD
+override _USTR_LDFLAGS += -lsystemd
+override _USTR_SRCS += $(shell ls ustreamer/http/systemd/*.c)
+endif
+
+ifneq ($(MK_WITH_PTHREAD_NP),)
+override _CFLAGS += -DMK_WITH_PTHREAD_NP -DWITH_PTHREAD_NP
+endif
+
+ifneq ($(MK_WITH_SETPROCTITLE),)
+override _CFLAGS += -DMK_WITH_SETPROCTITLE -DWITH_SETPROCTITLE
+ifneq ($(findstring linux,$(shell $(CC) -dumpmachine)),)
+override _USTR_LDFLAGS += -lbsd
+endif
+endif
+
+ifneq ($(MK_WITH_PDEATHSIG),)
+override _CFLAGS += -DMK_WITH_PDEATHSIG -DWITH_PDEATHSIG
+endif
+
+ifneq ($(MK_WITH_V4P),)
+override _TARGETS += $(_V4P)
+override _OBJS += $(_V4P_SRCS:%.c=$(_BUILD)/%.o)
+override _CFLAGS += -DMK_WITH_V4P -DWITH_V4P $(shell $(PKG_CONFIG) --cflags libdrm)
+override _V4P_LDFLAGS += $(shell $(PKG_CONFIG) --libs libdrm)
+override _USTR_SRCS += $(shell ls libs/drm/*.c)
+override _USTR_LDFLAGS += $(shell $(PKG_CONFIG) --libs libdrm)
+endif
+
+
+# =====
+all: $(_TARGETS)
+
+
+install: all
+	mkdir -p $(R_DESTDIR)$(PREFIX)/bin
+	for i in $(subst .bin,,$(_TARGETS)); do \
+		install -m755 $$i.bin $(R_DESTDIR)$(PREFIX)/bin/$$i; \
+	done
+
+
+install-strip: install
+	for i in $(subst .bin,,$(_TARGETS)); do \
+		strip $(R_DESTDIR)$(PREFIX)/bin/$$i; \
+	done
+
+
+$(_USTR): $(_USTR_SRCS:%.c=$(_BUILD)/%.o)
+	$(info == LD $@)
+	$(ECHO) $(CC) $^ -o $@ $(_USTR_LDFLAGS)
+
+
+$(_DUMP): $(_DUMP_SRCS:%.c=$(_BUILD)/%.o)
+	$(info == LD $@)
+	$(ECHO) $(CC) $^ -o $@ $(_DUMP_LDFLAGS)
+
+
+$(_V4P): $(_V4P_SRCS:%.c=$(_BUILD)/%.o)
+	$(info == LD $@)
+	$(ECHO) $(CC) $^ -o $@ $(_V4P_LDFLAGS)
+
+
+$(_BUILD)/%.o: %.c
+	$(info -- CC $<)
+	$(ECHO) mkdir -p $(dir $@) || true
+	$(ECHO) $(CC) $< -o $@ $(_CFLAGS)
+
+
+clean:
+	rm -rf $(_USTR) $(_DUMP) $(_V4P) $(_BUILD)
+
+
+-include $(_OBJS:%.o=%.d)

src/data/blank_jpeg.h

@@ -1,688 +0,0 @@
-/*****************************************************************************
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
-#                                                                            #
-#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
-#                                                                            #
-#    This program is free software: you can redistribute it and/or modify    #
-#    it under the terms of the GNU General Public License as published by    #
-#    the Free Software Foundation, either version 3 of the License, or       #
-#    (at your option) any later version.                                     #
-#                                                                            #
-#    This program is distributed in the hope that it will be useful,         #
-#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
-#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
-#    GNU General Public License for more details.                            #
-#                                                                            #
-#    You should have received a copy of the GNU General Public License       #
-#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
-#                                                                            #
-*****************************************************************************/
-
-
-const unsigned BLANK_JPG_WIDTH = 640;
-const unsigned BLANK_JPG_HEIGHT = 480;
-
-const unsigned long BLANK_JPG_SIZE = 13845;
-
-const unsigned char BLANK_JPG_DATA[] = {
-	0xff, 0xd8, 0xff, 0xe1, 0x9, 0x50, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x6e, 0x73, 0x2e, 0x61, 0x64, 0x6f, 0x62, 0x65,
-	0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x78, 0x61, 0x70, 0x2f, 0x31, 0x2e, 0x30, 0x2f, 0x0, 0x3c, 0x3f, 0x78, 0x70, 0x61, 0x63, 0x6b,
-	0x65, 0x74, 0x20, 0x62, 0x65, 0x67, 0x69, 0x6e, 0x3d, 0x22, 0xef, 0xbb, 0xbf, 0x22, 0x20, 0x69, 0x64, 0x3d, 0x22, 0x57, 0x35,
-	0x4d, 0x30, 0x4d, 0x70, 0x43, 0x65, 0x68, 0x69, 0x48, 0x7a, 0x72, 0x65, 0x53, 0x7a, 0x4e, 0x54, 0x63, 0x7a, 0x6b, 0x63, 0x39,
-	0x64, 0x22, 0x3f, 0x3e, 0x20, 0x3c, 0x78, 0x3a, 0x78, 0x6d, 0x70, 0x6d, 0x65, 0x74, 0x61, 0x20, 0x78, 0x6d, 0x6c, 0x6e, 0x73,
-	0x3a, 0x78, 0x3d, 0x22, 0x61, 0x64, 0x6f, 0x62, 0x65, 0x3a, 0x6e, 0x73, 0x3a, 0x6d, 0x65, 0x74, 0x61, 0x2f, 0x22, 0x20, 0x78,
-	0x3a, 0x78, 0x6d, 0x70, 0x74, 0x6b, 0x3d, 0x22, 0x41, 0x64, 0x6f, 0x62, 0x65, 0x20, 0x58, 0x4d, 0x50, 0x20, 0x43, 0x6f, 0x72,
-	0x65, 0x20, 0x35, 0x2e, 0x36, 0x2d, 0x63, 0x31, 0x33, 0x38, 0x20, 0x37, 0x39, 0x2e, 0x31, 0x35, 0x39, 0x38, 0x32, 0x34, 0x2c,
-	0x20, 0x32, 0x30, 0x31, 0x36, 0x2f, 0x30, 0x39, 0x2f, 0x31, 0x34, 0x2d, 0x30, 0x31, 0x3a, 0x30, 0x39, 0x3a, 0x30, 0x31, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x22, 0x3e, 0x20, 0x3c, 0x72, 0x64, 0x66, 0x3a, 0x52, 0x44, 0x46, 0x20, 0x78, 0x6d,
-	0x6c, 0x6e, 0x73, 0x3a, 0x72, 0x64, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x77,
-	0x33, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x31, 0x39, 0x39, 0x39, 0x2f, 0x30, 0x32, 0x2f, 0x32, 0x32, 0x2d, 0x72, 0x64, 0x66, 0x2d,
-	0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x2d, 0x6e, 0x73, 0x23, 0x22, 0x3e, 0x20, 0x3c, 0x72, 0x64, 0x66, 0x3a, 0x44, 0x65, 0x73,
-	0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x72, 0x64, 0x66, 0x3a, 0x61, 0x62, 0x6f, 0x75, 0x74, 0x3d, 0x22, 0x22,
-	0x2f, 0x3e, 0x20, 0x3c, 0x2f, 0x72, 0x64, 0x66, 0x3a, 0x52, 0x44, 0x46, 0x3e, 0x20, 0x3c, 0x2f, 0x78, 0x3a, 0x78, 0x6d, 0x70,
-	0x6d, 0x65, 0x74, 0x61, 0x3e, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-	0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3c, 0x3f, 0x78, 0x70,
-	0x61, 0x63, 0x6b, 0x65, 0x74, 0x20, 0x65, 0x6e, 0x64, 0x3d, 0x22, 0x77, 0x22, 0x3f, 0x3e, 0xff, 0xed, 0x0, 0x2c, 0x50, 0x68,
-	0x6f, 0x74, 0x6f, 0x73, 0x68, 0x6f, 0x70, 0x20, 0x33, 0x2e, 0x30, 0x0, 0x38, 0x42, 0x49, 0x4d, 0x4, 0x25, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x10, 0xd4, 0x1d, 0x8c, 0xd9, 0x8f, 0x0, 0xb2, 0x4, 0xe9, 0x80, 0x9, 0x98, 0xec, 0xf8, 0x42, 0x7e, 0xff, 0xdb,
-	0x0, 0x84, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1,
-	0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1,
-	0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3,
-	0x3, 0x3, 0x3, 0x3, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1, 0x2, 0x2, 0x2, 0x1, 0x2, 0x2, 0x3,
-	0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3,
-	0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3,
-	0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0xff, 0xdd, 0x0, 0x4, 0x0, 0x50, 0xff, 0xee, 0x0, 0xe, 0x41, 0x64, 0x6f, 0x62, 0x65,
-	0x0, 0x64, 0xc0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xc0, 0x0, 0x11, 0x8, 0x1, 0xe0, 0x2, 0x80, 0x3, 0x0, 0x11, 0x0, 0x1,
-	0x11, 0x1, 0x2, 0x11, 0x1, 0xff, 0xc4, 0x0, 0x7d, 0x0, 0x1, 0x0, 0x2, 0x3, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0xb, 0x7, 0x8, 0x9, 0x5, 0x6, 0x2, 0x3, 0x1, 0x1, 0x1, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x10, 0x1, 0x0, 0x1, 0x4, 0x2, 0x1, 0x3,
-	0x2, 0x3, 0x4, 0x8, 0x4, 0x6, 0x3, 0x0, 0x0, 0x0, 0x3, 0x2, 0x4, 0x5, 0x6, 0x1, 0x7, 0x8, 0x9, 0x11, 0x12,
-	0xa, 0x13, 0x14, 0x21, 0x22, 0x15, 0x37, 0x77, 0xb6, 0x16, 0x23, 0x31, 0x35, 0x39, 0x41, 0x75, 0xb4, 0x17, 0x38, 0xb5, 0xb7,
-	0x18, 0x1a, 0x24, 0x32, 0x51, 0x78, 0x56, 0x97, 0xd4, 0x11, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xda, 0x0, 0xc, 0x3, 0x0, 0x0, 0x1, 0x11, 0x2, 0x11, 0x0, 0x3f, 0x0, 0xaf,
-	0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd0,
-	0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff,
-	0xd1, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7,
-	0xff, 0xd2, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x7, 0xff, 0xd3, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x7, 0xff, 0xd4, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x7, 0xff, 0xd5, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x7, 0xff, 0xd6, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd7, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd0, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd1, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd2, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd3, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd4, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd5, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd6, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd7, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd0, 0xaf, 0xfc, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd1, 0xaf, 0xfc, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd2, 0xaf, 0xfc, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd3, 0xaf, 0xfc,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd4, 0xaf,
-	0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd5,
-	0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff,
-	0xd6, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7,
-	0xff, 0xd7, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x7, 0xff, 0xd0, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x7, 0xff, 0xd1, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x7, 0xff, 0xd2, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x7, 0xff, 0xd3, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x6, 0x4c, 0xe9, 0x5b, 0xb, 0x1c, 0xaf, 0x71, 0xf5, 0x2e, 0x2f, 0x29, 0x65, 0x69, 0x92, 0xc6, 0x64,
-	0xbb, 0x33, 0x43, 0xb0, 0xc8, 0xe3, 0xaf, 0xed, 0xa1, 0xbc, 0xb1, 0xbf, 0xb1, 0xbc, 0xda, 0x71, 0x56, 0xf7, 0x76, 0x57, 0xb6,
-	0x97, 0x14, 0x49, 0x6f, 0x75, 0x69, 0x75, 0x6f, 0x25, 0x54, 0x49, 0x1d, 0x74, 0xd5, 0x45, 0x74, 0x55, 0xcd, 0x35, 0x71, 0xcf,
-	0x1c, 0xf3, 0xc0, 0x24, 0x45, 0xeb, 0x5f, 0xe9, 0x19, 0x61, 0xd4, 0x3f, 0xb6, 0x7c, 0xbb, 0xf1, 0x67, 0x4e, 0xb6, 0xc6, 0x75,
-	0x4c, 0x95, 0x47, 0x71, 0xdc, 0x5d, 0x53, 0xaa, 0xe3, 0x20, 0xb3, 0xc6, 0x75, 0x94, 0xf5, 0x71, 0x15, 0xbf, 0xf4, 0xe7, 0x4d,
-	0xc2, 0x63, 0xa0, 0x8a, 0x1b, 0x1d, 0x2, 0xf6, 0x5f, 0x6e, 0x72, 0x56, 0x50, 0x51, 0xf6, 0xf0, 0xd3, 0xd7, 0xf7, 0xe2, 0xa6,
-	0x9b, 0xa, 0xeb, 0xa2, 0xc4, 0x23, 0x22, 0xd, 0xd8, 0xf4, 0xe3, 0xeb, 0xed, 0x2f, 0xb5, 0xbc, 0xe3, 0xf1, 0xa7, 0xae, 0xbb,
-	0x17, 0x5c, 0xc7, 0x6d, 0xba, 0x46, 0xdd, 0xd9, 0x36, 0x38, 0x7d, 0x97, 0x5b, 0xcb, 0x47, 0x5c, 0xb8, 0xdc, 0xc6, 0x36, 0x6b,
-	0xc, 0x85, 0x72, 0x59, 0xdd, 0xd1, 0x1c, 0x91, 0x49, 0xcc, 0x55, 0x57, 0x1d, 0x3c, 0xfe, 0x9a, 0xa9, 0xe7, 0x8e, 0x78, 0xe3,
-	0x9e, 0x39, 0x6, 0xf5, 0xfa, 0xf4, 0x78, 0xe9, 0xd2, 0x3e, 0x34, 0xf9, 0x4d, 0xd5, 0x7a, 0x6f, 0x44, 0x75, 0xbe, 0xbb, 0xd6,
-	0x3a, 0xbe, 0x6b, 0xa0, 0x30, 0xbb, 0x3e, 0x57, 0xb, 0xad, 0x45, 0x73, 0xd, 0x95, 0xee, 0x7e, 0xe3, 0xb1, 0x7b, 0x23, 0x15,
-	0x36, 0x52, 0x6a, 0x6e, 0xae, 0x6e, 0x6b, 0xe6, 0xea, 0x4c, 0x76, 0x26, 0xda, 0x2e, 0x79, 0xe2, 0xae, 0x38, 0xf8, 0x43, 0x4f,
-	0xe5, 0xff, 0x0, 0xc8, 0x6b, 0xe7, 0xa6, 0xff, 0x0, 0xa5, 0xd7, 0x6f, 0xfa, 0x83, 0xed, 0x57, 0xd7, 0xf8, 0xeb, 0xfe, 0x3a,
-	0xe7, 0xa3, 0xb5, 0x1c, 0x8c, 0x56, 0x3b, 0xcf, 0x6b, 0x64, 0x71, 0xf5, 0xe4, 0x3e, 0x59, 0xa, 0xa0, 0xa6, 0xeb, 0x8d, 0x57,
-	0x49, 0xc4, 0x73, 0x35, 0xa5, 0x1b, 0x1e, 0xd3, 0x25, 0xbc, 0x91, 0xd7, 0x3f, 0xca, 0x68, 0x6d, 0x31, 0xd6, 0xf2, 0xd3, 0x2c,
-	0xf5, 0xf3, 0x5d, 0x76, 0xf6, 0xf7, 0x1, 0xda, 0xee, 0xc7, 0x83, 0xd0, 0x8f, 0xd3, 0x7, 0x27, 0xff, 0x0, 0xe, 0x76, 0xe,
-	0xa9, 0xaf, 0xca, 0xce, 0xf4, 0xd7, 0x61, 0xae, 0xd3, 0x69, 0xc6, 0x65, 0x31, 0x98, 0xce, 0xee, 0xcb, 0x58, 0xe5, 0xe1, 0xb3,
-	0xbe, 0xb0, 0xa6, 0x1d, 0xea, 0xdf, 0x71, 0xc9, 0xe0, 0xba, 0x47, 0x57, 0xbf, 0xaa, 0x6b, 0xa9, 0x7f, 0x11, 0x8f, 0xb1, 0xb2,
-	0xfd, 0xa3, 0x67, 0x55, 0x31, 0xcd, 0x2d, 0x9f, 0xdc, 0x8e, 0xd6, 0xae, 0x43, 0x15, 0xea, 0xfe, 0xa3, 0x9e, 0x87, 0x9d, 0xd5,
-	0x2d, 0x3a, 0x2f, 0x73, 0xfa, 0x79, 0xeb, 0x1d, 0x25, 0x84, 0xca, 0xdf, 0x5b, 0xc1, 0x46, 0xe7, 0xab, 0x74, 0xdf, 0x5c, 0x5b,
-	0x59, 0x63, 0x20, 0xb8, 0xb7, 0xbb, 0xb4, 0xba, 0xbe, 0xcd, 0xec, 0x5d, 0x39, 0xce, 0xad, 0xd9, 0xd8, 0xcb, 0x7b, 0x5a, 0x2e,
-	0x7e, 0x54, 0xd1, 0x8c, 0xb4, 0xc8, 0xd7, 0x55, 0x5e, 0xd2, 0xf1, 0x4d, 0x32, 0x45, 0x1f, 0x20, 0xf1, 0xfc, 0xca, 0xf4, 0x2e,
-	0xeb, 0xad, 0xbf, 0xab, 0x6b, 0xf2, 0x77, 0xd3, 0x43, 0x7a, 0xa7, 0xb2, 0xb4, 0x6b, 0xdc, 0x3d, 0xce, 0xd3, 0x1f, 0x52, 0xf1,
-	0xb2, 0x45, 0xba, 0xc1, 0x9c, 0xc2, 0x5a, 0xd1, 0x27, 0x37, 0x55, 0x75, 0x6, 0xeb, 0x45, 0x73, 0x64, 0x32, 0xb9, 0x1b, 0xf,
-	0xc3, 0x57, 0x4d, 0x78, 0x3c, 0xbc, 0xb7, 0x59, 0x9, 0xae, 0x28, 0x96, 0x28, 0xee, 0xf9, 0xb9, 0xa6, 0x3b, 0x2a, 0xc2, 0x30,
-	0x12, 0x47, 0x24, 0x52, 0x57, 0x14, 0xb4, 0x57, 0x14, 0xb1, 0x57, 0x54, 0x72, 0x47, 0x25, 0x3c, 0xd1, 0x24, 0x72, 0x51, 0xcf,
-	0x34, 0xd7, 0x45, 0x74, 0x55, 0xc7, 0x15, 0x51, 0x5d, 0x15, 0x71, 0xcf, 0x1c, 0xf1, 0xcf, 0x1e, 0xfc, 0x72, 0xf, 0xc0, 0x3a,
-	0x19, 0xe9, 0xa3, 0xe0, 0x76, 0x6b, 0xd4, 0x3, 0xc8, 0x9b, 0x6e, 0xae, 0xe7, 0x33, 0x79, 0xaa, 0x75, 0xde, 0xab, 0x85, 0x97,
-	0x75, 0xed, 0x5d, 0xbb, 0x1f, 0x14, 0x32, 0x64, 0xf1, 0x7a, 0xad, 0xb5, 0xf5, 0x9e, 0x3a, 0x1c, 0x56, 0xbd, 0xc5, 0xe4, 0x17,
-	0x18, 0xfa, 0xb6, 0x8d, 0x8f, 0x25, 0x7d, 0x1d, 0xbd, 0xa7, 0xdf, 0xa2, 0xb8, 0xe0, 0x8b, 0x89, 0xee, 0xaa, 0x8e, 0x6a, 0x6d,
-	0xea, 0x86, 0xb0, 0x90, 0x37, 0x92, 0x7d, 0xb9, 0xe8, 0xb9, 0xe9, 0x95, 0x9b, 0x8f, 0xc7, 0x5b, 0xf, 0xc, 0x74, 0x8f, 0x21,
-	0x3b, 0x3f, 0x9, 0x69, 0x8c, 0x9f, 0x70, 0xb4, 0xcb, 0xe9, 0x1a, 0x5f, 0x67, 0xdf, 0xeb, 0x52, 0x5e, 0x5b, 0x71, 0x91, 0x86,
-	0x9d, 0xc3, 0xb1, 0x7b, 0x82, 0xbc, 0xfd, 0xf5, 0xae, 0xc9, 0x95, 0xb5, 0xc8, 0x53, 0x77, 0xc6, 0x3b, 0x19, 0xc, 0x90, 0x43,
-	0xc, 0x94, 0x53, 0x5d, 0x36, 0x91, 0xd3, 0x6f, 0x10, 0x3f, 0x5b, 0xf, 0x40, 0xfa, 0x35, 0xfa, 0x99, 0x78, 0xcf, 0xda, 0x3d,
-	0xd7, 0xd2, 0xb0, 0x6a, 0x9e, 0x21, 0x6d, 0x5d, 0x51, 0x87, 0x97, 0x2b, 0xb9, 0x6c, 0x18, 0xdd, 0x73, 0xf, 0xd6, 0x37, 0xbd,
-	0x51, 0x27, 0x18, 0xda, 0xb8, 0xc4, 0xcb, 0xd8, 0xfd, 0x51, 0xaf, 0xe4, 0xb9, 0xeb, 0xfd, 0x9b, 0x4f, 0xce, 0xf3, 0x8e, 0xa7,
-	0xed, 0x5c, 0x62, 0x6a, 0xaa, 0x6b, 0xdb, 0x88, 0xe5, 0x86, 0xd6, 0xfa, 0x3b, 0xde, 0x6e, 0xa1, 0xe4, 0x38, 0x81, 0xe8, 0xdf,
-	0xd6, 0xdd, 0x77, 0xd8, 0xfe, 0xa4, 0x7d, 0x35, 0xd7, 0xdd, 0x89, 0xaa, 0xe8, 0xfd, 0xb3, 0xa1, 0xde, 0xdb, 0x77, 0xc, 0x77,
-	0xd8, 0x3d, 0xc3, 0x56, 0xb1, 0xda, 0x74, 0xdd, 0x8e, 0x8c, 0x3f, 0x53, 0xef, 0x97, 0xd8, 0x9c, 0x8c, 0xda, 0xde, 0xe1, 0x88,
-	0xae, 0x1b, 0x88, 0x63, 0xbe, 0xb2, 0x86, 0xf2, 0xd7, 0x8b, 0xbb, 0x3a, 0x27, 0x86, 0x5a, 0x28, 0xaf, 0x9a, 0x23, 0x96, 0x9f,
-	0x6a, 0x43, 0xeb, 0xfd, 0x72, 0xfa, 0xcb, 0xad, 0xfa, 0x93, 0xcf, 0x7d, 0x8f, 0x4e, 0xea, 0x9e, 0xbe, 0xd2, 0x3a, 0xcb, 0x51,
-	0x83, 0xac, 0xfa, 0xda, 0xfe, 0xd, 0x5b, 0xaf, 0x75, 0x3c, 0xe, 0x97, 0xae, 0x43, 0x7d, 0x7d, 0x8b, 0xba, 0x92, 0xfa, 0xf6,
-	0x2c, 0x1e, 0xb9, 0x61, 0x8d, 0xc6, 0x47, 0x77, 0x79, 0x25, 0x3c, 0x55, 0x2c, 0x9c, 0x45, 0xc5, 0x72, 0x73, 0xc7, 0xbd, 0x5c,
-	0xf3, 0xc8, 0x35, 0xa7, 0xc0, 0x5f, 0x4f, 0xee, 0xe3, 0xf5, 0x1, 0xed, 0x59, 0xf4, 0x3e, 0xba, 0xae, 0xdb, 0x58, 0xd3, 0xf5,
-	0x98, 0x6d, 0x32, 0x5d, 0x99, 0xda, 0x59, 0xab, 0x39, 0xef, 0x35, 0xed, 0x17, 0x11, 0x7b, 0x24, 0xd4, 0x59, 0x51, 0xc5, 0x94,
-	0x13, 0x5a, 0xcd, 0x9f, 0xd9, 0xf3, 0x55, 0x5b, 0x4b, 0x46, 0x3b, 0x17, 0x14, 0xd0, 0xd7, 0x73, 0x54, 0x52, 0x57, 0x24, 0xb0,
-	0x5b, 0x45, 0x3d, 0xc4, 0x41, 0x22, 0xce, 0xc0, 0xea, 0xf, 0x43, 0xcf, 0x4a, 0x3b, 0x4c, 0x56, 0xa9, 0xdc, 0xda, 0x87, 0xfe,
-	0x24, 0x7b, 0xd2, 0x28, 0xac, 0xef, 0xf2, 0x9a, 0xee, 0xc5, 0x8c, 0xb0, 0xee, 0x6e, 0xc0, 0xb8, 0x8e, 0x4b, 0x39, 0x66, 0x8a,
-	0xef, 0x33, 0xa2, 0xe5, 0x32, 0x1a, 0xff, 0x0, 0x4c, 0xe8, 0xf8, 0xa9, 0x69, 0xbc, 0xf9, 0xda, 0xda, 0xe4, 0x28, 0xb3, 0xbc,
-	0xbb, 0x86, 0x68, 0xa4, 0xf7, 0xbc, 0xa6, 0x1f, 0xbf, 0x18, 0x60, 0xad, 0x2f, 0xd4, 0xd7, 0xd1, 0x2f, 0xb3, 0xaf, 0xe6, 0xd3,
-	0x3b, 0x67, 0xd3, 0x9f, 0x48, 0xe9, 0xdd, 0x77, 0x31, 0x73, 0x61, 0x4, 0x7b, 0xb6, 0x1b, 0xa1, 0x7a, 0x7f, 0x23, 0x6f, 0x8c,
-	0x8a, 0x2b, 0x9a, 0xae, 0xe6, 0xbc, 0xcc, 0xe4, 0x3a, 0xda, 0xc7, 0xb, 0xd8, 0x98, 0x4b, 0x68, 0x6b, 0xb5, 0x86, 0x9e, 0x78,
-	0xc3, 0xdb, 0xe4, 0xa6, 0xb9, 0xa2, 0x49, 0x22, 0x92, 0x8e, 0x22, 0xf9, 0x71, 0x20, 0x63, 0x8f, 0x52, 0xdf, 0x4b, 0xcf, 0x7,
-	0x35, 0x5f, 0x19, 0x24, 0xf3, 0x77, 0xc3, 0x5e, 0xee, 0xd6, 0x35, 0x8d, 0x6, 0xe3, 0x9c, 0x75, 0x38, 0x9d, 0x16, 0xf7, 0x74,
-	0x9f, 0x75, 0xd1, 0xbb, 0xa, 0xea, 0xfe, 0xea, 0x58, 0xeb, 0xc2, 0x75, 0xb6, 0xc7, 0x7d, 0x79, 0x95, 0xdb, 0x71, 0xdb, 0xd5,
-	0xad, 0x31, 0xcf, 0x54, 0xd8, 0x8b, 0xd9, 0x6f, 0x78, 0xa7, 0x9b, 0x49, 0x63, 0x93, 0xf0, 0x1c, 0xc1, 0x2f, 0x20, 0xc1, 0x3e,
-	0x85, 0x7e, 0x2d, 0x74, 0x8f, 0x97, 0x1b, 0x57, 0x96, 0x9d, 0x59, 0xdd, 0xfa, 0x46, 0x1b, 0x6a, 0xc3, 0xe4, 0x3a, 0x53, 0xb,
-	0x6f, 0x84, 0xcd, 0x4f, 0x8e, 0xc7, 0x49, 0xb5, 0xe8, 0x99, 0x6c, 0x86, 0xcf, 0x55, 0xbd, 0x1b, 0x4e, 0x85, 0x9f, 0xbb, 0xb3,
-	0xba, 0xbb, 0xd6, 0x76, 0x4b, 0x2a, 0xa9, 0xa2, 0xaa, 0x67, 0x83, 0xf4, 0x4d, 0x4d, 0x1f, 0x66, 0xe2, 0x89, 0xad, 0xeb, 0x92,
-	0x1a, 0xc3, 0x9d, 0x3e, 0x77, 0x78, 0x45, 0xda, 0x3e, 0x7, 0xf7, 0x96, 0x5b, 0xa9, 0xbb, 0x2, 0x19, 0x72, 0x9a, 0xfd, 0xf7,
-	0x17, 0x19, 0xae, 0xb2, 0xec, 0x2b, 0x7b, 0x4a, 0xe0, 0xc2, 0x76, 0xe, 0x9d, 0xcd, 0xcd, 0x51, 0x5b, 0x64, 0xed, 0x3f, 0x54,
-	0xb1, 0xd9, 0x66, 0xf1, 0xd5, 0x73, 0x4c, 0x19, 0x4c, 0x7d, 0x55, 0xd5, 0x2d, 0x95, 0xd7, 0xf9, 0xd7, 0x4, 0xb6, 0xf3, 0xcc,
-	0x1a, 0x5a, 0x9, 0x44, 0xfa, 0x3, 0xf8, 0x73, 0xe3, 0xf, 0x93, 0x7d, 0x45, 0xe4, 0x6, 0x6f, 0xbe, 0xfa, 0x5f, 0x4d, 0xed,
-	0xc, 0xb6, 0xaf, 0xd8, 0xfa, 0xc6, 0x2b, 0x5f, 0xbf, 0xd9, 0xad, 0xaf, 0x26, 0xb8, 0xc5, 0xe3, 0xaf, 0x75, 0x89, 0x6e, 0xee,
-	0xad, 0x2d, 0xab, 0xb5, 0xbc, 0xb5, 0xf6, 0x86, 0x6b, 0x9a, 0x38, 0xaf, 0x9e, 0x2a, 0xe2, 0xaf, 0xd5, 0xfd, 0x9e, 0xde, 0xfc,
-	0xfb, 0x84, 0x62, 0x33, 0x10, 0xc7, 0x6f, 0x97, 0xca, 0xc1, 0xd, 0x1c, 0x47, 0xc, 0x19, 0x2b, 0xe8, 0x62, 0x8e, 0x9f, 0x7f,
-	0x6a, 0x23, 0x8e, 0xe6, 0x5a, 0x23, 0xa3, 0x8f, 0x7f, 0x7e, 0x7d, 0xa9, 0xa6, 0x9e, 0x38, 0x7, 0x9a, 0x9, 0x48, 0xfa, 0x14,
-	0x7a, 0x66, 0xf5, 0x9f, 0x79, 0xf4, 0xf7, 0x72, 0x79, 0x5, 0xe4, 0x87, 0x5e, 0x61, 0x77, 0x3d, 0x47, 0xb2, 0xb1, 0x99, 0xde,
-	0x9b, 0xea, 0x5c, 0x5e, 0xc9, 0x88, 0xb0, 0xc8, 0xfe, 0x3, 0x1b, 0x17, 0xce, 0xdb, 0x7e, 0xec, 0xdd, 0x66, 0x4c, 0x84, 0x17,
-	0xb1, 0xe2, 0x76, 0x5b, 0x4c, 0xd5, 0x11, 0x63, 0x30, 0xd9, 0x6b, 0x7a, 0x62, 0xbf, 0xc6, 0x5d, 0x63, 0xef, 0xf9, 0x8a, 0xba,
-	0x7e, 0xe7, 0x1c, 0x82, 0x3d, 0xde, 0x53, 0x78, 0xf1, 0xb9, 0x78, 0xa7, 0xdf, 0xfd, 0x9f, 0xd0, 0x7b, 0xd4, 0x33, 0x7e, 0xd8,
-	0xeb, 0xdd, 0x9a, 0xf7, 0x17, 0x67, 0x93, 0x92, 0xd6, 0x4b, 0x4b, 0x7d, 0x9b, 0x5b, 0x96, 0xaf, 0xc5, 0xea, 0xdb, 0x6e, 0x3a,
-	0x29, 0x3d, 0xf9, 0xe3, 0x1d, 0xb3, 0xe0, 0x27, 0xb7, 0xbd, 0x8b, 0x8f, 0x7e, 0x79, 0x8f, 0x89, 0xbe, 0xdd, 0x5e, 0xd5, 0xd1,
-	0x57, 0x1c, 0x6, 0xbf, 0x82, 0x57, 0x7f, 0x4e, 0xff, 0x0, 0x8e, 0x9e, 0x3e, 0x77, 0x67, 0x4e, 0x79, 0x17, 0x94, 0xee, 0x5e,
-	0x8a, 0xe9, 0xbe, 0xdb, 0xc9, 0xe1, 0x3b, 0x33, 0x54, 0xb0, 0xc2, 0xe4, 0x7b, 0x3b, 0xac, 0x74, 0x9d, 0xf6, 0xfb, 0x11, 0x63,
-	0x71, 0xab, 0x4f, 0x71, 0x71, 0x65, 0x8b, 0xbb, 0xda, 0xb0, 0x79, 0x6b, 0x8c, 0x7d, 0xa4, 0xf7, 0x1c, 0x71, 0x5d, 0x71, 0xc5,
-	0x55, 0x14, 0x55, 0x5f, 0x1f, 0x2e, 0x78, 0xe7, 0x9f, 0xcc, 0x11, 0x57, 0xcd, 0xc7, 0x1c, 0x59, 0x9c, 0xbc, 0x51, 0x51, 0x44,
-	0x51, 0x45, 0x93, 0xbf, 0x8e, 0x38, 0xe3, 0xa7, 0x8a, 0x23, 0x8e, 0x3a, 0x2e, 0xa5, 0xa6, 0x8a, 0x28, 0xa2, 0x9e, 0x38, 0xa6,
-	0x8a, 0x28, 0xa7, 0x8e, 0x38, 0xe3, 0x8e, 0x38, 0xf6, 0xe3, 0x80, 0x79, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xd4, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0x57, 0xe8, 0x6f, 0xdf, 0x97, 0x4c, 0xff, 0x0, 0x15, 0xfa,
-	0xef, 0xf9, 0xbf, 0xe, 0xb, 0xf, 0x7c, 0xc4, 0xf3, 0x8b, 0xaa, 0x7c, 0x4d, 0xed, 0xf, 0x1b, 0x7a, 0xdb, 0xbc, 0xec, 0x31,
-	0x90, 0x75, 0x47, 0x93, 0x95, 0xf6, 0x96, 0x95, 0x9e, 0xdd, 0x33, 0x1f, 0x66, 0x6c, 0x26, 0x9f, 0x96, 0xc1, 0x45, 0xa0, 0xc1,
-	0x84, 0xe7, 0x6d, 0xb2, 0xbb, 0xa2, 0x4b, 0x9, 0x34, 0x5d, 0x82, 0x3d, 0xbe, 0xea, 0xd3, 0x29, 0x3c, 0xdc, 0x73, 0x1d, 0x9f,
-	0x15, 0x45, 0x34, 0xbe, 0xd6, 0xb4, 0xdc, 0x55, 0x48, 0x45, 0xf, 0xd6, 0x3b, 0xd2, 0xb2, 0xef, 0xc3, 0xfd, 0xba, 0x6e, 0xfe,
-	0xe8, 0xec, 0x54, 0xf9, 0x2f, 0x17, 0x7b, 0xb, 0x33, 0xf2, 0x92, 0xca, 0xc2, 0x9a, 0xee, 0xff, 0x0, 0xe0, 0xbe, 0xd1, 0x99,
-	0x9a, 0xb9, 0xad, 0xb5, 0x8b, 0xe9, 0x69, 0xaa, 0x5a, 0xeb, 0xd1, 0x33, 0x32, 0x57, 0xed, 0x83, 0xc8, 0x57, 0xcf, 0x34, 0xc3,
-	0x5f, 0x3c, 0x58, 0x5c, 0x55, 0xc4, 0xdf, 0x84, 0x96, 0xf4, 0x34, 0xc3, 0xd2, 0x8b, 0xfc, 0x46, 0x3c, 0x46, 0xfe, 0x2d, 0xe3,
-	0x3f, 0xe9, 0xd9, 0x30, 0x74, 0xff, 0x0, 0xea, 0x34, 0xd7, 0x72, 0x9b, 0x7f, 0x9e, 0x1e, 0x3b, 0x6a, 0x78, 0x48, 0xa8, 0xb8,
-	0xcd, 0x6d, 0x1e, 0x3f, 0xe9, 0x3a, 0xee, 0x22, 0x9, 0x24, 0xa6, 0x18, 0xe6, 0xca, 0x66, 0xbb, 0x93, 0xb4, 0x71, 0xb8, 0xf8,
-	0xab, 0x96, 0xaf, 0xd3, 0x15, 0x12, 0x5d, 0xdc, 0xd1, 0xc7, 0x35, 0x73, 0xf9, 0x53, 0xc7, 0x3e, 0xe0, 0xea, 0xf7, 0xa8, 0x47,
-	0x67, 0xd9, 0xfa, 0x4a, 0xfa, 0x63, 0xf5, 0xff, 0x0, 0x49, 0x78, 0xf7, 0x3c, 0x78, 0x1d, 0xeb, 0x3d, 0x6, 0x2f, 0xa5, 0xb4,
-	0xcd, 0xa2, 0xce, 0xde, 0x2b, 0x7c, 0x95, 0xae, 0x46, 0xfb, 0x15, 0x7f, 0x9e, 0xed, 0x4e, 0xd8, 0xae, 0x88, 0xfe, 0xd7, 0x1c,
-	0x6c, 0xb9, 0x4a, 0xa1, 0xbb, 0x96, 0x39, 0xe9, 0xe7, 0xe5, 0x6b, 0x95, 0xcb, 0x43, 0x35, 0x34, 0xf3, 0x44, 0x3f, 0x0, 0x41,
-	0x76, 0x69, 0xa6, 0xb9, 0x9a, 0x5b, 0x8b, 0x89, 0x64, 0x9e, 0xe2, 0x79, 0x2b, 0x9a, 0x79, 0xe6, 0xae, 0xb9, 0x66, 0x9a, 0x69,
-	0x6b, 0xe6, 0xb9, 0x65, 0x96, 0x5a, 0xf9, 0xaa, 0xb9, 0x24, 0x92, 0xba, 0xb9, 0xe6, 0xaa, 0xb9, 0xe7, 0x9e, 0x79, 0xe7, 0x9f,
-	0x7e, 0x41, 0xfc, 0xc1, 0xdf, 0xbf, 0x40, 0x9f, 0x36, 0x76, 0xbe, 0x97, 0xf2, 0x73, 0x13, 0xe3, 0xe, 0xc5, 0x99, 0xbc, 0xbc,
-	0xe9, 0xdf, 0x21, 0x6e, 0xae, 0xb1, 0xd8, 0xec, 0x3d, 0xd4, 0xf2, 0x4d, 0x65, 0xa9, 0x76, 0xbd, 0xae, 0x36, 0x7b, 0xbd, 0x73,
-	0x3f, 0x88, 0x8a, 0x49, 0x79, 0xa2, 0xc3, 0x8d, 0xae, 0x3b, 0x1e, 0x71, 0x17, 0xf1, 0xc3, 0x47, 0x1f, 0x8b, 0x96, 0x6b, 0x29,
-	0x24, 0xe7, 0xda, 0xd6, 0x90, 0x7c, 0x6f, 0xaf, 0xbf, 0x8b, 0x9a, 0xf7, 0x40, 0x79, 0x9f, 0x47, 0x60, 0x69, 0x58, 0xeb, 0x6c,
-	0x4e, 0xa9, 0xe4, 0x7e, 0xb3, 0x37, 0x65, 0xdd, 0xe3, 0x2d, 0x22, 0xae, 0x1b, 0x5b, 0x2e, 0xc5, 0xb5, 0xcb, 0x5c, 0xe2, 0xfb,
-	0xe, 0xab, 0x68, 0xfe, 0x1c, 0xc5, 0xf6, 0xf3, 0x97, 0x75, 0x5a, 0x66, 0x26, 0xe7, 0x8a, 0xf9, 0xe7, 0x9b, 0xdc, 0x9c, 0xfc,
-	0x7c, 0x28, 0xa3, 0x88, 0xf8, 0xa8, 0x38, 0x6c, 0x9, 0x2c, 0x7d, 0x34, 0x7d, 0x9b, 0xa8, 0x6b, 0x9e, 0x41, 0xf7, 0xf7, 0x58,
-	0x66, 0xb2, 0x56, 0x76, 0x1b, 0x5f, 0x66, 0xf5, 0xbe, 0xb5, 0x95, 0xd2, 0xed, 0xee, 0xe6, 0xa2, 0x9, 0x33, 0x55, 0x75, 0xf6,
-	0x5f, 0x31, 0x75, 0xb0, 0xe2, 0x71, 0xbc, 0x49, 0x4f, 0x1f, 0x8b, 0xc9, 0x51, 0x8b, 0xd8, 0xf8, 0xbe, 0xfb, 0x14, 0x55, 0xf7,
-	0x39, 0xb4, 0xb2, 0x9e, 0x5e, 0x29, 0xaa, 0x88, 0x64, 0xaa, 0x80, 0xd3, 0x5f, 0x58, 0x8f, 0x7, 0x7c, 0x87, 0xe8, 0xcf, 0x2b,
-	0xbb, 0xcb, 0xbb, 0x36, 0x2d, 0x4f, 0x66, 0xda, 0x7a, 0x67, 0xb8, 0xbb, 0x2f, 0x69, 0xec, 0x6d, 0x5f, 0xb5, 0xf1, 0x76, 0x17,
-	0xb9, 0x8d, 0x67, 0x19, 0x1e, 0xe9, 0x97, 0xb9, 0xce, 0x53, 0xa5, 0x6c, 0xf9, 0x3b, 0x68, 0xa6, 0x8b, 0x54, 0xcb, 0xeb, 0x72,
-	0xde, 0x57, 0x61, 0x69, 0x6f, 0x7d, 0xcc, 0x1c, 0x5e, 0x5a, 0x5a, 0x53, 0x25, 0xaf, 0x32, 0x51, 0x4d, 0x7f, 0x6c, 0x38, 0xe2,
-	0xe, 0xbd, 0x7a, 0x12, 0xff, 0x0, 0x89, 0xef, 0x8f, 0xbf, 0xe9, 0x3d, 0xcb, 0xff, 0x0, 0x64, 0xfb, 0x4, 0x19, 0x7, 0xea,
-	0xd, 0xff, 0x0, 0x11, 0xad, 0xa3, 0xf8, 0x51, 0xd5, 0x9f, 0xf4, 0x8b, 0xc0, 0x77, 0x77, 0x44, 0xbf, 0xc6, 0x7a, 0x47, 0xfa,
-	0x2e, 0xe3, 0xbb, 0x13, 0x5d, 0xc2, 0xd9, 0xc3, 0xdc, 0x7b, 0x2e, 0x83, 0xae, 0x6e, 0x57, 0x12, 0x5d, 0x58, 0x5b, 0xcd, 0x71,
-	0x91, 0xef, 0x7e, 0xf1, 0x87, 0x17, 0x4e, 0x1e, 0x4d, 0x82, 0x2e, 0x7d, 0xad, 0xf2, 0x36, 0x9d, 0x69, 0x8f, 0xc9, 0x5b, 0xc3,
-	0x24, 0x55, 0x57, 0xc5, 0x17, 0x16, 0x18, 0x1e, 0x63, 0xa7, 0x9e, 0x6b, 0x97, 0xde, 0xa0, 0x84, 0x2e, 0xd1, 0xb4, 0x6c, 0x9b,
-	0xbe, 0xc9, 0x9d, 0xdc, 0x37, 0xc, 0xee, 0x57, 0x67, 0xda, 0xb6, 0x7c, 0xad, 0xf6, 0x73, 0x61, 0xd8, 0x73, 0x97, 0xd7, 0x19,
-	0x2c, 0xc6, 0x6b, 0x31, 0x92, 0xb8, 0x92, 0xea, 0xff, 0x0, 0x25, 0x92, 0xbf, 0xba, 0x92, 0x5b, 0x8b, 0xbb, 0xcb, 0xbb, 0x89,
-	0x6a, 0xae, 0xba, 0xeb, 0xab, 0x9a, 0xaa, 0xab, 0x90, 0x78, 0x20, 0xf4, 0x79, 0xcc, 0x65, 0xaa, 0xc4, 0xc7, 0x80, 0xab, 0x29,
-	0x91, 0xab, 0x5, 0x16, 0x46, 0x6c, 0xc4, 0x58, 0x5e, 0x6f, 0x6e, 0x79, 0xc4, 0xc7, 0x96, 0xb8, 0xb6, 0x82, 0xca, 0x7c, 0xa4,
-	0x78, 0xee, 0x65, 0xfc, 0x1d, 0x19, 0x19, 0xec, 0xed, 0xa3, 0x8a, 0xb9, 0xf8, 0xa3, 0x89, 0x6a, 0x8a, 0x3a, 0x69, 0xe6, 0xae,
-	0x69, 0xa7, 0x8e, 0x38, 0x9, 0x2e, 0x7d, 0x32, 0x7f, 0xbf, 0x7f, 0x26, 0xff, 0x0, 0x84, 0x9a, 0x9f, 0xf3, 0x8d, 0x40, 0xeb,
-	0x6e, 0xed, 0xb1, 0xf8, 0xbf, 0xea, 0xf5, 0x8f, 0xf2, 0xb7, 0xc1, 0xae, 0xcd, 0x82, 0xcb, 0x47, 0xef, 0xbf, 0x1b, 0xbb, 0x6b,
-	0xb2, 0xf0, 0x1a, 0x96, 0x46, 0x3a, 0x60, 0xbc, 0xd8, 0xf0, 0xf6, 0x7a, 0x96, 0xdf, 0x93, 0xd6, 0x75, 0x5e, 0xe0, 0xd1, 0x3f,
-	0x15, 0x25, 0xbc, 0xd9, 0x7c, 0x3d, 0xd5, 0xbd, 0xbd, 0xbd, 0x86, 0xd1, 0x8b, 0xe2, 0x4a, 0x69, 0xe2, 0x49, 0x7e, 0x15, 0xf3,
-	0xd, 0x37, 0x16, 0x17, 0x14, 0x84, 0x28, 0x7c, 0x99, 0xf1, 0xaf, 0xb5, 0x7c, 0x4a, 0xee, 0x5d, 0xbb, 0xa3, 0xbb, 0x8b, 0x7,
-	0x56, 0x1b, 0x6d, 0xd5, 0x6e, 0xb8, 0xe6, 0xb, 0xbb, 0x7f, 0xbb, 0x36, 0xb, 0x69, 0xc0, 0x5d, 0x55, 0x25, 0x58, 0x5d, 0xbf,
-	0x55, 0xc8, 0xc9, 0x14, 0x3c, 0x65, 0x35, 0xcc, 0xed, 0xb4, 0x7c, 0xd7, 0x4, 0xbf, 0x1a, 0x24, 0x8a, 0x4a, 0x64, 0xb7, 0x9e,
-	0x88, 0x6e, 0x61, 0x9a, 0x18, 0xc2, 0x54, 0x7f, 0x4c, 0x97, 0xee, 0x37, 0xc9, 0xef, 0xe2, 0xbe, 0x9d, 0xfc, 0xa1, 0x70, 0x8,
-	0x7b, 0x67, 0xff, 0x0, 0xbf, 0x73, 0x5f, 0xea, 0xd9, 0x1f, 0xf7, 0x93, 0x3, 0x28, 0xf8, 0xed, 0xd1, 0x9b, 0x97, 0x92, 0xdd,
-	0xdf, 0xd6, 0x5d, 0x13, 0xa0, 0xc1, 0xcc, 0xbb, 0x47, 0x65, 0xed, 0x78, 0xdd, 0x72, 0xd2, 0xe3, 0x98, 0x6a, 0xb8, 0xb7, 0xc3,
-	0xd8, 0xcf, 0x5f, 0x33, 0xe7, 0x36, 0x4c, 0x84, 0x54, 0x57, 0x1d, 0x75, 0x62, 0xb5, 0x8c, 0x1d, 0xbd, 0xce, 0x42, 0xef, 0xe3,
-	0x57, 0x15, 0x7e, 0x1a, 0xda, 0xbf, 0x8f, 0xbd, 0x5e, 0xdc, 0x72, 0x12, 0xe5, 0xf5, 0x32, 0xf3, 0xa6, 0xc7, 0xd2, 0xdb, 0x59,
-	0xf0, 0xcb, 0xc4, 0xdf, 0x18, 0x78, 0x86, 0xde, 0xeb, 0xaf, 0x26, 0xd1, 0xb7, 0x2d, 0xdf, 0x9, 0xc4, 0xf1, 0xf1, 0x3d, 0xff,
-	0x0, 0x4c, 0x68, 0xd7, 0x3f, 0xb2, 0xe0, 0xd3, 0xf3, 0xf7, 0x54, 0x53, 0x54, 0x94, 0xdf, 0xf7, 0x16, 0x56, 0xda, 0xfe, 0x6c,
-	0x85, 0xdf, 0x14, 0xf1, 0x71, 0xff, 0x0, 0xa4, 0x92, 0x5e, 0x7f, 0x3b, 0x9e, 0x2a, 0xe4, 0x30, 0xe7, 0xaf, 0x17, 0x8f, 0x9a,
-	0x8f, 0x92, 0xfe, 0x35, 0xf4, 0xaf, 0xa8, 0xff, 0x0, 0x47, 0x51, 0x46, 0x77, 0x1f, 0x8c, 0xd5, 0x75, 0x8b, 0x4d, 0xc7, 0x23,
-	0x65, 0x6f, 0x4f, 0x17, 0x39, 0x7e, 0xa0, 0xdf, 0x2b, 0x8b, 0x23, 0xa5, 0x67, 0xf2, 0x50, 0xc3, 0xf7, 0x6b, 0x82, 0xfb, 0x49,
-	0xda, 0x33, 0x35, 0x59, 0x5d, 0xc5, 0x57, 0x3c, 0xcb, 0x7, 0x19, 0x6a, 0xe9, 0x97, 0x9a, 0x78, 0xb4, 0xe7, 0x8a, 0x42, 0x22,
-	0xc0, 0x98, 0xff, 0x0, 0xd3, 0x25, 0xfb, 0x8d, 0xf2, 0x7b, 0xf8, 0xaf, 0xa7, 0x7f, 0x28, 0x5c, 0x2, 0x1e, 0xd9, 0xff, 0x0,
-	0xef, 0xdc, 0xd7, 0xfa, 0xb6, 0x47, 0xfd, 0xe4, 0xc0, 0xf2, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xff, 0xd5, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0x57, 0xe8, 0x6f, 0xdf, 0x97, 0x4c, 0xff, 0x0, 0x15, 0xfa, 0xef, 0xf9,
-	0xbf, 0xe, 0x9, 0x43, 0xfd, 0x4f, 0xff, 0x0, 0xdc, 0x5e, 0x17, 0x7f, 0xab, 0x77, 0xf7, 0xfb, 0x3e, 0x9d, 0x6, 0x35, 0xf4,
-	0x75, 0xf5, 0x2c, 0xd3, 0xfb, 0x1b, 0x50, 0x87, 0xd3, 0x8f, 0xcd, 0x6a, 0xf1, 0x7b, 0x76, 0x89, 0xba, 0x62, 0x64, 0xd0, 0xfa,
-	0x83, 0x66, 0xde, 0x64, 0xa6, 0xf3, 0x17, 0x90, 0xc5, 0x5f, 0xdb, 0xd1, 0x63, 0x6b, 0xd2, 0x7b, 0x75, 0xcd, 0xe5, 0x5c, 0x7c,
-	0x6d, 0xa4, 0xa3, 0x8e, 0x28, 0xd6, 0x6f, 0x2b, 0x92, 0x99, 0x20, 0x9b, 0x8a, 0x2c, 0x28, 0xae, 0x9e, 0x78, 0xb0, 0xa6, 0x80,
-	0xf8, 0x7c, 0x7f, 0xa6, 0xa6, 0xe3, 0xe0, 0x17, 0xab, 0x8f, 0x89, 0x17, 0x78, 0x58, 0xf2, 0x5b, 0x27, 0x8e, 0x9d, 0x85, 0xde,
-	0x11, 0x4b, 0xd5, 0x1b, 0xc4, 0xd4, 0x57, 0x71, 0x3e, 0x2a, 0x4e, 0x71, 0x99, 0x7b, 0xd9, 0x3a, 0xe7, 0x72, 0xb9, 0xa2, 0x2a,
-	0x61, 0x83, 0x6d, 0xc1, 0xda, 0xd3, 0x5f, 0xd8, 0x9b, 0xf4, 0xc7, 0x98, 0xb1, 0x8b, 0xf1, 0x51, 0x53, 0x4c, 0x94, 0x5d, 0x5b,
-	0xda, 0x87, 0xd9, 0x7a, 0xe9, 0x6c, 0xb8, 0x9d, 0x2f, 0xd5, 0x33, 0xc2, 0x3d, 0xc7, 0x3d, 0x2c, 0x30, 0x60, 0xf5, 0x3d, 0x17,
-	0xa4, 0xb6, 0x5c, 0xcc, 0xf7, 0x32, 0xc7, 0x5, 0xbc, 0x38, 0x9c, 0x17, 0x91, 0x5b, 0xee, 0x53, 0x23, 0x2c, 0xf3, 0x4d, 0xfd,
-	0x4c, 0x30, 0xc7, 0x67, 0x6b, 0x5f, 0x35, 0x55, 0x5f, 0xe9, 0xa6, 0x9e, 0x39, 0xe7, 0x9f, 0xc8, 0x1b, 0xf, 0xf5, 0x36, 0x68,
-	0xf9, 0xcc, 0xb7, 0x4d, 0xf8, 0xb7, 0xd9, 0x56, 0x34, 0x49, 0x36, 0xb5, 0xa8, 0x76, 0x26, 0xff, 0x0, 0xa9, 0xe6, 0x64, 0x86,
-	0x3a, 0xe5, 0x86, 0x2c, 0x87, 0x60, 0x6b, 0x9a, 0xfe, 0x57, 0x1, 0x71, 0x34, 0xb4, 0x55, 0xcc, 0x71, 0x45, 0x54, 0x3d, 0x7f,
-	0x7b, 0x45, 0x35, 0x55, 0xc7, 0xb5, 0x55, 0x49, 0xc7, 0x1c, 0x55, 0xc7, 0x3c, 0xfb, 0x54, 0x10, 0xea, 0x0, 0x1b, 0xdd, 0xe9,
-	0x87, 0xa2, 0xe7, 0xfb, 0xf, 0xd4, 0x1b, 0xc4, 0x1c, 0x1e, 0xb9, 0x1c, 0xf2, 0x5e, 0xe2, 0xfb, 0xdb, 0x41, 0xde, 0xaf, 0x79,
-	0x82, 0x89, 0xab, 0xe6, 0x2c, 0x7, 0x5a, 0x66, 0xad, 0xfb, 0xb, 0x66, 0x92, 0x5e, 0x60, 0xa6, 0xaa, 0xa8, 0x83, 0xfa, 0x3f,
-	0xac, 0x5c, 0xf1, 0x5d, 0x55, 0x7b, 0x51, 0xed, 0x57, 0xea, 0xe7, 0x8e, 0x39, 0xe4, 0x1d, 0x98, 0xfa, 0x9c, 0xf6, 0x9c, 0x35,
-	0xdf, 0x6b, 0x78, 0xa1, 0xa4, 0xc1, 0x24, 0x1c, 0xec, 0x1a, 0xff, 0x0, 0x5e, 0xf6, 0x56, 0xd3, 0x93, 0x86, 0x9f, 0x87, 0xe2,
-	0x68, 0xc3, 0x6e, 0x3b, 0x26, 0xb5, 0x89, 0xc1, 0x49, 0x2f, 0xb7, 0x3f, 0x73, 0xec, 0x4b, 0x7b, 0xa3, 0x64, 0x78, 0x8f, 0xdf,
-	0x8e, 0x29, 0xf9, 0x51, 0x5f, 0xb7, 0xbf, 0x3e, 0xfe, 0xc1, 0x17, 0x90, 0x7d, 0x36, 0x9b, 0xb9, 0xed, 0xbd, 0x77, 0xb5, 0x60,
-	0x37, 0x9d, 0x13, 0x64, 0xcc, 0xea, 0x1b, 0x8e, 0xad, 0x93, 0xb6, 0xcc, 0xeb, 0x9b, 0x36, 0xbd, 0x90, 0xb9, 0xc5, 0x66, 0xb0,
-	0xb9, 0x4b, 0x3a, 0xfe, 0xe5, 0xbd, 0xf6, 0x3f, 0x21, 0x67, 0x24, 0x57, 0x16, 0xd3, 0xc7, 0x57, 0xe5, 0xef, 0x4d, 0x5f, 0xaa,
-	0x9e, 0x79, 0xa7, 0x9f, 0x7e, 0x39, 0xe7, 0x8e, 0x42, 0x45, 0x7e, 0x34, 0x7d, 0x47, 0xdd, 0xdf, 0xa7, 0xd9, 0xe3, 0xf5, 0x4f,
-	0x2a, 0x3a, 0xa7, 0x59, 0xef, 0xc, 0x4, 0x76, 0x3f, 0xb3, 0x6f, 0x77, 0x5d, 0x42, 0xbb, 0x7d, 0xf, 0xb0, 0x2e, 0x69, 0xaa,
-	0x9a, 0x29, 0x92, 0xff, 0x0, 0x3b, 0x87, 0xaa, 0xda, 0xfb, 0x43, 0xd9, 0xa4, 0x96, 0x1e, 0x2b, 0x8a, 0xbb, 0x7b, 0x6b, 0x5c,
-	0xd, 0x15, 0xfc, 0xf8, 0xaf, 0x99, 0x39, 0xe6, 0x9e, 0x69, 0x90, 0x3a, 0x21, 0xb8, 0xf8, 0x41, 0xe9, 0xb5, 0xea, 0xfd, 0xd0,
-	0x9b, 0x17, 0x75, 0x78, 0x85, 0x8e, 0xd7, 0xba, 0x77, 0xb8, 0x21, 0xae, 0xfa, 0x9a, 0xb2, 0xfa, 0xce, 0xbb, 0x69, 0xa3, 0x5d,
-	0xe1, 0xb7, 0xd9, 0xed, 0xe8, 0xc9, 0x73, 0xad, 0xf7, 0x77, 0x59, 0xe1, 0xb9, 0xaf, 0x9, 0x77, 0x1e, 0x6e, 0x4e, 0x79, 0xaa,
-	0x4c, 0xb5, 0x8d, 0x32, 0x4f, 0x2d, 0x72, 0x57, 0x73, 0x6f, 0x7b, 0x77, 0x4d, 0x12, 0xc3, 0x28, 0x70, 0xfb, 0xd1, 0x67, 0x50,
-	0xd8, 0x7a, 0xf7, 0xd5, 0xbb, 0xaa, 0x74, 0x1d, 0xbb, 0x1d, 0x26, 0x23, 0x6b, 0xd1, 0xef, 0xfc, 0x82, 0xd4, 0x36, 0x7c, 0x4c,
-	0xd5, 0x51, 0x5c, 0xd8, 0xbd, 0x87, 0x5a, 0xea, 0x8e, 0xcb, 0xc2, 0xe6, 0xb1, 0xd2, 0xd7, 0x1d, 0x55, 0xc7, 0x54, 0x96, 0x59,
-	0x2b, 0x29, 0x62, 0xab, 0x9a, 0x79, 0xe6, 0x9e, 0x79, 0xa7, 0xf2, 0xe7, 0x9e, 0x1, 0xed, 0xfd, 0x41, 0xbf, 0xe2, 0x35, 0xb4,
-	0x7f, 0xa, 0x3a, 0xb3, 0xfe, 0x91, 0x78, 0xe, 0xdb, 0xfa, 0xd6, 0x63, 0x2e, 0x3b, 0x67, 0xd2, 0x2b, 0xaa, 0xbb, 0x13, 0x47,
-	0x8f, 0x8b, 0x9d, 0x5b, 0x5, 0x9a, 0xf1, 0xdf, 0xb5, 0xaf, 0x2b, 0xb1, 0xf6, 0x9e, 0xda, 0x8d, 0x2f, 0x62, 0xd2, 0x72, 0x5a,
-	0xbe, 0x2e, 0xe6, 0x3a, 0xed, 0x7d, 0xa1, 0xaa, 0xce, 0x9c, 0x96, 0xff, 0x0, 0x8e, 0xe7, 0x8a, 0xf8, 0xe3, 0xed, 0xfc, 0x79,
-	0xe3, 0x9e, 0x3d, 0xb8, 0xf6, 0xe7, 0x80, 0x84, 0x68, 0x24, 0x81, 0xa0, 0xfd, 0x47, 0xfd, 0xdf, 0xa0, 0xe8, 0x9a, 0x56, 0x89,
-	0x67, 0xe3, 0x7f, 0x55, 0x64, 0x2d, 0x34, 0xad, 0x4b, 0x5c, 0xd4, 0xad, 0x6f, 0xee, 0x76, 0x9d, 0xba, 0x2b, 0x9b, 0xdb, 0x6d,
-	0x73, 0xf, 0x67, 0x87, 0x82, 0xee, 0xe2, 0x38, 0xa9, 0xfb, 0x51, 0xcd, 0x73, 0x15, 0x9f, 0x15, 0xd7, 0x4d, 0x3f, 0xa7, 0x8a,
-	0xaa, 0xe7, 0x8e, 0x3f, 0x20, 0x77, 0xbb, 0xc6, 0x5f, 0x30, 0xf6, 0x5f, 0x39, 0xbd, 0x36, 0xbb, 0x9b, 0xbe, 0xb6, 0xcd, 0x3b,
-	0x7, 0xa2, 0xe6, 0x2f, 0xf4, 0xbe, 0xff, 0x0, 0xd5, 0xeb, 0xc0, 0xeb, 0xb7, 0xd7, 0xf9, 0x1c, 0x6d, 0x10, 0x6b, 0x7a, 0x8e,
-	0x4e, 0x8, 0x2e, 0xa8, 0xb9, 0xc9, 0x71, 0xc5, 0xd7, 0x32, 0xdc, 0xd3, 0x3f, 0x3c, 0xd7, 0x4f, 0x3f, 0xa7, 0x8e, 0x78, 0xfc,
-	0x81, 0xc3, 0xef, 0xa6, 0x4f, 0xf7, 0xef, 0xe4, 0xdf, 0xf0, 0x93, 0x53, 0xfe, 0x71, 0xa8, 0x1c, 0xa7, 0xf2, 0xb3, 0xb8, 0xbb,
-	0x1b, 0xa0, 0x3d, 0x50, 0x7c, 0x9c, 0xed, 0xfe, 0xa6, 0xd9, 0xaf, 0xb5, 0xd, 0xff, 0x0, 0x47, 0xf2, 0xc7, 0xba, 0x72, 0xd8,
-	0x1c, 0xd5, 0x85, 0x7f, 0x9d, 0x12, 0x71, 0xd8, 0x3b, 0x1c, 0x17, 0x76, 0x17, 0xd6, 0xf5, 0x7b, 0xc1, 0x91, 0xc3, 0xe5, 0xac,
-	0x66, 0x96, 0xd6, 0xf6, 0xd2, 0x6a, 0x6b, 0x82, 0xee, 0xd6, 0x69, 0x22, 0x92, 0x9a, 0xa8, 0xaf, 0x9e, 0x39, 0x9, 0x24, 0x66,
-	0xf1, 0xbe, 0x3f, 0xfd, 0x40, 0x3e, 0x16, 0xf1, 0x9c, 0xc1, 0x51, 0xaf, 0x75, 0xaf, 0x98, 0x7d, 0x3d, 0x67, 0xf6, 0x68, 0x86,
-	0x79, 0x2a, 0x92, 0xe7, 0x47, 0xdc, 0x2e, 0x20, 0xaa, 0x7a, 0xb0, 0x79, 0x39, 0x78, 0xa2, 0x5c, 0xc6, 0x5b, 0xa5, 0x3b, 0x32,
-	0xab, 0x4a, 0xea, 0xb4, 0xb9, 0xe2, 0x99, 0xa4, 0xc7, 0xdc, 0xd1, 0xcd, 0x7c, 0x71, 0x2d, 0xcd, 0x95, 0xcd, 0xbc, 0xe1, 0xfe,
-	0x7d, 0x3c, 0x5d, 0x61, 0xbe, 0x74, 0xbe, 0x9f, 0xe6, 0x67, 0x55, 0xf6, 0x76, 0xb5, 0x91, 0xd4, 0x37, 0xdd, 0x1b, 0xbc, 0x35,
-	0x7c, 0xe, 0xcd, 0xaf, 0x65, 0x22, 0xfb, 0x77, 0x56, 0x17, 0xf6, 0xda, 0x84, 0xb5, 0xd3, 0x55, 0x15, 0xd3, 0xcd, 0x50, 0xdd,
-	0xd8, 0xde, 0xdb, 0x49, 0x1d, 0xc5, 0xad, 0xcc, 0x35, 0x57, 0x6f, 0x77, 0x6b, 0x2c, 0x73, 0x43, 0x5d, 0x71, 0x49, 0x45, 0x75,
-	0x4, 0x2e, 0x73, 0xff, 0x0, 0xdf, 0xb9, 0xaf, 0xf5, 0x6c, 0x8f, 0xfb, 0xc9, 0x81, 0x2a, 0xdf, 0x40, 0x5f, 0x1c, 0x75, 0x4e,
-	0x94, 0xe9, 0xee, 0xeb, 0xf5, 0x22, 0xee, 0xee, 0x6d, 0xf0, 0x1a, 0xe6, 0x3f, 0x5a, 0xda, 0xb5, 0xde, 0xbf, 0xcc, 0x65, 0x21,
-	0xe7, 0xed, 0xe2, 0x3a, 0xfb, 0x4e, 0xa2, 0xbc, 0x9f, 0x6a, 0x6f, 0x36, 0x74, 0x55, 0x4d, 0x7f, 0x7e, 0xbc, 0xa6, 0x53, 0x13,
-	0x46, 0x1e, 0xce, 0xa8, 0x7e, 0x37, 0x3c, 0x55, 0x8e, 0xbe, 0x83, 0x8e, 0x2a, 0xa6, 0xe7, 0x8e, 0x2a, 0xf, 0xe9, 0xde, 0x1e,
-	0x5e, 0x7d, 0x3e, 0xbe, 0x48, 0xf6, 0x66, 0xc3, 0xdc, 0x3d, 0xd9, 0xd6, 0x5d, 0xcf, 0xbd, 0xf6, 0x36, 0xd3, 0xc6, 0x3a, 0x9c,
-	0xde, 0xc5, 0x77, 0x77, 0xe4, 0x16, 0x27, 0xf1, 0x11, 0x62, 0x31, 0x96, 0x98, 0x7c, 0x6d, 0xb5, 0xae, 0x23, 0x5e, 0xed, 0xbc,
-	0x46, 0xb, 0x15, 0x67, 0x67, 0x8e, 0xb1, 0x8a, 0x3a, 0x21, 0xb4, 0xb5, 0x82, 0x2e, 0x3e, 0x3c, 0xd5, 0xf1, 0xf9, 0xd5, 0x55,
-	0x55, 0x7, 0x4a, 0x3c, 0x1c, 0xf2, 0x83, 0xd3, 0x33, 0xc9, 0xde, 0xb9, 0xd9, 0xbc, 0x1, 0xf1, 0xa6, 0xcf, 0x6d, 0xb4, 0xeb,
-	0xd8, 0xba, 0xc7, 0x76, 0xa6, 0x4e, 0xb1, 0xec, 0x28, 0xf7, 0x69, 0xa9, 0xbb, 0xd1, 0x76, 0x5c, 0x8c, 0x96, 0x9b, 0x7d, 0x96,
-	0xbb, 0xb0, 0x76, 0x6, 0xc7, 0xb5, 0x66, 0x2e, 0xe4, 0xb5, 0xbd, 0xda, 0xf9, 0x9e, 0x8b, 0x5e, 0x2e, 0xf9, 0xae, 0xd2, 0x89,
-	0x39, 0x96, 0xde, 0x8a, 0x63, 0x86, 0xae, 0x63, 0x8, 0x4f, 0xf9, 0x71, 0xe3, 0x7e, 0xd9, 0xe2, 0x57, 0x91, 0x3d, 0xa5, 0xd0,
-	0x5b, 0x85, 0x17, 0x12, 0x5e, 0x68, 0x5b, 0x2d, 0xd5, 0xa6, 0x1b, 0x2f, 0x34, 0x15, 0x41, 0x1e, 0xcf, 0xa8, 0xde, 0xfb, 0x64,
-	0x35, 0x1d, 0xaa, 0xd7, 0x8e, 0x69, 0xa6, 0x3e, 0x60, 0xcf, 0xeb, 0xd7, 0x36, 0xf7, 0x15, 0x53, 0x47, 0x35, 0x71, 0xc, 0xd5,
-	0x57, 0x17, 0x3c, 0xfc, 0xe3, 0xab, 0x8e, 0x2, 0x52, 0x1f, 0x4c, 0x97, 0xee, 0x37, 0xc9, 0xef, 0xe2, 0xbe, 0x9d, 0xfc, 0xa1,
-	0x70, 0x8, 0x7b, 0x67, 0xff, 0x0, 0xbf, 0x73, 0x5f, 0xea, 0xd9, 0x1f, 0xf7, 0x93, 0x3, 0xc9, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd6, 0xaf, 0xfc, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x6, 0x57, 0xe8, 0x6f, 0xdf, 0x97, 0x4c,
-	0xff, 0x0, 0x15, 0xfa, 0xef, 0xf9, 0xbf, 0xe, 0x9, 0x43, 0xfd, 0x4f, 0xff, 0x0, 0xdc, 0x5e, 0x17, 0x7f, 0xab, 0x77, 0xf7,
-	0xfb, 0x3e, 0x9d, 0x4, 0x49, 0x23, 0x92, 0x48, 0xa4, 0xa2, 0x58, 0xab, 0xae, 0x29, 0x62, 0xae, 0x99, 0x23, 0x92, 0x3a, 0xb9,
-	0xa2, 0x48, 0xe4, 0xa3, 0x9e, 0x2a, 0xa2, 0xba, 0x2b, 0xa7, 0x9e, 0x2a, 0xa2, 0xba, 0x2a, 0xe3, 0x8e, 0x78, 0xe7, 0x8e, 0x7d,
-	0xf8, 0xe4, 0x13, 0x4d, 0xf4, 0x6b, 0xf5, 0x44, 0xc0, 0x79, 0x59, 0xaf, 0xea, 0xfe, 0x28, 0x79, 0x49, 0x79, 0x8d, 0xcc, 0x77,
-	0xe6, 0x85, 0x5d, 0x9e, 0x67, 0xaa, 0x37, 0x3d, 0xa2, 0x3b, 0x4b, 0x89, 0x7b, 0x52, 0xcb, 0x51, 0xa7, 0x9c, 0x8e, 0x36, 0x5e,
-	0x6e, 0x6e, 0xb8, 0xe7, 0x9e, 0x3b, 0x6b, 0x4a, 0xb3, 0xb7, 0xaa, 0x4e, 0x67, 0xa3, 0xe3, 0x73, 0x93, 0xc7, 0xc3, 0x55, 0xcf,
-	0x3c, 0xd7, 0x3c, 0x77, 0x92, 0x48, 0x1c, 0xdb, 0xfa, 0x96, 0xbf, 0xe7, 0x33, 0xa5, 0xff, 0x0, 0xfa, 0xc7, 0xaf, 0xff, 0x0,
-	0xdd, 0x5e, 0xd8, 0x7, 0x49, 0xfd, 0x3d, 0xbc, 0x99, 0xe8, 0xbf, 0x55, 0x8f, 0x8, 0x72, 0x5e, 0x8, 0x79, 0x29, 0x99, 0x8f,
-	0x8e, 0xea, 0xd6, 0xf4, 0x5b, 0x6d, 0x52, 0xfe, 0x3b, 0xc9, 0xac, 0x6d, 0x76, 0x4d, 0xab, 0x9, 0xab, 0x53, 0x4f, 0xf4, 0x1b,
-	0xb7, 0x7a, 0xfe, 0xe6, 0xf3, 0xef, 0x71, 0x91, 0xdb, 0xb4, 0xf8, 0xac, 0x2d, 0x2a, 0xca, 0xd3, 0xf0, 0x92, 0x4e, 0x2e, 0xe0,
-	0xaa, 0x6b, 0x88, 0xeb, 0xb4, 0xbc, 0xaa, 0x9e, 0x42, 0x39, 0xde, 0x64, 0xfa, 0x56, 0xf9, 0x75, 0xe1, 0xb6, 0xd1, 0x99, 0x83,
-	0x64, 0xeb, 0xbc, 0xf7, 0x62, 0xf5, 0x85, 0xbd, 0xc5, 0xd4, 0xb8, 0xe, 0xe6, 0xeb, 0xac, 0x16, 0x53, 0x3f, 0xa7, 0x64, 0xb0,
-	0xd1, 0xd7, 0x5d, 0x56, 0xb7, 0x5b, 0x1c, 0x58, 0xf8, 0xaf, 0xaf, 0x74, 0x1c, 0xbf, 0x36, 0xdc, 0x71, 0xf8, 0x8b, 0x2c, 0xa7,
-	0xdb, 0xa6, 0x99, 0xa9, 0x93, 0x8b, 0x69, 0xee, 0xe0, 0xa6, 0x9b, 0x8a, 0xc3, 0x4d, 0xba, 0x9b, 0xa1, 0xfb, 0xab, 0xbe, 0x33,
-	0xd6, 0xfa, 0xcf, 0x4c, 0x75, 0x56, 0xfd, 0xd9, 0xd9, 0xab, 0x8b, 0xb8, 0x2c, 0xbf, 0xb, 0xa5, 0xea, 0xf9, 0x7c, 0xf4, 0x76,
-	0x93, 0x4f, 0xf9, 0xd3, 0x5e, 0x56, 0xfa, 0xc6, 0xd6, 0x5b, 0xc, 0x35, 0xa4, 0x71, 0xfb, 0xc9, 0x2d, 0xc5, 0xdc, 0xb0, 0x41,
-	0xc, 0x54, 0xd5, 0x24, 0x95, 0xd3, 0x45, 0x3c, 0xd5, 0xc0, 0x4c, 0x2b, 0xd3, 0x9f, 0xc0, 0xde, 0xb7, 0xf4, 0x90, 0xea, 0xd,
-	0xff, 0x0, 0xcc, 0x8f, 0x34, 0xf7, 0x4d, 0x5b, 0x1, 0xda, 0x97, 0x9a, 0xa4, 0xf8, 0xab, 0xda, 0x22, 0xc8, 0xdb, 0xe4, 0xf0,
-	0xfd, 0x65, 0xab, 0x5c, 0xcb, 0x16, 0x47, 0x9d, 0x1f, 0x57, 0x9a, 0xf, 0x7e, 0x77, 0x4e, 0xcf, 0xdc, 0xef, 0xb1, 0xd0, 0x45,
-	0x37, 0xec, 0xfa, 0x67, 0xf9, 0xd7, 0x15, 0x16, 0x56, 0x1c, 0xcb, 0x1d, 0x57, 0x13, 0xdd, 0x84, 0x55, 0xfc, 0xe9, 0xf2, 0xcb,
-	0x63, 0xf3, 0x5b, 0xc9, 0xbe, 0xc6, 0xef, 0xdc, 0xed, 0xad, 0xc6, 0x27, 0x1d, 0xb0, 0x5e, 0xc1, 0x89, 0xd1, 0xf5, 0x9b, 0x89,
-	0xa8, 0x9e, 0xbd, 0x4f, 0xaf, 0xf0, 0x31, 0xf3, 0x63, 0xab, 0x60, 0xab, 0x92, 0x2f, 0x78, 0x2b, 0xbe, 0xa6, 0xd3, 0x8a, 0xae,
-	0xaf, 0xab, 0x8f, 0xfa, 0xb9, 0x72, 0x37, 0x57, 0x12, 0x51, 0xc7, 0x14, 0xd7, 0xc7, 0x1c, 0x6, 0xa2, 0x3, 0xb0, 0x9e, 0x93,
-	0x1e, 0x9a, 0x3a, 0x7, 0xa8, 0x66, 0xc5, 0xda, 0xb0, 0xf6, 0x7, 0x74, 0x73, 0xa0, 0xe3, 0x7a, 0xeb, 0x1, 0x1d, 0x76, 0xba,
-	0x7e, 0xa1, 0x5e, 0x3a, 0x7e, 0xcb, 0xcc, 0x65, 0x33, 0x50, 0xcd, 0x6f, 0x88, 0xda, 0x79, 0xb3, 0xce, 0x63, 0xee, 0xf1, 0x74,
-	0x68, 0x38, 0x2c, 0x97, 0x11, 0xd3, 0x7d, 0x54, 0x7c, 0x49, 0x73, 0x75, 0x35, 0x74, 0xdb, 0x71, 0x5d, 0x9f, 0x32, 0xd1, 0x72,
-	0xd, 0x27, 0xf2, 0x9f, 0xc2, 0xdf, 0x21, 0xbc, 0x3e, 0xec, 0x9c, 0x97, 0x5c, 0xf7, 0x1f, 0x5f, 0x67, 0x71, 0x9c, 0xc7, 0x97,
-	0xab, 0x19, 0xab, 0xee, 0x36, 0x38, 0xcb, 0xeb, 0xdd, 0x23, 0x7f, 0xb7, 0x9e, 0xb9, 0xf9, 0xc5, 0x64, 0x74, 0xdd, 0x8e, 0x2b,
-	0x7e, 0x6c, 0x32, 0xbc, 0x65, 0x2d, 0xa0, 0xe6, 0x4e, 0x2d, 0x3e, 0x54, 0xdf, 0xdb, 0x55, 0xc5, 0x51, 0x5c, 0x43, 0x14, 0xd1,
-	0xd7, 0x1d, 0x21, 0x28, 0x7f, 0xa7, 0x97, 0xc4, 0x9e, 0xe8, 0xe8, 0x1d, 0x1f, 0xbd, 0x3b, 0xf7, 0xba, 0x30, 0x39, 0x8e, 0xb1,
-	0xd6, 0x3b, 0x6b, 0x1b, 0xa5, 0x63, 0xb4, 0xad, 0x67, 0x6f, 0x82, 0xe7, 0x5f, 0xcb, 0xe4, 0xf0, 0x1a, 0x7f, 0x3b, 0x1e, 0x63,
-	0x21, 0xd8, 0x39, 0xac, 0x3e, 0x4e, 0x9b, 0x59, 0x70, 0xf8, 0x19, 0x28, 0xce, 0xd1, 0x16, 0x2a, 0x6b, 0xaa, 0x68, 0x92, 0xe6,
-	0xf, 0xc4, 0xdc, 0x53, 0x4d, 0x36, 0xb5, 0xdb, 0xcd, 0x70, 0x1c, 0xdf, 0xf4, 0xf6, 0xec, 0x8d, 0x67, 0xb8, 0x3d, 0x7d, 0xb2,
-	0xbd, 0xa3, 0xa5, 0xd7, 0x44, 0xda, 0x86, 0xf9, 0xdb, 0x5e, 0x58, 0xec, 0xda, 0xc5, 0xdd, 0x11, 0xd3, 0x17, 0x19, 0x1c, 0xe,
-	0x53, 0x40, 0xed, 0x5b, 0x8c, 0x4e, 0x5a, 0xa8, 0xe9, 0xfc, 0xa8, 0x97, 0x2f, 0x63, 0x55, 0x17, 0x55, 0xf1, 0xef, 0xcf, 0x3c,
-	0x57, 0x2f, 0x3e, 0xfc, 0xf3, 0xcf, 0xe7, 0xc8, 0x62, 0x7f, 0xa8, 0x37, 0xfc, 0x46, 0xb6, 0x8f, 0xe1, 0x47, 0x56, 0x7f, 0xd2,
-	0x2f, 0x1, 0xd5, 0x6f, 0x45, 0xff, 0x0, 0x33, 0xfa, 0x77, 0xca, 0x9f, 0x18, 0x72, 0x3e, 0x9b, 0x5e, 0x4b, 0xcb, 0x8a, 0xbd,
-	0xd8, 0xf1, 0xba, 0x96, 0x7f, 0x47, 0xd3, 0x31, 0x5b, 0x15, 0xcc, 0x36, 0x90, 0x76, 0xb7, 0x51, 0x64, 0x6d, 0xee, 0xe6, 0xa3,
-	0x5d, 0xc2, 0x5d, 0xfd, 0xc8, 0x25, 0xa3, 0x77, 0xeb, 0xab, 0x69, 0x64, 0xa2, 0xde, 0x3b, 0x7e, 0x63, 0xbc, 0x8f, 0x1b, 0x6d,
-	0x6d, 0x77, 0x6d, 0x55, 0x52, 0xda, 0x5c, 0xcb, 0x10, 0x71, 0x87, 0xce, 0xff, 0x0, 0x47, 0x6f, 0x28, 0xfc, 0x41, 0xdc, 0x73,
-	0x39, 0xd, 0x3f, 0x4a, 0xda, 0xfb, 0xbb, 0xa2, 0x2e, 0xb2, 0x37, 0x32, 0x6a, 0x7d, 0x91, 0xa2, 0xe0, 0xef, 0x36, 0x5c, 0xa6,
-	0x2b, 0x15, 0x24, 0xde, 0xf6, 0x78, 0xfe, 0xcb, 0xd7, 0xb0, 0x36, 0x93, 0xe4, 0x35, 0x5c, 0xc5, 0xa5, 0x12, 0x47, 0xc, 0x97,
-	0xb5, 0x41, 0x4e, 0x22, 0xf2, 0x5a, 0xa9, 0xfc, 0x3c, 0xfc, 0x49, 0x5d, 0x56, 0xd1, 0x7, 0x34, 0x3a, 0xef, 0xa8, 0xbb, 0x53,
-	0xb7, 0x36, 0x28, 0xf5, 0x1e, 0xad, 0xeb, 0x8d, 0xe3, 0xb0, 0xf6, 0x79, 0x2e, 0xa0, 0xb2, 0xfd, 0x85, 0xa6, 0x6a, 0xf9, 0x9d,
-	0x8f, 0x25, 0xd, 0xc5, 0xcd, 0x72, 0xc7, 0xd, 0x17, 0x76, 0xb8, 0xab, 0x3b, 0x99, 0x2c, 0xa9, 0xe6, 0xab, 0x79, 0x39, 0xe6,
-	0xb9, 0xb8, 0xa2, 0x8a, 0x69, 0x8e, 0xba, 0xaa, 0xe7, 0x8e, 0x28, 0xab, 0x9e, 0x2, 0x72, 0x5e, 0x13, 0xf4, 0x7, 0x60, 0x78,
-	0x5b, 0xe9, 0x1b, 0xd9, 0xfa, 0x3f, 0x91, 0x7c, 0x6b, 0xba, 0x6, 0xcd, 0xfd, 0x2, 0xef, 0xad, 0xcf, 0x33, 0x63, 0x79, 0xb1,
-	0xe3, 0x24, 0xb6, 0xd5, 0xac, 0xf7, 0xd, 0x72, 0xfe, 0x3c, 0x3e, 0x2b, 0x61, 0xcc, 0xf1, 0x2d, 0x18, 0x3b, 0x7c, 0xdd, 0x55,
-	0xf1, 0x45, 0x32, 0x45, 0x5, 0xcd, 0xc4, 0x34, 0xc9, 0x35, 0x11, 0xf1, 0x2d, 0x52, 0x73, 0x55, 0x14, 0x87, 0x25, 0xbe, 0x99,
-	0x3f, 0xdf, 0xbf, 0x93, 0x7f, 0xc2, 0x4d, 0x4f, 0xf9, 0xc6, 0xa0, 0x71, 0x6b, 0xd4, 0x47, 0xfe, 0x7d, 0x7c, 0xcb, 0xff, 0x0,
-	0xec, 0xe7, 0x76, 0xff, 0x0, 0xdc, 0x4d, 0x80, 0x1f, 0x19, 0xe2, 0x67, 0x95, 0x9d, 0xb1, 0xe1, 0xaf, 0x75, 0xeb, 0x1d, 0xdd,
-	0xd4, 0x39, 0x6f, 0xc2, 0x66, 0x70, 0xb3, 0x53, 0x69, 0x9e, 0xc0, 0x5d, 0xd7, 0x2f, 0x3a, 0xfe, 0xf3, 0xaa, 0x5c, 0x5c, 0x5b,
-	0xcb, 0x9a, 0xd3, 0x76, 0x7b, 0x48, 0xf9, 0xe3, 0x9b, 0x9c, 0x3e, 0x5e, 0x2b, 0x7a, 0x78, 0xf9, 0xd3, 0xed, 0x3d, 0xac, 0xf4,
-	0x47, 0x71, 0x5, 0x71, 0xcf, 0x14, 0x72, 0x52, 0x16, 0x1f, 0xf8, 0x61, 0xe4, 0xe7, 0x45, 0xf9, 0x95, 0xd5, 0x16, 0x9e, 0x45,
-	0xf4, 0xcc, 0x18, 0xfb, 0x4b, 0xed, 0xba, 0x2c, 0x6e, 0xf, 0xb1, 0xf1, 0x72, 0x45, 0x63, 0x1e, 0xe3, 0xac, 0x6d, 0x9a, 0xd5,
-	0xa5, 0x5e, 0xfa, 0x7e, 0xeb, 0x25, 0xad, 0x34, 0xcb, 0x75, 0x79, 0x81, 0x87, 0x2b, 0xcd, 0x56, 0x53, 0xd7, 0xfd, 0x5d, 0xcd,
-	0x85, 0xcc, 0x53, 0xc3, 0xfd, 0x54, 0xb4, 0x71, 0xc0, 0x57, 0x61, 0xd1, 0x7d, 0xf, 0xb8, 0x79, 0x3b, 0xe4, 0x9e, 0x91, 0xd0,
-	0xba, 0x24, 0x5c, 0xd5, 0xb1, 0xf6, 0x67, 0x60, 0xd5, 0xaf, 0xc3, 0x79, 0xcc, 0x35, 0xdc, 0x41, 0x84, 0xc5, 0xf3, 0x79, 0x73,
-	0x79, 0xb1, 0x6c, 0xd7, 0xd1, 0x47, 0xcd, 0x32, 0x57, 0x8c, 0xd5, 0xf5, 0xeb, 0x4b, 0xac, 0x8d, 0xcf, 0x14, 0xf3, 0xf2, 0xe6,
-	0xde, 0xda, 0xbf, 0x8f, 0xbd, 0x5e, 0xdc, 0x72, 0x12, 0x62, 0xf5, 0xd8, 0xee, 0xfd, 0x4f, 0xc5, 0x6f, 0x15, 0xfa, 0x1b, 0xd3,
-	0x87, 0xa3, 0xe7, 0x8f, 0xb, 0x8e, 0xcc, 0xea, 0xf8, 0x1b, 0xad, 0xc3, 0x1f, 0x6b, 0x73, 0x4f, 0x19, 0x3b, 0xe, 0xa3, 0xeb,
-	0xf9, 0xad, 0xec, 0x75, 0x4b, 0x1c, 0xbd, 0x50, 0xf1, 0xd, 0x53, 0xdd, 0x76, 0x1e, 0xe9, 0x8d, 0x9a, 0xfa, 0xea, 0xe3, 0x9e,
-	0x3e, 0x77, 0x32, 0x61, 0xae, 0x3e, 0xef, 0x1c, 0xf1, 0x71, 0x57, 0x35, 0x4, 0x46, 0x1, 0xb0, 0xbe, 0x28, 0xf9, 0x9, 0xb2,
-	0xf8, 0xab, 0xe4, 0x57, 0x52, 0xf7, 0xfe, 0xab, 0xf7, 0xe5, 0xc8, 0x75, 0xbe, 0xdd, 0x61, 0x97, 0xbf, 0xc6, 0xdb, 0xcf, 0xcd,
-	0xbf, 0x39, 0xfd, 0x62, 0xe3, 0x89, 0x31, 0x9b, 0x7e, 0xb1, 0x24, 0xbe, 0xfc, 0x71, 0x44, 0x3b, 0x2e, 0xaf, 0x7d, 0x77, 0x63,
-	0x55, 0x5c, 0xfb, 0xf1, 0x47, 0x13, 0xfc, 0xbf, 0xb6, 0x9e, 0x1, 0x28, 0x5f, 0x5e, 0x8f, 0x1c, 0x75, 0x5f, 0x26, 0x3c, 0x62,
-	0xea, 0xf, 0x50, 0xbe, 0x93, 0xe2, 0x1d, 0x86, 0x8d, 0x4f, 0x59, 0xd7, 0x78, 0xd9, 0xb2, 0xd8, 0xc8, 0x38, 0xae, 0x6d, 0x8f,
-	0xa3, 0x7b, 0x2, 0xb8, 0x32, 0x7a, 0xb6, 0x7a, 0xe2, 0x98, 0x63, 0x9a, 0xe2, 0xa9, 0x74, 0x7d, 0x9b, 0x35, 0x4f, 0xce, 0x2f,
-	0xd3, 0xf8, 0x7b, 0x6c, 0xc5, 0xdc, 0x93, 0x73, 0xc7, 0x16, 0xde, 0xd4, 0x87, 0xab, 0xf4, 0xc9, 0x7e, 0xe3, 0x7c, 0x9e, 0xfe,
-	0x2b, 0xe9, 0xdf, 0xca, 0x17, 0x0, 0x8d, 0x2e, 0x6f, 0xc0, 0xcf, 0x39, 0x65, 0xcc, 0xe5, 0xe5, 0x8b, 0xc3, 0x1f, 0x2b, 0xe4,
-	0x8a, 0x4c, 0x9d, 0xfc, 0x91, 0xc9, 0x1f, 0x8e, 0xbd, 0xbf, 0x5c, 0x72, 0x47, 0x5d, 0xd4, 0xb5, 0x51, 0x5d, 0x15, 0xd3, 0xa7,
-	0xf3, 0x4d, 0x74, 0x57, 0x4f, 0x3c, 0x73, 0xc7, 0x3c, 0x73, 0xed, 0xcf, 0x0, 0xc0, 0x7d, 0x99, 0xd3, 0x5d, 0xbf, 0xd2, 0xb9,
-	0x5c, 0x7e, 0xb, 0xb9, 0x3a, 0xa7, 0xb2, 0x7a, 0x97, 0x39, 0x96, 0xc7, 0xfe, 0xd6, 0xc5, 0xe1, 0xbb, 0x33, 0x46, 0xd9, 0xf4,
-	0x3c, 0xae, 0x4b, 0x15, 0xf8, 0x99, 0xac, 0xff, 0x0, 0x69, 0xe3, 0xf1, 0xdb, 0x4e, 0x2f, 0x15, 0x77, 0x79, 0x8f, 0xfc, 0x5d,
-	0xb4, 0x91, 0x7d, 0xe8, 0xe8, 0xaa, 0x3f, 0xb9, 0x1d, 0x54, 0xfc, 0xbe, 0x54, 0xf3, 0xc7, 0x1, 0x8d, 0x80, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7f, 0xff, 0xd7, 0xaf, 0xfc, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xb9, 0xac, 0x6c, 0x39, 0x1d,
-	0x4b, 0x64, 0xd7, 0xb6, 0xbc, 0x47, 0x30, 0xd3, 0x96, 0xd6, 0x73, 0x98, 0x9d, 0x87, 0x17, 0x55, 0xc4, 0x5f, 0x7e, 0xde, 0x9c,
-	0x8e, 0x16, 0xfe, 0xdf, 0x25, 0x65, 0xcc, 0xf0, 0xfc, 0xa9, 0xfb, 0xd0, 0xf1, 0x73, 0x6d, 0x4f, 0xca, 0x9f, 0x7e, 0x3e, 0x54,
-	0xfb, 0xf1, 0xee, 0xd, 0xc8, 0xf3, 0x1f, 0xd4, 0x3b, 0xc9, 0x1f, 0x3b, 0x2d, 0xba, 0xfa, 0xd7, 0xbf, 0xb2, 0xba, 0x96, 0x4a,
-	0x1e, 0xb2, 0x9f, 0x67, 0xb8, 0xd5, 0xb8, 0xd6, 0x35, 0x4b, 0x3d, 0x6b, 0x98, 0x64, 0xdb, 0xa3, 0xc0, 0x47, 0x99, 0xe6, 0xf6,
-	0xab, 0x59, 0xa5, 0xe6, 0xf3, 0x8a, 0xe9, 0xd6, 0xed, 0x7e, 0xdf, 0x15, 0x7b, 0x7d, 0xbf, 0x6a, 0xbd, 0xbf, 0xf7, 0x7e, 0x41,
-	0xa3, 0x60, 0xf5, 0xf5, 0xfd, 0x83, 0x39, 0xa9, 0xe7, 0xb0, 0xbb, 0x46, 0xb1, 0x97, 0xc9, 0x6b, 0xfb, 0x26, 0xb9, 0x95, 0xc7,
-	0xe7, 0x70, 0x19, 0xec, 0x35, 0xe5, 0xc6, 0x3b, 0x2d, 0x85, 0xcc, 0xe2, 0x6e, 0xe2, 0xbe, 0xc6, 0x65, 0x71, 0x97, 0xf6, 0xb2,
-	0x45, 0x73, 0x65, 0x90, 0xc7, 0xde, 0xc1, 0x44, 0xb0, 0xcb, 0x1d, 0x54, 0xd7, 0x1c, 0x94, 0x71, 0x55, 0x3c, 0xf1, 0xcf, 0x1c,
-	0x72, 0xd, 0xb6, 0xf3, 0x53, 0xcd, 0xce, 0xcc, 0xf3, 0x9f, 0x6d, 0xea, 0xfd, 0xf7, 0xb6, 0xb1, 0x58, 0x1b, 0x3d, 0xcb, 0xae,
-	0xfa, 0x87, 0x3, 0xd5, 0x37, 0xf9, 0x9c, 0x15, 0x13, 0x5b, 0xd3, 0xb9, 0x57, 0x84, 0xce, 0x6c, 0x79, 0xd9, 0x76, 0xdc, 0x9d,
-	0x85, 0x7c, 0xfe, 0x13, 0x1b, 0x97, 0xcb, 0x5d, 0x6c, 0x72, 0x73, 0x3c, 0x16, 0xbc, 0x51, 0x6b, 0x4d, 0x54, 0x7b, 0xc7, 0x45,
-	0x14, 0xf3, 0xc5, 0x14, 0x86, 0xa6, 0x6b, 0xbb, 0x26, 0xc3, 0xa8, 0x67, 0x71, 0x5b, 0x46, 0xa5, 0x9e, 0xcd, 0x6a, 0xfb, 0x36,
-	0xa, 0xf6, 0xc, 0x9e, 0xf, 0x62, 0xd7, 0x72, 0x97, 0xd8, 0x4c, 0xee, 0x1b, 0x25, 0x6b, 0x5f, 0xce, 0xdb, 0x21, 0x8a, 0xcb,
-	0xe3, 0x67, 0xb6, 0xc8, 0x63, 0xaf, 0x6d, 0xeb, 0xe3, 0xde, 0x89, 0x61, 0x92, 0x89, 0x28, 0xe7, 0xf3, 0xe3, 0x9e, 0x1, 0xdc,
-	0xce, 0x8e, 0xfa, 0x87, 0x7c, 0xe4, 0xea, 0xfc, 0x3e, 0x33, 0x5d, 0xec, 0x3c, 0x6f, 0x57, 0x77, 0xd6, 0x3b, 0x1d, 0x6f, 0xcd,
-	0xaf, 0xed, 0xcd, 0xd7, 0x3, 0x92, 0xd7, 0xf7, 0xdb, 0x88, 0x61, 0x86, 0x58, 0xec, 0x68, 0x9f, 0x63, 0xd3, 0x32, 0xb8, 0x6c,
-	0x25, 0xe5, 0x70, 0x7b, 0xc7, 0xc4, 0xb3, 0xdd, 0x62, 0x2e, 0x6f, 0x2e, 0xa9, 0x8f, 0xde, 0x59, 0xb9, 0x9a, 0xba, 0xe6, 0xa8,
-	0x33, 0x2e, 0xd3, 0xf5, 0x30, 0x79, 0x3f, 0x7f, 0x87, 0x9e, 0xd7, 0x50, 0xe8, 0x2e, 0x8d, 0xd6, 0xf3, 0x52, 0xf3, 0xf0, 0x8b,
-	0x2f, 0x99, 0xba, 0xde, 0x76, 0x9b, 0x6b, 0x58, 0xaa, 0xa2, 0x4a, 0x64, 0xae, 0x1c, 0x4d, 0xbe, 0x7b, 0x5a, 0xf9, 0xde, 0x53,
-	0x55, 0x54, 0xd5, 0x15, 0x72, 0x4f, 0x5c, 0x54, 0xd5, 0x4f, 0xeb, 0x8a, 0x4e, 0x39, 0xf6, 0xe0, 0x38, 0xad, 0xe4, 0xff, 0x0,
-	0x99, 0xde, 0x4a, 0xf9, 0x8b, 0xb4, 0xd1, 0xb4, 0xf9, 0x3, 0xda, 0x59, 0xdd, 0xd7, 0xf0, 0x53, 0x4d, 0x2e, 0xbf, 0xac, 0x51,
-	0xcc, 0x38, 0x6d, 0x17, 0x53, 0xa2, 0x6f, 0x78, 0xfe, 0xde, 0xb1, 0xa5, 0xe1, 0xe2, 0xb3, 0xd7, 0xf1, 0x73, 0x7e, 0x1b, 0xe3,
-	0xc, 0xb7, 0x9c, 0x41, 0x5e, 0x42, 0xf2, 0x88, 0xe8, 0xe6, 0xea, 0xe2, 0x7a, 0xf8, 0xf9, 0xf2, 0x1a, 0xba, 0x0, 0x32, 0x7f,
-	0x4e, 0x77, 0x4f, 0x6a, 0x78, 0xfb, 0xd8, 0x38, 0x3e, 0xd4, 0xe9, 0x8d, 0xe3, 0x39, 0xd7, 0xbb, 0xfe, 0xb9, 0x24, 0x95, 0xe2,
-	0xb6, 0x2c, 0xc, 0xf1, 0xd1, 0x3d, 0x31, 0x4f, 0x4f, 0xdb, 0xba, 0xb0, 0xbe, 0xb3, 0xba, 0x8a, 0xe7, 0x1b, 0x98, 0xc4, 0x5f,
-	0xc5, 0xfa, 0x2e, 0x6c, 0xaf, 0x21, 0x9e, 0xd2, 0xe6, 0x3f, 0xd3, 0x2c, 0x75, 0xd3, 0xf9, 0x3, 0xbe, 0x5a, 0x57, 0xd4, 0xb5,
-	0xe5, 0x3e, 0x23, 0x3, 0x6d, 0x8f, 0xde, 0x3a, 0x3b, 0xa4, 0x77, 0x4c, 0xe5, 0xb7, 0xc2, 0x2a, 0xb6, 0x1c, 0x6c, 0x9b, 0x96,
-	0xa1, 0xcd, 0xfc, 0x11, 0xdb, 0x5b, 0xc5, 0xc4, 0xd9, 0x1c, 0x4d, 0x19, 0xbc, 0xed, 0x9f, 0x39, 0x49, 0xee, 0x28, 0x96, 0x59,
-	0x64, 0xb5, 0xe6, 0xd6, 0xdb, 0x9f, 0xb9, 0xc5, 0x31, 0xdb, 0xc5, 0xc5, 0x3f, 0xa8, 0x34, 0xf3, 0xcc, 0x7f, 0x5a, 0xff, 0x0,
-	0x31, 0x7c, 0xbe, 0xd5, 0x33, 0x3d, 0x69, 0x35, 0xe6, 0xb1, 0xd3, 0x1d, 0x53, 0x9f, 0xb5, 0xe7, 0x1f, 0x9f, 0xd4, 0x3a, 0xb6,
-	0xdf, 0x29, 0x67, 0x94, 0xda, 0xb1, 0x72, 0x53, 0xed, 0x73, 0x8c, 0xdb, 0x37, 0x2c, 0xbe, 0x4b, 0x21, 0x9c, 0xbe, 0xc6, 0x5e,
-	0x7c, 0xab, 0x8e, 0xe2, 0xd2, 0xc7, 0xf6, 0x6d, 0x95, 0xdd, 0xb5, 0x5f, 0x66, 0xe6, 0x9, 0xe9, 0xf9, 0xf3, 0x58, 0x73, 0xdb,
-	0xc6, 0xcf, 0x22, 0xfb, 0x2f, 0xc5, 0x1e, 0xe3, 0xd5, 0xbb, 0xd7, 0xa8, 0x6e, 0xf1, 0x16, 0x5b, 0xfe, 0x9f, 0x6, 0x7e, 0xdf,
-	0xb, 0x73, 0x9d, 0xc4, 0xc3, 0x9c, 0xc5, 0xd1, 0x1e, 0xcb, 0xae, 0xe5, 0x35, 0x7c, 0xa7, 0x17, 0x18, 0xcb, 0x8a, 0xe3, 0x8a,
-	0x7e, 0x6b, 0xc5, 0x66, 0x26, 0xe2, 0x8e, 0x79, 0xe7, 0x8f, 0x85, 0x7c, 0xf1, 0x57, 0xf9, 0x3, 0xd6, 0xf2, 0x93, 0xca, 0x4e,
-	0xd7, 0xf3, 0xb, 0xb5, 0xee, 0xfb, 0xa3, 0xba, 0x2e, 0xf0, 0x77, 0xdb, 0xc5, 0xf6, 0xf, 0xb, 0xaf, 0x5c, 0x5c, 0x6b, 0xd8,
-	0x58, 0x70, 0x38, 0xea, 0xf1, 0xd8, 0x18, 0x65, 0x83, 0x1d, 0xc7, 0x18, 0xe8, 0x25, 0x96, 0x2a, 0x26, 0xa2, 0x29, 0x79, 0xe2,
-	0xaa, 0xb8, 0xe7, 0x8f, 0x97, 0xb7, 0x1f, 0x97, 0xbf, 0xf6, 0x86, 0x0, 0xc7, 0x64, 0x72, 0x18, 0x7c, 0x85, 0x86, 0x5f, 0x11,
-	0x7f, 0x79, 0x8b, 0xca, 0xe2, 0xef, 0x2d, 0x72, 0x38, 0xcc, 0x9e, 0x3a, 0xea, 0x7b, 0x1c, 0x86, 0x3b, 0x21, 0x63, 0x3c, 0x77,
-	0x36, 0x57, 0xf6, 0x17, 0xb6, 0xd2, 0x45, 0x73, 0x67, 0x79, 0x67, 0x73, 0x15, 0x32, 0x45, 0x2c, 0x75, 0x53, 0x5c, 0x75, 0xd3,
-	0xc5, 0x54, 0xf3, 0xc7, 0x3c, 0x71, 0xcf, 0x1, 0xdb, 0xbf, 0x1e, 0xbe, 0xa0, 0x2f, 0x3a, 0x7a, 0x5f, 0x13, 0x8e, 0xd6, 0x77,
-	0x8b, 0x8d, 0x17, 0xc8, 0x4d, 0x7e, 0xc2, 0x3a, 0x2d, 0xe3, 0xbd, 0xed, 0xc, 0x56, 0x52, 0x1d, 0xf6, 0x3b, 0x48, 0x21, 0xb9,
-	0xa6, 0x18, 0xa3, 0xde, 0x35, 0x8c, 0xb6, 0x1a, 0x5c, 0x94, 0xf5, 0x5c, 0x4b, 0x1d, 0x53, 0x5c, 0xe5, 0xec, 0xf2, 0xd7, 0x52,
-	0xd1, 0x17, 0xc7, 0xee, 0x53, 0x55, 0x5c, 0xd7, 0xc0, 0x6c, 0x9e, 0x67, 0xea, 0x67, 0xf2, 0x42, 0x7c, 0x65, 0xdc, 0x5a, 0xff,
-	0x0, 0x8e, 0x7d, 0x23, 0x8c, 0xcc, 0x57, 0x45, 0x1c, 0x58, 0xdf, 0xe6, 0x72, 0xdb, 0xe6, 0x77, 0x19, 0x6f, 0x27, 0x12, 0xd1,
-	0xcc, 0x95, 0x5d, 0xe2, 0x6c, 0xb3, 0x1a, 0xed, 0xd5, 0xe5, 0x15, 0x43, 0xc5, 0x54, 0xf1, 0x4d, 0x17, 0xb0, 0x73, 0x4d, 0x5c,
-	0xf1, 0x57, 0xbf, 0x3c, 0x71, 0xcd, 0x35, 0x7, 0x1f, 0x7c, 0xb3, 0xf5, 0xc, 0xf2, 0xcb, 0xcd, 0x5b, 0xc8, 0x69, 0xef, 0x4e,
-	0xcf, 0xbe, 0xc8, 0xea, 0x96, 0x17, 0x3c, 0x5e, 0x61, 0xfa, 0xdb, 0x59, 0xb6, 0x8b, 0x55, 0xeb, 0x9c, 0x4d, 0xcd, 0x14, 0xf1,
-	0xc4, 0x77, 0x54, 0x6b, 0x58, 0xce, 0x68, 0xa3, 0x33, 0x91, 0x83, 0x9e, 0x6b, 0xe6, 0x2b, 0xdc, 0xa4, 0xb7, 0xf7, 0xd0, 0xd3,
-	0x2d, 0x74, 0x47, 0x35, 0x31, 0xd5, 0xf0, 0xe0, 0x3c, 0x9f, 0xf, 0xbc, 0xe5, 0xef, 0xbf, 0x6, 0xb6, 0x4d, 0xc7, 0x6b, 0xe8,
-	0x4c, 0x86, 0xb1, 0x8e, 0xcc, 0x6f, 0x58, 0x3b, 0xd, 0x7b, 0x3d, 0x2e, 0xcd, 0xad, 0xdb, 0x6c, 0x90, 0xd7, 0x8d, 0xc7, 0x5f,
-	0xd5, 0x92, 0xb7, 0x8e, 0xd6, 0xb, 0x99, 0xa2, 0xa2, 0xda, 0x5f, 0xc5, 0x55, 0xef, 0x55, 0x7c, 0x7b, 0xf3, 0xcf, 0x1c, 0x7b,
-	0x7e, 0x5f, 0x9f, 0xb8, 0x6b, 0xdf, 0x6a, 0xf6, 0x56, 0xd1, 0xdc, 0x9d, 0x99, 0xbf, 0xf6, 0xd6, 0xed, 0x35, 0x9d, 0xc6, 0xe1,
-	0xd9, 0x7b, 0x8e, 0xc5, 0xbd, 0x6d, 0x13, 0xe3, 0xec, 0xe8, 0xc7, 0xd8, 0x4d, 0x9f, 0xda, 0x32, 0xb7, 0x59, 0x9c, 0xac, 0x96,
-	0x76, 0x31, 0x73, 0x54, 0x76, 0x76, 0xb5, 0xde, 0xde, 0x57, 0xcd, 0x11, 0x53, 0xcf, 0x3c, 0x51, 0x4f, 0xb7, 0x1f, 0xe4, 0xf,
-	0x81, 0x6, 0xed, 0xf8, 0x2b, 0xe7, 0x97, 0x73, 0x78, 0xd, 0xda, 0xb7, 0x3d, 0x8b, 0xd5, 0x92, 0xda, 0xe6, 0xb0, 0xbb, 0x6,
-	0x3b, 0x9c, 0x46, 0xf9, 0xd7, 0x19, 0xeb, 0x9b, 0xd8, 0xf5, 0x2d, 0xe3, 0x1f, 0xc, 0x77, 0x5c, 0xe2, 0x6b, 0xc9, 0xc5, 0x67,
-	0x25, 0x13, 0x5a, 0xe5, 0xf5, 0xfb, 0xdb, 0xaa, 0xa7, 0xb0, 0xbd, 0x8b, 0xda, 0x7b, 0x7e, 0x6b, 0x96, 0x2f, 0x7a, 0xa0, 0x9e,
-	0x78, 0xe4, 0xf, 0x94, 0xf1, 0x5f, 0xcc, 0xbe, 0xe1, 0xf0, 0xdf, 0xb3, 0x76, 0x1e, 0xdd, 0xe9, 0x58, 0xb4, 0xbb, 0x5d, 0xdf,
-	0x62, 0xc1, 0x64, 0x75, 0xb9, 0x32, 0x7b, 0x5e, 0xab, 0x67, 0xb5, 0x7e, 0xcb, 0xc4, 0xe5, 0xb2, 0x76, 0x79, 0x5c, 0x84, 0x58,
-	0x5a, 0x2f, 0xa4, 0xa3, 0xf6, 0x6d, 0xcd, 0xdc, 0xd6, 0x11, 0x47, 0x24, 0xd4, 0x73, 0xf7, 0x2a, 0x87, 0x8e, 0x63, 0xf7, 0xf8,
-	0xd7, 0x5f, 0x15, 0x7, 0xc0, 0x79, 0x19, 0xe4, 0x4f, 0x6a, 0x79, 0x55, 0xdb, 0xbb, 0x3f, 0x77, 0x77, 0x2e, 0x72, 0x2c, 0xf6,
-	0xf7, 0xb5, 0xd3, 0x8b, 0x86, 0xfa, 0x7b, 0x3b, 0x4a, 0x31, 0xb8, 0xab, 0x2b, 0x2c, 0x2e, 0x2e, 0xd3, 0xf, 0x8c, 0xc6, 0xe1,
-	0xb1, 0x30, 0xd5, 0x55, 0xb6, 0x2f, 0x1d, 0x6b, 0x67, 0x65, 0x4f, 0xb4, 0x51, 0xfb, 0x71, 0x54, 0xb5, 0x57, 0x2d, 0x5f, 0x29,
-	0x24, 0xae, 0xaa, 0x83, 0x7, 0x0, 0xe, 0x8f, 0xf5, 0x2f, 0xaa, 0xa7, 0x96, 0xfd, 0x3b, 0xe3, 0x8c, 0xfe, 0x29, 0x60, 0x73,
-	0x3a, 0x2e, 0xc5, 0xd2, 0x97, 0x18, 0x3d, 0xbb, 0x57, 0x93, 0x5a, 0xde, 0xf4, 0x7c, 0x76, 0xd7, 0x2f, 0xf4, 0x67, 0x78, 0xaf,
-	0x23, 0x26, 0xc1, 0xaf, 0x7e, 0x3a, 0xf6, 0x6a, 0x65, 0xab, 0x11, 0x34, 0x99, 0x7b, 0x9e, 0x62, 0x8a, 0xae, 0x2a, 0xe2, 0x1e,
-	0x26, 0xe6, 0x9a, 0x3d, 0xa9, 0xe2, 0x9a, 0x69, 0xf, 0x99, 0xf0, 0xfb, 0xd4, 0x9f, 0xc9, 0xef, 0x6, 0xb5, 0xbd, 0xc7, 0x54,
-	0xe8, 0x4c, 0xae, 0x9b, 0x8d, 0xc4, 0xef, 0x59, 0xcb, 0x1d, 0x87, 0x60, 0xa7, 0x66, 0xd4, 0x6c, 0xf6, 0x4b, 0x89, 0x72, 0x38,
-	0xeb, 0xe, 0x71, 0xb6, 0xbc, 0xdb, 0x4d, 0x75, 0x3c, 0x5f, 0x86, 0x86, 0x8b, 0x6a, 0xb9, 0xf7, 0xa6, 0x9e, 0x3f, 0x55, 0x5c,
-	0xfb, 0xf3, 0xcf, 0xf6, 0x7b, 0x6, 0xe1, 0x7f, 0xe6, 0xd, 0xf5, 0x1a, 0xff, 0x0, 0xf2, 0x8e, 0xa8, 0xff, 0x0, 0xf5, 0x66,
-	0x23, 0xff, 0x0, 0xeb, 0x7, 0x3e, 0x7c, 0xbe, 0xf3, 0x5f, 0xbd, 0x3c, 0xe1, 0xdd, 0x75, 0x8d, 0xfb, 0xbe, 0x72, 0x3a, 0xe6,
-	0x47, 0x61, 0xd4, 0x75, 0x7f, 0xe8, 0x7e, 0x1a, 0x4d, 0x6b, 0x5d, 0xb6, 0xd6, 0xed, 0x23, 0xc3, 0x7e, 0xd6, 0xc8, 0x66, 0xbe,
-	0x13, 0xda, 0xda, 0xcb, 0x2d, 0x33, 0xdc, 0x7e, 0x3b, 0x27, 0x2f, 0x3f, 0x73, 0x9e, 0x7d, 0xfe, 0x3e, 0xdc, 0x7f, 0x90, 0x35,
-	0x28, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd0,
-	0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff,
-	0xd1, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7,
-	0xff, 0xd2, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x7, 0xff, 0xd3, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x7, 0xff, 0xd4, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x7, 0xff, 0xd5, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x7, 0xff, 0xd6, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd7, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd0, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd1, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd2, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd3, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd4, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd5, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd6, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd7, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd0, 0xaf, 0xfc, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd1, 0xaf, 0xfc, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd2, 0xaf, 0xfc, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd3, 0xaf, 0xfc,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd4, 0xaf,
-	0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff, 0xd5,
-	0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xff,
-	0xd6, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7,
-	0xff, 0xd7, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x7, 0xff, 0xd0, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x7, 0xff, 0xd1, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x7, 0xff, 0xd2, 0xaf, 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-	0x0, 0x0, 0x0, 0x7, 0xff, 0xd9
-};

src/data/index.html

@@ -1,53 +0,0 @@
-<!DOCTYPE html>
-
-<html>
-<head>
-	<meta charset="utf-8" />
-	<title>uStreamer</title>
-</head>
-
-<body>
-	<h3>&micro;Streamer v%VERSION%</h3>
-	<hr>
-	<ul>
-		<li>
-			<a href="/ping"><b><samp>/ping</samp></b></a><br>
-			Get JSON structure with state of the server.
-		</li>
-		<br>
-		<li>
-			<a href="/snapshot"><b><samp>/snapshot</samp></b></a><br>
-			Get a current actual image from the server.
-		</li>
-		<br>
-		<li>
-			<a href="/stream"><b><samp>/stream</samp></b></a><br>
-			Get a live stream. Query params:<br>
-			<br>
-			<ul>
-				<li>
-					<b><samp>extra_headers=1</samp></b><br>
-					Add <samp>X-UStreamer-*</samp> headers to /stream handle (like on <a href="/snapshot"><samp>/snapshot</samp></a>).
-				</li>
-				<br>
-				<li>
-					<b><samp>advance_headers=1</samp></b><br>
-					Enable workaround for Chromium/Blink
-					<a href="https://bugs.chromium.org/p/chromium/issues/detail?id=527446">Bug #527446</a>.
-				</li>
-				<br>
-				<li>
-					<b><samp>dual_final_frames=1</samp></b><br>
-					Enable workaround for Safari/WebKit bug when using option <samp>--drop-same-frames</samp>.<br>
-					Without this option, when the frame series is completed, WebKit-based browsers<br>
-					renders the last one with a delay.
-				</li>
-			</ul>
-		</li>
-		<br>
-	</ul>
-	<br>
-	<hr>
-	<a href="https://github.com/pi-kvm/ustreamer">Sources &amp; docs</a>
-</body>
-</html>

src/device.c

@@ -1,458 +0,0 @@
-/*****************************************************************************
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
-#                                                                            #
-#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
-#                                                                            #
-#    This program is free software: you can redistribute it and/or modify    #
-#    it under the terms of the GNU General Public License as published by    #
-#    the Free Software Foundation, either version 3 of the License, or       #
-#    (at your option) any later version.                                     #
-#                                                                            #
-#    This program is distributed in the hope that it will be useful,         #
-#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
-#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
-#    GNU General Public License for more details.                            #
-#                                                                            #
-#    You should have received a copy of the GNU General Public License       #
-#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
-#                                                                            #
-*****************************************************************************/
-
-
-#include <stdlib.h>
-#include <stddef.h>
-#include <stdbool.h>
-#include <string.h>
-#include <strings.h>
-#include <unistd.h>
-#include <fcntl.h>
-
-#include <sys/mman.h>
-#include <linux/videodev2.h>
-
-#include "tools.h"
-#include "logging.h"
-#include "xioctl.h"
-#include "device.h"
-
-
-static const struct {
-	const char *name;
-	const v4l2_std_id standard;
-} _STANDARDS[] = {
-	{"UNKNOWN",	V4L2_STD_UNKNOWN},
-	{"PAL",		V4L2_STD_PAL},
-	{"NTSC",	V4L2_STD_NTSC},
-	{"SECAM",	V4L2_STD_SECAM},
-};
-
-static const struct {
-	const char *name;
-	const unsigned format;
-} _FORMATS[] = {
-	{"YUYV",	V4L2_PIX_FMT_YUYV},
-	{"UYVY",	V4L2_PIX_FMT_UYVY},
-	{"RGB565",	V4L2_PIX_FMT_RGB565},
-};
-
-
-static int _device_open_check_cap(struct device_t *dev);
-static int _device_open_dv_timings(struct device_t *dev);
-static int _device_apply_dv_timings(struct device_t *dev);
-static int _device_open_format(struct device_t *dev);
-static void _device_open_alloc_picbufs(struct device_t *dev);
-static int _device_open_mmap(struct device_t *dev);
-static int _device_open_queue_buffers(struct device_t *dev);
-
-static const char *_format_to_string_auto(char *buf, const size_t size, const unsigned format);
-static const char *_format_to_string_null(const unsigned format);
-static const char *_standard_to_string(const v4l2_std_id standard);
-
-
-struct device_t *device_init() {
-	struct device_runtime_t *run;
-	struct device_t *dev;
-
-	A_CALLOC(run, 1);
-	run->fd = -1;
-
-	A_CALLOC(dev, 1);
-	dev->path = "/dev/video0";
-	dev->width = 640;
-	dev->height = 480;
-	dev->format = V4L2_PIX_FMT_YUYV;
-	dev->standard = V4L2_STD_UNKNOWN;
-	dev->n_buffers = max_u(sysconf(_SC_NPROCESSORS_ONLN), 1) + 1;
-	dev->n_workers = dev->n_buffers;
-	dev->soft_fps = 30;
-	dev->timeout = 1;
-	dev->error_delay = 1;
-	dev->run = run;
-	return dev;
-}
-
-void device_destroy(struct device_t *dev) {
-	free(dev->run);
-	free(dev);
-}
-
-int device_parse_format(const char *const str) {
-	for (unsigned index = 0; index < sizeof(_FORMATS) / sizeof(_FORMATS[0]); ++index) {
-		if (!strcasecmp(str, _FORMATS[index].name)) {
-			return _FORMATS[index].format;
-		}
-	}
-	return FORMAT_UNKNOWN;
-}
-
-v4l2_std_id device_parse_standard(const char *const str) {
-	for (unsigned index = 1; index < sizeof(_STANDARDS) / sizeof(_STANDARDS[0]); ++index) {
-		if (!strcasecmp(str, _STANDARDS[index].name)) {
-			return _STANDARDS[index].standard;
-		}
-	}
-	return STANDARD_UNKNOWN;
-}
-
-int device_open(struct device_t *dev) {
-	if ((dev->run->fd = open(dev->path, O_RDWR|O_NONBLOCK)) < 0) {
-		LOG_PERROR("Can't open device");
-		goto error;
-	}
-	LOG_INFO("Device fd=%d opened", dev->run->fd);
-
-	if (_device_open_check_cap(dev) < 0) {
-		goto error;
-	}
-	if (_device_open_dv_timings(dev) < 0) {
-		goto error;
-	}
-	if (_device_open_format(dev) < 0) {
-		goto error;
-	}
-	if (_device_open_mmap(dev) < 0) {
-		goto error;
-	}
-	if (_device_open_queue_buffers(dev) < 0) {
-		goto error;
-	}
-	_device_open_alloc_picbufs(dev);
-
-	LOG_DEBUG("Device fd=%d initialized", dev->run->fd);
-	return 0;
-
-	error:
-		device_close(dev);
-		return -1;
-}
-
-void device_close(struct device_t *dev) {
-	if (dev->run->pictures) {
-		LOG_DEBUG("Releasing picture buffers ...");
-		for (unsigned index = 0; index < dev->run->n_buffers && dev->run->pictures[index].data; ++index) {
-			free(dev->run->pictures[index].data);
-			dev->run->pictures[index].data = NULL;
-		}
-		free(dev->run->pictures);
-		dev->run->pictures = NULL;
-	}
-
-	if (dev->run->hw_buffers) {
-		LOG_DEBUG("Unmapping HW buffers ...");
-		for (unsigned index = 0; index < dev->run->n_buffers; ++index) {
-			if (dev->run->hw_buffers[index].start != MAP_FAILED) {
-				if (munmap(dev->run->hw_buffers[index].start, dev->run->hw_buffers[index].length) < 0) {
-					LOG_PERROR("Can't unmap device buffer %d", index);
-				}
-			}
-		}
-		dev->run->n_buffers = 0;
-		free(dev->run->hw_buffers);
-		dev->run->hw_buffers = NULL;
-	}
-
-	if (dev->run->fd >= 0) {
-		LOG_DEBUG("Closing device ...");
-		if (close(dev->run->fd) < 0) {
-			LOG_PERROR("Can't close device fd=%d", dev->run->fd);
-		} else {
-			LOG_INFO("Device fd=%d closed", dev->run->fd);
-		}
-		dev->run->fd = -1;
-	}
-}
-
-static int _device_open_check_cap(struct device_t *dev) {
-	struct v4l2_capability cap;
-	int input = dev->input; // Needs pointer to int for ioctl()
-
-	MEMSET_ZERO(cap);
-
-	LOG_DEBUG("Calling ioctl(VIDIOC_QUERYCAP) ...");
-	if (xioctl(dev->run->fd, VIDIOC_QUERYCAP, &cap) < 0) {
-		LOG_PERROR("Can't query device (VIDIOC_QUERYCAP)");
-		return -1;
-	}
-
-	if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
-		LOG_ERROR("Video capture not supported by our device");
-		return -1;
-	}
-
-	if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
-		LOG_ERROR("Device does not support streaming IO");
-		return -1;
-	}
-
-	LOG_INFO("Using input channel: %d", input);
-	if (xioctl(dev->run->fd, VIDIOC_S_INPUT, &input) < 0) {
-		LOG_ERROR("Can't set input channel");
-		return -1;
-	}
-
-	if (dev->standard != V4L2_STD_UNKNOWN) {
-		LOG_INFO("Using TV standard: %s", _standard_to_string(dev->standard));
-		if (xioctl(dev->run->fd, VIDIOC_S_STD, &dev->standard) < 0) {
-			LOG_ERROR("Can't set video standard");
-			return -1;
-		}
-	} else {
-		LOG_INFO("Using TV standard: DEFAULT");
-	}
-	return 0;
-}
-
-static int _device_open_dv_timings(struct device_t *dev) {
-	if (dev->dv_timings) {
-		LOG_DEBUG("Using DV-timings");
-
-		if (_device_apply_dv_timings(dev) < 0) {
-			return -1;
-		}
-
-		struct v4l2_event_subscription sub;
-
-		MEMSET_ZERO(sub);
-		sub.type = V4L2_EVENT_SOURCE_CHANGE;
-
-		LOG_DEBUG("Calling ioctl(VIDIOC_SUBSCRIBE_EVENT) ...");
-		if (xioctl(dev->run->fd, VIDIOC_SUBSCRIBE_EVENT, &sub) < 0) {
-			LOG_PERROR("Can't subscribe to V4L2_EVENT_SOURCE_CHANGE");
-			return -1;
-		}
-
-	} else {
-		dev->run->width = dev->width;
-		dev->run->height = dev->height;
-	}
-	return 0;
-}
-
-static int _device_apply_dv_timings(struct device_t *dev) {
-	struct v4l2_dv_timings dv_timings;
-
-	MEMSET_ZERO(dv_timings);
-
-	LOG_DEBUG("Calling ioctl(VIDIOC_QUERY_DV_TIMINGS) ...");
-	if (xioctl(dev->run->fd, VIDIOC_QUERY_DV_TIMINGS, &dv_timings) == 0) {
-		LOG_INFO(
-			"Got new DV timings: resolution=%dx%d; pixclk=%llu",
-			dv_timings.bt.width,
-			dv_timings.bt.height,
-			dv_timings.bt.pixelclock
-		);
-
-		LOG_DEBUG("Calling ioctl(VIDIOC_S_DV_TIMINGS) ...");
-		if (xioctl(dev->run->fd, VIDIOC_S_DV_TIMINGS, &dv_timings) < 0) {
-			LOG_PERROR("Failed to set DV timings");
-			return -1;
-		}
-
-		dev->run->width = dv_timings.bt.width;
-		dev->run->height = dv_timings.bt.height;
-
-	} else {
-		LOG_DEBUG("Calling ioctl(VIDIOC_QUERYSTD) ...");
-		if (xioctl(dev->run->fd, VIDIOC_QUERYSTD, &dev->standard) == 0) {
-			LOG_INFO("Applying the new VIDIOC_S_STD: %s ...", _standard_to_string(dev->standard));
-			if (xioctl(dev->run->fd, VIDIOC_S_STD, &dev->standard) < 0) {
-				LOG_PERROR("Can't set video standard");
-				return -1;
-			}
-		}
-	}
-	return 0;
-}
-
-static int _device_open_format(struct device_t *dev) {
-	struct v4l2_format fmt;
-
-	MEMSET_ZERO(fmt);
-	fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-	fmt.fmt.pix.width = dev->run->width;
-	fmt.fmt.pix.height = dev->run->height;
-	fmt.fmt.pix.pixelformat = dev->format;
-	fmt.fmt.pix.field = V4L2_FIELD_ANY;
-
-	// Set format
-	LOG_DEBUG("Calling ioctl(VIDIOC_S_FMT) ...");
-	if (xioctl(dev->run->fd, VIDIOC_S_FMT, &fmt) < 0) {
-		char format_str[8];
-
-		LOG_PERROR(
-			"Unable to set format=%s; resolution=%dx%d",
-			_format_to_string_auto(format_str, 8, dev->format),
-			dev->run->width,
-			dev->run->height
-		);
-		return -1;
-	}
-
-	// Check resolution
-	if (fmt.fmt.pix.width != dev->run->width || fmt.fmt.pix.height != dev->run->height) {
-		LOG_ERROR("Requested resolution=%dx%d is unavailable", dev->run->width, dev->run->height);
-	}
-	dev->run->width = fmt.fmt.pix.width;
-	dev->run->height = fmt.fmt.pix.height;
-	LOG_INFO("Using resolution: %dx%d", dev->run->width, dev->run->height);
-
-	// Check format
-	if (fmt.fmt.pix.pixelformat != dev->format) {
-		char format_requested_str[8];
-		char format_obtained_str[8];
-		char *format_str_nullable;
-
-		LOG_ERROR(
-			"Could not obtain the requested pixelformat=%s; driver gave us %s",
-			_format_to_string_auto(format_requested_str, 8, dev->format),
-			_format_to_string_auto(format_obtained_str, 8, fmt.fmt.pix.pixelformat)
-		);
-
-		if ((format_str_nullable = (char *)_format_to_string_null(fmt.fmt.pix.pixelformat)) != NULL) {
-			LOG_INFO(
-				"Falling back to %s mode (consider using '--format=%s' option)",
-				format_str_nullable,
-				format_str_nullable
-			);
-		} else {
-			LOG_ERROR("Unsupported pixel format");
-			return -1;
-		}
-	}
-	dev->run->format = fmt.fmt.pix.pixelformat;
-	return 0;
-}
-
-static int _device_open_mmap(struct device_t *dev) {
-	struct v4l2_requestbuffers req;
-
-	MEMSET_ZERO(req);
-	req.count = dev->n_buffers;
-	req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-	req.memory = V4L2_MEMORY_MMAP;
-
-	LOG_DEBUG("Calling ioctl(VIDIOC_REQBUFS) ...");
-	if (xioctl(dev->run->fd, VIDIOC_REQBUFS, &req)) {
-		LOG_PERROR("Device '%s' doesn't support memory mapping", dev->path);
-		return -1;
-	}
-
-	if (req.count < 1) {
-		LOG_ERROR("Insufficient buffer memory: %d", req.count);
-		return -1;
-	} else {
-		LOG_INFO("Requested %d HW buffers, got %d", dev->n_buffers, req.count);
-	}
-
-	LOG_DEBUG("Allocating HW buffers ...");
-
-	A_CALLOC(dev->run->hw_buffers, req.count);
-	for (dev->run->n_buffers = 0; dev->run->n_buffers < req.count; ++dev->run->n_buffers) {
-		struct v4l2_buffer buf_info;
-
-		MEMSET_ZERO(buf_info);
-		buf_info.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-		buf_info.memory = V4L2_MEMORY_MMAP;
-		buf_info.index = dev->run->n_buffers;
-
-		LOG_DEBUG("Calling ioctl(VIDIOC_QUERYBUF) for device buffer %d ...", dev->run->n_buffers);
-		if (xioctl(dev->run->fd, VIDIOC_QUERYBUF, &buf_info) < 0) {
-			LOG_PERROR("Can't VIDIOC_QUERYBUF");
-			return -1;
-		}
-
-		LOG_DEBUG("Mapping device buffer %d ...", dev->run->n_buffers);
-		dev->run->hw_buffers[dev->run->n_buffers].length = buf_info.length;
-		dev->run->hw_buffers[dev->run->n_buffers].start = mmap(NULL, buf_info.length, PROT_READ|PROT_WRITE, MAP_SHARED, dev->run->fd, buf_info.m.offset);
-		if (dev->run->hw_buffers[dev->run->n_buffers].start == MAP_FAILED) {
-			LOG_PERROR("Can't map device buffer %d", dev->run->n_buffers);
-			return -1;
-		}
-	}
-	return 0;
-}
-
-static int _device_open_queue_buffers(struct device_t *dev) {
-	for (unsigned index = 0; index < dev->run->n_buffers; ++index) {
-		struct v4l2_buffer buf_info;
-
-		MEMSET_ZERO(buf_info);
-		buf_info.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-		buf_info.memory = V4L2_MEMORY_MMAP;
-		buf_info.index = index;
-
-		LOG_DEBUG("Calling ioctl(VIDIOC_QBUF) for buffer %d ...", index);
-		if (xioctl(dev->run->fd, VIDIOC_QBUF, &buf_info) < 0) {
-			LOG_PERROR("Can't VIDIOC_QBUF");
-			return -1;
-		}
-	}
-	return 0;
-}
-
-static void _device_open_alloc_picbufs(struct device_t *dev) {
-	LOG_DEBUG("Allocating picture buffers ...");
-	A_CALLOC(dev->run->pictures, dev->run->n_buffers);
-
-	dev->run->max_picture_size = ((dev->run->width * dev->run->height) << 1) * 2;
-	for (unsigned index = 0; index < dev->run->n_buffers; ++index) {
-		LOG_DEBUG("Allocating picture buffer %d sized %lu bytes... ", index, dev->run->max_picture_size);
-		A_CALLOC(dev->run->pictures[index].data, dev->run->max_picture_size);
-		dev->run->pictures[index].allocated = dev->run->max_picture_size;
-	}
-}
-
-static const char *_format_to_string_auto(char *buf, const size_t size, const unsigned format) {
-	assert(size >= 8);
-	buf[0] = format & 0x7f;
-	buf[1] = (format >> 8) & 0x7f;
-	buf[2] = (format >> 16) & 0x7f;
-	buf[3] = (format >> 24) & 0x7f;
-	if (format & (1 << 31)) {
-		buf[4] = '-';
-		buf[5] = 'B';
-		buf[6] = 'E';
-		buf[7] = '\0';
-	} else {
-		buf[4] = '\0';
-	}
-	return buf;
-}
-
-static const char *_format_to_string_null(const unsigned format) {
-    for (unsigned index = 0; index < sizeof(_FORMATS) / sizeof(_FORMATS[0]); ++index) {
-		if (format == _FORMATS[index].format) {
-			return _FORMATS[index].name;
-		}
-    }
-    return NULL;
-}
-
-static const char *_standard_to_string(v4l2_std_id standard) {
-	for (unsigned index = 0; index < sizeof(_STANDARDS) / sizeof(_STANDARDS[0]); ++index) {
-		if (standard == _STANDARDS[index].standard) {
-			return _STANDARDS[index].name;
-		}
-	}
-	return _STANDARDS[0].name;
-}

src/device.h

@@ -1,94 +0,0 @@
-/*****************************************************************************
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
-#                                                                            #
-#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
-#                                                                            #
-#    This program is free software: you can redistribute it and/or modify    #
-#    it under the terms of the GNU General Public License as published by    #
-#    the Free Software Foundation, either version 3 of the License, or       #
-#    (at your option) any later version.                                     #
-#                                                                            #
-#    This program is distributed in the hope that it will be useful,         #
-#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
-#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
-#    GNU General Public License for more details.                            #
-#                                                                            #
-#    You should have received a copy of the GNU General Public License       #
-#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
-#                                                                            #
-*****************************************************************************/
-
-
-#pragma once
-
-#include <stddef.h>
-#include <stdbool.h>
-#include <signal.h>
-
-#include <linux/videodev2.h>
-
-
-#define STANDARD_UNKNOWN	V4L2_STD_UNKNOWN
-#define STANDARDS_STR		"UNKNOWN, PAL, NTSC, SECAM"
-
-#define FORMAT_UNKNOWN	-1
-#define FORMATS_STR		"YUYV, UYVY, RGB565"
-
-
-struct hw_buffer_t {
-	void	*start;
-	size_t	length;
-};
-
-struct picture_t {
-	unsigned char	*data;
-	unsigned long	size;
-	unsigned long	allocated;
-	long double		grab_time;
-	long double		encode_begin_time;
-	long double		encode_end_time;
-};
-
-struct device_runtime_t {
-	int					fd;
-	unsigned			width;
-	unsigned			height;
-	unsigned			format;
-	unsigned			n_buffers;
-	unsigned			n_workers;
-	struct hw_buffer_t	*hw_buffers;
-	struct picture_t	*pictures;
-	unsigned long		max_picture_size;
-	bool				capturing;
-};
-
-struct device_t {
-	char			*path;
-	unsigned		input;
-	unsigned		width;
-	unsigned		height;
-	unsigned		format;
-	v4l2_std_id		standard;
-	bool			dv_timings;
-	unsigned		n_buffers;
-	unsigned		n_workers;
-	unsigned		soft_fps;
-	unsigned		every_frame;
-	unsigned		min_frame_size;
-	bool			persistent;
-	unsigned		timeout;
-	unsigned		error_delay;
-
-	struct device_runtime_t *run;
-	sig_atomic_t volatile stop;
-};
-
-
-struct device_t *device_init();
-void device_destroy(struct device_t *dev);
-
-int device_parse_format(const char *const str);
-v4l2_std_id device_parse_standard(const char *const str);
-
-int device_open(struct device_t *dev);
-void device_close(struct device_t *dev);

src/dump/file.c

@@ -0,0 +1,96 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "file.h"
+
+
+us_output_file_s *us_output_file_init(const char *path, bool json) {
+	us_output_file_s *out;
+	US_CALLOC(out, 1);
+
+	if (!strcmp(path, "-")) {
+		US_LOG_INFO("Using output: <stdout>");
+		out->fp = stdout;
+	} else {
+		US_LOG_INFO("Using output: %s", path);
+		if ((out->fp = fopen(path, "wb")) == NULL) {
+			US_LOG_PERROR("Can't open output file");
+			goto error;
+		}
+	}
+
+	out->json = json;
+	return out;
+
+	error:
+		us_output_file_destroy(out);
+		return NULL;
+}
+
+void us_output_file_write(void *v_out, const us_frame_s *frame) {
+	us_output_file_s *out = v_out;
+	if (out->json) {
+		us_base64_encode(frame->data, frame->used, &out->base64_data, &out->base64_allocated);
+		fprintf(
+			out->fp,
+			"{\"size\": %zu,"
+			" \"width\": %u,"
+			" \"height\": %u,"
+			" \"format\": %u,"
+			" \"stride\": %u,"
+			" \"online\": %u,"
+			" \"key\": %u,"
+			" \"gop\": %u,"
+			" \"grab_begin_ts\": %.3Lf,"
+			" \"grab_end_ts\": %.3Lf,"
+			" \"encode_begin_ts\": %.3Lf,"
+			" \"encode_end_ts\": %.3Lf,"
+			" \"data\": \"%s\"}\n",
+			frame->used,
+			frame->width,
+			frame->height,
+			frame->format,
+			frame->stride,
+			frame->online,
+			frame->key,
+			frame->gop,
+			frame->grab_begin_ts,
+			frame->grab_end_ts,
+			frame->encode_begin_ts,
+			frame->encode_end_ts,
+			out->base64_data);
+	} else {
+		fwrite(frame->data, 1, frame->used, out->fp);
+	}
+	fflush(out->fp);
+}
+
+void us_output_file_destroy(void *v_out) {
+	us_output_file_s *out = v_out;
+	US_DELETE(out->base64_data, free);
+	if (out->fp && out->fp != stdout) {
+		if (fclose(out->fp) < 0) {
+			US_LOG_PERROR("Can't close output file");
+		}
+	}
+	free(out);
+}

src/dump/file.h

@@ -0,0 +1,49 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+#include <sys/types.h>
+
+#include "../libs/tools.h"
+#include "../libs/logging.h"
+#include "../libs/frame.h"
+#include "../libs/base64.h"
+
+
+typedef struct {
+	const char *path;
+	bool		json;
+
+	FILE		*fp;
+	char		*base64_data;
+	size_t		base64_allocated;
+} us_output_file_s;
+
+
+us_output_file_s *us_output_file_init(const char *path, bool json);
+void us_output_file_write(void *v_out, const us_frame_s *frame);
+void us_output_file_destroy(void *v_out);

src/dump/main.c

@@ -0,0 +1,332 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <limits.h>
+#include <float.h>
+#include <getopt.h>
+#include <errno.h>
+
+#include "../libs/const.h"
+#include "../libs/errors.h"
+#include "../libs/tools.h"
+#include "../libs/logging.h"
+#include "../libs/frame.h"
+#include "../libs/memsink.h"
+#include "../libs/fpsi.h"
+#include "../libs/signal.h"
+#include "../libs/options.h"
+
+#include "file.h"
+
+
+enum _OPT_VALUES {
+	_O_SINK = 's',
+	_O_SINK_TIMEOUT = 't',
+	_O_OUTPUT = 'o',
+	_O_OUTPUT_JSON = 'j',
+	_O_COUNT = 'c',
+	_O_INTERVAL = 'i',
+	_O_KEY_REQUIRED = 'k',
+
+	_O_HELP = 'h',
+	_O_VERSION = 'v',
+
+	_O_LOG_LEVEL = 10000,
+	_O_PERF,
+	_O_VERBOSE,
+	_O_DEBUG,
+	_O_FORCE_LOG_COLORS,
+	_O_NO_LOG_COLORS,
+};
+
+static const struct option _LONG_OPTS[] = {
+	{"sink",				required_argument,	NULL,	_O_SINK},
+	{"sink-timeout",		required_argument,	NULL,	_O_SINK_TIMEOUT},
+	{"output",				required_argument,	NULL,	_O_OUTPUT},
+	{"output-json",			no_argument,		NULL,	_O_OUTPUT_JSON},
+	{"count",				required_argument,	NULL,	_O_COUNT},
+	{"interval",			required_argument,	NULL,	_O_INTERVAL},
+	{"key-required",		no_argument,		NULL,	_O_KEY_REQUIRED},
+
+	{"log-level",			required_argument,	NULL,	_O_LOG_LEVEL},
+	{"perf",				no_argument,		NULL,	_O_PERF},
+	{"verbose",				no_argument,		NULL,	_O_VERBOSE},
+	{"debug",				no_argument,		NULL,	_O_DEBUG},
+	{"force-log-colors",	no_argument,		NULL,	_O_FORCE_LOG_COLORS},
+	{"no-log-colors",		no_argument,		NULL,	_O_NO_LOG_COLORS},
+
+	{"help",				no_argument,		NULL,	_O_HELP},
+	{"version",				no_argument,		NULL,	_O_VERSION},
+
+	{NULL, 0, NULL, 0},
+};
+
+
+volatile bool _g_stop = false;
+
+
+typedef struct {
+	void *v_out;
+	void (*write)(void *v_out, const us_frame_s *frame);
+	void (*destroy)(void *v_out);
+} _output_context_s;
+
+
+static void _signal_handler(int signum);
+
+static int _dump_sink(
+	const char *sink_name,
+	unsigned sink_timeout,
+	long long count,
+	long double interval,
+	bool key_required,
+	_output_context_s *ctx);
+
+static void _help(FILE *fp);
+
+
+int main(int argc, char *argv[]) {
+	US_LOGGING_INIT;
+	US_THREAD_RENAME("main");
+
+	const char *sink_name = NULL;
+	unsigned sink_timeout = 1;
+	const char *out_path = NULL;
+	bool out_json = false;
+	long long count = 0;
+	long double interval = 0;
+	bool key_required = false;
+
+#	define OPT_SET(_dest, _value) { \
+			_dest = _value; \
+			break; \
+		}
+
+#	define OPT_NUMBER(_name, _dest, _min, _max, _base) { \
+			errno = 0; char *_end = NULL; long long _tmp = strtoll(optarg, &_end, _base); \
+			if (errno || *_end || _tmp < _min || _tmp > _max) { \
+				printf("Invalid value for '%s=%s': min=%lld, max=%lld\n", _name, optarg, (long long)_min, (long long)_max); \
+				return 1; \
+			} \
+			_dest = _tmp; \
+			break; \
+		}
+
+#	define OPT_LDOUBLE(_name, _dest, _min, _max) { \
+			errno = 0; char *_end = NULL; long double _tmp = strtold(optarg, &_end); \
+			if (errno || *_end || _tmp < _min || _tmp > _max) { \
+				printf("Invalid value for '%s=%s': min=%Lf, max=%Lf\n", _name, optarg, (long double)_min, (long double)_max); \
+				return 1; \
+			} \
+			_dest = _tmp; \
+			break; \
+		}
+
+	char short_opts[128];
+	us_build_short_options(_LONG_OPTS, short_opts, 128);
+
+	for (int ch; (ch = getopt_long(argc, argv, short_opts, _LONG_OPTS, NULL)) >= 0;) {
+		switch (ch) {
+			case _O_SINK:			OPT_SET(sink_name, optarg);
+			case _O_SINK_TIMEOUT:	OPT_NUMBER("--sink-timeout", sink_timeout, 1, 60, 0);
+			case _O_OUTPUT:			OPT_SET(out_path, optarg);
+			case _O_OUTPUT_JSON:	OPT_SET(out_json, true);
+			case _O_COUNT:			OPT_NUMBER("--count", count, 0, LLONG_MAX, 0);
+			case _O_INTERVAL:		OPT_LDOUBLE("--interval", interval, 0, 60);
+			case _O_KEY_REQUIRED:	OPT_SET(key_required, true);
+
+			case _O_LOG_LEVEL:			OPT_NUMBER("--log-level", us_g_log_level, US_LOG_LEVEL_INFO, US_LOG_LEVEL_DEBUG, 0);
+			case _O_PERF:				OPT_SET(us_g_log_level, US_LOG_LEVEL_PERF);
+			case _O_VERBOSE:			OPT_SET(us_g_log_level, US_LOG_LEVEL_VERBOSE);
+			case _O_DEBUG:				OPT_SET(us_g_log_level, US_LOG_LEVEL_DEBUG);
+			case _O_FORCE_LOG_COLORS:	OPT_SET(us_g_log_colored, true);
+			case _O_NO_LOG_COLORS:		OPT_SET(us_g_log_colored, false);
+
+			case _O_HELP:		_help(stdout); return 0;
+			case _O_VERSION:	puts(US_VERSION); return 0;
+
+			case 0:		break;
+			default:	return 1;
+		}
+	}
+
+#	undef OPT_LDOUBLE
+#	undef OPT_NUMBER
+#	undef OPT_SET
+
+	if (sink_name == NULL || sink_name[0] == '\0') {
+		puts("Missing option --sink. See --help for details.");
+		return 1;
+	}
+
+	_output_context_s ctx = {0};
+
+	if (out_path && out_path[0] != '\0') {
+		if ((ctx.v_out = (void*)us_output_file_init(out_path, out_json)) == NULL) {
+			return 1;
+		}
+		ctx.write = us_output_file_write;
+		ctx.destroy = us_output_file_destroy;
+	}
+
+	us_install_signals_handler(_signal_handler, false);
+	const int retval = abs(_dump_sink(sink_name, sink_timeout, count, interval, key_required, &ctx));
+	if (ctx.v_out && ctx.destroy) {
+		ctx.destroy(ctx.v_out);
+	}
+	return retval;
+}
+
+
+static void _signal_handler(int signum) {
+	char *const name = us_signum_to_string(signum);
+	US_LOG_INFO_NOLOCK("===== Stopping by %s =====", name);
+	free(name);
+	_g_stop = true;
+}
+
+static int _dump_sink(
+	const char *sink_name,
+	unsigned sink_timeout,
+	long long count,
+	long double interval,
+	bool key_required,
+	_output_context_s *ctx
+) {
+
+	int retval = -1;
+
+	if (count == 0) {
+		count = -1;
+	}
+
+	const useconds_t interval_us = interval * 1000000;
+
+	us_frame_s *frame = us_frame_init();
+	us_fpsi_s *fpsi = us_fpsi_init("SINK", false);
+	us_memsink_s *sink = NULL;
+
+	if ((sink = us_memsink_init_opened("input", sink_name, false, 0, false, 0, sink_timeout)) == NULL) {
+		goto error;
+	}
+
+	long double last_ts = 0;
+
+	while (!_g_stop) {
+		bool key_requested;
+		const int got = us_memsink_client_get(sink, frame, &key_requested, key_required);
+		if (got == 0) {
+			key_required = false;
+
+			const long double now = us_get_now_monotonic();
+
+			char fourcc_str[8];
+			US_LOG_VERBOSE("%s %.3Lf - %s %ux%u - gop=%u, key=%u, kr=%u - GRAB=%.3Lf ~~%.3Lf~~ ENC=%.3Lf ~~> LAT=%.3Lf - size=%zu",
+				(frame->online ? " ON" : "OFF"),
+				(last_ts ? now - last_ts : 0),
+				us_fourcc_to_string(frame->format, fourcc_str, 8),
+				frame->width,
+				frame->height,
+				frame->gop,
+				frame->key,
+				key_requested,
+				frame->grab_end_ts - frame->grab_begin_ts,
+				frame->encode_begin_ts - frame->grab_end_ts,
+				frame->encode_end_ts - frame->encode_begin_ts,
+				now - frame->grab_begin_ts,
+				frame->used);
+
+			last_ts = now;
+
+			us_fpsi_update(fpsi, true, NULL);
+
+			if (ctx->v_out != NULL) {
+				ctx->write(ctx->v_out, frame);
+			}
+
+			if (count >= 0) {
+				--count;
+				if (count <= 0) {
+					break;
+				}
+			}
+
+			if (interval_us > 0) {
+				usleep(interval_us);
+			}
+		} else if (got == US_ERROR_NO_DATA) {
+			usleep(1000);
+		} else {
+			goto error;
+		}
+	}
+
+	retval = 0;
+
+error:
+	US_DELETE(sink, us_memsink_destroy);
+	us_fpsi_destroy(fpsi);
+	us_frame_destroy(frame);
+	US_LOG_INFO("Bye-bye");
+	return retval;
+}
+
+static void _help(FILE *fp) {
+#	define SAY(_msg, ...) fprintf(fp, _msg "\n", ##__VA_ARGS__)
+	SAY("\nuStreamer-dump - Dump uStreamer's memory sink to file");
+	SAY("═════════════════════════════════════════════════════");
+	SAY("Version: %s; license: GPLv3", US_VERSION);
+	SAY("Copyright (C) 2018-2024 Maxim Devaev <mdevaev@gmail.com>\n");
+	SAY("Example:");
+	SAY("════════");
+	SAY("    ustreamer-dump --sink test --output - \\");
+	SAY("        | ffmpeg -use_wallclock_as_timestamps 1 -i pipe: -c:v libx264 test.mp4\n");
+	SAY("Sink options:");
+	SAY("═════════════");
+	SAY("    -s|--sink <name>  ──────── Memory sink ID. No default.\n");
+	SAY("    -t|--sink-timeout <sec>  ─ Timeout for the upcoming frame. Default: 1.\n");
+	SAY("    -o|--output <filename> ─── Filename to dump output to. Use '-' for stdout. Default: just consume the sink.\n");
+	SAY("    -j|--output-json  ──────── Format output as JSON. Required option --output. Default: disabled.\n");
+	SAY("    -c|--count  <N>  ───────── Limit the number of frames. Default: 0 (infinite).\n");
+	SAY("    -i|--interval <sec>  ───── Delay between reading frames (float). Default: 0.\n");
+	SAY("    -k|--key-required  ─────── Request keyframe from the sink. Default: disabled.\n");
+	SAY("Logging options:");
+	SAY("════════════════");
+	SAY("    --log-level <N>  ──── Verbosity level of messages from 0 (info) to 3 (debug).");
+	SAY("                          Enabling debugging messages can slow down the program.");
+	SAY("                          Available levels: 0 (info), 1 (performance), 2 (verbose), 3 (debug).");
+	SAY("                          Default: %d.\n", us_g_log_level);
+	SAY("    --perf  ───────────── Enable performance messages (same as --log-level=1). Default: disabled.\n");
+	SAY("    --verbose  ────────── Enable verbose messages and lower (same as --log-level=2). Default: disabled.\n");
+	SAY("    --debug  ──────────── Enable debug messages and lower (same as --log-level=3). Default: disabled.\n");
+	SAY("    --force-log-colors  ─ Force color logging. Default: colored if stderr is a TTY.\n");
+	SAY("    --no-log-colors  ──── Disable color logging. Default: ditto.\n");
+	SAY("Help options:");
+	SAY("═════════════");
+	SAY("    -h|--help  ─────── Print this text and exit.\n");
+	SAY("    -v|--version  ──── Print version and exit.\n");
+#	undef SAY
+}

src/encoder.c

@@ -1,181 +0,0 @@
-/*****************************************************************************
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
-#                                                                            #
-#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
-#                                                                            #
-#    This program is free software: you can redistribute it and/or modify    #
-#    it under the terms of the GNU General Public License as published by    #
-#    the Free Software Foundation, either version 3 of the License, or       #
-#    (at your option) any later version.                                     #
-#                                                                            #
-#    This program is distributed in the hope that it will be useful,         #
-#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
-#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
-#    GNU General Public License for more details.                            #
-#                                                                            #
-#    You should have received a copy of the GNU General Public License       #
-#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
-#                                                                            #
-*****************************************************************************/
-
-
-#include <strings.h>
-#include <assert.h>
-
-#include "tools.h"
-#include "logging.h"
-#include "device.h"
-#include "encoder.h"
-
-#include "jpeg/encoder.h"
-
-#ifdef OMX_ENCODER
-#	include "omx/encoder.h"
-#endif
-
-
-static const struct {
-	const char *name;
-	const enum encoder_type_t type;
-} _ENCODER_TYPES[] = {
-	{"CPU",	ENCODER_TYPE_CPU},
-#	ifdef OMX_ENCODER
-	{"OMX",	ENCODER_TYPE_OMX},
-#	endif
-};
-
-
-struct encoder_t *encoder_init() {
-	struct encoder_t *encoder;
-
-	A_CALLOC(encoder, 1);
-	encoder->type = ENCODER_TYPE_CPU;
-	encoder->quality = 80;
-	return encoder;
-}
-
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#pragma GCC diagnostic push
-void encoder_prepare(struct encoder_t *encoder, struct device_t *dev) {
-#pragma GCC diagnostic pop
-
-	assert(encoder->type != ENCODER_TYPE_UNKNOWN);
-
-	if (encoder->type != ENCODER_TYPE_CPU) {
-		LOG_DEBUG("Initializing encoder ...");
-	}
-
-	LOG_INFO("Using JPEG quality: %d%%", encoder->quality);
-
-#	ifdef OMX_ENCODER
-	if (encoder->type == ENCODER_TYPE_OMX) {
-		if (dev->n_workers > OMX_MAX_ENCODERS) {
-			LOG_INFO(
-				"OMX-based encoder can only work with %u worker threads; forced --workers=%u",
-				OMX_MAX_ENCODERS, OMX_MAX_ENCODERS
-			);
-			dev->n_workers = OMX_MAX_ENCODERS;
-		}
-		encoder->n_omxs = dev->n_workers;
-
-		A_CALLOC(encoder->omxs, encoder->n_omxs);
-		for (unsigned index = 0; index < encoder->n_omxs; ++index) {
-			if ((encoder->omxs[index] = omx_encoder_init()) == NULL) {
-				goto use_fallback;
-			}
-		}
-	}
-#	endif
-
-	return;
-
-#	pragma GCC diagnostic ignored "-Wunused-label"
-#	pragma GCC diagnostic push
-	use_fallback:
-		LOG_ERROR("Can't initialize selected encoder, using CPU instead it");
-		encoder->type = ENCODER_TYPE_CPU;
-#	pragma GCC diagnostic pop
-}
-
-void encoder_destroy(struct encoder_t *encoder) {
-#	ifdef OMX_ENCODER
-	if (encoder->omxs) {
-		for (unsigned index = 0; index < encoder->n_omxs; ++index) {
-			if (encoder->omxs[index]) {
-				omx_encoder_destroy(encoder->omxs[index]);
-			}
-		}
-		free(encoder->omxs);
-	}
-#	endif
-	free(encoder);
-}
-
-enum encoder_type_t encoder_parse_type(const char *const str) {
-	for (unsigned index = 0; index < sizeof(_ENCODER_TYPES) / sizeof(_ENCODER_TYPES[0]); ++index) {
-		if (!strcasecmp(str, _ENCODER_TYPES[index].name)) {
-			return _ENCODER_TYPES[index].type;
-		}
-	}
-	return ENCODER_TYPE_UNKNOWN;
-}
-
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#pragma GCC diagnostic push
-void encoder_prepare_live(struct encoder_t *encoder, struct device_t *dev) {
-	assert(encoder->type != ENCODER_TYPE_UNKNOWN);
-
-#pragma GCC diagnostic pop
-#	ifdef OMX_ENCODER
-	if (encoder->type == ENCODER_TYPE_OMX) {
-		for (unsigned index = 0; index < encoder->n_omxs; ++index) {
-			if (omx_encoder_prepare_live(encoder->omxs[index], dev, encoder->quality, encoder->omx_use_ijg) < 0) {
-				goto use_fallback;
-			}
-		}
-	}
-#	endif
-
-	return;
-
-#	pragma GCC diagnostic ignored "-Wunused-label"
-#	pragma GCC diagnostic push
-	use_fallback:
-		LOG_ERROR("Can't prepare selected encoder, falling back to CPU");
-		encoder->type = ENCODER_TYPE_CPU;
-#	pragma GCC diagnostic pop
-}
-
-#pragma GCC diagnostic ignored "-Wunused-label"
-#pragma GCC diagnostic push
-int encoder_compress_buffer(struct encoder_t *encoder, struct device_t *dev,
-	const unsigned worker_number, const unsigned buf_index) {
-#pragma GCC diagnostic pop
-
-	assert(encoder->type != ENCODER_TYPE_UNKNOWN);
-
-	dev->run->pictures[buf_index].encode_begin_time = get_now_monotonic();
-
-	if (encoder->type == ENCODER_TYPE_CPU) {
-		jpeg_encoder_compress_buffer(dev, buf_index, encoder->quality);
-	}
-#	ifdef OMX_ENCODER
-	else if (encoder->type == ENCODER_TYPE_OMX) {
-		if (omx_encoder_compress_buffer(encoder->omxs[worker_number], dev, buf_index) < 0) {
-			goto error;
-		}
-	}
-#	endif
-
-	dev->run->pictures[buf_index].encode_end_time = get_now_monotonic();
-
-	return 0;
-
-#	pragma GCC diagnostic ignored "-Wunused-label"
-#	pragma GCC diagnostic push
-	error:
-		LOG_INFO("HW compressing error, falling back to CPU");
-		encoder->type = ENCODER_TYPE_CPU;
-		return -1;
-#	pragma GCC diagnostic pop
-}

src/http.c

@@ -1,682 +0,0 @@
-/*****************************************************************************
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
-#                                                                            #
-#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
-#                                                                            #
-#    This program is free software: you can redistribute it and/or modify    #
-#    it under the terms of the GNU General Public License as published by    #
-#    the Free Software Foundation, either version 3 of the License, or       #
-#    (at your option) any later version.                                     #
-#                                                                            #
-#    This program is distributed in the hope that it will be useful,         #
-#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
-#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
-#    GNU General Public License for more details.                            #
-#                                                                            #
-#    You should have received a copy of the GNU General Public License       #
-#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
-#                                                                            #
-*****************************************************************************/
-
-
-#include <stdlib.h>
-#include <stdbool.h>
-#include <string.h>
-#include <strings.h>
-#include <assert.h>
-
-#include <event2/event.h>
-#include <event2/thread.h>
-#include <event2/http.h>
-#include <event2/buffer.h>
-#include <event2/bufferevent.h>
-#include <event2/keyvalq_struct.h>
-
-#include <uuid/uuid.h>
-
-#ifndef EVTHREAD_USE_PTHREADS_IMPLEMENTED
-#	error Required libevent-pthreads support
-#endif
-
-#include "tools.h"
-#include "logging.h"
-#include "stream.h"
-#include "http.h"
-
-#include "data/index_html.h"
-#include "data/blank_jpeg.h"
-
-
-static bool _http_get_param_true(struct evkeyvalq *params, const char *key);
-
-static void _http_callback_root(struct evhttp_request *request, void *arg);
-static void _http_callback_ping(struct evhttp_request *request, void *v_server);
-static void _http_callback_snapshot(struct evhttp_request *request, void *v_server);
-
-static void _http_callback_stream(struct evhttp_request *request, void *v_server);
-static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_ctx);
-static void _http_callback_stream_error(struct bufferevent *buf_event, short what, void *v_ctx);
-
-static void _http_exposed_refresh(int fd, short event, void *v_server);
-static void _http_queue_send_stream(struct http_server_t *server, const bool stream_updated, const bool picture_updated);
-
-static bool _expose_new_picture(struct http_server_t *server);
-static bool _expose_blank_picture(struct http_server_t *server);
-
-
-struct http_server_t *http_server_init(struct stream_t *stream) {
-	struct http_server_runtime_t *run;
-	struct http_server_t *server;
-	struct exposed_t *exposed;
-
-	A_CALLOC(exposed, 1);
-
-	A_CALLOC(run, 1);
-	run->stream = stream;
-	run->exposed = exposed;
-	run->drop_same_frames_blank = 10;
-
-	A_CALLOC(server, 1);
-	server->host = "127.0.0.1";
-	server->port = 8080;
-	server->timeout = 10;
-	server->run = run;
-
-	_expose_blank_picture(server);
-
-	assert(!evthread_use_pthreads());
-	assert((run->base = event_base_new()));
-	assert((run->http = evhttp_new(run->base)));
-	evhttp_set_allowed_methods(run->http, EVHTTP_REQ_GET|EVHTTP_REQ_HEAD);
-
-	assert(!evhttp_set_cb(run->http, "/", _http_callback_root, NULL));
-	assert(!evhttp_set_cb(run->http, "/ping", _http_callback_ping, (void *)server));
-	assert(!evhttp_set_cb(run->http, "/snapshot", _http_callback_snapshot, (void *)server));
-	assert(!evhttp_set_cb(run->http, "/stream", _http_callback_stream, (void *)server));
-
-	return server;
-}
-
-void http_server_destroy(struct http_server_t *server) {
-	if (server->run->refresh) {
-		event_del(server->run->refresh);
-		event_free(server->run->refresh);
-	}
-
-	evhttp_free(server->run->http);
-	event_base_free(server->run->base);
-	libevent_global_shutdown();
-
-	free(server->run->exposed->picture.data);
-	free(server->run->exposed);
-	free(server->run);
-	free(server);
-}
-
-int http_server_listen(struct http_server_t *server) {
-	struct timeval refresh_interval;
-
-	refresh_interval.tv_sec = 0;
-	refresh_interval.tv_usec = 1000000 / (server->run->stream->dev->soft_fps * 2);
-	assert((server->run->refresh = event_new(server->run->base, -1, EV_PERSIST, _http_exposed_refresh, server)));
-	assert(!event_add(server->run->refresh, &refresh_interval));
-
-	server->run->drop_same_frames_blank = max_u(server->drop_same_frames, server->run->drop_same_frames_blank);
-
-	LOG_DEBUG("Binding HTTP to [%s]:%d ...", server->host, server->port);
-	evhttp_set_timeout(server->run->http, server->timeout);
-
-	if (evhttp_bind_socket(server->run->http, server->host, server->port) < 0) {
-		LOG_PERROR("Can't listen HTTP on [%s]:%d", server->host, server->port)
-		return -1;
-	}
-
-	LOG_INFO("Listening HTTP on [%s]:%d", server->host, server->port);
-	return 0;
-}
-
-void http_server_loop(struct http_server_t *server) {
-	LOG_INFO("Starting HTTP eventloop ...");
-	event_base_dispatch(server->run->base);
-	LOG_INFO("HTTP eventloop stopped");
-}
-
-void http_server_loop_break(struct http_server_t *server) {
-	event_base_loopbreak(server->run->base);
-}
-
-
-static bool _http_get_param_true(struct evkeyvalq *params, const char *key) {
-	const char *value_str;
-
-	if ((value_str = evhttp_find_header(params, key)) != NULL) {
-		if (!strcasecmp(value_str, "true") || !strcasecmp(value_str, "yes") || value_str[0] == '1') {
-			return true;
-		}
-	}
-	return false;
-}
-
-#define ADD_HEADER(_key, _value) \
-	assert(!evhttp_add_header(evhttp_request_get_output_headers(request), _key, _value))
-
-#define PROCESS_HEAD_REQUEST { \
-		if (evhttp_request_get_command(request) == EVHTTP_REQ_HEAD) { \
-			evhttp_send_reply(request, HTTP_OK, "OK", NULL); \
-			return; \
-		} \
-	}
-
-static void _http_callback_root(struct evhttp_request *request, UNUSED void *arg) {
-	struct evbuffer *buf;
-
-	PROCESS_HEAD_REQUEST;
-
-	assert((buf = evbuffer_new()));
-	assert(evbuffer_add_printf(buf, HTML_INDEX_PAGE));
-	ADD_HEADER("Content-Type", "text/html");
-	evhttp_send_reply(request, HTTP_OK, "OK", buf);
-	evbuffer_free(buf);
-}
-
-static void _http_callback_ping(struct evhttp_request *request, void *v_server) {
-	struct http_server_t *server = (struct http_server_t *)v_server;
-	struct evbuffer *buf;
-
-	PROCESS_HEAD_REQUEST;
-
-	assert((buf = evbuffer_new()));
-	assert(evbuffer_add_printf(buf,
-		"{\"source\": {\"resolution\": {\"width\": %u, \"height\": %u},"
-		" \"online\": %s, \"quality\": %u, \"soft_fps\": %u, \"captured_fps\": %u},"
-		" \"stream\": {\"queued_fps\": %u,  \"clients\": %u, \"clients_stat\": {",
-		(server->fake_width ? server->fake_width : server->run->exposed->width),
-		(server->fake_height ? server->fake_height : server->run->exposed->height),
-		bool_to_string(server->run->exposed->online),
-		server->run->stream->encoder->quality,
-		server->run->stream->dev->soft_fps,
-		server->run->exposed->captured_fps,
-		server->run->exposed->queued_fps,
-		server->run->stream_clients_count
-	));
-	for (struct stream_client_t * client = server->run->stream_clients; client != NULL; client = client->next) {
-		assert(evbuffer_add_printf(buf,
-			"\"%s\": {\"fps\": %u, \"advance_headers\": %s, \"dual_final_frames\": %s}%s",
-			client->id,
-			client->fps,
-			bool_to_string(client->advance_headers),
-			bool_to_string(client->dual_final_frames),
-			(client->next ? ", " : "")
-		));
-	}
-	assert(evbuffer_add_printf(buf, "}}}"));
-
-	ADD_HEADER("Content-Type", "application/json");
-	evhttp_send_reply(request, HTTP_OK, "OK", buf);
-	evbuffer_free(buf);
-}
-
-static void _http_callback_snapshot(struct evhttp_request *request, void *v_server) {
-	struct http_server_t *server = (struct http_server_t *)v_server;
-	struct evbuffer *buf;
-	char header_buf[64];
-
-	PROCESS_HEAD_REQUEST;
-
-#	define EXPOSED(_next) server->run->exposed->_next
-
-	assert((buf = evbuffer_new()));
-	assert(!evbuffer_add(buf, (const void *)EXPOSED(picture.data), EXPOSED(picture.size)));
-
-	ADD_HEADER("Access-Control-Allow-Origin:", "*");
-	ADD_HEADER("Cache-Control", "no-store, no-cache, must-revalidate, pre-check=0, post-check=0, max-age=0");
-	ADD_HEADER("Pragma", "no-cache");
-	ADD_HEADER("Expires", "Mon, 3 Jan 2000 12:34:56 GMT");
-
-#	define ADD_TIME_HEADER(_key, _value) \
-		{ sprintf(header_buf, "%.06Lf", _value); ADD_HEADER(_key, header_buf); }
-
-#	define ADD_UNSIGNED_HEADER(_key, _value) \
-		{ sprintf(header_buf, "%u", _value); ADD_HEADER(_key, header_buf); }
-
-	ADD_TIME_HEADER("X-Timestamp", get_now_real());
-
-	ADD_HEADER("X-UStreamer-Online",					bool_to_string(EXPOSED(online)));
-	ADD_UNSIGNED_HEADER("X-UStreamer-Width",			EXPOSED(width));
-	ADD_UNSIGNED_HEADER("X-UStreamer-Height",			EXPOSED(height));
-	ADD_TIME_HEADER("X-UStreamer-Grab-Time",			EXPOSED(picture.grab_time));
-	ADD_TIME_HEADER("X-UStreamer-Encode-Begin-Time",	EXPOSED(picture.encode_begin_time));
-	ADD_TIME_HEADER("X-UStreamer-Encode-End-Time",		EXPOSED(picture.encode_end_time));
-	ADD_TIME_HEADER("X-UStreamer-Expose-Begin-Time",	EXPOSED(expose_begin_time));
-	ADD_TIME_HEADER("X-UStreamer-Expose-Cmp-Time",		EXPOSED(expose_cmp_time));
-	ADD_TIME_HEADER("X-UStreamer-Expose-End-Time",		EXPOSED(expose_end_time));
-	ADD_TIME_HEADER("X-UStreamer-Send-Time",			get_now_monotonic());
-
-#	undef ADD_TIME_HEADER
-#	undef ADD_UNSUGNED_HEADER
-
-	ADD_HEADER("Content-Type", "image/jpeg");
-
-	evhttp_send_reply(request, HTTP_OK, "OK", buf);
-	evbuffer_free(buf);
-
-#	undef EXPOSED
-}
-
-#undef ADD_HEADER
-
-static void _http_callback_stream(struct evhttp_request *request, void *v_server) {
-	// https://github.com/libevent/libevent/blob/29cc8386a2f7911eaa9336692a2c5544d8b4734f/http.c#L2814
-	// https://github.com/libevent/libevent/blob/29cc8386a2f7911eaa9336692a2c5544d8b4734f/http.c#L2789
-	// https://github.com/libevent/libevent/blob/29cc8386a2f7911eaa9336692a2c5544d8b4734f/http.c#L362
-	// https://github.com/libevent/libevent/blob/29cc8386a2f7911eaa9336692a2c5544d8b4734f/http.c#L791
-	// https://github.com/libevent/libevent/blob/29cc8386a2f7911eaa9336692a2c5544d8b4734f/http.c#L1458
-
-	struct http_server_t *server = (struct http_server_t *)v_server;
-	struct evhttp_connection *conn;
-	struct evkeyvalq params;
-	struct bufferevent *buf_event;
-	struct stream_client_t *client;
-	char *client_addr;
-	unsigned short client_port;
-	uuid_t uuid;
-
-	PROCESS_HEAD_REQUEST;
-
-	conn = evhttp_request_get_connection(request);
-	if (conn != NULL) {
-		A_CALLOC(client, 1);
-		client->server = server;
-		client->request = request;
-		client->need_initial = true;
-		client->need_first_frame = true;
-
-		evhttp_parse_query(evhttp_request_get_uri(request), &params);
-		client->extra_headers = _http_get_param_true(&params, "extra_headers");
-		client->advance_headers = _http_get_param_true(&params, "advance_headers");
-		client->dual_final_frames = _http_get_param_true(&params, "dual_final_frames");
-		evhttp_clear_headers(&params);
-
-		uuid_generate(uuid);
-		uuid_unparse_lower(uuid, client->id);
-
-		if (server->run->stream_clients == NULL) {
-			server->run->stream_clients = client;
-		} else {
-			struct stream_client_t *last = server->run->stream_clients;
-
-			for (; last->next != NULL; last = last->next);
-			client->prev = last;
-			last->next = client;
-		}
-		server->run->stream_clients_count += 1;
-
-		evhttp_connection_get_peer(conn, &client_addr, &client_port);
-		LOG_INFO(
-			"HTTP: Registered the new stream client: [%s]:%u; id=%s;"
-			" advance_headers=%s; dual_final_frames=%s; clients now: %u",
-			client_addr,
-			client_port,
-			client->id,
-			bool_to_string(client->advance_headers),
-			bool_to_string(client->dual_final_frames),
-			server->run->stream_clients_count
-		);
-
-		buf_event = evhttp_connection_get_bufferevent(conn);
-		bufferevent_setcb(buf_event, NULL, NULL, _http_callback_stream_error, (void *)client);
-		bufferevent_enable(buf_event, EV_READ);
-	} else {
-		evhttp_request_free(request);
-	}
-}
-
-#undef PROCESS_HEAD_REQUEST
-
-static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_client) {
-#	define BOUNDARY "boundarydonotcross"
-#	define RN "\r\n"
-
-	struct stream_client_t *client = (struct stream_client_t *)v_client;
-	struct evbuffer *buf;
-	long double now = get_now_monotonic();
-	long long now_second = floor_ms(now);
-
-	if (now_second != client->fps_accum_second) {
-		client->fps = client->fps_accum;
-		client->fps_accum = 0;
-		client->fps_accum_second = now_second;
-	}
-	client->fps_accum += 1;
-
-	assert((buf = evbuffer_new()));
-
-	// В хроме и его производных есть фундаментальный баг: он отрисовывает
-	// фрейм с задержкой на один, как только ему придут заголовки следующего.
-	// В сочетании с drop_same_frames это дает значительный лаг стрима
-	// при большом количестве дропов (на статичном изображении, где внезапно
-	// что-то изменилось.
-	//
-	// https://bugs.chromium.org/p/chromium/issues/detail?id=527446
-	//
-	// Включение advance_headers заставляет стример отсылать заголовки
-	// будущего фрейма сразу после данных текущего, чтобы триггернуть отрисовку.
-	// Естественным следствием этого является невозможность установки заголовка
-	// Content-Length, так как предсказывать будущее мы еще не научились.
-	// Его наличие не требуется RFC, однако никаких стандартов на MJPG over HTTP
-	// в природе не существует, и никто не может гарантировать, что отсутствие
-	// Content-Length не сломает вещание для каких-нибудь маргинальных браузеров.
-	//
-	// Кроме того, advance_headers форсит отключение заголовков X-UStreamer-*
-	// по тем же причинам, по которым у нас нет Content-Length.
-
-#	define ADD_ADVANCE_HEADERS \
-		{ assert(evbuffer_add_printf(buf, \
-		"Content-Type: image/jpeg" RN "X-Timestamp: %.06Lf" RN RN, get_now_real())); }
-
-	if (client->need_initial) {
-		assert(evbuffer_add_printf(buf,
-			"HTTP/1.0 200 OK" RN
-			"Access-Control-Allow-Origin: *" RN
-			"Cache-Control: no-store, no-cache, must-revalidate, pre-check=0, post-check=0, max-age=0" RN
-			"Pragma: no-cache" RN
-			"Expires: Mon, 3 Jan 2000 12:34:56 GMT" RN
-			"Set-Cookie: stream_client_id=%s; path=/; max-age=30" RN
-			"Content-Type: multipart/x-mixed-replace;boundary=" BOUNDARY RN
-			RN
-			"--" BOUNDARY RN,
-			client->id
-		));
-
-		if (client->advance_headers) {
-			ADD_ADVANCE_HEADERS;
-		}
-
-		assert(!bufferevent_write_buffer(buf_event, buf));
-		client->need_initial = false;
-	}
-
-#	define EXPOSED(_next) client->server->run->exposed->_next
-
-	if (!client->advance_headers) {
-		assert(evbuffer_add_printf(buf,
-			"Content-Type: image/jpeg" RN
-			"Content-Length: %lu" RN
-			"X-Timestamp: %.06Lf" RN
-			"%s",
-			EXPOSED(picture.size) * sizeof(*EXPOSED(picture.data)),
-			get_now_real(), (client->extra_headers ? "" : RN)
-		));
-		if (client->extra_headers) {
-			assert(evbuffer_add_printf(buf,
-				"X-UStreamer-Online: %s" RN
-				"X-UStreamer-Width: %u" RN
-				"X-UStreamer-Height: %u" RN
-				"X-UStreamer-Client-FPS: %u" RN
-				"X-UStreamer-Grab-Time: %.06Lf" RN
-				"X-UStreamer-Encode-Begin-Time: %.06Lf" RN
-				"X-UStreamer-Encode-End-Time: %.06Lf" RN
-				"X-UStreamer-Expose-Begin-Time: %.06Lf" RN
-				"X-UStreamer-Expose-Cmp-Time: %.06Lf" RN
-				"X-UStreamer-Expose-End-Time: %.06Lf" RN
-				"X-UStreamer-Send-Time: %.06Lf" RN
-				RN,
-				bool_to_string(EXPOSED(online)),
-				EXPOSED(width),
-				EXPOSED(height),
-				client->fps,
-				EXPOSED(picture.grab_time),
-				EXPOSED(picture.encode_begin_time),
-				EXPOSED(picture.encode_end_time),
-				EXPOSED(expose_begin_time),
-				EXPOSED(expose_cmp_time),
-				EXPOSED(expose_end_time),
-				now
-			));
-		}
-	}
-
-	assert(!evbuffer_add(buf,
-		(void *)EXPOSED(picture.data),
-		EXPOSED(picture.size) * sizeof(*EXPOSED(picture.data))
-	));
-	assert(evbuffer_add_printf(buf, RN "--" BOUNDARY RN));
-
-	if (client->advance_headers) {
-		ADD_ADVANCE_HEADERS;
-	}
-
-	assert(!bufferevent_write_buffer(buf_event, buf));
-	evbuffer_free(buf);
-
-	bufferevent_setcb(buf_event, NULL, NULL, _http_callback_stream_error, (void *)client);
-	bufferevent_enable(buf_event, EV_READ);
-
-#	undef BOUNDARY
-#	undef RN
-#	undef ADD_ADVANCE_HEADERS
-#	undef EXPOSED
-}
-
-static void _http_callback_stream_error(UNUSED struct bufferevent *buf_event, UNUSED short what, void *v_client) {
-	struct stream_client_t *client = (struct stream_client_t *)v_client;
-	struct evhttp_connection *conn;
-	char *client_addr = "???";
-	unsigned short client_port = 0;
-
-	client->server->run->stream_clients_count -= 1;
-
-	conn = evhttp_request_get_connection(client->request);
-	if (conn != NULL) {
-		evhttp_connection_get_peer(conn, &client_addr, &client_port);
-	}
-	LOG_INFO(
-		"HTTP: Disconnected the stream client: [%s]:%u; clients now: %u",
-		client_addr, client_port, client->server->run->stream_clients_count
-	);
-	if (conn != NULL) {
-		evhttp_connection_free(conn);
-	}
-
-	if (client->prev == NULL) {
-		client->server->run->stream_clients = client->next;
-	} else {
-		client->prev->next = client->next;
-	}
-	if (client->next != NULL) {
-		client->next->prev = client->prev;
-	}
-	free(client);
-}
-
-static void _http_queue_send_stream(struct http_server_t *server, const bool stream_updated, const bool picture_updated) {
-	struct evhttp_connection *conn;
-	struct bufferevent *buf_event;
-	long long now;
-	bool queued = false;
-	static unsigned queued_fps_accum = 0;
-	static long long queued_fps_second = 0;
-
-	for (struct stream_client_t *client = server->run->stream_clients; client != NULL; client = client->next) {
-		conn = evhttp_request_get_connection(client->request);
-		if (conn != NULL) {
-			// Фикс для бага WebKit. При включенной опции дропа одинаковых фреймов,
-			// WebKit отрисовывает последний фрейм в серии с некоторой задержкой,
-			// и нужно послать два фрейма, чтобы серия была вовремя завершена.
-			// Это похоже на баг Blink (см. _http_callback_stream_write() и advance_headers),
-			// но фикс для него не лечит проблему вебкита. Такие дела.
-
-			bool dual_update = (
-				server->drop_same_frames
-				&& client->dual_final_frames
-				&& stream_updated
-				&& client->updated_prev
-				&& !picture_updated
-			);
-
-			if (dual_update || picture_updated || client->need_first_frame) {
-				buf_event = evhttp_connection_get_bufferevent(conn);
-				bufferevent_setcb(buf_event, NULL, _http_callback_stream_write, _http_callback_stream_error, (void *)client);
-				bufferevent_enable(buf_event, EV_READ|EV_WRITE);
-
-				client->need_first_frame = false;
-				client->updated_prev = (picture_updated || client->need_first_frame); // Игнорировать dual
-				queued = true;
-			} else if (stream_updated) { // Для dual
-				client->updated_prev = false;
-			}
-		}
-	}
-
-	if (queued) {
-		if ((now = floor_ms(get_now_monotonic())) != queued_fps_second) {
-			server->run->exposed->queued_fps = queued_fps_accum;
-			queued_fps_accum = 0;
-			queued_fps_second = now;
-		}
-		queued_fps_accum += 1;
-	}
-}
-
-static void _http_exposed_refresh(UNUSED int fd, UNUSED short what, void *v_server) {
-	struct http_server_t *server = (struct http_server_t *)v_server;
-	bool stream_updated = false;
-	bool picture_updated = false;
-
-#	define UNLOCK_STREAM \
-		{ server->run->stream->updated = false; A_PTHREAD_M_UNLOCK(&server->run->stream->mutex); }
-
-	if (server->run->stream->updated) {
-		LOG_DEBUG("Refreshing HTTP exposed ...");
-		A_PTHREAD_M_LOCK(&server->run->stream->mutex);
-		if (server->run->stream->picture.size > 0) { // If online
-			picture_updated = _expose_new_picture(server);
-			UNLOCK_STREAM;
-		} else {
-			UNLOCK_STREAM;
-			picture_updated = _expose_blank_picture(server);
-		}
-		stream_updated = true;
-	} else if (!server->run->exposed->online) {
-		LOG_DEBUG("Refreshing HTTP exposed (BLANK) ...");
-		picture_updated = _expose_blank_picture(server);
-		stream_updated = true;
-	}
-
-#	undef UNLOCK_STREAM
-
-	_http_queue_send_stream(server, stream_updated, picture_updated);
-}
-
-static bool _expose_new_picture(struct http_server_t *server) {
-#	define STREAM(_next) server->run->stream->_next
-#	define EXPOSED(_next) server->run->exposed->_next
-
-	assert(STREAM(picture.size) > 0);
-	EXPOSED(captured_fps) = STREAM(captured_fps);
-	EXPOSED(expose_begin_time) = get_now_monotonic();
-
-#	define MEM_STREAM_TO_EXPOSED \
-		EXPOSED(picture.data), STREAM(picture.data), \
-		STREAM(picture.size) * sizeof(*STREAM(picture.data))
-
-	if (server->drop_same_frames) {
-		if (
-			EXPOSED(online)
-			&& EXPOSED(dropped) < server->drop_same_frames
-			&& EXPOSED(picture.size) == STREAM(picture.size)
-			&& !memcmp(MEM_STREAM_TO_EXPOSED)
-		) {
-			EXPOSED(expose_cmp_time) = get_now_monotonic();
-			EXPOSED(expose_end_time) = EXPOSED(expose_cmp_time);
-			LOG_VERBOSE(
-				"HTTP: dropped same frame number %u; comparsion time = %.06Lf",
-				EXPOSED(dropped), EXPOSED(expose_cmp_time) - EXPOSED(expose_begin_time)
-			);
-			EXPOSED(dropped) += 1;
-			return false; // Not updated
-		} else {
-			EXPOSED(expose_cmp_time) = get_now_monotonic();
-			LOG_VERBOSE(
-				"HTTP: passed same frame check (frames are differ); comparsion time = %.06Lf",
-				EXPOSED(expose_cmp_time) - EXPOSED(expose_begin_time)
-			);
-		}
-	}
-
-	if (EXPOSED(picture.allocated) < STREAM(picture.allocated)) {
-		A_REALLOC(EXPOSED(picture.data), STREAM(picture.allocated));
-		EXPOSED(picture.allocated) = STREAM(picture.allocated);
-	}
-
-	memcpy(MEM_STREAM_TO_EXPOSED);
-
-#	undef MEM_STREAM_TO_EXPOSED
-
-	EXPOSED(picture.size) = STREAM(picture.size);
-
-	EXPOSED(picture.grab_time) = STREAM(picture.grab_time);
-	EXPOSED(picture.encode_begin_time) = STREAM(picture.encode_begin_time);
-	EXPOSED(picture.encode_end_time) = STREAM(picture.encode_end_time);
-
-	EXPOSED(width) = STREAM(width);
-	EXPOSED(height) = STREAM(height);
-	EXPOSED(online) = true;
-	EXPOSED(dropped) = 0;
-	EXPOSED(expose_cmp_time) = EXPOSED(expose_begin_time);
-	EXPOSED(expose_end_time) = get_now_monotonic();
-
-	LOG_VERBOSE(
-		"HTTP: exposed new frame; full exposition time =  %.06Lf",
-		 EXPOSED(expose_end_time) - EXPOSED(expose_begin_time)
-	);
-
-#	undef STREAM
-#	undef EXPOSED
-	return true; // Updated
-}
-
-static bool _expose_blank_picture(struct http_server_t *server) {
-#	define EXPOSED(_next) server->run->exposed->_next
-
-	EXPOSED(expose_begin_time) = get_now_monotonic();
-	EXPOSED(expose_cmp_time) = EXPOSED(expose_begin_time);
-
-	if (EXPOSED(online) || EXPOSED(picture.size) == 0) {
-		if (EXPOSED(picture.allocated) < BLANK_JPG_SIZE) {
-			A_REALLOC(EXPOSED(picture.data), BLANK_JPG_SIZE);
-			EXPOSED(picture.allocated) = BLANK_JPG_SIZE;
-		}
-
-		memcpy(
-			EXPOSED(picture.data), BLANK_JPG_DATA,
-			BLANK_JPG_SIZE * sizeof(*EXPOSED(picture.data))
-		);
-
-		EXPOSED(picture.size) = BLANK_JPG_SIZE;
-
-		EXPOSED(picture.grab_time) = 0;
-		EXPOSED(picture.encode_begin_time) = 0;
-		EXPOSED(picture.encode_end_time) = 0;
-
-		EXPOSED(width) = BLANK_JPG_WIDTH;
-		EXPOSED(height) = BLANK_JPG_HEIGHT;
-		EXPOSED(captured_fps) = 0;
-		EXPOSED(online) = false;
-		goto updated;
-	}
-
-	if (EXPOSED(dropped) < server->run->drop_same_frames_blank) {
-		LOG_PERF("HTTP: dropped same frame (BLANK) number %u", EXPOSED(dropped));
-		EXPOSED(dropped) += 1;
-		EXPOSED(expose_end_time) = get_now_monotonic();
-		return false; // Not updated
-	}
-
-	updated:
-		EXPOSED(dropped) = 0;
-		EXPOSED(expose_end_time) = get_now_monotonic();
-		return true; // Updated
-
-#	undef EXPOSED
-}

src/http.h

@@ -1,92 +0,0 @@
-/*****************************************************************************
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
-#                                                                            #
-#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
-#                                                                            #
-#    This program is free software: you can redistribute it and/or modify    #
-#    it under the terms of the GNU General Public License as published by    #
-#    the Free Software Foundation, either version 3 of the License, or       #
-#    (at your option) any later version.                                     #
-#                                                                            #
-#    This program is distributed in the hope that it will be useful,         #
-#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
-#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
-#    GNU General Public License for more details.                            #
-#                                                                            #
-#    You should have received a copy of the GNU General Public License       #
-#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
-#                                                                            #
-*****************************************************************************/
-
-
-#include <stdbool.h>
-
-#include <event2/event.h>
-#include <event2/http.h>
-
-#include "tools.h"
-#include "stream.h"
-
-
-struct stream_client_t {
-	struct http_server_t	*server;
-	struct evhttp_request	*request;
-
-	bool					extra_headers;
-	bool					advance_headers;
-	bool					dual_final_frames;
-
-	char					id[37]; // ex. "1b4e28ba-2fa1-11d2-883f-0016d3cca427" + "\0"
-	bool					need_initial;
-	bool					need_first_frame;
-	bool					updated_prev;
-	unsigned				fps;
-	unsigned				fps_accum;
-	long long				fps_accum_second;
-
-	struct stream_client_t	*prev;
-	struct stream_client_t	*next;
-};
-
-struct exposed_t {
-	struct picture_t	picture;
-	unsigned			width;
-	unsigned			height;
-	unsigned			captured_fps;
-	unsigned			queued_fps;
-	bool				online;
-	unsigned			dropped;
-	long double			expose_begin_time;
-	long double			expose_cmp_time;
-	long double			expose_end_time;
-};
-
-struct http_server_runtime_t {
-	struct event_base		*base;
-	struct evhttp			*http;
-	struct event			*refresh;
-	struct stream_t			*stream;
-	struct exposed_t		*exposed;
-	struct stream_client_t	*stream_clients;
-	unsigned				stream_clients_count;
-	unsigned				drop_same_frames_blank;
-};
-
-struct http_server_t {
-	char		*host;
-	unsigned	port;
-	unsigned	drop_same_frames;
-	unsigned	fake_width;
-	unsigned	fake_height;
-	unsigned	timeout;
-
-	struct http_server_runtime_t *run;
-};
-
-
-struct http_server_t *http_server_init(struct stream_t *stream);
-void http_server_destroy(struct http_server_t *server);
-
-int http_server_listen(struct http_server_t *server);
-void http_server_loop(struct http_server_t *server);
-void http_server_loop_break(struct http_server_t *server);