Bump version: 5.54 → 5.55

(cherry picked from commit f3bfdb2fd74c0bb5249df3f21ab6daf0ec12318a)
Signed-off-by: Maxim Devaev <mdevaev@gmail.com>

.bumpversion.cfg

@@ -1,16 +1,39 @@
 [bumpversion]
 commit = True
 tag = True
-current_version = 0.60
-parse = (?P<major>\d+)\.(?P<minor>\d+)(\.(?P<patch>\d+)(\-(?P<release>[a-z]+))?)?
+current_version = 5.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/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,9 +1,18 @@
-/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/build/
+/python/ustreamer.egg-info/
+/janus/build/
 /ustreamer
-/*.sock
-*.o
+/ustreamer-dump
+/config.mk
+vgcore.*
+*.sock
+*.so
+*.bin
+*.pkg.tar.xz
+*.pkg.tar.zst
+*.tar.gz

Makefile

@@ -1,63 +1,127 @@
+-include config.mk
+
 DESTDIR ?=
 PREFIX ?= /usr/local
+MANPREFIX ?= $(PREFIX)/share/man
+
+CC ?= gcc
+PY ?= python3
 CFLAGS ?= -O3
 LDFLAGS ?=
-CC ?= gcc
+
+export
+
+_LINTERS_IMAGE ?= ustreamer-linters
 
 
 # =====
-LIBS = -lm -ljpeg -pthread -levent -levent_pthreads -luuid
-override CFLAGS += -c -std=c11 -Wall -Wextra -D_GNU_SOURCE
-SOURCES = $(shell ls src/*.c src/encoders/cpu/*.c src/encoders/hw/*.c)
-PROG = ustreamer
+define optbool
+$(filter $(shell echo $(1) | tr A-Z a-z), yes on 1)
+endef
 
-ifeq ($(shell ls -d /opt/vc/include 2>/dev/null), /opt/vc/include)
-SOURCES += $(shell ls src/encoders/omx/*.c)
-LIBS += -lbcm_host -lvcos -lopenmaxil -L/opt/vc/lib
-override CFLAGS += -DWITH_OMX_ENCODER -DOMX_SKIP64BIT -I/opt/vc/include
+ifeq ($(V),)
+	ECHO = @
 endif
 
-OBJECTS = $(SOURCES:.c=.o)
-
-
 # =====
-all: $(SOURCES) $(PROG)
+all:
+	+ $(MAKE) apps
+ifneq ($(call optbool,$(WITH_PYTHON)),)
+	+ $(MAKE) python
+endif
+ifneq ($(call optbool,$(WITH_JANUS)),)
+	+ $(MAKE) janus
+endif
 
 
-install: $(PROG)
-	install -Dm755 $(PROG) $(DESTDIR)$(PREFIX)/bin/$(PROG)
+apps:
+	$(MAKE) -C src
+	$(ECHO) ln -sf src/*.bin .
+
+
+python:
+	$(MAKE) -C python
+	$(ECHO) ln -sf python/build/lib.*/*.so .
+
+
+janus:
+	$(MAKE) -C janus
+	$(ECHO) ln -sf janus/*.so .
+
+
+install: all
+	$(MAKE) -C src install
+ifneq ($(call optbool,$(WITH_PYTHON)),)
+	$(MAKE) -C python install
+endif
+ifneq ($(call optbool,$(WITH_JANUS)),)
+	$(MAKE) -C janus install
+endif
+	mkdir -p $(DESTDIR)$(MANPREFIX)/man1
+	for man in $(shell ls man); do \
+		install -m644 man/$$man $(DESTDIR)$(MANPREFIX)/man1/$$man; \
+		gzip -f $(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)-jpeg-h.py src/ustreamer/data/blank.jpeg src/ustreamer/data/blank_jpeg.c BLANK
+	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/encoders/*/*.o vgcore.* *.sock $(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 *.bin *.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.60
-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 encoder
-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,72 +1,215 @@
 # µ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>2</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 |
-| Streaming via UNIX domain socket | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes | ![#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 |
-| 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>3</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 SIGNAL``` 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()```.
 
-  * ```3``` ...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.
+
+* AUR has a package for 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
+* FreeBSD port: https://www.freshports.org/multimedia/ustreamer.
+
+### Preconditions
+You'll need  ```make```, ```gcc```, ```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
 ```
 
+: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 [Auvidea B101](https://www.raspberrypi.org/forums/viewtopic.php?f=38&t=120702&start=400#p1339178) on Raspberry Pi:
-```bash
+```
 $ ./ustreamer \
     --format=uyvy \ # Device input format
-    --encoder=omx \ # Hardware encoding with OpenMAX
-    --workers=3 \ # Maximum workers for OpenMAX
+    --encoder=m2m-image \ # Hardware encoding on V4L2 M2M driver
+    --workers=3 \ # Workers number
     --persistent \ # Don't re-initialize device on timeout (for example when HDMI cable was disconnected)
     --dv-timings \ # Use DV-timings
-    --drop-same-frames=30 # Save that traffic
+    --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-2023 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,82 +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>2</sup> |
-| Возможность пропуска фреймов при передаче<br>статического изображения по HTTP<br>для экономии трафика | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть <sup>2</sup> | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Нет |
-| Стрим через UNIX domain socket | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть | ![#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=+) Нет |
-| Поддержка контролов веб-камер (фокус,<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>3</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 придерживается концепции 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
-    --workers=3 \ # Максимум воркеров для OpenMAX
-    --persistent \ # Не переинициализировать устройство при таймауте (например, когда был отключен HDMI-кабель)
-    --dv-timings \ # Включение DV-таймингов
-    --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 @@
+DESTDIR ?=
+PREFIX ?= /usr/local
+
+CC ?= gcc
+CFLAGS ?= -O3
+LDFLAGS ?=
+
+
+# =====
+_PLUGIN = libjanus_ustreamer.so
+
+_CFLAGS = -fPIC -MD -c -std=c17 -Wall -Wextra -D_GNU_SOURCE $(shell pkg-config --cflags glib-2.0) $(CFLAGS)
+_LDFLAGS = -shared -lm -pthread -lrt -ljansson -lopus -lasound -lspeexdsp $(shell pkg-config --libs glib-2.0) $(LDFLAGS)
+
+_SRCS = $(shell ls src/uslibs/*.c src/*.c)
+
+_BUILD = build
+
+
+define optbool
+$(filter $(shell echo $(1) | tr A-Z a-z), yes on 1)
+endef
+
+
+WITH_PTHREAD_NP ?= 1
+ifneq ($(call optbool,$(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 $(DESTDIR)$(PREFIX)/lib/ustreamer/janus
+	install -m755 $(_PLUGIN) $(DESTDIR)$(PREFIX)/lib/ustreamer/janus/$(PLUGIN)
+
+
+clean:
+	rm -rf $(_PLUGIN) $(_BUILD)
+
+
+_OBJS = $(_SRCS:%.c=$(_BUILD)/%.o)
+-include $(_OBJS:%.o=%.d)

janus/src/audio.c

@@ -0,0 +1,255 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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 "audio.h"
+
+
+#define _JLOG_PERROR_ALSA(_err, _prefix, _msg, ...)	US_JLOG_ERROR(_prefix, _msg ": %s", ##__VA_ARGS__, snd_strerror(_err))
+#define _JLOG_PERROR_RES(_err, _prefix, _msg, ...)	US_JLOG_ERROR(_prefix, _msg ": %s", ##__VA_ARGS__, speex_resampler_strerror(_err))
+#define _JLOG_PERROR_OPUS(_err, _prefix, _msg, ...)	US_JLOG_ERROR(_prefix, _msg ": %s", ##__VA_ARGS__, opus_strerror(_err))
+
+// A number of frames per 1 channel:
+//   - https://github.com/xiph/opus/blob/7b05f44/src/opus_demo.c#L368
+#define _HZ_TO_FRAMES(_hz)	(6 * (_hz) / 50) // 120ms
+#define _HZ_TO_BUF16(_hz)	(_HZ_TO_FRAMES(_hz) * 2) // One stereo frame = (16bit L) + (16bit R)
+#define _HZ_TO_BUF8(_hz)	(_HZ_TO_BUF16(_hz) * sizeof(int16_t))
+
+#define _MIN_PCM_HZ			8000
+#define _MAX_PCM_HZ			192000
+#define _MAX_BUF16			_HZ_TO_BUF16(_MAX_PCM_HZ)
+#define _MAX_BUF8			_HZ_TO_BUF8(_MAX_PCM_HZ)
+#define _ENCODER_INPUT_HZ	48000
+
+
+typedef struct {
+	int16_t		data[_MAX_BUF16];
+} _pcm_buffer_s;
+
+typedef struct {
+	uint8_t		data[_MAX_BUF8]; // Worst case
+	size_t		used;
+	uint64_t	pts;
+} _enc_buffer_s;
+
+
+static void *_pcm_thread(void *v_audio);
+static void *_encoder_thread(void *v_audio);
+
+
+bool us_audio_probe(const char *name) {
+	snd_pcm_t *pcm;
+	int err;
+	US_JLOG_INFO("audio", "Probing PCM capture ...");
+	if ((err = snd_pcm_open(&pcm, name, SND_PCM_STREAM_CAPTURE, 0)) < 0) {
+		_JLOG_PERROR_ALSA(err, "audio", "Can't probe PCM capture");
+		return false;
+	}
+	snd_pcm_close(pcm);
+	US_JLOG_INFO("audio", "PCM capture is available");
+	return true;
+}
+
+us_audio_s *us_audio_init(const char *name, unsigned pcm_hz) {
+	us_audio_s *audio;
+	US_CALLOC(audio, 1);
+	audio->pcm_hz = pcm_hz;
+	audio->pcm_queue = us_queue_init(8);
+	audio->enc_queue = us_queue_init(8);
+	atomic_init(&audio->stop, false);
+
+	int err;
+
+	{
+		if ((err = snd_pcm_open(&audio->pcm, name, SND_PCM_STREAM_CAPTURE, 0)) < 0) {
+			audio->pcm = NULL;
+			_JLOG_PERROR_ALSA(err, "audio", "Can't open PCM capture");
+			goto error;
+		}
+		assert(!snd_pcm_hw_params_malloc(&audio->pcm_params));
+
+#		define SET_PARAM(_msg, _func, ...) { \
+				if ((err = _func(audio->pcm, audio->pcm_params, ##__VA_ARGS__)) < 0) { \
+					_JLOG_PERROR_ALSA(err, "audio", _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 numbre",	snd_pcm_hw_params_set_channels, 2);
+		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, &audio->pcm_hz, 0);
+		if (audio->pcm_hz < _MIN_PCM_HZ || audio->pcm_hz > _MAX_PCM_HZ) {
+			US_JLOG_ERROR("audio", "Unsupported PCM freq: %u; should be: %u <= F <= %u",
+				audio->pcm_hz, _MIN_PCM_HZ, _MAX_PCM_HZ);
+			goto error;
+		}
+		audio->pcm_frames = _HZ_TO_FRAMES(audio->pcm_hz);
+		audio->pcm_size = _HZ_TO_BUF8(audio->pcm_hz);
+		SET_PARAM("Can't apply PCM params", snd_pcm_hw_params);
+
+#		undef SET_PARAM
+	}
+
+	if (audio->pcm_hz != _ENCODER_INPUT_HZ) {
+		audio->res = speex_resampler_init(2, audio->pcm_hz, _ENCODER_INPUT_HZ, SPEEX_RESAMPLER_QUALITY_DESKTOP, &err);
+		if (err < 0) {
+			audio->res = NULL;
+			_JLOG_PERROR_RES(err, "audio", "Can't create resampler");
+			goto error;
+		}
+	}
+
+	{
+		// OPUS_APPLICATION_VOIP, OPUS_APPLICATION_RESTRICTED_LOWDELAY
+		audio->enc = opus_encoder_create(_ENCODER_INPUT_HZ, 2, OPUS_APPLICATION_AUDIO, &err);
+		assert(err == 0);
+		assert(!opus_encoder_ctl(audio->enc, OPUS_SET_BITRATE(48000)));
+		assert(!opus_encoder_ctl(audio->enc, OPUS_SET_MAX_BANDWIDTH(OPUS_BANDWIDTH_FULLBAND)));
+		assert(!opus_encoder_ctl(audio->enc, OPUS_SET_SIGNAL(OPUS_SIGNAL_MUSIC)));
+		// OPUS_SET_INBAND_FEC(1), OPUS_SET_PACKET_LOSS_PERC(10): see rtpa.c
+	}
+
+	US_JLOG_INFO("audio", "Pipeline configured on %uHz; capturing ...", audio->pcm_hz);
+	audio->tids_created = true;
+	US_THREAD_CREATE(audio->enc_tid, _encoder_thread, audio);
+	US_THREAD_CREATE(audio->pcm_tid, _pcm_thread, audio);
+
+	return audio;
+
+	error:
+		us_audio_destroy(audio);
+		return NULL;
+}
+
+void us_audio_destroy(us_audio_s *audio) {
+	if (audio->tids_created) {
+		atomic_store(&audio->stop, true);
+		US_THREAD_JOIN(audio->pcm_tid);
+		US_THREAD_JOIN(audio->enc_tid);
+	}
+	US_DELETE(audio->enc, opus_encoder_destroy);
+	US_DELETE(audio->res, speex_resampler_destroy);
+	US_DELETE(audio->pcm, snd_pcm_close);
+	US_DELETE(audio->pcm_params, snd_pcm_hw_params_free);
+	US_QUEUE_DELETE_WITH_ITEMS(audio->enc_queue, free);
+	US_QUEUE_DELETE_WITH_ITEMS(audio->pcm_queue, free);
+	if (audio->tids_created) {
+		US_JLOG_INFO("audio", "Pipeline closed");
+	}
+	free(audio);
+}
+
+int us_audio_get_encoded(us_audio_s *audio, uint8_t *data, size_t *size, uint64_t *pts) {
+	if (atomic_load(&audio->stop)) {
+		return -1;
+	}
+	_enc_buffer_s *buf;
+	if (!us_queue_get(audio->enc_queue, (void **)&buf, 0.1)) {
+		if (*size < buf->used) {
+			free(buf);
+			return -3;
+		}
+		memcpy(data, buf->data, buf->used);
+		*size = buf->used;
+		*pts = buf->pts;
+		free(buf);
+		return 0;
+	}
+	return -2;
+}
+
+static void *_pcm_thread(void *v_audio) {
+	US_THREAD_RENAME("us_a_pcm");
+
+	us_audio_s *const audio = (us_audio_s *)v_audio;
+	uint8_t in[_MAX_BUF8];
+
+	while (!atomic_load(&audio->stop)) {
+		const int frames = snd_pcm_readi(audio->pcm, in, audio->pcm_frames);
+		if (frames < 0) {
+			_JLOG_PERROR_ALSA(frames, "audio", "Fatal: Can't capture PCM frames");
+			break;
+		} else if (frames < (int)audio->pcm_frames) {
+			US_JLOG_ERROR("audio", "Fatal: Too few PCM frames captured");
+			break;
+		}
+
+		if (us_queue_get_free(audio->pcm_queue)) {
+			_pcm_buffer_s *out;
+			US_CALLOC(out, 1);
+			memcpy(out->data, in, audio->pcm_size);
+			assert(!us_queue_put(audio->pcm_queue, out, 0));
+		} else {
+			US_JLOG_ERROR("audio", "PCM queue is full");
+		}
+	}
+
+	atomic_store(&audio->stop, true);
+	return NULL;
+}
+
+static void *_encoder_thread(void *v_audio) {
+	US_THREAD_RENAME("us_a_enc");
+
+	us_audio_s *const audio = (us_audio_s *)v_audio;
+	int16_t in_res[_MAX_BUF16];
+
+	while (!atomic_load(&audio->stop)) {
+		_pcm_buffer_s *in;
+		if (!us_queue_get(audio->pcm_queue, (void **)&in, 0.1)) {
+			int16_t *in_ptr;
+			if (audio->res != NULL) {
+				assert(audio->pcm_hz != _ENCODER_INPUT_HZ);
+				uint32_t in_count = audio->pcm_frames;
+				uint32_t out_count = _HZ_TO_FRAMES(_ENCODER_INPUT_HZ);
+				speex_resampler_process_interleaved_int(audio->res, in->data, &in_count, in_res, &out_count);
+				in_ptr = in_res;
+			} else {
+				assert(audio->pcm_hz == _ENCODER_INPUT_HZ);
+				in_ptr = in->data;
+			}
+
+			_enc_buffer_s *out;
+			US_CALLOC(out, 1);
+			const int size = opus_encode(audio->enc, in_ptr, _HZ_TO_FRAMES(_ENCODER_INPUT_HZ), out->data, US_ARRAY_LEN(out->data));
+			free(in);
+			if (size < 0) {
+				_JLOG_PERROR_OPUS(size, "audio", "Fatal: Can't encode PCM frame to OPUS");
+				free(out);
+				break;
+			}
+			out->used = size;
+			out->pts = audio->pts;
+			// https://datatracker.ietf.org/doc/html/rfc7587#section-4.2
+			audio->pts += _HZ_TO_FRAMES(_ENCODER_INPUT_HZ);
+
+			if (us_queue_put(audio->enc_queue, out, 0) != 0) {
+				US_JLOG_ERROR("audio", "OPUS encoder queue is full");
+				free(out);
+			}
+		}
+	}
+
+	atomic_store(&audio->stop, true);
+	return NULL;
+}

janus/src/audio.h

@@ -0,0 +1,71 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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 <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdatomic.h>
+#include <assert.h>
+
+#include <sys/types.h>
+
+#include <pthread.h>
+#include <alsa/asoundlib.h>
+#include <speex/speex_resampler.h>
+#include <opus/opus.h>
+
+#include "uslibs/tools.h"
+#include "uslibs/array.h"
+#include "uslibs/threading.h"
+
+#include "logging.h"
+#include "queue.h"
+
+
+typedef struct {
+	snd_pcm_t			*pcm;
+	unsigned			pcm_hz;
+	unsigned			pcm_frames;
+	size_t				pcm_size;
+	snd_pcm_hw_params_t	*pcm_params;
+	SpeexResamplerState	*res;
+	OpusEncoder			*enc;
+
+	us_queue_s			*pcm_queue;
+	us_queue_s			*enc_queue;
+	uint32_t			pts;
+
+	pthread_t			pcm_tid;
+	pthread_t			enc_tid;
+	bool				tids_created;
+	atomic_bool			stop;
+} us_audio_s;
+
+
+bool us_audio_probe(const char *name);
+
+us_audio_s *us_audio_init(const char *name, unsigned pcm_hz);
+void us_audio_destroy(us_audio_s *audio);
+
+int us_audio_get_encoded(us_audio_s *audio, uint8_t *data, size_t *size, uint64_t *pts);

janus/src/client.c

@@ -0,0 +1,146 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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 <pthread.h>
+#include <janus/plugins/plugin.h>
+
+#include "uslibs/types.h"
+#include "uslibs/tools.h"
+#include "uslibs/threading.h"
+#include "uslibs/list.h"
+
+#include "logging.h"
+#include "queue.h"
+#include "rtp.h"
+
+
+static void *_video_thread(void *v_client);
+static void *_audio_thread(void *v_client);
+static void *_common_thread(void *v_client, bool video);
+
+
+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_audio, false);
+
+	atomic_init(&client->stop, false);
+
+	client->video_queue = us_queue_init(2048);
+	US_THREAD_CREATE(client->video_tid, _video_thread, client);
+
+	client->audio_queue = us_queue_init(64);
+	US_THREAD_CREATE(client->audio_tid, _audio_thread, client);
+
+	return client;
+}
+
+void us_janus_client_destroy(us_janus_client_s *client) {
+	atomic_store(&client->stop, true);
+	us_queue_put(client->video_queue, NULL, 0);
+	us_queue_put(client->audio_queue, NULL, 0);
+
+	US_THREAD_JOIN(client->video_tid);
+	US_QUEUE_DELETE_WITH_ITEMS(client->video_queue, us_rtp_destroy);
+
+	US_THREAD_JOIN(client->audio_tid);
+	US_QUEUE_DELETE_WITH_ITEMS(client->audio_queue, us_rtp_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_audio))
+	) {
+		us_rtp_s *const new = us_rtp_dup(rtp);
+		if (us_queue_put((new->video ? client->video_queue : client->audio_queue), new, 0) != 0) {
+			US_JLOG_ERROR("client", "Session %p %s queue is full",
+				client->session, (new->video ? "video" : "audio"));
+			us_rtp_destroy(new);
+		}
+	}
+}
+
+static void *_video_thread(void *v_client) {
+	return _common_thread(v_client, true);
+}
+
+static void *_audio_thread(void *v_client) {
+	return _common_thread(v_client, false);
+}
+
+static void *_common_thread(void *v_client, bool video) {
+	us_janus_client_s *const client = (us_janus_client_s *)v_client;
+	us_queue_s *const queue = (video ? client->video_queue : client->audio_queue);
+	assert(queue != NULL); // Audio may be NULL
+
+	while (!atomic_load(&client->stop)) {
+		us_rtp_s *rtp;
+		if (!us_queue_get(queue, (void **)&rtp, 0.1)) {
+			if (rtp == NULL) {
+				break;
+			}
+
+			if (
+				atomic_load(&client->transmit)
+				&& (video || atomic_load(&client->transmit_audio))
+			) {
+				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->zero_playout_delay) {
+					// https://github.com/pikvm/pikvm/issues/784
+					packet.extensions.min_delay = 0;
+					packet.extensions.max_delay = 0;
+				} else {
+					packet.extensions.min_delay = 0;
+					// 10s - Chromium/WebRTC default
+					// 3s - Firefox default
+					packet.extensions.max_delay = 300; // == 3s, i.e. 10ms granularity
+				}*/
+
+				client->gw->relay_rtp(client->session, &packet);
+			}
+			us_rtp_destroy(rtp);
+		}
+	}
+	return NULL;
+}

janus/src/client.h

@@ -0,0 +1,57 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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 "queue.h"
+#include "rtp.h"
+
+
+typedef struct us_janus_client_sx {
+	janus_callbacks			*gw;
+	janus_plugin_session	*session;
+	atomic_bool				transmit;
+	atomic_bool				transmit_audio;
+
+	pthread_t				video_tid;
+	pthread_t				audio_tid;
+	atomic_bool				stop;
+
+	us_queue_s				*video_queue;
+	us_queue_s				*audio_queue;
+
+    US_LIST_STRUCT(struct us_janus_client_sx);
+} 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);

janus/src/config.c

@@ -0,0 +1,107 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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/tools.h"
+
+#include "const.h"
+#include "logging.h"
+
+
+static char *_get_value(janus_config *jcfg, const char *section, const char *option);
+// 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, "memsink", "object")) == NULL
+		&& (config->video_sink_name = _get_value(jcfg, "video", "sink")) == NULL
+	) {
+		US_JLOG_ERROR("config", "Missing config value: video.sink (ex. memsink.object)");
+		goto error;
+	}
+	if ((config->audio_dev_name = _get_value(jcfg, "audio", "device")) != NULL) {
+		if ((config->tc358743_dev_path = _get_value(jcfg, "audio", "tc358743")) == NULL) {
+			US_JLOG_INFO("config", "Missing config value: audio.tc358743");
+			goto error;
+		}
+	}
+
+	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->audio_dev_name, free);
+	US_DELETE(config->tc358743_dev_path, 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 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

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
+#    Copyright (C) 2018-2023  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    #
@@ -22,4 +22,14 @@
 
 #pragma once
 
-#define VERSION "0.60"
+
+typedef struct {
+	char	*video_sink_name;
+
+	char	*audio_dev_name;
+	char	*tc358743_dev_path;
+} 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-2023  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,46 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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); \
+	}
+
+#define US_ONCE(...) { \
+		const int m_reported = __LINE__; \
+		if (m_reported != once) { \
+			__VA_ARGS__; \
+			once = m_reported; \
+		} \
+	}

janus/src/memsinkfd.c

@@ -0,0 +1,83 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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/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 -2;
+}
+
+us_frame_s *us_memsink_fd_get_frame(int fd, us_memsink_shared_s *mem, u64 *frame_id, bool key_required) {
+	us_frame_s *frame = us_frame_init();
+	us_frame_set_data(frame, mem->data, 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 ok = true;
+	if (frame->format != V4L2_PIX_FMT_H264) {
+		US_JLOG_ERROR("video", "Got non-H264 frame from memsink");
+		ok = false;
+	}
+	if (flock(fd, LOCK_UN) < 0) {
+		US_JLOG_PERROR("video", "Can't unlock memsink");
+		ok = false;
+	}
+	if (!ok) {
+		US_DELETE(frame, us_frame_destroy);
+	}
+	return frame;
+}

janus/src/memsinkfd.h

@@ -0,0 +1,31 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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);
+us_frame_s *us_memsink_fd_get_frame(int fd, us_memsink_shared_s *mem, u64 *frame_id, bool key_required);

janus/src/plugin.c

@@ -0,0 +1,556 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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 <inttypes.h>
+#include <unistd.h>
+#include <fcntl.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/rtcp.h>
+
+#include "uslibs/types.h"
+#include "uslibs/const.h"
+#include "uslibs/tools.h"
+#include "uslibs/threading.h"
+#include "uslibs/list.h"
+#include "uslibs/memsinksh.h"
+
+#include "const.h"
+#include "logging.h"
+#include "queue.h"
+#include "client.h"
+#include "audio.h"
+#include "tc358743.h"
+#include "rtp.h"
+#include "rtpv.h"
+#include "rtpa.h"
+#include "memsinkfd.h"
+#include "config.h"
+
+
+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_queue_s			*_g_video_queue = 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_audio_tid;
+static atomic_bool		_g_audio_tid_created = false;
+
+static pthread_mutex_t	_g_video_lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t	_g_audio_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_key_required = false;
+
+
+#define _LOCK_VIDEO		US_MUTEX_LOCK(_g_video_lock)
+#define _UNLOCK_VIDEO	US_MUTEX_UNLOCK(_g_video_lock)
+
+#define _LOCK_AUDIO		US_MUTEX_LOCK(_g_audio_lock)
+#define _UNLOCK_AUDIO	US_MUTEX_UNLOCK(_g_audio_lock)
+
+#define _LOCK_ALL		{ _LOCK_VIDEO; _LOCK_AUDIO; }
+#define _UNLOCK_ALL		{ _UNLOCK_AUDIO; _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)
+
+
+janus_plugin *create(void);
+
+
+static void *_video_rtp_thread(void *arg) {
+	(void)arg;
+
+	US_THREAD_RENAME("us_video_rtp");
+	atomic_store(&_g_video_rtp_tid_created, true);
+
+	while (!_STOP) {
+		us_frame_s *frame;
+		if (us_queue_get(_g_video_queue, (void **)&frame, 0.1) == 0) {
+			_LOCK_VIDEO;
+			const bool zero_playout_delay = (frame->gop == 0);
+			us_rtpv_wrap(_g_rtpv, frame, zero_playout_delay);
+			_UNLOCK_VIDEO;
+			us_frame_destroy(frame);
+		}
+	}
+	return NULL;
+}
+
+static void *_video_sink_thread(void *arg) {
+	(void)arg;
+
+	US_THREAD_RENAME("us_video_sink");
+	atomic_store(&_g_video_sink_tid_created, true);
+
+	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;
+
+		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)) == 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 result = us_memsink_fd_wait_frame(fd, mem, frame_id);
+			if (result == 0) {
+				us_frame_s *const frame = us_memsink_fd_get_frame(fd, mem, &frame_id, atomic_load(&_g_key_required));
+				if (frame == NULL) {
+					goto close_memsink;
+				}
+				if (frame->key) {
+					atomic_store(&_g_key_required, false);
+				}
+				if (us_queue_put(_g_video_queue, frame, 0) != 0) {
+					US_ONCE({ US_JLOG_PERROR("video", "Video queue is full"); });
+					us_frame_destroy(frame);
+				}
+			} else if (result == -1) {
+				goto close_memsink;
+			}
+		}
+
+	close_memsink:
+		US_DELETE(mem, us_memsink_shared_unmap);
+		US_CLOSE_FD(fd, close);
+		US_JLOG_INFO("video", "Memsink closed");
+		sleep(1); // error_delay
+	}
+	return NULL;
+}
+
+static void *_audio_thread(void *arg) {
+	(void)arg;
+
+	US_THREAD_RENAME("us_audio");
+	atomic_store(&_g_audio_tid_created, true);
+	assert(_g_config->audio_dev_name != NULL);
+	assert(_g_config->tc358743_dev_path != NULL);
+
+	int once = 0;
+
+	while (!_STOP) {
+		if (!_HAS_WATCHERS || !_HAS_LISTENERS) {
+			usleep(_g_watchers_polling);
+			continue;
+		}
+
+		us_tc358743_info_s info = {0};
+		us_audio_s *audio = NULL;
+
+		if (us_tc358743_read_info(_g_config->tc358743_dev_path, &info) < 0) {
+			goto close_audio;
+		}
+		if (!info.has_audio) {
+			US_ONCE({ US_JLOG_INFO("audio", "No audio presented from the host"); });
+			goto close_audio;
+		}
+		US_ONCE({ US_JLOG_INFO("audio", "Detected host audio"); });
+		if ((audio = us_audio_init(_g_config->audio_dev_name, info.audio_hz)) == NULL) {
+			goto close_audio;
+		}
+
+		once = 0;
+
+		while (!_STOP && _HAS_WATCHERS && _HAS_LISTENERS) {
+			if (
+				us_tc358743_read_info(_g_config->tc358743_dev_path, &info) < 0
+				|| !info.has_audio
+				|| audio->pcm_hz != info.audio_hz
+			) {
+				goto close_audio;
+			}
+
+			uz size = US_RTP_DATAGRAM_SIZE - US_RTP_HEADER_SIZE;
+			u8 data[size];
+			u64 pts;
+			const int result = us_audio_get_encoded(audio, data, &size, &pts);
+			if (result == 0) {
+				_LOCK_AUDIO;
+				us_rtpa_wrap(_g_rtpa, data, size, pts);
+				_UNLOCK_AUDIO;
+			} else if (result == -1) {
+				goto close_audio;
+			}
+		}
+
+	close_audio:
+		US_DELETE(audio, us_audio_destroy);
+		sleep(1); // error_delay
+	}
+	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 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;
+
+	_g_video_queue = us_queue_init(1024);
+	_g_rtpv = us_rtpv_init(_relay_rtp_clients);
+	if (_g_config->audio_dev_name != NULL && us_audio_probe(_g_config->audio_dev_name)) {
+		_g_rtpa = us_rtpa_init(_relay_rtp_clients);
+		US_THREAD_CREATE(_g_audio_tid, _audio_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_audio_tid);
+#	undef JOIN
+
+	US_LIST_ITERATE(_g_clients, client, {
+		US_LIST_REMOVE(_g_clients, client);
+		us_janus_client_destroy(client);
+	});
+
+	US_QUEUE_DELETE_WITH_ITEMS(_g_video_queue, us_frame_destroy);
+
+	US_DELETE(_g_rtpa, us_rtpa_destroy);
+	US_DELETE(_g_rtpv, us_rtpv_destroy);
+	US_DELETE(_g_config, us_config_destroy);
+}
+
+#define _IF_DISABLED(...) { if (!_READY || _STOP) { __VA_ARGS__ } }
+
+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;
+	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_audio));
+		}
+	});
+	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);
+	_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;
+}
+
+#undef _IF_DISABLED
+
+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) {
+
+	assert(transaction != NULL);
+
+#	define FREE_MSG_JSEP { \
+			US_DELETE(msg, json_decref); \
+			US_DELETE(jsep, json_decref); \
+		}
+
+	if (session == NULL || msg == NULL) {
+		free(transaction);
+		FREE_MSG_JSEP;
+		return janus_plugin_result_new(JANUS_PLUGIN_ERROR, (msg ? "No session" : "No message"), NULL);
+	}
+
+#	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(), transaction, 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 ok_wait;
+	}
+
+	const char *const request_str = json_string_value(request);
+	if (request_str == NULL) {
+		PUSH_ERROR(400, "Request not a string");
+		goto ok_wait;
+	}
+	// 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_new(m_result, x_status, x_payload); \
+			} \
+			json_object_set_new(m_event, "result", m_result); \
+			_g_gw->push_event(session, create(), transaction, 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")) {
+		bool with_audio = false;
+		{
+			json_t *const params = json_object_get(msg, "params");
+			if (params != NULL) {
+				json_t *const audio = json_object_get(params, "audio");
+				if (audio != NULL && json_is_boolean(audio)) {
+					with_audio = (_g_rtpa != NULL && json_boolean_value(audio));
+				}
+			}
+		}
+
+		{
+			char *sdp;
+			char *const video_sdp = us_rtpv_make_sdp(_g_rtpv);
+			char *const audio_sdp = (with_audio ? us_rtpa_make_sdp(_g_rtpa) : us_strdup(""));
+			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
+			);
+			json_t *const offer_jsep = json_pack("{ssss}", "type", "offer", "sdp", sdp);
+			PUSH_STATUS("started", NULL, offer_jsep);
+			json_decref(offer_jsep);
+			free(audio_sdp);
+			free(video_sdp);
+			free(sdp);
+		}
+
+		{
+			_LOCK_ALL;
+			bool has_listeners = false;
+			US_LIST_ITERATE(_g_clients, client, {
+				if (client->session == session) {
+					atomic_store(&client->transmit_audio, with_audio);
+				}
+				has_listeners = (has_listeners || atomic_load(&client->transmit_audio));
+			});
+			atomic_store(&_g_has_listeners, has_listeners);
+			_UNLOCK_ALL;
+		}
+
+	} else if (!strcmp(request_str, "features")) {
+		json_t *const features = json_pack("{sb}", "audio", (_g_rtpa != NULL));
+		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");
+	}
+
+ok_wait:
+	FREE_MSG_JSEP;
+	return janus_plugin_result_new(JANUS_PLUGIN_OK_WAIT, NULL, NULL);
+
+#	undef PUSH_STATUS
+#	undef PUSH_ERROR
+#	undef FREE_MSG_JSEP
+}
+
+static void _plugin_incoming_rtcp(janus_plugin_session *handle, janus_plugin_rtcp *packet) {
+	(void)handle;
+	(void)packet;
+	if (packet->video && 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_rtcp = _plugin_incoming_rtcp,
+	);
+#	pragma GCC diagnostic pop
+	return &plugin;
+}

janus/src/queue.c

@@ -0,0 +1,112 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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 "queue.h"
+
+#include <errno.h>
+#include <time.h>
+#include <assert.h>
+
+#include <pthread.h>
+
+#include "uslibs/types.h"
+#include "uslibs/tools.h"
+#include "uslibs/threading.h"
+
+
+us_queue_s *us_queue_init(uint capacity) {
+	us_queue_s *queue;
+	US_CALLOC(queue, 1);
+	US_CALLOC(queue->items, capacity);
+	queue->capacity = capacity;
+	US_MUTEX_INIT(queue->mutex);
+
+	pthread_condattr_t attrs;
+	assert(!pthread_condattr_init(&attrs));
+	assert(!pthread_condattr_setclock(&attrs, CLOCK_MONOTONIC));
+	assert(!pthread_cond_init(&queue->full_cond, &attrs));
+	assert(!pthread_cond_init(&queue->empty_cond, &attrs));
+	assert(!pthread_condattr_destroy(&attrs));
+	return queue;
+}
+
+void us_queue_destroy(us_queue_s *queue) {
+	US_COND_DESTROY(queue->empty_cond);
+	US_COND_DESTROY(queue->full_cond);
+	US_MUTEX_DESTROY(queue->mutex);
+	free(queue->items);
+	free(queue);
+}
+
+#define _WAIT_OR_UNLOCK(x_var, x_cond) { \
+		struct timespec m_ts; \
+		assert(!clock_gettime(CLOCK_MONOTONIC, &m_ts)); \
+		us_ld_to_timespec(us_timespec_to_ld(&m_ts) + timeout, &m_ts); \
+		while (x_var) { \
+			const int err = pthread_cond_timedwait(&(x_cond), &queue->mutex, &m_ts); \
+			if (err == ETIMEDOUT) { \
+				US_MUTEX_UNLOCK(queue->mutex); \
+				return -1; \
+			} \
+			assert(!err); \
+		} \
+	}
+
+int us_queue_put(us_queue_s *queue, void *item, ldf timeout) {
+	US_MUTEX_LOCK(queue->mutex);
+	if (timeout == 0) {
+		if (queue->size == queue->capacity) {
+			US_MUTEX_UNLOCK(queue->mutex);
+			return -1;
+		}
+	} else {
+		_WAIT_OR_UNLOCK(queue->size == queue->capacity, queue->full_cond);
+	}
+	queue->items[queue->in] = item;
+	++queue->size;
+	++queue->in;
+	queue->in %= queue->capacity;
+	US_MUTEX_UNLOCK(queue->mutex);
+	US_COND_BROADCAST(queue->empty_cond);
+	return 0;
+}
+
+int us_queue_get(us_queue_s *queue, void **item, ldf timeout) {
+	US_MUTEX_LOCK(queue->mutex);
+	_WAIT_OR_UNLOCK(queue->size == 0, queue->empty_cond);
+	*item = queue->items[queue->out];
+	--queue->size;
+	++queue->out;
+	queue->out %= queue->capacity;
+	US_MUTEX_UNLOCK(queue->mutex);
+	US_COND_BROADCAST(queue->full_cond);
+	return 0;
+}
+
+#undef _WAIT_OR_UNLOCK
+
+int us_queue_get_free(us_queue_s *queue) {
+	US_MUTEX_LOCK(queue->mutex);
+	const uint size = queue->size;
+	US_MUTEX_UNLOCK(queue->mutex);
+	return queue->capacity - size;
+}

janus/src/queue.h

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
+#    Copyright (C) 2018-2023  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    #
@@ -22,27 +22,43 @@
 
 #pragma once
 
-#include <string.h>
+#include <pthread.h>
 
-#include <IL/OMX_Core.h>
-#include <IL/OMX_Component.h>
+#include "uslibs/types.h"
+#include "uslibs/tools.h"
 
 
-#define OMX_INIT_STRUCTURE(_var) { \
-		memset(&(_var), 0, sizeof(_var)); \
-		(_var).nSize = sizeof(_var); \
-		(_var).nVersion.nVersion = OMX_VERSION; \
-		(_var).nVersion.s.nVersionMajor = OMX_VERSION_MAJOR; \
-		(_var).nVersion.s.nVersionMinor = OMX_VERSION_MINOR; \
-		(_var).nVersion.s.nRevision = OMX_VERSION_REVISION; \
-		(_var).nVersion.s.nStep = OMX_VERSION_STEP; \
+// Based on https://github.com/seifzadeh/c-pthread-queue/blob/master/queue.h
+
+typedef struct {
+	void			**items;
+	uint			size;
+	uint			capacity;
+	uint			in;
+	uint			out;
+
+	pthread_mutex_t	mutex;
+	pthread_cond_t	full_cond;
+	pthread_cond_t	empty_cond;
+} us_queue_s;
+
+
+#define US_QUEUE_DELETE_WITH_ITEMS(x_queue, x_free_item) { \
+		if (x_queue) { \
+			while (!us_queue_get_free(x_queue)) { \
+				void *m_ptr; \
+				if (!us_queue_get(x_queue, &m_ptr, 0)) { \
+					US_DELETE(m_ptr, x_free_item); \
+				} \
+			} \
+			us_queue_destroy(x_queue); \
+		} \
 	}
 
 
-int component_enable_port(OMX_HANDLETYPE *component, OMX_U32 port);
-int component_disable_port(OMX_HANDLETYPE *component, OMX_U32 port);
+us_queue_s *us_queue_init(uint capacity);
+void us_queue_destroy(us_queue_s *queue);
 
-int component_get_portdef(OMX_HANDLETYPE *component, OMX_PARAM_PORTDEFINITIONTYPE *portdef, OMX_U32 port);
-int component_set_portdef(OMX_HANDLETYPE *component, OMX_PARAM_PORTDEFINITIONTYPE *portdef);
-
-int component_set_state(OMX_HANDLETYPE *component, OMX_STATETYPE state);
+int us_queue_put(us_queue_s *queue, void *item, ldf timeout);
+int us_queue_get(us_queue_s *queue, void **item, ldf timeout);
+int us_queue_get_free(us_queue_s *queue);

janus/src/rtp.c

@@ -0,0 +1,69 @@
+/*****************************************************************************
+#                                                                            #
+#    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-2023  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(uint payload, bool video) {
+	us_rtp_s *rtp;
+	US_CALLOC(rtp, 1);
+	rtp->payload = payload;
+	rtp->video = video;
+	rtp->ssrc = us_triple_u32(us_get_now_monotonic_u64());
+	return rtp;
+}
+
+us_rtp_s *us_rtp_dup(const us_rtp_s *rtp) {
+	us_rtp_s *new;
+	US_CALLOC(new, 1);
+	memcpy(new, rtp, sizeof(us_rtp_s));
+	return new;
+}
+
+void us_rtp_destroy(us_rtp_s *rtp) {
+	free(rtp);
+}
+
+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,51 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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"
+
+
+// https://stackoverflow.com/questions/47635545/why-webrtc-chose-rtp-max-packet-size-to-1200-bytes
+#define US_RTP_DATAGRAM_SIZE	1200
+#define US_RTP_HEADER_SIZE		12
+
+
+typedef struct {
+	uint	payload;
+	bool	video;
+	u32		ssrc;
+
+	u16		seq;
+	u8		datagram[US_RTP_DATAGRAM_SIZE];
+	uz		used;
+	bool	zero_playout_delay;
+} us_rtp_s;
+
+typedef void (*us_rtp_callback_f)(const us_rtp_s *rtp);
+
+
+us_rtp_s *us_rtp_init(uint payload, bool video);
+us_rtp_s *us_rtp_dup(const us_rtp_s *rtp);
+void us_rtp_destroy(us_rtp_s *rtp);
+
+void us_rtp_write_header(us_rtp_s *rtp, u32 pts, bool marked);

janus/src/rtpa.c

@@ -0,0 +1,71 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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 <inttypes.h>
+
+#include "uslibs/types.h"
+#include "uslibs/tools.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(111, false);
+	rtpa->callback = callback;
+	return rtpa;
+}
+
+void us_rtpa_destroy(us_rtpa_s *rtpa) {
+	us_rtp_destroy(rtpa->rtp);
+	free(rtpa);
+}
+
+char *us_rtpa_make_sdp(us_rtpa_s *rtpa) {
+	const uint pl = rtpa->rtp->payload;
+	char *sdp;
+	US_ASPRINTF(sdp,
+		"m=audio 1 RTP/SAVPF %u" RN
+		"c=IN IP4 0.0.0.0" RN
+		"a=rtpmap:%u OPUS/48000/2" RN
+		// "a=fmtp:%u useinbandfec=1" RN
+		"a=rtcp-fb:%u nack" RN
+		"a=rtcp-fb:%u nack pli" RN
+		"a=rtcp-fb:%u goog-remb" RN
+		"a=ssrc:%" PRIu32 " cname:ustreamer" RN
+		"a=sendonly" RN,
+		pl, pl, pl, pl, pl, // pl,
+		rtpa->rtp->ssrc
+	);
+	return sdp;
+}
+
+void us_rtpa_wrap(us_rtpa_s *rtpa, const u8 *data, uz size, u32 pts) {
+    if (size + US_RTP_HEADER_SIZE <= US_RTP_DATAGRAM_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,40 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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);
+
+char *us_rtpa_make_sdp(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,182 @@
+/*****************************************************************************
+#                                                                            #
+#    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-2023  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"
+
+
+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(96, true);
+	rtpv->callback = callback;
+	return rtpv;
+}
+
+void us_rtpv_destroy(us_rtpv_s *rtpv) {
+	us_rtp_destroy(rtpv->rtp);
+	free(rtpv);
+}
+
+char *us_rtpv_make_sdp(us_rtpv_s *rtpv) {
+	// https://tools.ietf.org/html/rfc6184
+	// https://github.com/meetecho/janus-gateway/issues/2443
+	const uint pl = rtpv->rtp->payload;
+	char *sdp;
+	US_ASPRINTF(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" RN
+		"a=fmtp:%u 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=ssrc:%" PRIu32 " cname:ustreamer" RN
+		"a=extmap:1 http://www.webrtc.org/experiments/rtp-hdrext/playout-delay" RN
+		"a=sendonly" RN,
+		pl, pl, pl, pl,
+		pl, pl, pl,
+		rtpv->rtp->ssrc
+	);
+	return sdp;
+}
+
+#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->zero_playout_delay = zero_playout_delay;
+
+	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;
+
+	if (size + US_RTP_HEADER_SIZE <= US_RTP_DATAGRAM_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;
+		rtpv->callback(rtpv->rtp);
+		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_DATAGRAM_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;
+		rtpv->callback(rtpv->rtp);
+
+		src += frag_size;
+		remaining -= frag_size;
+		first = false;
+	}
+}
+
+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,41 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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);
+
+char *us_rtpv_make_sdp(us_rtpv_s *rtpv);
+void us_rtpv_wrap(us_rtpv_s *rtpv, const us_frame_s *frame, bool zero_playout_delay);

janus/src/tc358743.c

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
+#    Copyright (C) 2018-2023  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    #
@@ -20,60 +20,54 @@
 *****************************************************************************/
 
 
-#pragma once
+#include "tc358743.h"
 
-#include "pthread.h"
+#include <unistd.h>
+#include <fcntl.h>
 
-#include "tools.h"
-#include "device.h"
+#include <linux/videodev2.h>
+#include <linux/v4l2-controls.h>
 
-#ifdef WITH_OMX_ENCODER
-#	include "encoders/omx/encoder.h"
-#	define ENCODER_TYPES_OMX_HINT ", OMX"
-#else
-#	define ENCODER_TYPES_OMX_HINT ""
+#include "uslibs/types.h"
+#include "uslibs/tools.h"
+#include "uslibs/xioctl.h"
+
+#include "logging.h"
+
+
+#ifndef V4L2_CID_USER_TC358743_BASE
+#	define V4L2_CID_USER_TC358743_BASE (V4L2_CID_USER_BASE + 0x1080)
+#endif
+#ifndef TC358743_CID_AUDIO_PRESENT
+#	define TC358743_CID_AUDIO_PRESENT (V4L2_CID_USER_TC358743_BASE + 1)
+#endif
+#ifndef TC358743_CID_AUDIO_SAMPLING_RATE
+#	define TC358743_CID_AUDIO_SAMPLING_RATE (V4L2_CID_USER_TC358743_BASE + 0)
 #endif
 
 
-#define ENCODER_TYPES_STR \
-	"CPU, HW" \
-	ENCODER_TYPES_OMX_HINT
+int us_tc358743_read_info(const char *path, us_tc358743_info_s *info) {
+	US_MEMSET_ZERO(*info);
 
-enum encoder_type_t {
-	ENCODER_TYPE_UNKNOWN, // Only for encoder_parse_type() and main()
-	ENCODER_TYPE_CPU,
-	ENCODER_TYPE_HW,
-#	ifdef WITH_OMX_ENCODER
-	ENCODER_TYPE_OMX,
-#	endif
-};
+	int fd = -1;
+	if ((fd = open(path, O_RDWR)) < 0) {
+		US_JLOG_PERROR("audio", "Can't open TC358743 V4L2 device");
+		return -1;
+	}
 
-struct encoder_runtime_t {
-	enum encoder_type_t	type;
-	unsigned			quality;
-	pthread_mutex_t		mutex;
+#	define READ_CID(x_cid, x_field) { \
+			struct v4l2_control m_ctl = {.id = x_cid}; \
+			if (us_xioctl(fd, VIDIOC_G_CTRL, &m_ctl) < 0) { \
+				US_JLOG_PERROR("audio", "Can't get value of " #x_cid); \
+				close(fd); \
+				return -1; \
+			} \
+			info->x_field = m_ctl.value; \
+		}
+	READ_CID(TC358743_CID_AUDIO_PRESENT,		has_audio);
+	READ_CID(TC358743_CID_AUDIO_SAMPLING_RATE,	audio_hz);
+#	undef READ_CID
 
-#	ifdef WITH_OMX_ENCODER
-	unsigned				n_omxs;
-	struct omx_encoder_t	**omxs;
-#	endif
-};
-
-struct encoder_t {
-	enum encoder_type_t	type;
-	unsigned			quality;
-
-	struct encoder_runtime_t *run;
-};
-
-
-struct encoder_t *encoder_init();
-void encoder_destroy(struct encoder_t *encoder);
-
-enum encoder_type_t encoder_parse_type(const char *str);
-const char *encoder_type_to_string(enum encoder_type_t type);
-
-void encoder_prepare(struct encoder_t *encoder, struct device_t *dev);
-void encoder_prepare_live(struct encoder_t *encoder, struct device_t *dev);
-
-int encoder_compress_buffer(struct encoder_t *encoder, struct device_t *dev, unsigned worker_number, unsigned buf_index);
+	close(fd);
+	return 0;
+}

janus/src/tc358743.h

@@ -0,0 +1,34 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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 {
+	bool	has_audio;
+	uint	audio_hz;
+} us_tc358743_info_s;
+
+
+int us_tc358743_read_info(const char *path, us_tc358743_info_s *info);

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/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.h

@@ -0,0 +1 @@
+../../../src/libs/memsinksh.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,44 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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 <stdbool.h>
+#include <stdint.h>
+
+
+typedef long long sll;
+typedef ssize_t sz;
+typedef int8_t s8;
+typedef int16_t s16;
+typedef int32_t s32;
+typedef int64_t s64;
+
+typedef unsigned uint;
+typedef unsigned long long ull;
+typedef size_t uz;
+typedef uint8_t u8;
+typedef uint16_t u16;
+typedef uint32_t u32;
+typedef uint64_t u64;
+
+typedef long double ldf;

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.9
+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 = _, __, x, y, ws, make-html-h, make-jpeg-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,51 @@
+[tox]
+envlist = cppcheck, flake8, pylint, mypy, vulture, htmlhint
+skipsdist = true
+
+[testenv]
+basepython = python3.11
+changedir = /src
+
+[testenv:cppcheck]
+allowlist_externals = cppcheck
+commands = cppcheck \
+			--force \
+			--std=c17 \
+			--error-exitcode=1 \
+			--quiet \
+			--enable=warning,unusedFunction,portability,performance,style \
+			--suppress=assignmentInAssert \
+			--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==5.0.4
+	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
+
+[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 5.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,336 @@
+.\" Manpage for ustreamer.
+.\" Open an issue or pull request to https://github.com/pikvm/ustreamer to correct errors or typos
+.TH USTREAMER 1 "version 5.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 Auvidea B101 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 intraface
+.nf
+\fB\-\-workers=3 \e\fR # Maximum workers for V4L2 encoder
+.nf
+\fB\-\-persistent \e\fR # Don\'t re\-initialize device on timeout (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, RGB565, RGB24, 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 then this limit. Useful if the device produces small\-sized garbage frames. Default: 128 bytes.
+.TP
+.BR \-n ", " \-\-persistent
+Don't re\-initialize device on timeout. 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 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.
+
+NOOP ─ Don't compress MJPEG stream (do nothing).
+.TP
+.BR \-g\ \fIWxH,... ", " \-\-glitched\-resolutions\ \fIWxH,...
+It doesn't do anything. Still here for compatibility.
+.TP
+.BR \-k\ \fIpath ", " \-\-blank\ \fIpath
+Path to JPEG file that will be shown when the device is disconnected during the streaming. Default: black screen 640x480 with 'NO SIGNAL'.
+.TP
+.BR \-K\ \fIsec ", " \-\-last\-as\-blank\ \fIsec
+Show the last frame received from the camera after it was disconnected, but no more than specified time (or endlessly if 0 is specified). If the device has not yet been online, display 'NO SIGNAL' or the image specified by option \-\-blank. Note: currently this option has no effect on memory sinks. Default: disabled.
+.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 \-\-sink\ \fIname
+Use the specified shared memory object to sink JPEG frames. Default: disabled.
+.TP
+.BR \-\-sink\-mode\ \fImode
+Set JPEG sink permissions (like 777). Default: 660.
+.TP
+.BR \-\-sink\-rm
+Remove shared memory on stop. Default: disabled.
+.TP
+.BR \-\-sink\-client\-ttl\ \fIsec
+Client TTL. Default: 10.
+.TP
+.BR \-\-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. 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.
+
+
+.SS "Process options"
+.TP
+.BR \-\-exit\-on\-parent\-death
+Exit the program if the parent process is dead. Required \fBHAS_PDEATHSIG\fR feature. 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,48 @@
+# Contributor: Maxim Devaev <mdevaev@gmail.com>
+# Author: Maxim Devaev <mdevaev@gmail.com>
+
+
+pkgname=ustreamer
+pkgver=5.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 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)
+	makedepends+=(python-setuptools)
+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
+
+
+# LD does not link mmal with this option
+# This DOESN'T affect setup.py
+LDFLAGS="${LDFLAGS//--as-needed/}"
+export LDFLAGS="${LDFLAGS//,,/,}"
+
+
+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/v3-hdmi.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

@@ -1,27 +1,30 @@
 # Copyright 2019 Gentoo Authors
 # Distributed under the terms of the GNU General Public License v2
- 
+
 EAPI=7
- 
+
 inherit git-r3
- 
-DESCRIPTION="µStreamer - Lightweight and fast MJPG-HTTP streamer"
-HOMEPAGE="https://github.com/pi-kvm/ustreamer"
-EGIT_REPO_URI="https://github.com/pi-kvm/ustreamer.git"
- 
+
+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
-	>=sys-apps/util-linux-2.33
+	>=dev-libs/libbsd-0.9.1
 "
 RDEPEND="${DEPEND}"
 BDEPEND=""
- 
+
 src_install() {
-	dobin ustreamer 
+	dobin ustreamer
+	dobin ustreamer-dump
+	doman man/ustreamer.1
+	doman man/ustreamer-dump.1
 }

pkg/openwrt/Makefile

@@ -0,0 +1,46 @@
+#
+# This is free software, licensed under the GNU General Public License v2.
+# See /LICENSE for more information.
+#
+
+include $(TOPDIR)/rules.mk
+
+PKG_NAME:=ustreamer
+PKG_VERSION:=5.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:=+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/Makefile

@@ -0,0 +1,20 @@
+-include ../config.mk
+
+DESTDIR ?=
+PREFIX ?= /usr/local
+
+PY ?= python3
+
+
+# =====
+all:
+	$(info == PY_BUILD ustreamer-*.so)
+	$(ECHO) $(PY) setup.py build
+
+
+install:
+	$(PY) setup.py install --prefix=$(PREFIX) --root=$(if $(DESTDIR),$(DESTDIR),/)
+
+
+clean:
+	rm -rf build ustreamer.egg-info

python/setup.py

@@ -0,0 +1,35 @@
+import os
+
+from setuptools import Extension
+from setuptools import setup
+
+
+# =====
+def _find_sources(suffix: str) -> list[str]:
+    sources: list[str] = []
+    for (root_path, _, names) in os.walk("src"):
+        for name in names:
+            if name.endswith(suffix):
+                sources.append(os.path.join(root_path, name))
+    return sources
+
+
+if __name__ == "__main__":
+    setup(
+        name="ustreamer",
+        version="5.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"],
+                undef_macros=["NDEBUG"],
+                sources=_find_sources(".c"),
+                depends=_find_sources(".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.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,44 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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 <stdbool.h>
+#include <stdint.h>
+
+
+typedef long long sll;
+typedef ssize_t sz;
+typedef int8_t s8;
+typedef int16_t s16;
+typedef int32_t s32;
+typedef int64_t s64;
+
+typedef unsigned uint;
+typedef unsigned long long ull;
+typedef size_t uz;
+typedef uint8_t u8;
+typedef uint16_t u16;
+typedef uint32_t u32;
+typedef uint64_t u64;
+
+typedef long double ldf;

python/src/ustreamer.c

@@ -0,0 +1,305 @@
+#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/types.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;
+
+	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) {
+	US_DELETE(self->mem, us_memsink_shared_unmap);
+	US_CLOSE_FD(self->fd, close);
+	US_DELETE(self->frame, us_frame_destroy);
+}
+
+static int _MemsinkObject_init(_MemsinkObject *self, PyObject *args, PyObject *kwargs) {
+	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
+
+	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)) == 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;
+
+#	define RETURN_OS_ERROR { \
+			Py_BLOCK_THREADS \
+			PyErr_SetFromErrno(PyExc_OSError); \
+			return -1; \
+		}
+
+	ldf now_ts;
+	do {
+		Py_BEGIN_ALLOW_THREADS
+
+		const int retval = us_flock_timedwait_monotonic(self->fd, self->lock_timeout);
+		now_ts = us_get_now_monotonic();
+
+		if (retval < 0 && errno != EWOULDBLOCK) {
+			RETURN_OS_ERROR;
+
+		} else if (retval == 0) {
+			us_memsink_shared_s *mem = self->mem;
+			if (mem->magic == US_MEMSINK_MAGIC && mem->version == US_MEMSINK_VERSION && mem->id != self->frame_id) {
+				if (self->drop_same_frames > 0) {
+					if (
+						US_FRAME_COMPARE_META_USED_NOTS(self->mem, self->frame)
+						&& (self->frame_ts + self->drop_same_frames > now_ts)
+						&& !memcmp(self->frame->data, mem->data, mem->used)
+					) {
+						self->frame_id = mem->id;
+						goto drop;
+					}
+				}
+
+				Py_BLOCK_THREADS
+				return 0;
+			}
+
+			if (flock(self->fd, LOCK_UN) < 0) {
+				RETURN_OS_ERROR;
+			}
+		}
+
+	drop:
+		if (usleep(1000) < 0) {
+			RETURN_OS_ERROR;
+		}
+		Py_END_ALLOW_THREADS
+		if (PyErr_CheckSignals() < 0) {
+			return -1;
+		}
+	} while (now_ts < deadline_ts);
+
+	return -2;
+#	undef RETURN_OS_ERROR
+}
+
+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 -2: Py_RETURN_NONE;
+		default: return NULL;
+	}
+
+	us_memsink_shared_s *mem = self->mem;
+	us_frame_set_data(self->frame, mem->data, mem->used);
+	US_FRAME_COPY_META(self->mem, self->frame);
+	self->frame_id = mem->id;
+	self->frame_ts = us_get_now_monotonic();
+	mem->last_client_ts = self->frame_ts;
+	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_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) { // cppcheck-suppress unusedFunction
+	PyObject *module = PyModule_Create(&_Module);
+	if (module == NULL) {
+		return NULL;
+	}
+
+	if (PyType_Ready(&_MemsinkType) < 0) {
+		return NULL;
+	}
+
+	Py_INCREF(&_MemsinkType);
+
+	if (PyModule_AddObject(module, "Memsink", (PyObject *)&_MemsinkType) < 0) {
+		return NULL;
+	}
+
+	return module;
+}

src/Makefile

@@ -0,0 +1,129 @@
+DESTDIR ?=
+PREFIX ?= /usr/local
+
+CC ?= gcc
+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)
+_LDFLAGS = $(LDFLAGS)
+
+_COMMON_LIBS = -lm -ljpeg -pthread -lrt
+
+_USTR_LIBS = $(_COMMON_LIBS) -levent -levent_pthreads
+_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_LIBS = $(_COMMON_LIBS)
+_DUMP_SRCS = $(shell ls \
+	libs/*.c \
+	dump/*.c \
+)
+
+_V4P_LIBS = $(_COMMON_LIBS)
+_V4P_SRCS = $(shell ls \
+	libs/*.c \
+	v4p/*.c \
+)
+
+_BUILD = build
+
+
+_TARGETS = $(_USTR) $(_DUMP)
+_OBJS = $(_USTR_SRCS:%.c=$(_BUILD)/%.o) $(_DUMP_SRCS:%.c=$(_BUILD)/%.o)
+
+
+define optbool
+$(filter $(shell echo $(1) | tr A-Z a-z), yes on 1)
+endef
+
+
+ifneq ($(call optbool,$(WITH_GPIO)),)
+_USTR_LIBS += -lgpiod
+override _CFLAGS += -DWITH_GPIO $(shell pkg-config --atleast-version=2 libgpiod 2> /dev/null && echo -DHAVE_GPIOD2)
+_USTR_SRCS += $(shell ls ustreamer/gpio/*.c)
+endif
+
+
+ifneq ($(call optbool,$(WITH_SYSTEMD)),)
+_USTR_LIBS += -lsystemd
+override _CFLAGS += -DWITH_SYSTEMD
+_USTR_SRCS += $(shell ls ustreamer/http/systemd/*.c)
+endif
+
+
+WITH_PTHREAD_NP ?= 1
+ifneq ($(call optbool,$(WITH_PTHREAD_NP)),)
+override _CFLAGS += -DWITH_PTHREAD_NP
+endif
+
+
+WITH_SETPROCTITLE ?= 1
+ifneq ($(call optbool,$(WITH_SETPROCTITLE)),)
+ifeq ($(shell uname -s | tr A-Z a-z),linux)
+_USTR_LIBS += -lbsd
+endif
+override _CFLAGS += -DWITH_SETPROCTITLE
+endif
+
+
+WITH_V4P ?= 0
+ifneq ($(call optbool,$(WITH_V4P)),)
+override _TARGETS += $(_V4P)
+override _OBJS += $(_V4P_SRCS:%.c=$(_BUILD)/%.o)
+override _CFLAGS += $(shell pkg-config --cflags libdrm)
+_V4P_LDFLAGS = $(shell pkg-config --libs libdrm)
+endif
+
+# =====
+all: $(_TARGETS)
+
+
+install: all
+	mkdir -p $(DESTDIR)$(PREFIX)/bin
+	for i in $(subst .bin,,$(_TARGETS)); do install -m755 $$i.bin $(DESTDIR)$(PREFIX)/bin/$$i; done
+
+
+install-strip: install
+	for i in $(subst .bin,,$(_TARGETS)); do strip $(DESTDIR)$(PREFIX)/bin/$$i; done
+
+
+$(_USTR): $(_USTR_SRCS:%.c=$(_BUILD)/%.o)
+	$(info == LD $@)
+	$(ECHO) $(CC) $^ -o $@ $(_LDFLAGS) $(_USTR_LIBS)
+
+
+$(_DUMP): $(_DUMP_SRCS:%.c=$(_BUILD)/%.o)
+	$(info == LD $@)
+	$(ECHO) $(CC) $^ -o $@ $(_LDFLAGS) $(_DUMP_LIBS)
+
+
+$(_V4P): $(_V4P_SRCS:%.c=$(_BUILD)/%.o)
+	$(info == LD $@)
+	$(ECHO) $(CC) $^ -o $@ $(_LDFLAGS) $(_V4P_LDFLAGS) $(_V4P_LIBS)
+
+
+$(_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,687 +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_JPEG_WIDTH = 640;
-const unsigned BLANK_JPEG_HEIGHT = 480;
-
-const unsigned char BLANK_JPEG_DATA[] = {
-	0xFF, 0xD8, 0xFF, 0xE1, 0x09, 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, 0x00, 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, 0x00, 0x2C, 0x50, 0x68,
-	0x6F, 0x74, 0x6F, 0x73, 0x68, 0x6F, 0x70, 0x20, 0x33, 0x2E, 0x30, 0x00, 0x38, 0x42, 0x49, 0x4D, 0x04, 0x25, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x10, 0xD4, 0x1D, 0x8C, 0xD9, 0x8F, 0x00, 0xB2, 0x04, 0xE9, 0x80, 0x09, 0x98, 0xEC, 0xF8, 0x42, 0x7E, 0xFF, 0xDB,
-	0x00, 0x84, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-	0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
-	0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x01, 0x01, 0x02, 0x02, 0x02, 0x01, 0x02, 0x02, 0x03,
-	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
-	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
-	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0xFF, 0xDD, 0x00, 0x04, 0x00, 0x50, 0xFF, 0xEE, 0x00, 0x0E, 0x41, 0x64, 0x6F, 0x62, 0x65,
-	0x00, 0x64, 0xC0, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x01, 0xE0, 0x02, 0x80, 0x03, 0x00, 0x11, 0x00, 0x01,
-	0x11, 0x01, 0x02, 0x11, 0x01, 0xFF, 0xC4, 0x00, 0x7D, 0x00, 0x01, 0x00, 0x02, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x0B, 0x07, 0x08, 0x09, 0x05, 0x06, 0x02, 0x03, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x01, 0x00, 0x01, 0x04, 0x02, 0x01, 0x03,
-	0x02, 0x03, 0x04, 0x08, 0x04, 0x06, 0x03, 0x00, 0x00, 0x00, 0x03, 0x02, 0x04, 0x05, 0x06, 0x01, 0x07, 0x08, 0x09, 0x11, 0x12,
-	0x0A, 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, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xDA, 0x00, 0x0C, 0x03, 0x00, 0x00, 0x01, 0x11, 0x02, 0x11, 0x00, 0x3F, 0x00, 0xAF,
-	0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD0,
-	0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF,
-	0xD1, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
-	0xFF, 0xD2, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x07, 0xFF, 0xD3, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x07, 0xFF, 0xD4, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x07, 0xFF, 0xD5, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x07, 0xFF, 0xD6, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD7, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD0, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD1, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD2, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD3, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD4, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD5, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD6, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD7, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD0, 0xAF, 0xFC, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD1, 0xAF, 0xFC, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD2, 0xAF, 0xFC, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD3, 0xAF, 0xFC,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD4, 0xAF,
-	0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD5,
-	0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF,
-	0xD6, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
-	0xFF, 0xD7, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x07, 0xFF, 0xD0, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x07, 0xFF, 0xD1, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x07, 0xFF, 0xD2, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x07, 0xFF, 0xD3, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x06, 0x4C, 0xE9, 0x5B, 0x0B, 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, 0x02, 0xF6, 0x5F, 0x6E, 0x72, 0x56, 0x50, 0x51, 0xF6, 0xF0, 0xD3, 0xD7, 0xF7, 0xE2, 0xA6,
-	0x9B, 0x0A, 0xEB, 0xA2, 0xC4, 0x23, 0x22, 0x0D, 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,
-	0x0C, 0x85, 0x72, 0x59, 0xDD, 0xD1, 0x1C, 0x91, 0x49, 0xCC, 0x55, 0x57, 0x1D, 0x3C, 0xFE, 0x9A, 0xA9, 0xE7, 0x8E, 0x78, 0xE3,
-	0x9E, 0x39, 0x06, 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, 0x0B, 0xAD, 0x45, 0x73, 0x0D, 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, 0x00, 0xC8, 0x6B, 0xE7, 0xA6, 0xFF, 0x00, 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, 0x0A, 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, 0x01, 0xDA, 0xEE, 0xC7, 0x83, 0xD0, 0x8F, 0xD3, 0x07, 0x27, 0xFF, 0x00, 0x0E, 0x76, 0x0E,
-	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, 0x06, 0xEB, 0x45, 0x73, 0x64, 0x32, 0xB9, 0x1B, 0x0F,
-	0xC3, 0x57, 0x4D, 0x78, 0x3C, 0xBC, 0xB7, 0x59, 0x09, 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, 0x0F, 0xC0, 0x3A,
-	0x19, 0xE9, 0xA3, 0xE0, 0x76, 0x6B, 0xD4, 0x03, 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, 0x0F, 0x0C, 0x74, 0x8F, 0x21,
-	0x3B, 0x3F, 0x09, 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, 0x0C, 0x90, 0x43,
-	0x0C, 0x94, 0x53, 0x5D, 0x36, 0x91, 0xD3, 0x6F, 0x10, 0x3F, 0x5B, 0x0F, 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, 0x0F, 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, 0x0C, 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, 0x0D, 0x5B, 0xAF, 0x75, 0x3C, 0x0E, 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, 0x01, 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, 0x0F, 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, 0x00, 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, 0x04, 0x7B, 0xB6, 0x1B, 0xA1, 0x7A, 0x7F, 0x23, 0x6F, 0x8C,
-	0x8A, 0x2B, 0x9A, 0xAE, 0xE6, 0xBC, 0xCC, 0xE4, 0x3A, 0xDA, 0xC7, 0x0B, 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, 0x07,
-	0x35, 0x5F, 0x19, 0x24, 0xF3, 0x77, 0xC3, 0x5E, 0xEE, 0xD6, 0x35, 0x8D, 0x06, 0xE3, 0x9C, 0x75, 0x38, 0x9D, 0x16, 0xF7, 0x74,
-	0x9F, 0x75, 0xD1, 0xBB, 0x0A, 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, 0x0B,
-	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, 0x07, 0xF7, 0x96, 0x5B, 0xA9, 0xBB, 0x02, 0x19, 0x72, 0x9A, 0xFD, 0xF7,
-	0x17, 0x19, 0xAE, 0xB2, 0xEC, 0x2B, 0x7B, 0x4A, 0xE0, 0xC2, 0x76, 0x0E, 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, 0x04, 0xB6, 0xF3, 0xCC,
-	0x1A, 0x5A, 0x09, 0x44, 0xFA, 0x03, 0xF8, 0x73, 0xE3, 0x0F, 0x93, 0x7D, 0x45, 0xE4, 0x06, 0x6F, 0xBE, 0xFA, 0x5F, 0x4D, 0xED,
-	0x0C, 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, 0x0D, 0x1C, 0x47, 0x0C, 0x19, 0x2B, 0xE8, 0x62, 0x8E, 0x9F, 0x7F,
-	0x6A, 0x23, 0x8E, 0xE6, 0x5A, 0x23, 0xA3, 0x8F, 0x7F, 0x7E, 0x7D, 0xA9, 0xA6, 0x9E, 0x38, 0x07, 0x9A, 0x09, 0x48, 0xFA, 0x14,
-	0x7A, 0x66, 0xF5, 0x9F, 0x79, 0xF4, 0xF7, 0x72, 0x79, 0x05, 0xE4, 0x87, 0x5E, 0x61, 0x77, 0x3D, 0x47, 0xB2, 0xB1, 0x99, 0xDE,
-	0x9B, 0xEA, 0x5C, 0x5E, 0xC9, 0x88, 0xB0, 0xC8, 0xFE, 0x03, 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, 0x06, 0xBF, 0x82, 0x57, 0x7F, 0x4E, 0xFF, 0x00, 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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xD4, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x57, 0xE8, 0x6F, 0xDF, 0x97, 0x4C, 0xFF, 0x00, 0x15, 0xFA,
-	0xEF, 0xF9, 0xBF, 0x0E, 0x0B, 0x0F, 0x7C, 0xC4, 0xF3, 0x8B, 0xAA, 0x7C, 0x4D, 0xED, 0x0F, 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, 0x09, 0x34, 0x5D, 0x82, 0x3D, 0xBE, 0xEA, 0xD3, 0x29, 0x3C, 0xDC, 0x73, 0x1D, 0x9F,
-	0x15, 0x45, 0x34, 0xBE, 0xD6, 0xB4, 0xDC, 0x55, 0x48, 0x45, 0x0F, 0xD6, 0x3B, 0xD2, 0xB2, 0xEF, 0xC3, 0xFD, 0xBA, 0x6E, 0xFE,
-	0xE8, 0xEC, 0x54, 0xF9, 0x2F, 0x17, 0x7B, 0x0B, 0x33, 0xF2, 0x92, 0xCA, 0xC2, 0x9A, 0xEE, 0xFF, 0x00, 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, 0x00, 0xEA, 0x34, 0xD7, 0x72, 0x9B, 0x7F, 0x9E, 0x1E, 0x3B, 0x6A, 0x78, 0x48, 0xA8, 0xB8,
-	0xCD, 0x6D, 0x1E, 0x3F, 0xE9, 0x3A, 0xEE, 0x22, 0x09, 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, 0x00, 0x49, 0x78, 0xF7, 0x3C, 0x78, 0x1D, 0xEB, 0x3D, 0x06, 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, 0x00, 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, 0x0E, 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,
-	0x0E, 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, 0x09, 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, 0x09, 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, 0x07, 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,
-	0x0E, 0xBD, 0x7A, 0x12, 0xFF, 0x00, 0x89, 0xEF, 0x8F, 0xBF, 0xE9, 0x3D, 0xCB, 0xFF, 0x00, 0x64, 0xFB, 0x04, 0x19, 0x07, 0xEA,
-	0x0D, 0xFF, 0x00, 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, 0x0C, 0xEE, 0x57, 0x67, 0xDA, 0xB6, 0x7C, 0xAD, 0xF6, 0x73, 0x61, 0xD8, 0x73, 0x97, 0xD7, 0x19,
-	0x2C, 0xC6, 0x6B, 0x31, 0x92, 0xB8, 0x92, 0xEA, 0xFF, 0x00, 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, 0x05, 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, 0x09, 0x2E, 0x7D, 0x32, 0x7F, 0xBF, 0x7F, 0x26, 0xFF, 0x00, 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,
-	0x0D, 0x37, 0x16, 0x17, 0x14, 0x84, 0x28, 0x7C, 0x99, 0xF1, 0xAF, 0xB5, 0x7C, 0x4A, 0xEE, 0x5D, 0xBB, 0xA3, 0xBB, 0x8B, 0x07,
-	0x56, 0x1B, 0x6D, 0xD5, 0x6E, 0xB8, 0xE6, 0x0B, 0xBB, 0x7F, 0xBB, 0x36, 0x0B, 0x69, 0xC0, 0x5D, 0x55, 0x25, 0x58, 0x5D, 0xBF,
-	0x55, 0xC8, 0xC9, 0x14, 0x3C, 0x65, 0x35, 0xCC, 0xED, 0xB4, 0x7C, 0xD7, 0x04, 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, 0x08,
-	0x7B, 0x67, 0xFF, 0x00, 0xBF, 0x73, 0x5F, 0xEA, 0xD9, 0x1F, 0xF7, 0x93, 0x03, 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, 0x09, 0xC4, 0xF1, 0xF1, 0x3D, 0xFF,
-	0x00, 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, 0x00, 0xA4, 0x92, 0x5E, 0x7F, 0x3B, 0x9E, 0x2A, 0xE4, 0x30, 0xE7, 0xAF, 0x17, 0x8F, 0x9A,
-	0x8F, 0x92, 0xFE, 0x35, 0xF4, 0xAF, 0xA8, 0xFF, 0x00, 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, 0x07, 0x19, 0x6A, 0xE9, 0x97, 0x9A, 0x78, 0xB4, 0xE7, 0x8A, 0x42, 0x22,
-	0xC0, 0x98, 0xFF, 0x00, 0xD3, 0x25, 0xFB, 0x8D, 0xF2, 0x7B, 0xF8, 0xAF, 0xA7, 0x7F, 0x28, 0x5C, 0x02, 0x1E, 0xD9, 0xFF, 0x00,
-	0xEF, 0xDC, 0xD7, 0xFA, 0xB6, 0x47, 0xFD, 0xE4, 0xC0, 0xF2, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xD5, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x57, 0xE8, 0x6F, 0xDF, 0x97, 0x4C, 0xFF, 0x00, 0x15, 0xFA, 0xEF, 0xF9,
-	0xBF, 0x0E, 0x09, 0x43, 0xFD, 0x4F, 0xFF, 0x00, 0xDC, 0x5E, 0x17, 0x7F, 0xAB, 0x77, 0xF7, 0xFB, 0x3E, 0x9D, 0x06, 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, 0x05, 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, 0x0F, 0xF5, 0x36, 0x68,
-	0xF9, 0xCC, 0xB7, 0x4D, 0xF8, 0xB7, 0xD9, 0x56, 0x34, 0x49, 0x36, 0xB5, 0xA8, 0x76, 0x26, 0xFF, 0x00, 0xA9, 0xE6, 0x64, 0x86,
-	0x3A, 0xE5, 0x86, 0x2C, 0x87, 0x60, 0x6B, 0x9A, 0xFE, 0x57, 0x01, 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, 0x00, 0x1B, 0xDD, 0xE9,
-	0x87, 0xA2, 0xE7, 0xFB, 0x0F, 0xD4, 0x1B, 0xC4, 0x1C, 0x1E, 0xB9, 0x1C, 0xF2, 0x5E, 0xE2, 0xFB, 0xDB, 0x41, 0xDE, 0xAF, 0x79,
-	0x82, 0x89, 0xAB, 0xE6, 0x2C, 0x07, 0x5A, 0x66, 0xAD, 0xFB, 0x0B, 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, 0x00, 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, 0x0C, 0x04, 0x76, 0x3F, 0xB3, 0x6F, 0x77, 0x5D, 0x42, 0xBB, 0x7D, 0x0F, 0xB0, 0x2E, 0x69, 0xAA,
-	0x9A, 0x29, 0x92, 0xFF, 0x00, 0x3B, 0x87, 0xAA, 0xDA, 0xFB, 0x43, 0xD9, 0xA4, 0x96, 0x1E, 0x2B, 0x8A, 0xBB, 0x7B, 0x6B, 0x5C,
-	0x0D, 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, 0x09, 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, 0x01, 0xED, 0xFD, 0x41, 0xBF, 0xE2, 0x35, 0xB4,
-	0x7F, 0x0A, 0x3A, 0xB3, 0xFE, 0x91, 0x78, 0x0E, 0xDB, 0xFA, 0xD6, 0x63, 0x2E, 0x3B, 0x67, 0xD2, 0x2B, 0xAA, 0xBB, 0x13, 0x47,
-	0x8F, 0x8B, 0x9D, 0x5B, 0x05, 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, 0x00, 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, 0x0F, 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,
-	0x07, 0xA2, 0xE6, 0x2F, 0xF4, 0xBE, 0xFF, 0x00, 0xD5, 0xEB, 0xC0, 0xEB, 0xB7, 0xD7, 0xF9, 0x1C, 0x6D, 0x10, 0x6B, 0x7A, 0x8E,
-	0x4E, 0x08, 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, 0x0D, 0xFF, 0x00, 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, 0x09, 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, 0x0E, 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,
-	0x04, 0x2E, 0x73, 0xFF, 0x00, 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, 0x0F, 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, 0x0B, 0x15, 0x67, 0x67, 0x8E, 0xB1, 0x8A, 0x3A, 0x21, 0xB4, 0xB5, 0x82, 0x2E, 0x3E, 0x3C, 0xD5, 0xF1, 0xF9, 0xD5, 0x55,
-	0x55, 0x07, 0x4A, 0x3C, 0x1C, 0xF2, 0x83, 0xD3, 0x33, 0xC9, 0xDE, 0xB9, 0xD9, 0xBC, 0x01, 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, 0x06, 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, 0x08, 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, 0x0C, 0xD5,
-	0x57, 0x17, 0x3C, 0xFC, 0xE3, 0xAB, 0x8E, 0x02, 0x52, 0x1F, 0x4C, 0x97, 0xEE, 0x37, 0xC9, 0xEF, 0xE2, 0xBE, 0x9D, 0xFC, 0xA1,
-	0x70, 0x08, 0x7B, 0x67, 0xFF, 0x00, 0xBF, 0x73, 0x5F, 0xEA, 0xD9, 0x1F, 0xF7, 0x93, 0x03, 0xC9, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD6, 0xAF, 0xFC, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x57, 0xE8, 0x6F, 0xDF, 0x97, 0x4C,
-	0xFF, 0x00, 0x15, 0xFA, 0xEF, 0xF9, 0xBF, 0x0E, 0x09, 0x43, 0xFD, 0x4F, 0xFF, 0x00, 0xDC, 0x5E, 0x17, 0x7F, 0xAB, 0x77, 0xF7,
-	0xFB, 0x3E, 0x9D, 0x04, 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, 0x00, 0xFA, 0xC7, 0xAF, 0xFF, 0x00,
-	0xDD, 0x5E, 0xD8, 0x07, 0x49, 0xFD, 0x3D, 0xBC, 0x99, 0xE8, 0xBF, 0x55, 0x8F, 0x08, 0x72, 0x5E, 0x08, 0x79, 0x29, 0x99, 0x8F,
-	0x8E, 0xEA, 0xD6, 0xF4, 0x5B, 0x6D, 0x52, 0xFE, 0x3B, 0xC9, 0xAC, 0x6D, 0x76, 0x4D, 0xAB, 0x09, 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, 0x0E, 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, 0x0B, 0xA5, 0xEA, 0xF9, 0x7C, 0xF4, 0x76,
-	0x93, 0x4F, 0xF9, 0xD3, 0x5E, 0x56, 0xFA, 0xC6, 0xD6, 0x5B, 0x0C, 0x35, 0xA4, 0x71, 0xFB, 0xC9, 0x2D, 0xC5, 0xDC, 0xB0, 0x41,
-	0x0C, 0x54, 0xD5, 0x24, 0x95, 0xD3, 0x45, 0x3C, 0xD5, 0xC0, 0x4C, 0x2B, 0xD3, 0x9F, 0xC0, 0xDE, 0xB7, 0xF4, 0x90, 0xEA, 0x0D,
-	0xFF, 0x00, 0xCC, 0x8F, 0x34, 0xF7, 0x4D, 0x5B, 0x01, 0xDA, 0x97, 0x9A, 0xA4, 0xF8, 0xAB, 0xDA, 0x22, 0xC8, 0xDB, 0xE4, 0xF0,
-	0xFD, 0x65, 0xAB, 0x5C, 0xCB, 0x16, 0x47, 0x9D, 0x1F, 0x57, 0x9A, 0x0F, 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, 0x06, 0xA2, 0x03, 0xB0, 0x9E, 0x93,
-	0x1E, 0x9A, 0x3A, 0x07, 0xA8, 0x66, 0xC5, 0xDA, 0xB0, 0xF6, 0x07, 0x74, 0x73, 0xA0, 0xE3, 0x7A, 0xEB, 0x01, 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,
-	0x0D, 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,
-	0x0F, 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, 0x0E,
-	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, 0x01, 0xD5, 0x6F, 0x45, 0xFF, 0x00, 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, 0x00, 0x47, 0x6F, 0x28, 0xFC, 0x41, 0xDC, 0x73,
-	0x39, 0x0D, 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, 0x0C, 0x97,
-	0xB5, 0x41, 0x4E, 0x22, 0xF2, 0x5A, 0xA9, 0xFC, 0x3C, 0xFC, 0x49, 0x5D, 0x56, 0xD1, 0x07, 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, 0x0D, 0xC5, 0xCD, 0x72, 0xC7, 0x0D, 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, 0x02, 0x72, 0x5E, 0x13, 0xF4, 0x07, 0x60, 0x78,
-	0x5B, 0xE9, 0x1B, 0xD9, 0xFA, 0x3F, 0x91, 0x7C, 0x6B, 0xBA, 0x06, 0xCD, 0xFD, 0x02, 0xEF, 0xAD, 0xCF, 0x33, 0x63, 0x79, 0xB1,
-	0xE3, 0x24, 0xB6, 0xD5, 0xAC, 0xF7, 0x0D, 0x72, 0xFE, 0x3C, 0x3E, 0x2B, 0x61, 0xCC, 0xF1, 0x2D, 0x18, 0x3B, 0x7C, 0xDD, 0x55,
-	0xF1, 0x45, 0x32, 0x45, 0x05, 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, 0x00,
-	0xEC, 0xE7, 0x76, 0xFF, 0x00, 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, 0x05, 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, 0x0F, 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, 0x0F, 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, 0x0B, 0x8E, 0xCC, 0xEA, 0xF8, 0x1B, 0xAD, 0xC3, 0x1F, 0x6B, 0x73, 0x4F, 0x19, 0x3B, 0x0E, 0xA3, 0xEB,
-	0xF9, 0xAD, 0xEC, 0x75, 0x4B, 0x1C, 0xBD, 0x50, 0xF1, 0x0D, 0x53, 0xDD, 0x76, 0x1E, 0xE9, 0x8D, 0x9A, 0xFA, 0xEA, 0xE3, 0x9E,
-	0x3E, 0x77, 0x32, 0x61, 0xAE, 0x3E, 0xEF, 0x1C, 0xF1, 0x71, 0x57, 0x35, 0x04, 0x46, 0x01, 0xB0, 0xBE, 0x28, 0xF9, 0x09, 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, 0x01, 0x28, 0x5F, 0x5E, 0x8F, 0x1C, 0x75, 0x5F, 0x26, 0x3C, 0x62,
-	0xEA, 0x0F, 0x50, 0xBE, 0x93, 0xE2, 0x1D, 0x86, 0x8D, 0x4F, 0x59, 0xD7, 0x78, 0xD9, 0xB2, 0xD8, 0xC8, 0x38, 0xAE, 0x6D, 0x8F,
-	0xA3, 0x7B, 0x02, 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, 0x00, 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, 0x00, 0xC0, 0x7D, 0x99, 0xD3, 0x5D, 0xBF, 0xD2, 0xB9,
-	0x5C, 0x7E, 0x0B, 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, 0x00, 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, 0x01, 0x8D, 0x80, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xD7, 0xAF, 0xFC, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 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, 0x0D, 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, 0x0D, 0xB6, 0xF3, 0x53, 0xCD, 0xCE, 0xCC, 0xF3, 0x9F, 0x6D, 0xEA, 0xFD, 0xF7, 0xB6, 0xB1, 0x58, 0x1B, 0x3D, 0xCB, 0xAE,
-	0xFA, 0x87, 0x03, 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,
-	0x0A, 0xF6, 0x0C, 0x9E, 0x0F, 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, 0x01, 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, 0x03, 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, 0x00,
-	0x99, 0xDE, 0x4A, 0xF9, 0x8B, 0xB4, 0xD1, 0xB4, 0xF9, 0x03, 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,
-	0x0C, 0xB7, 0x9C, 0x41, 0x5E, 0x42, 0xF2, 0x88, 0xE8, 0xE6, 0xEA, 0xE2, 0x7A, 0xF8, 0xF9, 0xF2, 0x1A, 0xBA, 0x00, 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, 0x0C, 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, 0x03, 0xBE, 0x5A, 0x57, 0xD4, 0xB5,
-	0xE5, 0x3E, 0x23, 0x03, 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, 0x00,
-	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, 0x09, 0xE9, 0xF9, 0xF3, 0x58, 0x73, 0xDB,
-	0xC6, 0xCF, 0x22, 0xFB, 0x2F, 0xC5, 0x1E, 0xE3, 0xD5, 0xBB, 0xD7, 0xA8, 0x6E, 0xF1, 0x16, 0x5B, 0xFE, 0x9F, 0x06, 0x7E, 0xDF,
-	0x0B, 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, 0x03, 0xD6, 0xF2, 0x93, 0xCA, 0x4E,
-	0xD7, 0xF3, 0x0B, 0xB5, 0xEE, 0xFB, 0xA3, 0xBA, 0x2E, 0xF0, 0x77, 0xDB, 0xC5, 0xF6, 0x0F, 0x0B, 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, 0x00, 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, 0x01, 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, 0x0C, 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,
-	0x00, 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, 0x07, 0x1F, 0x7C, 0xB3, 0xF5, 0x0C, 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, 0x0F, 0xBC, 0xE5, 0xEF, 0xBF, 0x06, 0xB6, 0x4D, 0xC7, 0x6B, 0xE8,
-	0x4C, 0x86, 0xB1, 0x8E, 0xCC, 0x6F, 0x58, 0x3B, 0x0D, 0x7B, 0x3D, 0x2E, 0xCD, 0xAD, 0xDB, 0x6C, 0x90, 0xD7, 0x8D, 0xC7, 0x5F,
-	0xD5, 0x92, 0xB7, 0x8E, 0xD6, 0x0B, 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, 0x0F,
-	0x81, 0x06, 0xED, 0xF8, 0x2B, 0xE7, 0x97, 0x73, 0x78, 0x0D, 0xDA, 0xB7, 0x3D, 0x8B, 0xD5, 0x92, 0xDA, 0xE6, 0xB0, 0xBB, 0x06,
-	0x3B, 0x9C, 0x46, 0xF9, 0xD7, 0x19, 0xEB, 0x9B, 0xD8, 0xF5, 0x2D, 0xE3, 0x1F, 0x0C, 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, 0x0F, 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, 0x07, 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, 0x0F, 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, 0x07, 0x00, 0x0E, 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, 0x0F, 0x99, 0xF0, 0xFB, 0xD4, 0x9F, 0xC9, 0xEF, 0x06, 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, 0x0E, 0x71, 0xB6, 0xBC, 0xDB, 0x4D, 0x75, 0x3C, 0x5F, 0x86, 0x86, 0x8B, 0x6A, 0xB9, 0xF7, 0xA6, 0x9E, 0x3F, 0x55, 0x5C,
-	0xFB, 0xF3, 0xCF, 0xF6, 0x7B, 0x06, 0xE1, 0x7F, 0xE6, 0x0D, 0xF5, 0x1A, 0xFF, 0x00, 0xF2, 0x8E, 0xA8, 0xFF, 0x00, 0xF5, 0x66,
-	0x23, 0xFF, 0x00, 0xEB, 0x07, 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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD0,
-	0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF,
-	0xD1, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
-	0xFF, 0xD2, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x07, 0xFF, 0xD3, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x07, 0xFF, 0xD4, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x07, 0xFF, 0xD5, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x07, 0xFF, 0xD6, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD7, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD0, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD1, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD2, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD3, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD4, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD5, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD6, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD7, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD0, 0xAF, 0xFC, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD1, 0xAF, 0xFC, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD2, 0xAF, 0xFC, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD3, 0xAF, 0xFC,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD4, 0xAF,
-	0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xD5,
-	0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFF,
-	0xD6, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
-	0xFF, 0xD7, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x07, 0xFF, 0xD0, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x07, 0xFF, 0xD1, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x07, 0xFF, 0xD2, 0xAF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0x00, 0x00, 0x00, 0x07, 0xFF, 0xD9
-};

src/data/index.html

@@ -1,59 +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="/state"><b><samp>/state</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>key=abc123</samp></b><br>
-					User-defined key, which is part of cookie <samp>stream_client</samp>, which allows<br>
-					the stream client to determine its identifier and view statistics using <a href="/state"><samp>/state</samp></a>.
-				</li>
-				<br>
-				<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 frame 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,635 +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 <assert.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},
-	{"RGB24",	V4L2_PIX_FMT_RGB24},
-	{"JPEG",	V4L2_PIX_FMT_MJPEG},
-	{"JPEG",	V4L2_PIX_FMT_JPEG},
-};
-
-
-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 int _device_open_mmap(struct device_t *dev);
-static int _device_open_queue_buffers(struct device_t *dev);
-static void _device_open_alloc_picbufs(struct device_t *dev);
-static int _device_apply_resolution(struct device_t *dev, unsigned width, unsigned height);
-static void _device_apply_controls(struct device_t *dev);
-static int _device_check_control(struct device_t *dev, const char *name, unsigned cid, int value, bool quiet);
-static void _device_set_control(struct device_t *dev, const char *name, unsigned cid, int value, bool quiet);
-
-static const char *_format_to_string_fourcc(char *buf, size_t size, unsigned format);
-static const char *_format_to_string_nullable(unsigned format);
-static const char *_format_to_string_supported(unsigned format);
-static const char *_standard_to_string(v4l2_std_id standard);
-
-
-struct device_t *device_init() {
-	struct controls_t *ctl;
-	struct device_runtime_t *run;
-	struct device_t *dev;
-
-	A_CALLOC(ctl, 1);
-
-	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(min_u(sysconf(_SC_NPROCESSORS_ONLN), 4), 1) + 1;
-	dev->n_workers = dev->n_buffers;
-	dev->timeout = 1;
-	dev->error_delay = 1;
-	dev->ctl = ctl;
-	dev->run = run;
-	return dev;
-}
-
-void device_destroy(struct device_t *dev) {
-	free(dev->run);
-	free(dev->ctl);
-	free(dev);
-}
-
-int device_parse_format(const char *str) {
-	for (unsigned index = 0; index < ARRAY_LEN(_FORMATS); ++index) {
-		if (!strcasecmp(str, _FORMATS[index].name)) {
-			return _FORMATS[index].format;
-		}
-	}
-	return FORMAT_UNKNOWN;
-}
-
-v4l2_std_id device_parse_standard(const char *str) {
-	for (unsigned index = 1; index < ARRAY_LEN(_STANDARDS); ++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);
-	_device_apply_controls(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) {
-#			define HW_BUFFER(_next) dev->run->hw_buffers[index]._next
-
-			if (HW_BUFFER(allocated) > 0 && HW_BUFFER(data) != MAP_FAILED) {
-				if (munmap(HW_BUFFER(data), HW_BUFFER(allocated)) < 0) {
-					LOG_PERROR("Can't unmap device buffer %u", index);
-				}
-			}
-
-#			undef HW_BUFFER
-		}
-		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;
-	}
-}
-
-int device_switch_capturing(struct device_t *dev, bool enable) {
-	if (enable != dev->run->capturing) {
-		enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-
-		LOG_DEBUG("Calling ioctl(%s) ...", (enable ? "VIDIOC_STREAMON" : "VIDIOC_STREAMOFF"));
-		if (xioctl(dev->run->fd, (enable ? VIDIOC_STREAMON : VIDIOC_STREAMOFF), &type) < 0) {
-			LOG_PERROR("Unable to %s capturing", (enable ? "start" : "stop"));
-			if (enable) {
-				return -1;
-			}
-		}
-
-		dev->run->capturing = enable;
-		LOG_INFO("Capturing %s", (enable ? "started" : "stopped"));
-	}
-    return 0;
-}
-
-int device_grab_buffer(struct device_t *dev) {
-	struct v4l2_buffer buf_info;
-
-	MEMSET_ZERO(buf_info);
-	buf_info.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-	buf_info.memory = V4L2_MEMORY_MMAP;
-
-	LOG_DEBUG("Calling ioctl(VIDIOC_DQBUF) ...");
-	if (xioctl(dev->run->fd, VIDIOC_DQBUF, &buf_info) < 0) {
-		LOG_PERROR("Unable to dequeue buffer");
-		return -1;
-	}
-
-	LOG_DEBUG("Got a new frame in buffer index=%u; bytesused=%u", buf_info.index, buf_info.bytesused);
-	if (buf_info.index >= dev->run->n_buffers) {
-		LOG_ERROR("Got invalid buffer index=%u; nbuffers=%u", buf_info.index, dev->run->n_buffers);
-		return -1;
-	}
-
-	dev->run->hw_buffers[buf_info.index].used = buf_info.bytesused;
-	memcpy(&dev->run->hw_buffers[buf_info.index].buf_info, &buf_info, sizeof(struct v4l2_buffer));
-	return buf_info.index;
-}
-
-int device_release_buffer(struct device_t *dev, unsigned index) {
-	LOG_DEBUG("Calling ioctl(VIDIOC_QBUF) ...");
-	if (xioctl(dev->run->fd, VIDIOC_QBUF, &dev->run->hw_buffers[index].buf_info) < 0) {
-		LOG_PERROR("Unable to requeue buffer");
-		return -1;
-	}
-	dev->run->hw_buffers[index].used = 0;
-	return 0;
-}
-
-int device_consume_event(struct device_t *dev) {
-	struct v4l2_event event;
-
-	LOG_DEBUG("Calling ioctl(VIDIOC_DQEVENT) ...");
-	if (!xioctl(dev->run->fd, VIDIOC_DQEVENT, &event)) {
-		switch (event.type) {
-			case V4L2_EVENT_SOURCE_CHANGE:
-				LOG_INFO("Got V4L2_EVENT_SOURCE_CHANGE: source changed");
-				return -1;
-			case V4L2_EVENT_EOS:
-				LOG_INFO("Got V4L2_EVENT_EOS: end of stream (ignored)");
-				return 0;
-		}
-	} else {
-		LOG_PERROR("Got some V4L2 device event, but where is it? ");
-	}
-	return 0;
-}
-
-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) {
-	_device_apply_resolution(dev, dev->width, dev->height);
-	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;
-		}
-	}
-	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=%ux%u; 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;
-		}
-
-		if (_device_apply_resolution(dev, dv_timings.bt.width, dv_timings.bt.height) < 0) {
-			return -1;
-		}
-
-	} 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) {
-		LOG_PERROR("Unable to set pixelformat=%s; resolution=%ux%u",
-			_format_to_string_supported(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=%ux%u is unavailable", dev->run->width, dev->run->height);
-	}
-	if (_device_apply_resolution(dev, fmt.fmt.pix.width, fmt.fmt.pix.height) < 0) {
-		return -1;
-	}
-	LOG_INFO("Using resolution: %ux%u", dev->run->width, dev->run->height);
-
-	// Check format
-	if (fmt.fmt.pix.pixelformat != dev->format) {
-		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_supported(dev->format),
-			_format_to_string_supported(fmt.fmt.pix.pixelformat));
-
-		if ((format_str_nullable = (char *)_format_to_string_nullable(fmt.fmt.pix.pixelformat)) != NULL) {
-			LOG_INFO("Falling back to pixelformat=%s", format_str_nullable);
-		} else {
-			LOG_ERROR("Unsupported pixelformat=%s (fourcc)",
-				_format_to_string_fourcc(format_obtained_str, 8, fmt.fmt.pix.pixelformat));
-			return -1;
-		}
-	}
-
-	dev->run->format = fmt.fmt.pix.pixelformat;
-	LOG_INFO("Using pixelformat: %s", _format_to_string_supported(dev->run->format));
-	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: %u", req.count);
-		return -1;
-	} else {
-		LOG_INFO("Requested %u HW buffers, got %u", 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 %u ...", dev->run->n_buffers);
-		if (xioctl(dev->run->fd, VIDIOC_QUERYBUF, &buf_info) < 0) {
-			LOG_PERROR("Can't VIDIOC_QUERYBUF");
-			return -1;
-		}
-
-#		define HW_BUFFER(_next) dev->run->hw_buffers[dev->run->n_buffers]._next
-
-		LOG_DEBUG("Mapping device buffer %u ...", dev->run->n_buffers);
-		HW_BUFFER(data) = mmap(NULL, buf_info.length, PROT_READ|PROT_WRITE, MAP_SHARED, dev->run->fd, buf_info.m.offset);
-		if (HW_BUFFER(data) == MAP_FAILED) {
-			LOG_PERROR("Can't map device buffer %u", dev->run->n_buffers);
-			return -1;
-		}
-		HW_BUFFER(allocated) = buf_info.length;
-
-#		undef HW_BUFFER
-	}
-	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 %u ...", 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 %u sized %zu 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 int _device_apply_resolution(struct device_t *dev, unsigned width, unsigned height) {
-	// Тут VIDEO_MIN_* не используются из-за странностей минимального разрешения при отсутствии сигнала
-	// у некоторых устройств, например Auvidea B101
-	if (
-		width == 0 || width > VIDEO_MAX_WIDTH
-		|| height == 0 || height > VIDEO_MAX_HEIGHT
-	) {
-		LOG_ERROR("Requested forbidden resolution=%ux%u: min=1x1; max=%ux%u",
-			width, height, VIDEO_MAX_WIDTH, VIDEO_MAX_HEIGHT);
-		return -1;
-	}
-	dev->run->width = width;
-	dev->run->height = height;
-	return 0;
-}
-
-static void _device_apply_controls(struct device_t *dev) {
-#	define SET_CID(_cid, _dest, _value, _quiet) { \
-			if (_device_check_control(dev, #_dest, _cid, _value, _quiet) == 0) { \
-				_device_set_control(dev, #_dest, _cid, _value, _quiet); \
-			} \
-		}
-
-#	define SET_CID_MANUAL(_cid, _dest) { \
-			if (dev->ctl->_dest.value_set) { \
-				SET_CID(_cid, _dest, dev->ctl->_dest.value, false); \
-			} \
-		}
-
-#	define SET_CID_AUTO(_cid_auto, _cid_manual, _dest) { \
-			if (dev->ctl->_dest.value_set || dev->ctl->_dest.auto_set) { \
-				SET_CID(_cid_auto, _dest##_auto, dev->ctl->_dest.auto_set, dev->ctl->_dest.value_set); \
-				SET_CID_MANUAL(_cid_manual, _dest); \
-			} \
-		}
-
-	SET_CID_AUTO	(V4L2_CID_AUTOBRIGHTNESS,		V4L2_CID_BRIGHTNESS,				brightness);
-	SET_CID_MANUAL	(								V4L2_CID_CONTRAST,					contrast);
-	SET_CID_MANUAL	(								V4L2_CID_SATURATION,				saturation);
-	SET_CID_AUTO	(V4L2_CID_HUE_AUTO,				V4L2_CID_HUE,						hue);
-	SET_CID_MANUAL	(								V4L2_CID_GAMMA,						gamma);
-	SET_CID_MANUAL	(								V4L2_CID_SHARPNESS,					sharpness);
-	SET_CID_MANUAL	(								V4L2_CID_BACKLIGHT_COMPENSATION,	backlight_compensation);
-	SET_CID_AUTO	(V4L2_CID_AUTO_WHITE_BALANCE,	V4L2_CID_WHITE_BALANCE_TEMPERATURE,	white_balance);
-	SET_CID_AUTO	(V4L2_CID_AUTOGAIN,				V4L2_CID_GAIN,						gain);
-
-#	undef SET_CID_AUTO
-#	undef SET_CID_MANUAL
-#	undef SET_CID
-}
-
-static int _device_check_control(struct device_t *dev, const char *name, unsigned cid, int value, bool quiet) {
-	struct v4l2_queryctrl query;
-
-	MEMSET_ZERO(query);
-	query.id = cid;
-
-	if (xioctl(dev->run->fd, VIDIOC_QUERYCTRL, &query) < 0 || query.flags & V4L2_CTRL_FLAG_DISABLED) {
-		if (!quiet) {
-			LOG_ERROR("Changing control %s is unsupported", name);
-		}
-		return -1;
-	}
-	if (value < query.minimum || value > query.maximum || value % query.step != 0) {
-		if (!quiet) {
-			LOG_ERROR("Invalid value %d of control %s: min=%d, max=%d, default=%d, step=%u",
-				value, name, query.minimum, query.maximum, query.default_value, query.step);
-		}
-		return -2;
-	}
-	return 0;
-}
-
-static void _device_set_control(struct device_t *dev, const char *name, unsigned cid, int value, bool quiet) {
-	struct v4l2_control ctl;
-
-	MEMSET_ZERO(ctl);
-	ctl.id = cid;
-	ctl.value = value;
-
-	if (xioctl(dev->run->fd, VIDIOC_S_CTRL, &ctl) < 0) {
-		if (!quiet) {
-			LOG_PERROR("Can't set control %s", name);
-		}
-	} else if (!quiet) {
-		LOG_INFO("Using control %s: %d", name, ctl.value);
-	}
-}
-
-static const char *_format_to_string_fourcc(char *buf, size_t size, 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_nullable(unsigned format) {
-    for (unsigned index = 0; index < ARRAY_LEN(_FORMATS); ++index) {
-		if (format == _FORMATS[index].format) {
-			return _FORMATS[index].name;
-		}
-    }
-    return NULL;
-}
-
-static const char *_format_to_string_supported(unsigned format) {
-	const char *format_str = _format_to_string_nullable(format);
-	return (format_str == NULL ? "unsupported" : format_str);
-}
-
-static const char *_standard_to_string(v4l2_std_id standard) {
-	for (unsigned index = 0; index < ARRAY_LEN(_STANDARDS); ++index) {
-		if (standard == _STANDARDS[index].standard) {
-			return _STANDARDS[index].name;
-		}
-	}
-	return _STANDARDS[0].name;
-}

src/device.h

@@ -1,125 +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 <linux/videodev2.h>
-
-
-#define VIDEO_MIN_WIDTH		320
-#define VIDEO_MAX_WIDTH		1920
-
-#define VIDEO_MIN_HEIGHT	180
-#define VIDEO_MAX_HEIGHT	1200
-
-#define STANDARD_UNKNOWN	V4L2_STD_UNKNOWN
-#define STANDARDS_STR		"PAL, NTSC, SECAM"
-
-#define FORMAT_UNKNOWN	-1
-#define FORMATS_STR		"YUYV, UYVY, RGB565, RGB24, JPEG"
-
-
-struct hw_buffer_t {
-	unsigned char		*data;
-	size_t				used;
-	size_t				allocated;
-	struct v4l2_buffer	buf_info;
-};
-
-struct picture_t {
-	unsigned char	*data;
-	size_t			used;
-	size_t			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; // FIXME
-	struct hw_buffer_t	*hw_buffers;
-	struct picture_t	*pictures;
-	size_t				max_picture_size;
-	bool				capturing;
-};
-
-struct control_t {
-	int		value;
-	bool	value_set;
-	bool	auto_set;
-};
-
-struct controls_t {
-	struct control_t brightness;
-	struct control_t contrast;
-	struct control_t saturation;
-	struct control_t hue;
-	struct control_t gamma;
-	struct control_t sharpness;
-	struct control_t backlight_compensation;
-	struct control_t white_balance;
-	struct control_t gain;
-};
-
-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		desired_fps;
-	size_t			min_frame_size;
-	bool			persistent;
-	unsigned		timeout;
-	unsigned		error_delay;
-
-	struct controls_t *ctl;
-
-	struct device_runtime_t *run;
-};
-
-
-struct device_t *device_init();
-void device_destroy(struct device_t *dev);
-
-int device_parse_format(const char *str);
-v4l2_std_id device_parse_standard(const char *str);
-
-int device_open(struct device_t *dev);
-void device_close(struct device_t *dev);
-
-int device_switch_capturing(struct device_t *dev, bool enable);
-int device_grab_buffer(struct device_t *dev);
-int device_release_buffer(struct device_t *dev, unsigned index);
-int device_consume_event(struct device_t *dev);

src/dump/file.c

@@ -0,0 +1,77 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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 *output;
+	US_CALLOC(output, 1);
+
+	if (!strcmp(path, "-")) {
+		US_LOG_INFO("Using output: <stdout>");
+		output->fp = stdout;
+	} else {
+		US_LOG_INFO("Using output: %s", path);
+		if ((output->fp = fopen(path, "wb")) == NULL) {
+			US_LOG_PERROR("Can't open output file");
+			goto error;
+		}
+	}
+
+	output->json = json;
+	return output;
+
+	error:
+		us_output_file_destroy(output);
+		return NULL;
+}
+
+void us_output_file_write(void *v_output, const us_frame_s *frame) {
+	us_output_file_s *output = (us_output_file_s *)v_output;
+	if (output->json) {
+		us_base64_encode(frame->data, frame->used, &output->base64_data, &output->base64_allocated);
+		fprintf(output->fp,
+			"{\"size\": %zu, \"width\": %u, \"height\": %u,"
+			" \"format\": %u, \"stride\": %u, \"online\": %u, \"key\": %u, \"gop\": %u,"
+			" \"grab_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_ts, frame->encode_begin_ts, frame->encode_end_ts,
+			output->base64_data);
+	} else {
+		fwrite(frame->data, 1, frame->used, output->fp);
+	}
+	fflush(output->fp);
+}
+
+void us_output_file_destroy(void *v_output) {
+	us_output_file_s *output = (us_output_file_s *)v_output;
+	US_DELETE(output->base64_data, free);
+	if (output->fp && output->fp != stdout) {
+		if (fclose(output->fp) < 0) {
+			US_LOG_PERROR("Can't close output file");
+		}
+	}
+	free(output);
+}

src/dump/file.h

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
+#    Copyright (C) 2018-2023  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    #
@@ -23,24 +23,27 @@
 #pragma once
 
 #include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
 
-#include <sys/syscall.h>
+#include <sys/types.h>
 
-#include <IL/OMX_IVCommon.h>
-#include <IL/OMX_Core.h>
-#include <IL/OMX_Image.h>
-
-#include "../../logging.h"
-#include "../../tools.h"
+#include "../libs/tools.h"
+#include "../libs/logging.h"
+#include "../libs/frame.h"
+#include "../libs/base64.h"
 
 
-#define LOG_OMX_ERROR(_error, _msg, ...) { \
-		LOGGING_LOCK; \
-		printf("-- ERROR [%.03Lf tid=%ld] -- " _msg ": %s\n", get_now_monotonic(), \
-			syscall(SYS_gettid), ##__VA_ARGS__, omx_error_to_string(_error)); \
-		LOGGING_UNLOCK; \
-	}
+typedef struct {
+	const char *path;
+	bool		json;
+
+	FILE		*fp;
+	char		*base64_data;
+	size_t		base64_allocated;
+} us_output_file_s;
 
 
-const char *omx_error_to_string(OMX_ERRORTYPE error);
-const char *omx_state_to_string(OMX_STATETYPE state);
+us_output_file_s *us_output_file_init(const char *path, bool json);
+void us_output_file_write(void *v_output, const us_frame_s *frame);
+void us_output_file_destroy(void *v_output);

src/dump/main.c

@@ -0,0 +1,349 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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 <signal.h>
+#include <limits.h>
+#include <float.h>
+#include <getopt.h>
+#include <errno.h>
+#include <assert.h>
+
+#include "../libs/const.h"
+#include "../libs/tools.h"
+#include "../libs/logging.h"
+#include "../libs/frame.h"
+#include "../libs/memsink.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_output;
+	void (*write)(void *v_output, const us_frame_s *frame);
+	void (*destroy)(void *v_output);
+} _output_context_s;
+
+
+static void _signal_handler(int signum);
+static void _install_signal_handlers(void);
+
+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");
+
+	char *sink_name = NULL;
+	unsigned sink_timeout = 1;
+	char *output_path = NULL;
+	bool output_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(output_path, optarg);
+			case _O_OUTPUT_JSON:	OPT_SET(output_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 (output_path && output_path[0] != '\0') {
+		if ((ctx.v_output = (void *)us_output_file_init(output_path, output_json)) == NULL) {
+			return 1;
+		}
+		ctx.write = us_output_file_write;
+		ctx.destroy = us_output_file_destroy;
+	}
+
+	_install_signal_handlers();
+	const int retval = abs(_dump_sink(sink_name, sink_timeout, count, interval, key_required, &ctx));
+	if (ctx.v_output && ctx.destroy) {
+		ctx.destroy(ctx.v_output);
+	}
+	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 void _install_signal_handlers(void) {
+	struct sigaction sig_act = {0};
+
+	assert(!sigemptyset(&sig_act.sa_mask));
+	sig_act.sa_handler = _signal_handler;
+	assert(!sigaddset(&sig_act.sa_mask, SIGINT));
+	assert(!sigaddset(&sig_act.sa_mask, SIGTERM));
+	assert(!sigaddset(&sig_act.sa_mask, SIGPIPE));
+
+	US_LOG_DEBUG("Installing SIGINT handler ...");
+	assert(!sigaction(SIGINT, &sig_act, NULL));
+
+	US_LOG_DEBUG("Installing SIGTERM handler ...");
+	assert(!sigaction(SIGTERM, &sig_act, NULL));
+
+	US_LOG_DEBUG("Installing SIGTERM handler ...");
+	assert(!sigaction(SIGPIPE, &sig_act, NULL));
+}
+
+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_memsink_s *sink = NULL;
+
+	if ((sink = us_memsink_init("input", sink_name, false, 0, false, 0, sink_timeout)) == NULL) {
+		goto error;
+	}
+
+	unsigned fps = 0;
+	unsigned fps_accum = 0;
+	long long fps_second = 0;
+
+	long double last_ts = 0;
+
+	while (!_g_stop) {
+		bool key_requested;
+		const int error = us_memsink_client_get(sink, frame, &key_requested, key_required);
+		if (error == 0) {
+			key_required = false;
+
+			const long double now = us_get_now_monotonic();
+			const long long now_second = us_floor_ms(now);
+
+			char fourcc_str[8];
+			US_LOG_VERBOSE("Frame: %s - %ux%u -- online=%d, key=%d, kr=%d, gop=%u, latency=%.3Lf, backlog=%.3Lf, size=%zu",
+				us_fourcc_to_string(frame->format, fourcc_str, 8),
+				frame->width, frame->height,
+				frame->online, frame->key, key_requested, frame->gop,
+				now - frame->grab_ts, (last_ts ? now - last_ts : 0),
+				frame->used);
+			last_ts = now;
+
+			US_LOG_DEBUG("       stride=%u, grab_ts=%.3Lf, encode_begin_ts=%.3Lf, encode_end_ts=%.3Lf",
+				frame->stride, frame->grab_ts, frame->encode_begin_ts, frame->encode_end_ts);
+
+			if (now_second != fps_second) {
+				fps = fps_accum;
+				fps_accum = 0;
+				fps_second = now_second;
+				US_LOG_PERF_FPS("A new second has come; captured_fps=%u", fps);
+			}
+			fps_accum += 1;
+
+			if (ctx->v_output != NULL) {
+				ctx->write(ctx->v_output, frame);
+			}
+
+			if (count >= 0) {
+				--count;
+				if (count <= 0) {
+					break;
+				}
+			}
+
+			if (interval_us > 0) {
+				usleep(interval_us);
+			}
+		} else if (error == -2) {
+			usleep(1000);
+		} else {
+			goto error;
+		}
+	}
+
+	retval = 0;
+
+error:
+	US_DELETE(sink, us_memsink_destroy);
+	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-2023 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,222 +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 <linux/videodev2.h>
-
-#include "tools.h"
-#include "logging.h"
-#include "device.h"
-#include "encoder.h"
-
-#include "encoders/cpu/encoder.h"
-#include "encoders/hw/encoder.h"
-
-#ifdef WITH_OMX_ENCODER
-#	include "encoders/omx/encoder.h"
-#endif
-
-
-static const struct {
-	const char *name;
-	const enum encoder_type_t type;
-} _ENCODER_TYPES[] = {
-	{"CPU",	ENCODER_TYPE_CPU},
-	{"HW",	ENCODER_TYPE_HW},
-#	ifdef WITH_OMX_ENCODER
-	{"OMX",	ENCODER_TYPE_OMX},
-#	endif
-};
-
-
-struct encoder_t *encoder_init() {
-	struct encoder_runtime_t *run;
-	struct encoder_t *encoder;
-
-	A_CALLOC(run, 1);
-	run->type = ENCODER_TYPE_CPU;
-	run->quality = 80;
-	A_MUTEX_INIT(&run->mutex);
-
-	A_CALLOC(encoder, 1);
-	encoder->type = run->type;
-	encoder->quality = run->quality;
-	encoder->run = run;
-	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);
-	// XXX: Тут нет гонки, потому что encoder_prepare() запускается еще до существования других потоков
-	encoder->run->type = encoder->type;
-	encoder->run->quality = encoder->quality;
-
-	LOG_INFO("Using JPEG quality: %u%%", encoder->quality);
-
-#	ifdef WITH_OMX_ENCODER
-	if (encoder->run->type == ENCODER_TYPE_OMX) {
-		LOG_DEBUG("Preparing OMX JPEG encoder ...");
-
-		if (dev->n_workers > OMX_MAX_ENCODERS) {
-			LOG_INFO("OMX JPEG encoder sets limit for worker threads: %u", OMX_MAX_ENCODERS);
-			dev->n_workers = OMX_MAX_ENCODERS;
-		}
-		encoder->run->n_omxs = dev->n_workers;
-
-		A_CALLOC(encoder->run->omxs, encoder->run->n_omxs);
-		for (unsigned index = 0; index < encoder->run->n_omxs; ++index) {
-			if ((encoder->run->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->run->type = ENCODER_TYPE_CPU;
-		encoder->run->quality = encoder->quality;
-#	pragma GCC diagnostic pop
-}
-
-void encoder_destroy(struct encoder_t *encoder) {
-#	ifdef WITH_OMX_ENCODER
-	if (encoder->run->omxs) {
-		for (unsigned index = 0; index < encoder->run->n_omxs; ++index) {
-			if (encoder->run->omxs[index]) {
-				omx_encoder_destroy(encoder->run->omxs[index]);
-			}
-		}
-		free(encoder->run->omxs);
-	}
-#	endif
-	A_MUTEX_DESTROY(&encoder->run->mutex);
-	free(encoder->run);
-	free(encoder);
-}
-
-enum encoder_type_t encoder_parse_type(const char *str) {
-	for (unsigned index = 0; index < ARRAY_LEN(_ENCODER_TYPES); ++index) {
-		if (!strcasecmp(str, _ENCODER_TYPES[index].name)) {
-			return _ENCODER_TYPES[index].type;
-		}
-	}
-	return ENCODER_TYPE_UNKNOWN;
-}
-
-const char *encoder_type_to_string(enum encoder_type_t type) {
-	for (unsigned index = 0; index < ARRAY_LEN(_ENCODER_TYPES); ++index) {
-		if (_ENCODER_TYPES[index].type == type) {
-			return _ENCODER_TYPES[index].name;
-		}
-	}
-	return _ENCODER_TYPES[0].name;
-}
-
-void encoder_prepare_live(struct encoder_t *encoder, struct device_t *dev) {
-	assert(encoder->run->type != ENCODER_TYPE_UNKNOWN);
-
-	if (
-		(dev->run->format == V4L2_PIX_FMT_MJPEG || dev->run->format == V4L2_PIX_FMT_JPEG)
-		&& encoder->run->type != ENCODER_TYPE_HW
-	) {
-		LOG_INFO("Switching to HW JPEG encoder because the input format is (M)JPEG");
-		A_MUTEX_LOCK(&encoder->run->mutex);
-		encoder->run->type = ENCODER_TYPE_HW;
-		A_MUTEX_UNLOCK(&encoder->run->mutex);
-	}
-
-	if (encoder->run->type == ENCODER_TYPE_HW) {
-		if (dev->run->format != V4L2_PIX_FMT_MJPEG && dev->run->format != V4L2_PIX_FMT_JPEG) {
-			LOG_INFO("Switching to CPU JPEG encoder because the input format is not (M)JPEG");
-			goto use_fallback;
-		}
-		if (hw_encoder_prepare_live(dev, encoder->quality) < 0) {
-			A_MUTEX_LOCK(&encoder->run->mutex);
-			encoder->run->quality = 0;
-			A_MUTEX_UNLOCK(&encoder->run->mutex);
-			LOG_INFO("Using JPEG quality: HW-default");
-		}
-	}
-#	ifdef WITH_OMX_ENCODER
-	else if (encoder->run->type == ENCODER_TYPE_OMX) {
-		for (unsigned index = 0; index < encoder->run->n_omxs; ++index) {
-			if (omx_encoder_prepare_live(encoder->run->omxs[index], dev, encoder->quality) < 0) {
-				LOG_ERROR("Can't prepare OMX JPEG encoder, falling back to CPU");
-				goto use_fallback;
-			}
-		}
-	}
-#	endif
-
-	return;
-
-	use_fallback:
-		A_MUTEX_LOCK(&encoder->run->mutex);
-		encoder->run->type = ENCODER_TYPE_CPU;
-		encoder->run->quality = encoder->quality;
-		A_MUTEX_UNLOCK(&encoder->run->mutex);
-}
-
-#pragma GCC diagnostic ignored "-Wunused-label"
-#pragma GCC diagnostic push
-int encoder_compress_buffer(struct encoder_t *encoder, struct device_t *dev, unsigned worker_number, unsigned buf_index) {
-#pragma GCC diagnostic pop
-
-	assert(encoder->run->type != ENCODER_TYPE_UNKNOWN);
-
-	if (encoder->run->type == ENCODER_TYPE_CPU) {
-		cpu_encoder_compress_buffer(dev, buf_index, encoder->quality);
-	} else if (encoder->run->type == ENCODER_TYPE_HW) {
-		hw_encoder_compress_buffer(dev, buf_index);
-	}
-#	ifdef WITH_OMX_ENCODER
-	else if (encoder->run->type == ENCODER_TYPE_OMX) {
-		if (omx_encoder_compress_buffer(encoder->run->omxs[worker_number], dev, buf_index) < 0) {
-			goto use_fallback;
-		}
-	}
-#	endif
-
-	return 0;
-
-#	pragma GCC diagnostic ignored "-Wunused-label"
-#	pragma GCC diagnostic push
-	use_fallback:
-		LOG_INFO("Error while compressing, falling back to CPU");
-		A_MUTEX_LOCK(&encoder->run->mutex);
-		encoder->run->type = ENCODER_TYPE_CPU;
-		encoder->run->quality = encoder->quality;
-		A_MUTEX_UNLOCK(&encoder->run->mutex);
-		return -1;
-#	pragma GCC diagnostic pop
-}

src/encoders/cpu/encoder.c

@@ -1,307 +0,0 @@
-/*****************************************************************************
-#                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
-#                                                                            #
-#    This source file based on code of MJPG-Streamer.                        #
-#                                                                            #
-#    Copyright (C) 2005-2006  Laurent Pinchart & Michel Xhaard               #
-#    Copyright (C) 2006  Gabriel A. Devenyi                                  #
-#    Copyright (C) 2007  Tom Stöveken                                        #
-#    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 <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-
-#include <jpeglib.h>
-#include <linux/videodev2.h>
-
-#include "../../tools.h"
-#include "../../device.h"
-
-#include "encoder.h"
-
-
-struct _jpeg_dest_manager_t {
-	struct			jpeg_destination_mgr mgr; // Default manager
-	JOCTET			*buffer; // Start of buffer
-	unsigned char	*outbuffer_cursor;
-	size_t			*written;
-};
-
-
-static void _jpeg_set_dest_picture(j_compress_ptr jpeg, unsigned char *picture, size_t *written);
-
-static void _jpeg_write_scanlines_yuyv(
-	struct jpeg_compress_struct *jpeg, const unsigned char *data,
-	unsigned width, unsigned height);
-
-static void _jpeg_write_scanlines_uyvy(
-	struct jpeg_compress_struct *jpeg, const unsigned char *data,
-	unsigned width, unsigned height);
-
-static void _jpeg_write_scanlines_rgb565(
-	struct jpeg_compress_struct *jpeg, const unsigned char *data,
-	unsigned width, unsigned height);
-
-static void _jpeg_write_scanlines_rgb24(
-	struct jpeg_compress_struct *jpeg, const unsigned char *data,
-	unsigned width, unsigned height);
-
-static void _jpeg_init_destination(j_compress_ptr jpeg);
-static boolean _jpeg_empty_output_buffer(j_compress_ptr jpeg);
-static void _jpeg_term_destination(j_compress_ptr jpeg);
-
-
-void cpu_encoder_compress_buffer(struct device_t *dev, unsigned index, unsigned quality) {
-	// This function based on compress_image_to_jpeg() from mjpg-streamer
-
-	struct jpeg_compress_struct jpeg;
-	struct jpeg_error_mgr jpeg_error;
-
-	jpeg.err = jpeg_std_error(&jpeg_error);
-	jpeg_create_compress(&jpeg);
-
-#	define PICTURE(_next) dev->run->pictures[index]._next
-
-	PICTURE(used) = 0;
-	_jpeg_set_dest_picture(&jpeg, PICTURE(data), &PICTURE(used));
-
-	jpeg.image_width = dev->run->width;
-	jpeg.image_height = dev->run->height;
-	jpeg.input_components = 3;
-	jpeg.in_color_space = JCS_RGB;
-
-	jpeg_set_defaults(&jpeg);
-	jpeg_set_quality(&jpeg, quality, TRUE);
-
-	jpeg_start_compress(&jpeg, TRUE);
-
-#	define WRITE_SCANLINES(_format, _func) \
-		case _format: { _func(&jpeg, dev->run->hw_buffers[index].data, dev->run->width, dev->run->height); break; }
-
-	switch (dev->run->format) {
-		// https://www.fourcc.org/yuv.php
-		WRITE_SCANLINES(V4L2_PIX_FMT_YUYV, _jpeg_write_scanlines_yuyv);
-		WRITE_SCANLINES(V4L2_PIX_FMT_UYVY, _jpeg_write_scanlines_uyvy);
-		WRITE_SCANLINES(V4L2_PIX_FMT_RGB565, _jpeg_write_scanlines_rgb565);
-		WRITE_SCANLINES(V4L2_PIX_FMT_RGB24, _jpeg_write_scanlines_rgb24);
-		default: assert(0 && "Unsupported input format for CPU JPEG encoder");
-	}
-
-#	undef WRITE_SCANLINES
-
-	// TODO: process jpeg errors:
-	// https://stackoverflow.com/questions/19857766/error-handling-in-libjpeg
-	jpeg_finish_compress(&jpeg);
-	jpeg_destroy_compress(&jpeg);
-	assert(PICTURE(used) > 0);
-	assert(PICTURE(used) <= dev->run->max_picture_size);
-}
-
-static void _jpeg_set_dest_picture(j_compress_ptr jpeg, unsigned char *picture, size_t *written) {
-	struct _jpeg_dest_manager_t *dest;
-
-	if (jpeg->dest == NULL) {
-		assert((jpeg->dest = (struct jpeg_destination_mgr *)(*jpeg->mem->alloc_small)(
-			(j_common_ptr) jpeg, JPOOL_PERMANENT, sizeof(struct _jpeg_dest_manager_t)
-		)));
-	}
-
-	dest = (struct _jpeg_dest_manager_t *)jpeg->dest;
-	dest->mgr.init_destination = _jpeg_init_destination;
-	dest->mgr.empty_output_buffer = _jpeg_empty_output_buffer;
-	dest->mgr.term_destination = _jpeg_term_destination;
-	dest->outbuffer_cursor = picture;
-	dest->written = written;
-}
-
-#define YUV_R(_y, _, _v)	(((_y) + (359 * (_v))) >> 8)
-#define YUV_G(_y, _u, _v)	(((_y) - (88 * (_u)) - (183 * (_v))) >> 8)
-#define YUV_B(_y, _u, _)	(((_y) + (454 * (_u))) >> 8)
-#define NORM_COMPONENT(_x)	(((_x) > 255) ? 255 : (((_x) < 0) ? 0 : (_x)))
-
-static void _jpeg_write_scanlines_yuyv(
-	struct jpeg_compress_struct *jpeg, const unsigned char *data,
-	unsigned width, unsigned height) {
-
-	unsigned char *line_buffer;
-	JSAMPROW scanlines[1];
-	unsigned z = 0;
-
-	A_CALLOC(line_buffer, width * 3);
-
-	while (jpeg->next_scanline < height) {
-		unsigned char *ptr = line_buffer;
-
-		for (unsigned x = 0; x < width; ++x) {
-			int y = (!z ? data[0] << 8 : data[2] << 8);
-			int u = data[1] - 128;
-			int v = data[3] - 128;
-
-			int r = YUV_R(y, u, v);
-			int g = YUV_G(y, u, v);
-			int b = YUV_B(y, u, v);
-
-			*(ptr++) = NORM_COMPONENT(r);
-			*(ptr++) = NORM_COMPONENT(g);
-			*(ptr++) = NORM_COMPONENT(b);
-
-			if (z++) {
-				z = 0;
-				data += 4;
-			}
-		}
-
-		scanlines[0] = line_buffer;
-		jpeg_write_scanlines(jpeg, scanlines, 1);
-	}
-
-	free(line_buffer);
-}
-
-static void _jpeg_write_scanlines_uyvy(
-	struct jpeg_compress_struct *jpeg, const unsigned char *data,
-	unsigned width, unsigned height) {
-
-	unsigned char *line_buffer;
-	JSAMPROW scanlines[1];
-	unsigned z = 0;
-
-	A_CALLOC(line_buffer, width * 3);
-
-	while (jpeg->next_scanline < height) {
-		unsigned char *ptr = line_buffer;
-
-		for(unsigned x = 0; x < width; ++x) {
-			int y = (!z ? data[1] << 8 : data[3] << 8);
-			int u = data[0] - 128;
-			int v = data[2] - 128;
-
-			int r = YUV_R(y, u, v);
-			int g = YUV_G(y, u, v);
-			int b = YUV_B(y, u, v);
-
-			*(ptr++) = NORM_COMPONENT(r);
-			*(ptr++) = NORM_COMPONENT(g);
-			*(ptr++) = NORM_COMPONENT(b);
-
-			if (z++) {
-				z = 0;
-				data += 4;
-			}
-		}
-
-		scanlines[0] = line_buffer;
-		jpeg_write_scanlines(jpeg, scanlines, 1);
-	}
-
-	free(line_buffer);
-}
-
-#undef NORM_COMPONENT
-#undef YUV_B
-#undef YUV_G
-#undef YUV_R
-
-static void _jpeg_write_scanlines_rgb565(
-	struct jpeg_compress_struct *jpeg, const unsigned char *data,
-	unsigned width, unsigned height) {
-
-	unsigned char *line_buffer;
-	JSAMPROW scanlines[1];
-
-	A_CALLOC(line_buffer, width * 3);
-
-	while (jpeg->next_scanline < height) {
-		unsigned char *ptr = line_buffer;
-
-		for(unsigned x = 0; x < width; ++x) {
-			unsigned int two_byte = (data[1] << 8) + data[0];
-
-			*(ptr++) = data[1] & 248; // Red
-			*(ptr++) = (unsigned char)((two_byte & 2016) >> 3); // Green
-			*(ptr++) = (data[0] & 31) * 8; // Blue
-
-			data += 2;
-		}
-
-		scanlines[0] = line_buffer;
-		jpeg_write_scanlines(jpeg, scanlines, 1);
-	}
-
-	free(line_buffer);
-}
-
-static void _jpeg_write_scanlines_rgb24(
-	struct jpeg_compress_struct *jpeg, const unsigned char *data,
-	unsigned width, unsigned height) {
-
-	JSAMPROW scanlines[1];
-
-	while (jpeg->next_scanline < height) {
-		scanlines[0] = (unsigned char *)(data + jpeg->next_scanline * width * 3);
-		jpeg_write_scanlines(jpeg, scanlines, 1);
-	}
-}
-
-#define JPEG_OUTPUT_BUFFER_SIZE  4096
-
-static void _jpeg_init_destination(j_compress_ptr jpeg) {
-	struct _jpeg_dest_manager_t *dest = (struct _jpeg_dest_manager_t *)jpeg->dest;
-
-	// Allocate the output buffer - it will be released when done with image
-	assert((dest->buffer = (JOCTET *)(*jpeg->mem->alloc_small)(
-		(j_common_ptr) jpeg, JPOOL_IMAGE, JPEG_OUTPUT_BUFFER_SIZE * sizeof(JOCTET)
-	)));
-
-	dest->mgr.next_output_byte = dest->buffer;
-	dest->mgr.free_in_buffer = JPEG_OUTPUT_BUFFER_SIZE;
-}
-
-static boolean _jpeg_empty_output_buffer(j_compress_ptr jpeg) {
-	// Called whenever local jpeg buffer fills up
-
-	struct _jpeg_dest_manager_t *dest = (struct _jpeg_dest_manager_t *)jpeg->dest;
-
-	memcpy(dest->outbuffer_cursor, dest->buffer, JPEG_OUTPUT_BUFFER_SIZE);
-	dest->outbuffer_cursor += JPEG_OUTPUT_BUFFER_SIZE;
-	*dest->written += JPEG_OUTPUT_BUFFER_SIZE;
-
-	dest->mgr.next_output_byte = dest->buffer;
-	dest->mgr.free_in_buffer = JPEG_OUTPUT_BUFFER_SIZE;
-
-	return TRUE;
-}
-
-static void _jpeg_term_destination(j_compress_ptr jpeg) {
-	// Called by jpeg_finish_compress after all data has been written.
-	// Usually needs to flush buffer
-
-	struct _jpeg_dest_manager_t *dest = (struct _jpeg_dest_manager_t *)jpeg->dest;
-	size_t data_count = JPEG_OUTPUT_BUFFER_SIZE - dest->mgr.free_in_buffer;
-
-	// Write any data remaining in the buffer
-	memcpy(dest->outbuffer_cursor, dest->buffer, data_count);
-	dest->outbuffer_cursor += data_count;
-	*dest->written += data_count;
-}
-
-#undef JPEG_OUTPUT_BUFFER_SIZE

src/encoders/omx/component.c

@@ -1,156 +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 <unistd.h>
-
-#include <IL/OMX_Core.h>
-#include <IL/OMX_Component.h>
-
-#include "../../logging.h"
-
-#include "formatters.h"
-#include "component.h"
-
-
-static int _component_wait_port_changed(OMX_HANDLETYPE *component, OMX_U32 port, OMX_BOOL enabled);
-static int _component_wait_state_changed(OMX_HANDLETYPE *component, OMX_STATETYPE wanted);
-
-
-int component_enable_port(OMX_HANDLETYPE *component, OMX_U32 port) {
-	OMX_ERRORTYPE error;
-
-	LOG_DEBUG("Enabling OMX port %u ...", port);
-	if ((error = OMX_SendCommand(*component, OMX_CommandPortEnable, port, NULL)) != OMX_ErrorNone) {
-		LOG_OMX_ERROR(error, "Can't enable OMX port %u", port);
-		return -1;
-	}
-	return _component_wait_port_changed(component, port, OMX_TRUE);
-}
-
-int component_disable_port(OMX_HANDLETYPE *component, OMX_U32 port) {
-	OMX_ERRORTYPE error;
-
-	LOG_DEBUG("Disabling OMX port %u ...", port);
-	if ((error = OMX_SendCommand(*component, OMX_CommandPortDisable, port, NULL)) != OMX_ErrorNone) {
-		LOG_OMX_ERROR(error, "Can't disable OMX port %u", port);
-		return -1;
-	}
-	return _component_wait_port_changed(component, port, OMX_FALSE);
-}
-
-int component_get_portdef(OMX_HANDLETYPE *component, OMX_PARAM_PORTDEFINITIONTYPE *portdef, OMX_U32 port) {
-	OMX_ERRORTYPE error;
-
-	OMX_INIT_STRUCTURE(*portdef);
-	portdef->nPortIndex = port;
-
-	LOG_DEBUG("Fetching OMX port %u definition ...", port);
-	if ((error = OMX_GetParameter(*component, OMX_IndexParamPortDefinition, portdef)) != OMX_ErrorNone) {
-		LOG_OMX_ERROR(error, "Can't get OMX port %u definition", port);
-		return -1;
-	}
-	return 0;
-}
-
-int component_set_portdef(OMX_HANDLETYPE *component, OMX_PARAM_PORTDEFINITIONTYPE *portdef) {
-	OMX_ERRORTYPE error;
-
-	LOG_DEBUG("Writing OMX port %u definition ...", portdef->nPortIndex);
-	if ((error = OMX_SetParameter(*component, OMX_IndexParamPortDefinition, portdef)) != OMX_ErrorNone) {
-		LOG_OMX_ERROR(error, "Can't set OMX port %u definition", portdef->nPortIndex);
-		return -1;
-	}
-	return 0;
-}
-
-int component_set_state(OMX_HANDLETYPE *component, OMX_STATETYPE state) {
-	const char *state_str = omx_state_to_string(state);
-	OMX_ERRORTYPE error;
-	int retries = 50;
-
-	LOG_DEBUG("Switching component state to %s ...", state_str);
-
-	do {
-		error = OMX_SendCommand(*component, OMX_CommandStateSet, state, NULL);
-		if (error == OMX_ErrorNone) {
-			return _component_wait_state_changed(component, state);
-		} else if (error == OMX_ErrorInsufficientResources && retries) {
-			// Иногда железо не инициализируется, хз почему, просто ретраим, со второй попытки сработает
-			LOG_OMX_ERROR(error, "Can't switch OMX component state to %s, need to retry", state_str);
-			retries -= 1;
-			usleep(8000);
-		} else {
-			break;
-		}
-	} while (retries);
-
-	LOG_OMX_ERROR(error, "Can't switch OMX component state to %s", state_str);
-	return -1;
-}
-
-
-static int _component_wait_port_changed(OMX_HANDLETYPE *component, OMX_U32 port, OMX_BOOL enabled) {
-	OMX_ERRORTYPE error;
-	OMX_PARAM_PORTDEFINITIONTYPE portdef;
-	int retries = 50;
-
-	OMX_INIT_STRUCTURE(portdef);
-	portdef.nPortIndex = port;
-
-	do {
-		if ((error = OMX_GetParameter(*component, OMX_IndexParamPortDefinition, &portdef)) != OMX_ErrorNone) {
-			LOG_OMX_ERROR(error, "Can't get OMX port %u definition for waiting", port);
-			return -1;
-		}
-
-		if (portdef.bEnabled != enabled) {
-			LOG_DEBUG("Waiting for OMX %s port %u", (enabled ? "enabling" : "disabling"), port);
-			retries -= 1;
-			usleep(8000);
-		}
-	} while (portdef.bEnabled != enabled && retries);
-
-	LOG_DEBUG("OMX port %u %s", port, (enabled ? "enabled" : "disabled"));
-	return (portdef.bEnabled == enabled ? 0 : -1);
-}
-
-static int _component_wait_state_changed(OMX_HANDLETYPE *component, OMX_STATETYPE wanted) {
-	OMX_ERRORTYPE error;
-	OMX_STATETYPE state;
-	int retries = 50;
-
-	do {
-		if ((error = OMX_GetState(*component, &state)) != OMX_ErrorNone) {
-			LOG_OMX_ERROR(error, "Failed to get OMX component state");
-			return -1;
-		}
-
-		if (state != wanted) {
-			LOG_DEBUG("Waiting when OMX component state changes to %s", omx_state_to_string(wanted));
-			retries -= 1;
-			usleep(8000);
-		}
-	} while (state != wanted && retries);
-
-	LOG_DEBUG("Switched OMX component state to %s", omx_state_to_string(wanted))
-	return (state == wanted ? 0 : -1);
-}

src/encoders/omx/encoder.c

@@ -1,505 +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 <string.h>
-#include <unistd.h>
-#include <assert.h>
-
-#include <linux/videodev2.h>
-
-#include <bcm_host.h>
-#include <IL/OMX_Core.h>
-#include <IL/OMX_Component.h>
-#include <IL/OMX_Broadcom.h>
-#include <interface/vcos/vcos_semaphore.h>
-
-#include "../../logging.h"
-#include "../../tools.h"
-#include "../../device.h"
-
-#include "formatters.h"
-#include "component.h"
-#include "encoder.h"
-
-
-static const OMX_U32 _INPUT_PORT = 340;
-static const OMX_U32 _OUTPUT_PORT = 341;
-
-
-static int _i_omx = 0;
-
-
-static int _omx_init_component(struct omx_encoder_t *omx);
-static int _omx_init_disable_ports(struct omx_encoder_t *omx);
-static int _omx_setup_input(struct omx_encoder_t *omx, struct device_t *dev);
-static int _omx_setup_output(struct omx_encoder_t *omx, unsigned quality);
-static int _omx_encoder_clear_ports(struct omx_encoder_t *omx);
-
-static OMX_ERRORTYPE _omx_event_handler(
-	UNUSED OMX_HANDLETYPE encoder,
-	OMX_PTR v_omx, OMX_EVENTTYPE event, OMX_U32 data1,
-	UNUSED OMX_U32 data2, UNUSED OMX_PTR event_data);
-
-static OMX_ERRORTYPE _omx_input_required_handler(
-	UNUSED OMX_HANDLETYPE encoder,
-	OMX_PTR v_omx, UNUSED OMX_BUFFERHEADERTYPE *buffer);
-
-static OMX_ERRORTYPE _omx_output_available_handler(
-	UNUSED OMX_HANDLETYPE encoder,
-	OMX_PTR v_omx, UNUSED OMX_BUFFERHEADERTYPE *buffer);
-
-
-struct omx_encoder_t *omx_encoder_init() {
-	// Some theory:
-	//   - http://www.fourcc.org/yuv.php
-	//   - https://kwasi-ich.de/blog/2017/11/26/omx/
-	//   - https://github.com/hopkinskong/rpi-omx-jpeg-encode/blob/master/jpeg_bench.cpp
-	//   - https://github.com/kwasmich/OMXPlayground/blob/master/omxJPEGEnc.c
-	//   - https://github.com/gagle/raspberrypi-openmax-jpeg/blob/master/jpeg.c
-	//   - https://www.raspberrypi.org/forums/viewtopic.php?t=154790
-	//   - https://bitbucket.org/bensch128/omxjpegencode/src/master/jpeg_encoder.cpp
-
-	struct omx_encoder_t *omx;
-	OMX_ERRORTYPE error;
-
-	A_CALLOC(omx, 1);
-
-	assert(_i_omx >= 0);
-	if (_i_omx == 0) {
-		LOG_INFO("Initializing BCM ...");
-		bcm_host_init();
-
-		LOG_INFO("Initializing OMX ...");
-		if ((error = OMX_Init()) != OMX_ErrorNone) {
-			LOG_OMX_ERROR(error, "Can't initialize OMX");
-			goto error;
-		}
-	}
-	_i_omx += 1;
-
-	LOG_INFO("Initializing OMX JPEG encoder ...");
-
-	if (vcos_semaphore_create(&omx->handler_lock, "handler_lock", 0) != VCOS_SUCCESS) {
-		LOG_ERROR("Can't create VCOS semaphore");
-		goto error;
-	}
-	omx->i_handler_lock = true;
-
-	if (_omx_init_component(omx) < 0) {
-		goto error;
-	}
-
-	if (_omx_init_disable_ports(omx) < 0) {
-		goto error;
-	}
-
-	return omx;
-
-	error:
-		omx_encoder_destroy(omx);
-		return NULL;
-}
-
-void omx_encoder_destroy(struct omx_encoder_t *omx) {
-	OMX_ERRORTYPE error;
-
-	LOG_INFO("Destroying OMX JPEG encoder ...");
-
-	component_set_state(&omx->encoder, OMX_StateIdle);
-	_omx_encoder_clear_ports(omx);
-	component_set_state(&omx->encoder, OMX_StateLoaded);
-
-	if (omx->i_handler_lock) {
-		vcos_semaphore_delete(&omx->handler_lock);
-	}
-
-	if (omx->i_encoder) {
-		if ((error = OMX_FreeHandle(omx->encoder)) != OMX_ErrorNone) {
-			LOG_OMX_ERROR(error, "Can't free OMX.broadcom.image_encode");
-		}
-	}
-
-	assert(_i_omx >= 0);
-	_i_omx -= 1;
-	if (_i_omx == 0) {
-		LOG_INFO("Destroying OMX ...");
-		OMX_Deinit();
-
-		LOG_INFO("Destroying BCM ...");
-		bcm_host_deinit();
-	}
-
-	free(omx);
-}
-
-int omx_encoder_prepare_live(struct omx_encoder_t *omx, struct device_t *dev, unsigned quality) {
-	if (component_set_state(&omx->encoder, OMX_StateIdle) < 0) {
-		return -1;
-	}
-	if (_omx_encoder_clear_ports(omx) < 0) {
-		return -1;
-	}
-	if (_omx_setup_input(omx, dev) < 0) {
-		return -1;
-	}
-	if (_omx_setup_output(omx, quality) < 0) {
-		return -1;
-	}
-	if (component_set_state(&omx->encoder, OMX_StateExecuting) < 0) {
-		return -1;
-	}
-	return 0;
-}
-
-int omx_encoder_compress_buffer(struct omx_encoder_t *omx, struct device_t *dev, unsigned index) {
-#	define PICTURE(_next)	dev->run->pictures[index]._next
-#	define HW_BUFFER(_next)	dev->run->hw_buffers[index]._next
-#	define IN(_next)		omx->input_buffer->_next
-#	define OUT(_next)		omx->output_buffer->_next
-
-	OMX_ERRORTYPE error;
-	size_t slice_size = (IN(nAllocLen) < HW_BUFFER(used) ? IN(nAllocLen) : HW_BUFFER(used));
-	size_t pos = 0;
-
-	if ((error = OMX_FillThisBuffer(omx->encoder, omx->output_buffer)) != OMX_ErrorNone) {
-		LOG_OMX_ERROR(error, "Failed to request filling of the output buffer on encoder");
-		return -1;
-	}
-
-	PICTURE(used) = 0;
-	omx->output_available = false;
-	omx->input_required = true;
-
-	while (true) {
-		if (omx->failed) {
-			return -1;
-		}
-
-		if (omx->output_available) {
-			omx->output_available = false;
-
-			assert(PICTURE(used) + OUT(nFilledLen) <= dev->run->max_picture_size);
-			memcpy(PICTURE(data) + PICTURE(used), OUT(pBuffer) + OUT(nOffset), OUT(nFilledLen));
-			PICTURE(used) += OUT(nFilledLen);
-
-			if (OUT(nFlags) & OMX_BUFFERFLAG_ENDOFFRAME) {
-				OUT(nFlags) = 0;
-				break;
-			}
-
-			if ((error = OMX_FillThisBuffer(omx->encoder, omx->output_buffer)) != OMX_ErrorNone) {
-				LOG_OMX_ERROR(error, "Failed to request filling of the output buffer on encoder");
-				return -1;
-			}
-		}
-
-		if (omx->input_required) {
-			omx->input_required = false;
-
-			if (pos == HW_BUFFER(used)) {
-				continue;
-			}
-
-			memcpy(IN(pBuffer), HW_BUFFER(data) + pos, slice_size);
-			IN(nOffset) = 0;
-			IN(nFilledLen) = slice_size;
-
-			pos += slice_size;
-
-			if (pos + slice_size > HW_BUFFER(used)) {
-				slice_size = HW_BUFFER(used) - pos;
-			}
-
-			if ((error = OMX_EmptyThisBuffer(omx->encoder, omx->input_buffer)) != OMX_ErrorNone) {
-				LOG_OMX_ERROR(error, "Failed to request emptying of the input buffer on encoder");
-				return -1;
-			}
-		}
-
-		vcos_semaphore_wait(&omx->handler_lock);
-	}
-
-#	undef OUT
-#	undef IN
-#	undef HW_BUFFER
-#	undef PICTURE
-	return 0;
-}
-
-static int _omx_init_component(struct omx_encoder_t *omx) {
-	// http://home.nouwen.name/RaspberryPi/documentation/ilcomponents/image_encode.html
-
-	OMX_ERRORTYPE error;
-
-	OMX_CALLBACKTYPE callbacks;
-	MEMSET_ZERO(callbacks);
-	callbacks.EventHandler = _omx_event_handler;
-	callbacks.EmptyBufferDone = _omx_input_required_handler;
-	callbacks.FillBufferDone = _omx_output_available_handler;
-
-	LOG_DEBUG("Initializing OMX.broadcom.image_encode ...");
-	if ((error = OMX_GetHandle(&omx->encoder, "OMX.broadcom.image_encode", omx, &callbacks)) != OMX_ErrorNone) {
-		LOG_OMX_ERROR(error, "Can't initialize OMX.broadcom.image_encode");
-		return -1;
-	}
-	omx->i_encoder = true;
-	return 0;
-}
-
-static int _omx_init_disable_ports(struct omx_encoder_t *omx) {
-	OMX_ERRORTYPE error;
-	OMX_INDEXTYPE types[] = {
-		OMX_IndexParamAudioInit, OMX_IndexParamVideoInit,
-		OMX_IndexParamImageInit, OMX_IndexParamOtherInit,
-	};
-	OMX_PORT_PARAM_TYPE ports;
-
-	OMX_INIT_STRUCTURE(ports);
-	if ((error = OMX_GetParameter(omx->encoder, OMX_IndexParamImageInit, &ports)) != OMX_ErrorNone) {
-		LOG_OMX_ERROR(error, "Can't OMX_GetParameter(OMX_IndexParamImageInit)");
-		return -1;
-	}
-
-	for (unsigned index = 0; index < 4; ++index) {
-		if ((error = OMX_GetParameter(omx->encoder, types[index], &ports)) != OMX_ErrorNone) {
-			LOG_OMX_ERROR(error, "Can't OMX_GetParameter(types[%u])", index);
-			return -1;
-		}
-		for (OMX_U32 port = ports.nStartPortNumber; port < ports.nStartPortNumber + ports.nPorts; ++port) {
-			if (component_disable_port(&omx->encoder, port) < 0) {
-				return -1;
-			}
-		}
-	}
-	return 0;
-}
-
-static int _omx_setup_input(struct omx_encoder_t *omx, struct device_t *dev) {
-	OMX_ERRORTYPE error;
-	OMX_PARAM_PORTDEFINITIONTYPE portdef;
-
-	LOG_DEBUG("Setting up OMX JPEG input port ...");
-
-	if (component_get_portdef(&omx->encoder, &portdef, _INPUT_PORT) < 0) {
-		LOG_ERROR("... first");
-		return -1;
-	}
-
-	portdef.format.image.nFrameWidth = dev->run->width;
-	portdef.format.image.nFrameHeight = dev->run->height;
-	portdef.format.image.nStride = 0;
-#	define ALIGN_HEIGHT(_x, _y) (((_x) + ((_y) - 1)) & ~((_y) - 1))
-	portdef.format.image.nSliceHeight = ALIGN_HEIGHT(dev->run->height, 16);
-#	undef ALIGN_HEIGHT
-	portdef.format.image.bFlagErrorConcealment = OMX_FALSE;
-	portdef.format.image.eCompressionFormat = OMX_IMAGE_CodingUnused;
-	portdef.nBufferSize = dev->run->max_picture_size;
-
-#	define MAP_FORMAT(_v4l2_format, _omx_format) \
-		case _v4l2_format: { portdef.format.image.eColorFormat = _omx_format; break; }
-
-	switch (dev->run->format) {
-		// https://www.fourcc.org/yuv.php
-		// Also see comments inside OMX_IVCommon.h
-		MAP_FORMAT(V4L2_PIX_FMT_YUYV, OMX_COLOR_FormatYCbYCr);
-		MAP_FORMAT(V4L2_PIX_FMT_UYVY, OMX_COLOR_FormatCbYCrY);
-		MAP_FORMAT(V4L2_PIX_FMT_RGB565, OMX_COLOR_Format16bitRGB565);
-		MAP_FORMAT(V4L2_PIX_FMT_RGB24, OMX_COLOR_Format24bitRGB888);
-		// TODO: найти устройство с RGB565 и протестить его.
-		// FIXME: RGB24 не работает нормально, нижняя половина экрана зеленая.
-		// FIXME: Китайский EasyCap тоже не работает, мусор на экране.
-		// Вероятно обе проблемы вызваны некорректной реализацией OMX на пае.
-		default: assert(0 && "Unsupported input format for OMX JPEG encoder");
-	}
-
-#	undef MAP_FORMAT
-
-	if (component_set_portdef(&omx->encoder, &portdef) < 0) {
-		return -1;
-	}
-
-	if (component_get_portdef(&omx->encoder, &portdef, _INPUT_PORT) < 0) {
-		LOG_ERROR("... second");
-		return -1;
-	}
-
-	if (component_enable_port(&omx->encoder, _INPUT_PORT) < 0) {
-		return -1;
-	}
-	omx->i_input_port_enabled = true;
-
-	if ((error = OMX_AllocateBuffer(omx->encoder, &omx->input_buffer, _INPUT_PORT, NULL, portdef.nBufferSize)) != OMX_ErrorNone) {
-		LOG_OMX_ERROR(error, "Can't allocate OMX JPEG input buffer");
-		return -1;
-	}
-	return 0;
-}
-
-static int _omx_setup_output(struct omx_encoder_t *omx, unsigned quality) {
-	OMX_ERRORTYPE error;
-	OMX_PARAM_PORTDEFINITIONTYPE portdef;
-
-	LOG_DEBUG("Setting up OMX JPEG output port ...");
-
-	if (component_get_portdef(&omx->encoder, &portdef, _OUTPUT_PORT) < 0) {
-		LOG_ERROR("... first");
-		return -1;
-	}
-
-	portdef.format.image.bFlagErrorConcealment = OMX_FALSE;
-	portdef.format.image.eCompressionFormat = OMX_IMAGE_CodingJPEG;
-	portdef.format.image.eColorFormat = OMX_COLOR_FormatYCbYCr;
-
-	if (component_set_portdef(&omx->encoder, &portdef) < 0) {
-		return -1;
-	}
-
-	if (component_get_portdef(&omx->encoder, &portdef, _OUTPUT_PORT) < 0) {
-		LOG_ERROR("... second");
-		return -1;
-	}
-
-	{
-		OMX_CONFIG_BOOLEANTYPE exif;
-
-		OMX_INIT_STRUCTURE(exif);
-		exif.bEnabled = OMX_FALSE;
-
-		if ((error = OMX_SetParameter(omx->encoder, OMX_IndexParamBrcmDisableEXIF, &exif)) != OMX_ErrorNone) {
-			LOG_OMX_ERROR(error, "Can't disable EXIF on OMX JPEG");
-			return -1;
-		}
-	}
-
-	{
-		OMX_PARAM_IJGSCALINGTYPE ijg;
-
-		OMX_INIT_STRUCTURE(ijg);
-		ijg.nPortIndex = _OUTPUT_PORT;
-		ijg.bEnabled = OMX_TRUE;
-
-		if ((error = OMX_SetParameter(omx->encoder, OMX_IndexParamBrcmEnableIJGTableScaling, &ijg)) != OMX_ErrorNone) {
-			LOG_OMX_ERROR(error, "Can't set OMX JPEG IJG settings");
-			return -1;
-		}
-	}
-
-	{
-		OMX_IMAGE_PARAM_QFACTORTYPE qfactor;
-
-		OMX_INIT_STRUCTURE(qfactor);
-		qfactor.nPortIndex = _OUTPUT_PORT;
-		qfactor.nQFactor = quality;
-
-		if ((error = OMX_SetParameter(omx->encoder, OMX_IndexParamQFactor, &qfactor)) != OMX_ErrorNone) {
-			LOG_OMX_ERROR(error, "Can't set OMX JPEG quality");
-			return -1;
-		}
-	}
-
-	if (component_enable_port(&omx->encoder, _OUTPUT_PORT) < 0) {
-		return -1;
-	}
-	omx->i_output_port_enabled = true;
-
-	if ((error = OMX_AllocateBuffer(omx->encoder, &omx->output_buffer, _OUTPUT_PORT, NULL, portdef.nBufferSize)) != OMX_ErrorNone) {
-		LOG_OMX_ERROR(error, "Can't allocate OMX JPEG output buffer");
-		return -1;
-	}
-	return 0;
-}
-
-static int _omx_encoder_clear_ports(struct omx_encoder_t *omx) {
-	OMX_ERRORTYPE error;
-	int retcode = 0;
-
-	if (omx->i_output_port_enabled) {
-		retcode -= component_disable_port(&omx->encoder, _OUTPUT_PORT);
-		omx->i_output_port_enabled = false;
-	}
-	if (omx->i_input_port_enabled) {
-		retcode -= component_disable_port(&omx->encoder, _INPUT_PORT);
-		omx->i_input_port_enabled = false;
-	}
-
-	if (omx->input_buffer) {
-		if ((error = OMX_FreeBuffer(omx->encoder, _INPUT_PORT, omx->input_buffer)) != OMX_ErrorNone) {
-			LOG_OMX_ERROR(error, "Can't free OMX JPEG input buffer");
-			// retcode -= 1;
-		}
-		omx->input_buffer = NULL;
-	}
-	if (omx->output_buffer) {
-		if ((error = OMX_FreeBuffer(omx->encoder, _OUTPUT_PORT, omx->output_buffer)) != OMX_ErrorNone) {
-			LOG_OMX_ERROR(error, "Can't free OMX JPEG output buffer");
-			// retcode -= 1;
-		}
-		omx->output_buffer = NULL;
-	}
-	return retcode;
-}
-
-static OMX_ERRORTYPE _omx_event_handler(
-	UNUSED OMX_HANDLETYPE encoder,
-	OMX_PTR v_omx, OMX_EVENTTYPE event, OMX_U32 data1,
-	UNUSED OMX_U32 data2, UNUSED OMX_PTR event_data) {
-
-	// OMX calls this handler for all the events it emits
-
-	struct omx_encoder_t *omx = (struct omx_encoder_t *)v_omx;
-
-	if (event == OMX_EventError) {
-		LOG_OMX_ERROR((OMX_ERRORTYPE)data1, "OMX error event received");
-		omx->failed = true;
-		vcos_semaphore_post(&omx->handler_lock);
-	}
-	return OMX_ErrorNone;
-}
-
-static OMX_ERRORTYPE _omx_input_required_handler(
-	UNUSED OMX_HANDLETYPE encoder,
-	OMX_PTR v_omx, UNUSED OMX_BUFFERHEADERTYPE *buffer) {
-
-	// Called by OMX when the encoder component requires
-	// the input buffer to be filled with RAW image data
-
-	struct omx_encoder_t *omx = (struct omx_encoder_t *)v_omx;
-
-	omx->input_required = true;
-	vcos_semaphore_post(&omx->handler_lock);
-	return OMX_ErrorNone;
-}
-
-static OMX_ERRORTYPE _omx_output_available_handler(
-	UNUSED OMX_HANDLETYPE encoder,
-	OMX_PTR v_omx, UNUSED OMX_BUFFERHEADERTYPE *buffer) {
-
-	// Called by OMX when the encoder component has filled
-	// the output buffer with JPEG data
-
-	struct omx_encoder_t *omx = (struct omx_encoder_t *)v_omx;
-
-	omx->output_available = true;
-	vcos_semaphore_post(&omx->handler_lock);
-	return OMX_ErrorNone;
-}

src/encoders/omx/formatters.c

@@ -1,83 +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 <stdio.h>
-#include <assert.h>
-
-#include <IL/OMX_IVCommon.h>
-#include <IL/OMX_Core.h>
-
-#include "../../tools.h"
-#include "formatters.h"
-
-
-#define CASE_TO_STRING(_value) \
-	case _value: { return #_value; }
-
-#define CASE_ASSERT(_msg, _value) default: { \
-		char *_buf; A_CALLOC(_buf, 128); \
-		sprintf(_buf, _msg ": 0x%08x", _value); \
-		assert(0 && _buf); \
-	}
-
-const char *omx_error_to_string(OMX_ERRORTYPE error) {
-	switch (error) {
-		CASE_TO_STRING(OMX_ErrorNone);
-		CASE_TO_STRING(OMX_ErrorInsufficientResources);
-		CASE_TO_STRING(OMX_ErrorUndefined);
-		CASE_TO_STRING(OMX_ErrorInvalidComponentName);
-		CASE_TO_STRING(OMX_ErrorComponentNotFound);
-		CASE_TO_STRING(OMX_ErrorInvalidComponent);
-		CASE_TO_STRING(OMX_ErrorBadParameter);
-		CASE_TO_STRING(OMX_ErrorNotImplemented);
-		CASE_TO_STRING(OMX_ErrorUnderflow);
-		CASE_TO_STRING(OMX_ErrorOverflow);
-		CASE_TO_STRING(OMX_ErrorHardware);
-		CASE_TO_STRING(OMX_ErrorInvalidState);
-		CASE_TO_STRING(OMX_ErrorStreamCorrupt);
-		CASE_TO_STRING(OMX_ErrorPortsNotCompatible);
-		CASE_TO_STRING(OMX_ErrorResourcesLost);
-		CASE_TO_STRING(OMX_ErrorNoMore);
-		CASE_TO_STRING(OMX_ErrorVersionMismatch);
-		CASE_TO_STRING(OMX_ErrorNotReady);
-		CASE_TO_STRING(OMX_ErrorTimeout);
-		CASE_TO_STRING(OMX_ErrorSameState);
-		CASE_TO_STRING(OMX_ErrorResourcesPreempted);
-		CASE_TO_STRING(OMX_ErrorPortUnresponsiveDuringAllocation);
-		CASE_TO_STRING(OMX_ErrorPortUnresponsiveDuringDeallocation);
-		CASE_TO_STRING(OMX_ErrorPortUnresponsiveDuringStop);
-		CASE_TO_STRING(OMX_ErrorIncorrectStateTransition);
-		default: return "Unknown OMX error";
-	}
-}
-
-const char *omx_state_to_string(OMX_STATETYPE state) {
-	switch (state) {
-		CASE_TO_STRING(OMX_StateLoaded);
-		CASE_TO_STRING(OMX_StateIdle);
-		CASE_TO_STRING(OMX_StateExecuting);
-		CASE_ASSERT("Unsupported OMX state", state);
-	}
-}
-
-#undef CASE_ASSERT
-#undef CASE_TO_STRING

src/http.c

@@ -1,786 +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 <stdatomic.h>
-#include <string.h>
-#include <strings.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <assert.h>
-
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <sys/stat.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 "encoder.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 char *_http_get_param_uri(struct evkeyvalq *params, const char *key);
-
-static void _http_callback_root(struct evhttp_request *request, void *arg);
-static void _http_callback_state(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, bool stream_updated, 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, "/state", _http_callback_state, (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);
-	if (server->run->unix_fd) {
-		close(server->run->unix_fd);
-	}
-	event_base_free(server->run->base);
-	libevent_global_shutdown();
-
-	for (struct stream_client_t *client = server->run->stream_clients; client != NULL;) {
-		struct stream_client_t *next = client->next;
-
-		free(client->key);
-		free(client);
-		client = next;
-	}
-
-	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;
-	if (server->run->stream->dev->desired_fps > 0) {
-		refresh_interval.tv_usec = 1000000 / (server->run->stream->dev->desired_fps * 2);
-	} else {
-		refresh_interval.tv_usec = 16000; // ~60fps
-	}
-	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);
-
-	if (server->slowdown) {
-		stream_switch_slowdown(server->run->stream, true);
-	}
-
-	evhttp_set_timeout(server->run->http, server->timeout);
-
-	if (server->unix_path) {
-		struct sockaddr_un unix_addr;
-		int unix_fd_flags;
-
-		LOG_DEBUG("Binding HTTP to UNIX socket '%s' ...", server->unix_path);
-
-		assert((server->run->unix_fd = socket(AF_UNIX, SOCK_STREAM, 0)));
-		assert((unix_fd_flags = fcntl(server->run->unix_fd, F_GETFL)) >= 0);
-		unix_fd_flags |= O_NONBLOCK;
-		assert(fcntl(server->run->unix_fd, F_SETFL, unix_fd_flags) >= 0);
-
-		strncpy(unix_addr.sun_path, server->unix_path, 107);
-		unix_addr.sun_path[107] = '\0';
-		unix_addr.sun_family = AF_UNIX;
-
-		if (server->unix_rm && unlink(server->unix_path) < 0) {
-			if (errno != ENOENT) {
-				LOG_PERROR("Can't remove old UNIX socket '%s'", server->unix_path);
-				return -1;
-			}
-		}
-		if (bind(server->run->unix_fd, (struct sockaddr *)&unix_addr, sizeof(struct sockaddr_un)) < 0) {
-			LOG_PERROR("Can't bind HTTP to UNIX socket '%s'", server->unix_path);
-			return -1;
-		}
-		if (server->unix_mode && chmod(server->unix_path, server->unix_mode) < 0) {
-			LOG_PERROR("Can't set permissions %o to UNIX socket '%s'", server->unix_mode, server->unix_path);
-			return -1;
-		}
-		if (listen(server->run->unix_fd, 128) < 0) {
-			LOG_PERROR("Can't listen UNIX socket '%s'", server->unix_path);
-			return -1;
-		}
-		if (evhttp_accept_socket(server->run->http, server->run->unix_fd) < 0) {
-			LOG_PERROR("Can't evhttp_accept_socket() UNIX socket '%s'", server->unix_path);
-			return -1;
-		}
-
-		LOG_INFO("Listening HTTP on UNIX socket '%s'", server->unix_path);
-
-	} else {
-		LOG_DEBUG("Binding HTTP to [%s]:%u ...", server->host, server->port);
-		if (evhttp_bind_socket(server->run->http, server->host, server->port) < 0) {
-			LOG_PERROR("Can't bind HTTP on [%s]:%u", server->host, server->port)
-			return -1;
-		}
-		LOG_INFO("Listening HTTP on [%s]:%u", 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;
-}
-
-static char *_http_get_param_uri(struct evkeyvalq *params, const char *key) {
-	const char *value_str;
-
-	if ((value_str = evhttp_find_header(params, key)) != NULL) {
-		return evhttp_encode_uri(value_str);
-	}
-	return NULL;
-}
-
-#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, "%s", HTML_INDEX_PAGE));
-	ADD_HEADER("Content-Type", "text/html");
-	evhttp_send_reply(request, HTTP_OK, "OK", buf);
-	evbuffer_free(buf);
-}
-
-static void _http_callback_state(struct evhttp_request *request, void *v_server) {
-	struct http_server_t *server = (struct http_server_t *)v_server;
-	struct evbuffer *buf;
-	enum encoder_type_t encoder_run_type;
-	unsigned encoder_run_quality;
-
-	PROCESS_HEAD_REQUEST;
-
-#	define ENCODER(_next) server->run->stream->encoder->_next
-
-	A_MUTEX_LOCK(&ENCODER(run->mutex));
-	encoder_run_type = ENCODER(run->type);
-	encoder_run_quality = ENCODER(run->quality);
-	A_MUTEX_UNLOCK(&ENCODER(run->mutex));
-
-	assert((buf = evbuffer_new()));
-
-	assert(evbuffer_add_printf(buf,
-		"{\"ok\": true, \"result\": {"
-		" \"encoder\": {\"type\": \"%s\", \"quality\": %u},"
-		" \"source\": {\"resolution\": {\"width\": %u, \"height\": %u},"
-		" \"online\": %s, \"desired_fps\": %u, \"captured_fps\": %u},"
-		" \"stream\": {\"queued_fps\": %u, \"clients\": %u, \"clients_stat\": {",
-		encoder_type_to_string(encoder_run_type),
-		encoder_run_quality,
-		(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->dev->desired_fps,
-		server->run->exposed->captured_fps,
-		server->run->exposed->queued_fps,
-		server->run->stream_clients_count
-	));
-
-#	undef ENCODER
-
-	for (struct stream_client_t * client = server->run->stream_clients; client != NULL; client = client->next) {
-		assert(evbuffer_add_printf(buf,
-			"\"%s\": {\"fps\": %u, \"extra_headers\": %s, \"advance_headers\": %s, \"dual_final_frames\": %s}%s",
-			client->id,
-			client->fps,
-			bool_to_string(client->extra_headers),
-			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.used)));
-
-	ADD_HEADER("Access-Control-Allow-Origin:", "*");
-	ADD_HEADER("Cache-Control", "no-store, no-cache, must-revalidate, proxy-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-Dropped",			EXPOSED(dropped));
-	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_UNSUGNED_HEADER
-#	undef ADD_TIME_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->key = _http_get_param_uri(&params, "key");
-		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;
-
-		if (server->slowdown && server->run->stream_clients_count == 1) {
-			stream_switch_slowdown(server->run->stream, false);
-		}
-
-		evhttp_connection_get_peer(conn, &client_addr, &client_port);
-		LOG_INFO("HTTP: Registered the new stream client: [%s]:%u; id=%s; clients now: %u",
-			client_addr, client_port, client->id, 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, proxy-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=%s/%s; path=/; max-age=30" RN
-			"Content-Type: multipart/x-mixed-replace;boundary=" BOUNDARY RN
-			RN
-			"--" BOUNDARY RN,
-			(client->key != NULL ? client->key : "0"),
-			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: %zu" RN
-			"X-Timestamp: %.06Lf" RN
-			"%s",
-			EXPOSED(picture.used) * 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-Dropped: %u" 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(dropped),
-				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.used) * 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 EXPOSED
-#	undef ADD_ADVANCE_HEADERS
-#	undef RN
-#	undef BOUNDARY
-}
-
-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;
-
-#	define RUN(_next) client->server->run->_next
-
-	RUN(stream_clients_count) -= 1;
-	if (client->server->slowdown && RUN(stream_clients_count) <= 0) {
-		stream_switch_slowdown(RUN(stream), true);
-	}
-
-	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, RUN(stream_clients_count));
-	if (conn != NULL) {
-		evhttp_connection_free(conn);
-	}
-
-	if (client->prev == NULL) {
-		RUN(stream_clients) = client->next;
-	} else {
-		client->prev->next = client->next;
-	}
-	if (client->next != NULL) {
-		client->next->prev = client->prev;
-	}
-	free(client->key);
-	free(client);
-
-#	undef RUN
-}
-
-static void _http_queue_send_stream(struct http_server_t *server, bool stream_updated, 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 { \
-			atomic_store(&server->run->stream->updated, false); \
-			A_MUTEX_UNLOCK(&server->run->stream->mutex); \
-		}
-
-	if (atomic_load(&server->run->stream->updated)) {
-		LOG_DEBUG("Refreshing HTTP exposed ...");
-		A_MUTEX_LOCK(&server->run->stream->mutex);
-		if (server->run->stream->picture.used > 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.used) > 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.used) * sizeof(*STREAM(picture.data))
-
-	if (server->drop_same_frames) {
-		if (
-			EXPOSED(online)
-			&& EXPOSED(dropped) < server->drop_same_frames
-			&& EXPOSED(picture.used) == STREAM(picture.used)
-			&& !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.used) = STREAM(picture.used);
-
-	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 EXPOSED
-#	undef STREAM
-	return true; // Updated
-}
-
-static bool _expose_blank_picture(struct http_server_t *server) {
-#	define EXPOSED(_next)	server->run->exposed->_next
-#	define BLANK_JPEG_LEN	ARRAY_LEN(BLANK_JPEG_DATA)
-
-	EXPOSED(expose_begin_time) = get_now_monotonic();
-	EXPOSED(expose_cmp_time) = EXPOSED(expose_begin_time);
-
-	if (EXPOSED(online) || EXPOSED(picture.used) == 0) {
-		if (EXPOSED(picture.allocated) < BLANK_JPEG_LEN) {
-			A_REALLOC(EXPOSED(picture.data), BLANK_JPEG_LEN);
-			EXPOSED(picture.allocated) = BLANK_JPEG_LEN;
-		}
-
-		memcpy(EXPOSED(picture.data), BLANK_JPEG_DATA, BLANK_JPEG_LEN * sizeof(*EXPOSED(picture.data)));
-
-		EXPOSED(picture.used) = BLANK_JPEG_LEN;
-
-		EXPOSED(picture.grab_time) = 0;
-		EXPOSED(picture.encode_begin_time) = 0;
-		EXPOSED(picture.encode_end_time) = 0;
-
-		EXPOSED(width) = BLANK_JPEG_WIDTH;
-		EXPOSED(height) = BLANK_JPEG_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 BLANK_JPEG_LEN
-#	undef EXPOSED
-}

src/http.h

@@ -1,102 +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 <sys/stat.h>
-
-#include <event2/event.h>
-#include <event2/http.h>
-#include <event2/util.h>
-
-#include "tools.h"
-#include "stream.h"
-
-
-struct stream_client_t {
-	struct http_server_t	*server;
-	struct evhttp_request	*request;
-
-	char					*key;
-	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;
-	evutil_socket_t			unix_fd;
-	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;
-	char		*unix_path;
-	bool		unix_rm;
-	mode_t		unix_mode;
-	unsigned	drop_same_frames;
-	bool		slowdown;
-	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);

src/libs/array.h

@@ -0,0 +1,37 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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 <assert.h>
+
+
+#define US_ARRAY_LEN(x_array) (sizeof(x_array) / sizeof((x_array)[0]))
+
+#define US_ARRAY_ITERATE(x_array, x_start, x_item_ptr, ...) { \
+		const int m_len = US_ARRAY_LEN(x_array); \
+		assert(x_start <= m_len); \
+		for (int m_index = x_start; m_index < m_len; ++m_index) { \
+			__typeof__((x_array)[0]) *const x_item_ptr = &x_array[m_index]; \
+			__VA_ARGS__ \
+		} \
+	}

src/libs/base64.c

@@ -0,0 +1,79 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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 "base64.h"
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "types.h"
+#include "tools.h"
+
+
+static const char _ENCODING_TABLE[] = {
+	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+	'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+	'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+	'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+	'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+	'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+	'w', 'x', 'y', 'z', '0', '1', '2', '3',
+	'4', '5', '6', '7', '8', '9', '+', '/',
+};
+
+static const uint _MOD_TABLE[] = {0, 2, 1};
+
+
+void us_base64_encode(const u8 *data, uz size, char **encoded, uz *allocated) {
+	const uz encoded_size = 4 * ((size + 2) / 3) + 1; // +1 for '\0'
+
+	if (*encoded == NULL || (allocated && *allocated < encoded_size)) {
+		US_REALLOC(*encoded, encoded_size);
+		if (allocated) {
+			*allocated = encoded_size;
+		}
+	}
+
+	for (uint data_index = 0, encoded_index = 0; data_index < size;) {
+#		define OCTET(_name) uint _name = (data_index < size ? (u8)data[data_index++] : 0)
+		OCTET(octet_a);
+		OCTET(octet_b);
+		OCTET(octet_c);
+#		undef OCTET
+
+		const uint triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;
+
+#		define ENCODE(_offset) (*encoded)[encoded_index++] = _ENCODING_TABLE[(triple >> _offset * 6) & 0x3F]
+		ENCODE(3);
+		ENCODE(2);
+		ENCODE(1);
+		ENCODE(0);
+#		undef ENCODE
+	}
+
+	for (uint index = 0; index < _MOD_TABLE[size % 3]; index++) {
+		(*encoded)[encoded_size - 2 - index] = '=';
+	}
+
+	(*encoded)[encoded_size - 1] = '\0';
+}

src/libs/base64.h

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
+#    Copyright (C) 2018-2023  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    #
@@ -22,7 +22,7 @@
 
 #pragma once
 
-#include "../../device.h"
+#include "types.h"
 
 
-void cpu_encoder_compress_buffer(struct device_t *dev, unsigned index, unsigned quality);
+void us_base64_encode(const u8 *data, uz size, char **encoded, uz *allocated);

src/libs/const.h

@@ -0,0 +1,35 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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 "types.h"
+
+
+#define US_VERSION_MAJOR 5
+#define US_VERSION_MINOR 55
+
+#define US_MAKE_VERSION2(_major, _minor) #_major "." #_minor
+#define US_MAKE_VERSION1(_major, _minor) US_MAKE_VERSION2(_major, _minor)
+#define US_VERSION US_MAKE_VERSION1(US_VERSION_MAJOR, US_VERSION_MINOR)
+
+#define US_VERSION_U ((uint)(US_VERSION_MAJOR * 1000 + US_VERSION_MINOR))

src/libs/device.h

@@ -0,0 +1,137 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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 <linux/videodev2.h>
+
+#include "types.h"
+#include "frame.h"
+
+
+#define US_VIDEO_MIN_WIDTH		((uint)160)
+#define US_VIDEO_MAX_WIDTH		((uint)15360)
+
+#define US_VIDEO_MIN_HEIGHT		((uint)120)
+#define US_VIDEO_MAX_HEIGHT		((uint)8640)
+
+#define US_VIDEO_MAX_FPS		((uint)120)
+
+#define US_STANDARD_UNKNOWN		V4L2_STD_UNKNOWN
+#define US_STANDARDS_STR		"PAL, NTSC, SECAM"
+
+#define US_FORMAT_UNKNOWN		-1
+#define US_FORMATS_STR			"YUYV, YVYU, UYVY, RGB565, RGB24, BGR24, MJPEG, JPEG"
+
+#define US_IO_METHOD_UNKNOWN	-1
+#define US_IO_METHODS_STR		"MMAP, USERPTR"
+
+
+typedef struct {
+	us_frame_s			raw;
+	struct v4l2_buffer	buf;
+	int					dma_fd;
+	bool				grabbed;
+} us_hw_buffer_s;
+
+typedef struct {
+	int					fd;
+	uint				width;
+	uint				height;
+	uint				format;
+	uint				stride;
+	float				hz;
+	uint				hw_fps;
+	uint				jpeg_quality;
+	uz					raw_size;
+	uint				n_bufs;
+	us_hw_buffer_s		*hw_bufs;
+	enum v4l2_buf_type	capture_type;
+	bool				capture_mplane;
+	bool				capturing;
+	bool				persistent_timeout_reported;
+} us_device_runtime_s;
+
+typedef enum {
+	CTL_MODE_NONE = 0,
+	CTL_MODE_VALUE,
+	CTL_MODE_AUTO,
+	CTL_MODE_DEFAULT,
+} us_control_mode_e;
+
+typedef struct {
+	us_control_mode_e	mode;
+	int					value;
+} us_control_s;
+
+typedef struct {
+	us_control_s	brightness;
+	us_control_s	contrast;
+	us_control_s	saturation;
+	us_control_s	hue;
+	us_control_s	gamma;
+	us_control_s	sharpness;
+	us_control_s	backlight_compensation;
+	us_control_s	white_balance;
+	us_control_s	gain;
+	us_control_s	color_effect;
+	us_control_s	rotate;
+	us_control_s	flip_vertical;
+	us_control_s	flip_horizontal;
+} us_controls_s;
+
+typedef struct {
+	char				*path;
+	uint				input;
+	uint				width;
+	uint				height;
+	uint				format;
+	uint				jpeg_quality;
+	v4l2_std_id			standard;
+	enum v4l2_memory	io_method;
+	bool				dv_timings;
+	uint				n_bufs;
+	uint				desired_fps;
+	uz					min_frame_size;
+	bool				persistent;
+	uint				timeout;
+	us_controls_s 		ctl;
+	us_device_runtime_s *run;
+} us_device_s;
+
+
+us_device_s *us_device_init(void);
+void us_device_destroy(us_device_s *dev);
+
+int us_device_parse_format(const char *str);
+v4l2_std_id us_device_parse_standard(const char *str);
+int us_device_parse_io_method(const char *str);
+
+int us_device_open(us_device_s *dev);
+void us_device_close(us_device_s *dev);
+
+int us_device_export_to_dma(us_device_s *dev);
+int us_device_switch_capturing(us_device_s *dev, bool enable);
+int us_device_select(us_device_s *dev, bool *has_read, bool *has_write, bool *has_error);
+int us_device_grab_buffer(us_device_s *dev, us_hw_buffer_s **hw);
+int us_device_release_buffer(us_device_s *dev, us_hw_buffer_s *hw);
+int us_device_consume_event(us_device_s *dev);

src/libs/frame.c

@@ -0,0 +1,117 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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 "frame.h"
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include <linux/videodev2.h>
+
+#include "types.h"
+#include "tools.h"
+
+
+us_frame_s *us_frame_init(void) {
+	us_frame_s *frame;
+	US_CALLOC(frame, 1);
+	us_frame_realloc_data(frame, 512 * 1024);
+	frame->dma_fd = -1;
+	return frame;
+}
+
+void us_frame_destroy(us_frame_s *frame) {
+	US_DELETE(frame->data, free);
+	free(frame);
+}
+
+void us_frame_realloc_data(us_frame_s *frame, uz size) {
+	if (frame->allocated < size) {
+		US_REALLOC(frame->data, size);
+		frame->allocated = size;
+	}
+}
+
+void us_frame_set_data(us_frame_s *frame, const u8 *data, uz size) {
+	us_frame_realloc_data(frame, size);
+	memcpy(frame->data, data, size);
+	frame->used = size;
+}
+
+void us_frame_append_data(us_frame_s *frame, const u8 *data, uz size) {
+	const uz new_used = frame->used + size;
+	us_frame_realloc_data(frame, new_used);
+	memcpy(frame->data + frame->used, data, size);
+	frame->used = new_used;
+}
+
+void us_frame_copy(const us_frame_s *src, us_frame_s *dest) {
+	us_frame_set_data(dest, src->data, src->used);
+	US_FRAME_COPY_META(src, dest);
+}
+
+bool us_frame_compare(const us_frame_s *a, const us_frame_s *b) {
+	return (
+		a->allocated && b->allocated
+		&& US_FRAME_COMPARE_META_USED_NOTS(a, b)
+		&& !memcmp(a->data, b->data, b->used)
+	);
+}
+
+uint us_frame_get_padding(const us_frame_s *frame) {
+	uint bytes_per_pixel = 0;
+	switch (frame->format) {
+		case V4L2_PIX_FMT_YUYV:
+		case V4L2_PIX_FMT_YVYU:
+		case V4L2_PIX_FMT_UYVY:
+		case V4L2_PIX_FMT_RGB565: bytes_per_pixel = 2; break;
+		case V4L2_PIX_FMT_BGR24:
+		case V4L2_PIX_FMT_RGB24: bytes_per_pixel = 3; break;
+		// case V4L2_PIX_FMT_H264:
+		case V4L2_PIX_FMT_MJPEG:
+		case V4L2_PIX_FMT_JPEG: bytes_per_pixel = 0; break;
+		default: assert(0 && "Unknown format");
+	}
+	if (bytes_per_pixel > 0 && frame->stride > frame->width) {
+		return (frame->stride - frame->width * bytes_per_pixel);
+	}
+	return 0;
+}
+
+const char *us_fourcc_to_string(uint format, char *buf, uz size) {
+	assert(size >= 8);
+	buf[0] = format & 0x7F;
+	buf[1] = (format >> 8) & 0x7F;
+	buf[2] = (format >> 16) & 0x7F;
+	buf[3] = (format >> 24) & 0x7F;
+	if (format & ((uint)1 << 31)) {
+		buf[4] = '-';
+		buf[5] = 'B';
+		buf[6] = 'E';
+		buf[7] = '\0';
+	} else {
+		buf[4] = '\0';
+	}
+	return buf;
+}

src/libs/frame.h

@@ -0,0 +1,115 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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 <linux/videodev2.h>
+
+#include "types.h"
+#include "tools.h"
+
+
+typedef struct {
+	u8		*data;
+	uz		used;
+	uz		allocated;
+	int		dma_fd;
+
+	uint	width;
+	uint	height;
+	uint	format;
+	uint	stride;
+	// Stride is a bytesperline in V4L2
+	// https://www.kernel.org/doc/html/v4.14/media/uapi/v4l/pixfmt-v4l2.html
+	// https://medium.com/@oleg.shipitko/what-does-stride-mean-in-image-processing-bba158a72bcd
+
+	bool	online;
+	bool	key;
+	uint	gop;
+
+	ldf		grab_ts;
+	ldf		encode_begin_ts;
+	ldf		encode_end_ts;
+} us_frame_s;
+
+
+#define US_FRAME_COPY_META(x_src, x_dest) { \
+		x_dest->width = x_src->width; \
+		x_dest->height = x_src->height; \
+		x_dest->format = x_src->format; \
+		x_dest->stride = x_src->stride; \
+		x_dest->online = x_src->online; \
+		x_dest->key = x_src->key; \
+		x_dest->gop = x_src->gop; \
+		x_dest->grab_ts = x_src->grab_ts; \
+		x_dest->encode_begin_ts = x_src->encode_begin_ts; \
+		x_dest->encode_end_ts = x_src->encode_end_ts; \
+	}
+
+static inline void us_frame_copy_meta(const us_frame_s *src, us_frame_s *dest) {
+	US_FRAME_COPY_META(src, dest);
+}
+
+#define US_FRAME_COMPARE_META_USED_NOTS(x_a, x_b) ( \
+		x_a->used == x_b->used \
+		&& x_a->width == x_b->width \
+		&& x_a->height == x_b->height \
+		&& x_a->format == x_b->format \
+		&& x_a->stride == x_b->stride \
+		&& x_a->online == x_b->online \
+		&& x_a->key == x_b->key \
+		&& x_a->gop == x_b->gop \
+	)
+
+
+static inline void us_frame_encoding_begin(const us_frame_s *src, us_frame_s *dest, uint format) {
+	assert(src->used > 0);
+	us_frame_copy_meta(src, dest);
+	dest->encode_begin_ts = us_get_now_monotonic();
+	dest->format = format;
+	dest->stride = 0;
+	dest->used = 0;
+}
+
+static inline void us_frame_encoding_end(us_frame_s *dest) {
+	assert(dest->used > 0);
+	dest->encode_end_ts = us_get_now_monotonic();
+}
+
+
+us_frame_s *us_frame_init(void);
+void us_frame_destroy(us_frame_s *frame);
+
+void us_frame_realloc_data(us_frame_s *frame, uz size);
+void us_frame_set_data(us_frame_s *frame, const u8 *data, uz size);
+void us_frame_append_data(us_frame_s *frame, const u8 *data, uz size);
+
+void us_frame_copy(const us_frame_s *src, us_frame_s *dest);
+bool us_frame_compare(const us_frame_s *a, const us_frame_s *b);
+
+uint us_frame_get_padding(const us_frame_s *frame);
+
+const char *us_fourcc_to_string(uint format, char *buf, uz size);
+
+static inline bool us_is_jpeg(uint format) {
+	return (format == V4L2_PIX_FMT_JPEG || format == V4L2_PIX_FMT_MJPEG);
+}

src/libs/list.h

@@ -0,0 +1,71 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2023  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 <assert.h>
+
+
+#define US_LIST_STRUCT(...) \
+	__VA_ARGS__ *prev; \
+	__VA_ARGS__ *next;
+
+#define US_LIST_ITERATE(x_first, x_item, ...) { \
+		for (__typeof__(x_first) x_item = x_first; x_item;) { \
+			__typeof__(x_first) m_next = x_item->next; \
+			__VA_ARGS__ \
+			x_item = m_next; \
+		} \
+	}
+
+#define US_LIST_APPEND(x_first, x_item) { \
+		if (x_first == NULL) { \
+			x_first = x_item; \
+		} else { \
+			__typeof__(x_first) m_last = x_first; \
+			for (; m_last->next; m_last = m_last->next); \
+			x_item->prev = m_last; \
+			m_last->next = x_item; \
+		} \
+	}
+
+#define US_LIST_APPEND_C(x_first, x_item, x_count) { \
+		US_LIST_APPEND(x_first, x_item); \
+		++(x_count); \
+	}
+
+#define US_LIST_REMOVE(x_first, x_item) { \
+		if (x_item->prev == NULL) { \
+			x_first = x_item->next; \
+		} else { \
+			x_item->prev->next = x_item->next; \
+		} \
+		if (x_item->next != NULL) { \
+			x_item->next->prev = x_item->prev; \
+		} \
+	}
+
+#define US_LIST_REMOVE_C(x_first, x_item, x_count) { \
+		US_LIST_REMOVE(x_first, x_item); \
+		assert((x_count) >= 1); \
+		--(x_count); \
+	}