Bump version: 2.1 → 2.2

Fix two typos in log messages

.bumpversion.cfg

@@ -1,7 +1,7 @@
 [bumpversion]
 commit = True
 tag = True
-current_version = 0.56
+current_version = 2.2
 parse = (?P<major>\d+)\.(?P<minor>\d+)(\.(?P<patch>\d+)(\-(?P<release>[a-z]+))?)?
 serialize = 
 	{major}.{minor}
@@ -10,7 +10,10 @@ serialize =
 search = VERSION "{current_version}"
 replace = VERSION "{new_version}"
 
-[bumpversion:file:PKGBUILD]
+[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}

.dockerignore

@@ -0,0 +1,6 @@
+# Ignore everything
+*
+
+# Allow source code
+!Makefile
+!src/**

.github/FUNDING.yml

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

.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,12 @@
-/pkg/
-/src/ustreamer-*/
-/src/v*.tar.gz
-/v*.tar.gz
-/ustreamer-*.pkg.tar.xz
+/linters/.tox/
+/linters/.mypy_cache/
+/pkg/arch/pkg/
+/pkg/arch/src/
+/pkg/arch/v*.tar.gz
+/pkg/arch/ustreamer-*.pkg.tar.xz
+/pkg/arch/ustreamer-*.pkg.tar.zst
+/build/
+/config.mk
 /vgcore.*
 /ustreamer
 /*.sock
-*.o

Makefile

@@ -1,63 +1,140 @@
+-include config.mk
+
+PROG ?= ustreamer
 DESTDIR ?=
 PREFIX ?= /usr/local
+
+CC ?= gcc
 CFLAGS ?= -O3
 LDFLAGS ?=
-CC ?= gcc
+
+RPI_VC_HEADERS ?= /opt/vc/include
+RPI_VC_LIBS ?= /opt/vc/lib
+
+BUILD ?= build
+
+LINTERS_IMAGE ?= $(PROG)-linters
 
 
 # =====
-LIBS = -lm -ljpeg -pthread -levent -levent_pthreads -luuid
-override CFLAGS += -c -std=c99 -Wall -Wextra -D_GNU_SOURCE
-SOURCES = $(shell ls src/*.c src/encoders/cpu/*.c src/encoders/hw/*.c)
-PROG = ustreamer
+_LIBS = -lm -ljpeg -pthread -levent -levent_pthreads -luuid
+override CFLAGS += -c -std=c11 -Wall -Wextra -D_GNU_SOURCE
+_SRCS = $(shell ls src/*.c src/http/*.c src/encoders/cpu/*.c src/encoders/hw/*.c)
 
-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
+
+define optbool
+$(filter $(shell echo $(1) | tr A-Z a-z), yes on 1)
+endef
+
+
+ifneq ($(call optbool,$(WITH_OMX)),)
+_LIBS += -lbcm_host -lvcos -lopenmaxil -L$(RPI_VC_LIBS)
+override CFLAGS += -DWITH_OMX -DOMX_SKIP64BIT -I$(RPI_VC_HEADERS)
+_SRCS += $(shell ls src/encoders/omx/*.c)
 endif
 
-OBJECTS = $(SOURCES:.c=.o)
+
+ifneq ($(call optbool,$(WITH_GPIO)),)
+_LIBS += -lgpiod
+override CFLAGS += -DWITH_GPIO
+_SRCS += $(shell ls src/gpio/*.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)
+_LIBS += -lbsd
+endif
+override CFLAGS += -DWITH_SETPROCTITLE
+endif
 
 
 # =====
-all: $(SOURCES) $(PROG)
+all: $(PROG)
 
 
 install: $(PROG)
 	install -Dm755 $(PROG) $(DESTDIR)$(PREFIX)/bin/$(PROG)
 
 
+install-strip: install
+	strip $(DESTDIR)$(PREFIX)/bin/$(PROG)
+
+
+uninstall:
+	rm $(DESTDIR)$(PREFIX)/bin/$(PROG)
+
+
 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
+	tools/make-jpeg-h.py src/http/data/blank.jpeg src/http/data/blank_jpeg.h BLANK
+	tools/make-html-h.py src/http/data/index.html src/http/data/index_html.h INDEX
 
 
-$(PROG): $(OBJECTS)
-	$(CC) $(LIBS) $(LDFLAGS) $(OBJECTS) -o $@
+$(PROG): $(_SRCS:%.c=$(BUILD)/%.o)
+	$(info -- LD $@)
+	@ $(CC) $^ -o $@ $(LDFLAGS) $(_LIBS)
+	$(info ===== Build complete =====)
+	$(info == CC      = $(CC))
+	$(info == LIBS    = $(_LIBS))
+	$(info == CFLAGS  = $(CFLAGS))
+	$(info == LDFLAGS = $(LDFLAGS))
 
 
-.c.o:
-	$(CC) $(LIBS) $(CFLAGS) $< -o $@
+$(BUILD)/%.o: %.c
+	$(info -- CC $<)
+	@ mkdir -p $(dir $@) || true
+	@ $(CC) $< -o $@ $(CFLAGS)
 
 
 release:
 	make clean
+	make tox
 	make push
-	make bump
+	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 -rf $(PROG) $(BUILD) vgcore.* *.sock
+
+.PHONY: linters

PKGBUILD

@@ -1,30 +0,0 @@
-# Contributor: Maxim Devaev <mdevaev@gmail.com>
-# Author: Maxim Devaev <mdevaev@gmail.com>
-
-
-pkgname=ustreamer
-pkgver=0.56
-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,8 +1,11 @@
 # µStreamer
+[![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)
+
 [[Русская версия]](README.ru.md)
 
-µ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 [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/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:
 
@@ -10,20 +13,20 @@
 |----------|---------------|-------------------|
 | 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 |
+| 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 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 | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes | ![#ffaa00](https://placehold.it/15/ffaa00/000000?text=+) Partially yes <sup>1</sup> |
+| Option to skip frames when streaming<br>static images by HTTP to save the 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 |
+| Debug logs without recompiling,<br>performance statistics log,<br>access to HTTP streaming parameters | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) No |
+| Option to serve files<br>with a built-in HTTP server | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes | ![#ffaa00](https://placehold.it/15/ffaa00/000000?text=+) Regular files only |
+| Signaling about the stream state<br>on GPIO using [libgpiod](https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git/about) | ![#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 |
+| Compatibility with mjpg-streamer's API | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes | :) |
 
 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
@@ -31,37 +34,54 @@ If you're going to live-stream from your backyard webcam and need to control it,
 
 -----
 # Building
-You'll need  ```make```, ```gcc```, ```libevent``` with ```pthreads``` support, ```libjpeg8```/```libjpeg-turbo``` and ```libuuid```.
+You'll need  ```make```, ```gcc```, ```libevent``` with ```pthreads``` support, ```libjpeg8```/```libjpeg-turbo```, ```libuuid``` and ```libbsd``` (only for Linux).
 
-It should compile automatically with OpenMAX IL on Raspberry Pi, if the corresponding headers are present in ```/opt/vc/include```.
+* Arch: `sudo pacman -S libevent libjpeg-turbo libutil-linux libbsd`.
+* Raspbian: `sudo apt install libevent-dev libjpeg8-dev uuid-dev libbsd-dev`. Add `libraspberrypi-dev` for `WITH_OMX=1` and `libgpiod` for `WITH_GPIO=1`.
+* Debian: `sudo apt install build-essential libevent-dev libjpeg62-turbo-dev uuid-dev libbsd-dev`.
+* Ubuntu 20.04 x86_64: `sudo apt install build-essential libevent-dev libjpeg62-dev uuid-dev libbsd-dev make gcc libjpeg8 libjpeg-turbo8 libuuid1 libbsd0`.
+
+On Raspberry Pi you can build the program with OpenMAX IL. To do this pass option ```WITH_OMX=1``` to ```make```. 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```.
 
 ```
-$ 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
+AUR has a package for Arch Linux: https://aur.archlinux.org/packages/ustreamer. It should compile automatically with OpenMAX IL on Raspberry Pi, if the corresponding headers are present in ```/opt/vc/include```.  
+FreeBSD port: https://www.freshports.org/multimedia/ustreamer.
 
 -----
 # 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:
+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
+    --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```.
 
+-----
+# See also
+* [Running uStreamer via systemd service](https://github.com/pikvm/ustreamer/issues/16).
+* [uStreamer Ansible Role](https://github.com/mtlynch/ansible-role-ustreamer): Use [Ansible](https://docs.ansible.com/ansible/latest/index.html) to compile uStreamer and install it as a systemd service automatically.
+
 -----
 # License
 Copyright (C) 2018 by Maxim Devaev mdevaev@gmail.com

README.ru.md

@@ -1,8 +1,11 @@
-# µStreamer 
+# µStreamer
+[![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)
+
 [[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](https://en.wikipedia.org/wiki/Motion_JPEG) с любого устройства V4L2 в сеть. Этот формат нативно поддерживается всеми современными браузерами и большинством приложений для просмотра видео (mplayer, VLC и так далее). µStreamer был разработан в рамках проекта [Pi-KVM](https://github.com/pikvm/pikvm) специально для стриминга с устройств видеозахвата [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```, однако имеет ряд серьезных отличий. Основные приведены в этой таблице:
 
@@ -10,39 +13,45 @@
 |----------|---------------|-------------------|
 | Многопоточное кодирование 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>устройства от сервера во время работы | ![#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-new/userspace-api/v4l/dv-timings.html) - возможности<br>изменения  параметров разрешения<br>трансляции на лету по сигналу<br>источника (устройства видеозахвата) | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть | ![#ffaa00](https://placehold.it/15/ffaa00/000000?text=+) Условно есть <sup>1</sup> |
 | Возможность пропуска фреймов при передаче<br>статического изображения по HTTP<br>для экономии трафика | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть <sup>2</sup> | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Нет |
 | Стрим через 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>HTTP-сервером  | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть | ![#ffaa00](https://placehold.it/15/ffaa00/000000?text=+) Нет каталогов |
+| Вывод сигналов о состоянии стрима на GPIO<br>с помощью [libgpiod](https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git/about) | ![#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=+) Есть |
+| Совместимость с API mjpg-streamer'а | ![#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```.
+Для сборки вам понадобятся ```make```, ```gcc```, ```libevent``` с поддержкой ```pthreads```, ```libjpeg8```/```libjpeg-turbo```, ```libuuid``` и ```libbsd``` (только для Linux).
 
-На Raspberry Pi програма автоматически собирается с поддержкой OpenMAX IL, если обнаружит нужные хедеры в ```/opt/vc/include```.
+* Arch: `sudo pacman -S libevent libjpeg-turbo libutil-linux libbsd`.
+* Raspbian: `sudo apt install libevent-dev libjpeg8-dev uuid-dev libbsd-dev`.  Добавьте `libraspberrypi-dev` для сборки с `WITH_OMX=1` и `libgpiod` для `WITH_GPIO=1`.
+* Debian: `sudo apt install build-essential libevent-dev libjpeg62-turbo-dev uuid-dev libbsd-dev`.
+* Ubuntu 20.04 x86_64: `sudo apt install build-essential libevent-dev libjpeg62-dev uuid-dev libbsd-dev make gcc libjpeg8 libjpeg-turbo8 libuuid1 libbsd0`.
+
+На Raspberry Pi программу можно собрать с поддержкой OpenMAX IL. Для этого передайте ```make``` параметр ```WITH_OMX=1```. Для включения сборки с поддержкой GPIO установите [libgpiod](https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git/about) и добавьте параметр ```WITH_GPIO=1```. Если при сборке компилятор ругается на отсутствие функции ```pthread_get_name_np()``` или другой подобной, добавьте параметр ```WITH_PTHREAD_NP=0``` (по умолчанию он включен). При аналогичной ошибке с функцией ```setproctitle()``` добавьте параметр ```WITH_SETPROCTITLE=0```.
 
 ```
-$ git clone --depth=1 https://github.com/pi-kvm/ustreamer
+$ git clone --depth=1 https://github.com/pikvm/ustreamer
 $ cd ustreamer
 $ make
 $ ./ustreamer --help
 ```
 
-Для Arch Linux в AUR есть готовый пакет: https://aur.archlinux.org/packages/ustreamer
+Для Arch Linux в AUR есть готовый пакет: https://aur.archlinux.org/packages/ustreamer. На Raspberry Pi програма автоматически собирается с поддержкой OpenMAX IL, если обнаружит нужные хедеры в ```/opt/vc/include```.  
+Порт для FreeBSD: https://www.freshports.org/multimedia/ustreamer.
 
 -----
 # Использование
@@ -51,17 +60,28 @@ $ ./ustreamer --help
 # ./ustreamer --device=/dev/video1 --host=0.0.0.0 --port=80
 ```
 
+:exclamation: Обратите внимание, что начиная с версии µStreamer v2.0 кросс-доменные запросы были выключены по умолчанию [по соображениям безопасности](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS). Чтобы включить старое поведение, используйте опцию `--allow-origin=\*`.
+
 Рекомендуемый способ запуска µ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 # Экономим трафик
 ```
 
+:exclamation: Обратите внимание, что для использования `--drop-same-frames` для разных браузеров нужно использовать ряд специальных параметров в `/stream` (за деталями обратитесь к урлу `/`).
+
 За полным списком опций обращайтесь ко встроенной справке: ```ustreamer --help```.
 
+-----
+# Смотрите также
+* [Запуск с помощью systemd-сервиса](https://github.com/pikvm/ustreamer/issues/16).
+* [uStreamer Ansible Role](https://github.com/mtlynch/ansible-role-ustreamer): Использование [Ansible](https://docs.ansible.com/ansible/latest/index.html) для сборки и установки стримера как systemd-сервиса.
+
 -----
 # Лицензия
 Copyright (C) 2018 by Maxim Devaev mdevaev@gmail.com

linters/.dockerignore

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

linters/Dockerfile

@@ -0,0 +1,24 @@
+FROM archlinux/base
+
+RUN echo "Server = http://mirror.yandex.ru/archlinux/\$repo/os/\$arch" > /etc/pacman.d/mirrorlist
+
+RUN pacman -Syu --noconfirm \
+	&& pacman -S --needed --noconfirm \
+		base \
+		base-devel \
+		vim \
+		git \
+		libjpeg \
+		libevent \
+		libutil-linux \
+		libbsd \
+		python \
+		python-pip \
+		python-tox \
+		cppcheck \
+		npm \
+	&& (pacman -Sc --noconfirm || true)
+
+RUN npm install htmlhint -g
+
+CMD /bin/bash

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.8
+ignore_missing_imports = true
+disallow_untyped_defs = true
+strict_optional = true

linters/pylint.ini

@@ -0,0 +1,63 @@
+[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,
+	no-init,
+	no-self-use,
+	superfluous-parens,
+	abstract-class-not-used,
+	abstract-class-little-used,
+	duplicate-code,
+	bad-continuation,
+	bad-whitespace,
+	star-args,
+	broad-except,
+	redundant-keyword-arg,
+	wrong-import-order,
+	too-many-ancestors,
+	no-else-return,
+	len-as-condition,
+
+[REPORTS]
+msg-template = {symbol} -- {path}:{line}({obj}): {msg}
+
+[FORMAT]
+max-line-length = 160
+
+[BASIC]
+# List of builtins function names that should not be used, separated by a comma
+bad-functions =
+
+# Good variable names which should always be accepted, separated by a comma
+good-names = _, __, x, y, ws, make-html-h, make-jpeg-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,50 @@
+[tox]
+envlist = cppcheck, flake8, pylint, mypy, vulture, htmlhint
+skipsdist = true
+
+[testenv]
+basepython = python3.8
+changedir = /src
+
+[testenv:cppcheck]
+whitelist_externals = cppcheck
+commands = cppcheck \
+			--force \
+			--std=c11 \
+			--error-exitcode=1 \
+			--quiet \
+			--enable=warning,unusedFunction,portability,performance,style \
+			--suppress=assignmentInAssert \
+			--suppress=variableScope \
+			--inline-suppr \
+			-DCHAR_BIT=8 \
+		src
+
+[testenv:flake8]
+whitelist_externals = bash
+commands = bash -c 'flake8 --config=linters/flake8.ini tools/*.py'
+deps =
+	flake8
+	flake8-quotes
+
+[testenv:pylint]
+whitelist_externals = bash
+commands = bash -c 'pylint --rcfile=linters/pylint.ini --output-format=colorized --reports=no tools/*.py'
+deps =
+	pylint
+
+[testenv:mypy]
+whitelist_externals = bash
+commands = bash -c 'mypy --config-file=linters/mypy.ini tools/*.py'
+deps =
+	mypy
+
+[testenv:vulture]
+whitelist_externals = bash
+commands = bash -c 'vulture tools/*.py'
+deps =
+	vulture
+
+[testenv:htmlhint]
+whitelist_externals = htmlhint
+commands = htmlhint src/http/data/*.html

pkg/arch/PKGBUILD

@@ -0,0 +1,34 @@
+# Contributor: Maxim Devaev <mdevaev@gmail.com>
+# Author: Maxim Devaev <mdevaev@gmail.com>
+
+
+pkgname=ustreamer
+pkgver=2.2
+pkgrel=1
+pkgdesc="Lightweight and fast MJPG-HTTP streamer"
+url="https://github.com/pikvm/ustreamer"
+license=(GPL)
+arch=(i686 x86_64 armv6h armv7h aarch64)
+depends=(libjpeg libevent libutil-linux libbsd libgpiod)
+# optional: raspberrypi-firmware for OMX encoder
+makedepends=(gcc make)
+source=(${pkgname}::"git+https://github.com/pikvm/ustreamer#commit=v${pkgver}")
+md5sums=(SKIP)
+
+
+build() {
+	cd "$srcdir"
+	rm -rf $pkgname-build
+	cp -r $pkgname $pkgname-build
+	cd $pkgname-build
+
+	local _options="WITH_GPIO=1"
+	[ -e /opt/vc/include/IL/OMX_Core.h ] && _options="$_options WITH_OMX=1"
+
+	make $_options CFLAGS="$CFLAGS" LDFLAGS="$LDFLAGS" $MAKEFLAGS
+}
+
+package() {
+	cd "$srcdir/$pkgname-build"
+	make DESTDIR="$pkgdir" PREFIX=/usr install
+}

pkg/docker/Dockerfile.arm.cross

@@ -0,0 +1,41 @@
+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 \
+		libraspberrypi-dev \
+		libgpiod-dev \
+	&& rm -rf /var/lib/apt/lists/*
+
+WORKDIR /build/ustreamer/
+COPY . .
+RUN make -j5 WITH_OMX=1 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 \
+		uuid \
+		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,34 @@
+FROM balenalib/raspberrypi3-debian:build as build
+
+RUN apt-get update \
+	&& apt-get install -y --no-install-recommends \
+		gcc \
+		libjpeg8-dev \
+		libbsd-dev \
+		libraspberrypi-dev \
+		libgpiod-dev \
+	&& rm -rf /var/lib/apt/lists/*
+
+WORKDIR /build/ustreamer/
+COPY . .
+RUN make -j5 WITH_OMX=1 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 \
+		uuid \
+		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,40 @@
+FROM debian:buster-slim as build
+
+RUN apt-get update \
+	&& apt-get install -y \
+		ca-certificates \
+		make \
+		gcc \
+		git \
+		libevent-dev \
+		libjpeg62-turbo-dev \
+		uuid-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 \
+		uuid \
+		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/gentoo/ustreamer-9999.ebuild

@@ -5,9 +5,9 @@ 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 MJPG-HTTP streamer"
+HOMEPAGE="https://github.com/pikvm/ustreamer"
+EGIT_REPO_URI="https://github.com/pikvm/ustreamer.git"
  
 LICENSE="GPL-3"
 SLOT="0"
@@ -18,6 +18,7 @@ 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=""

pkg/openwrt/Makefile

@@ -0,0 +1,45 @@
+#
+# 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:=2.2
+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 +libuuid +libbsd +libevent2 +libevent2-core +libevent2-extra +libevent2-pthreads
+  URL:=https://github.com/pikvm/ustreamer
+endef
+
+define Package/ustreamer/description
+ µStreamer - Lightweight and fast MJPG-HTTP streamer
+endef
+
+define Package/ustreamer/install
+	$(INSTALL_DIR) $(1)/usr/bin
+	$(INSTALL_BIN) $(PKG_BUILD_DIR)/ustreamer $(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
+}

src/config.h

@@ -22,4 +22,6 @@
 
 #pragma once
 
-#define VERSION "0.56"
+#ifndef VERSION
+#	define VERSION "2.2"
+#endif

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

@@ -20,6 +20,8 @@
 *****************************************************************************/
 
 
+#include "device.h"
+
 #include <stdlib.h>
 #include <stddef.h>
 #include <stdbool.h>
@@ -27,15 +29,21 @@
 #include <strings.h>
 #include <unistd.h>
 #include <fcntl.h>
+#include <errno.h>
 #include <assert.h>
 
+#include <sys/select.h>
 #include <sys/mman.h>
+#include <sys/time.h>
+
 #include <linux/videodev2.h>
+#include <linux/v4l2-controls.h>
 
 #include "tools.h"
 #include "logging.h"
+#include "threading.h"
 #include "xioctl.h"
-#include "device.h"
+#include "picture.h"
 
 
 static const struct {
@@ -60,31 +68,47 @@ static const struct {
 	{"JPEG",	V4L2_PIX_FMT_JPEG},
 };
 
+static const struct {
+	const char *name;
+	const enum v4l2_memory io_method;
+} _IO_METHODS[] = {
+	{"MMAP",	V4L2_MEMORY_MMAP},
+	{"USERPTR",	V4L2_MEMORY_USERPTR},
+};
+
 
 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 void _device_open_hw_fps(struct device_t *dev);
+static int _device_open_io_method(struct device_t *dev);
+static int _device_open_io_method_mmap(struct device_t *dev);
+static int _device_open_io_method_userptr(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 int _device_query_control(struct device_t *dev, struct v4l2_queryctrl *query, const char *name, unsigned cid, bool quiet);
+static void _device_set_control(struct device_t *dev, struct v4l2_queryctrl *query, 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);
+static const char *_io_method_to_string_supported(enum v4l2_memory io_method);
 
 
-struct device_t *device_init() {
-	struct controls_t *ctl;
+struct device_t *device_init(void) {
 	struct device_runtime_t *run;
 	struct device_t *dev;
+	long cores_sysconf;
+	unsigned cores_available;
 
-	A_CALLOC(ctl, 1);
+	cores_sysconf = sysconf(_SC_NPROCESSORS_ONLN);
+	cores_sysconf = (cores_sysconf < 0 ? 0 : cores_sysconf);
+	cores_available = max_u(min_u(cores_sysconf, 4), 1);
 
 	A_CALLOC(run, 1);
 	run->fd = -1;
@@ -95,18 +119,18 @@ struct device_t *device_init() {
 	dev->height = 480;
 	dev->format = V4L2_PIX_FMT_YUYV;
 	dev->standard = V4L2_STD_UNKNOWN;
-	dev->n_buffers = max_u(sysconf(_SC_NPROCESSORS_ONLN), 1) + 1;
-	dev->n_workers = dev->n_buffers;
+	dev->n_buffers = cores_available + 1;
+	dev->n_workers = min_u(cores_available, dev->n_buffers);
+	dev->min_frame_size = 128;
 	dev->timeout = 1;
 	dev->error_delay = 1;
-	dev->ctl = ctl;
+	dev->io_method = V4L2_MEMORY_MMAP;
 	dev->run = run;
 	return dev;
 }
 
 void device_destroy(struct device_t *dev) {
 	free(dev->run);
-	free(dev->ctl);
 	free(dev);
 }
 
@@ -128,6 +152,15 @@ v4l2_std_id device_parse_standard(const char *str) {
 	return STANDARD_UNKNOWN;
 }
 
+int device_parse_io_method(const char *str) {
+	for (unsigned index = 0; index < ARRAY_LEN(_IO_METHODS); ++index) {
+		if (!strcasecmp(str, _IO_METHODS[index].name)) {
+			return _IO_METHODS[index].io_method;
+		}
+	}
+	return IO_METHOD_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");
@@ -144,7 +177,8 @@ int device_open(struct device_t *dev) {
 	if (_device_open_format(dev) < 0) {
 		goto error;
 	}
-	if (_device_open_mmap(dev) < 0) {
+	_device_open_hw_fps(dev);
+	if (_device_open_io_method(dev) < 0) {
 		goto error;
 	}
 	if (_device_open_queue_buffers(dev) < 0) {
@@ -153,6 +187,8 @@ int device_open(struct device_t *dev) {
 	_device_open_alloc_picbufs(dev);
 	_device_apply_controls(dev);
 
+	dev->run->n_workers = min_u(dev->run->n_buffers, dev->n_workers);
+
 	LOG_DEBUG("Device fd=%d initialized", dev->run->fd);
 	return 0;
 
@@ -162,26 +198,34 @@ int device_open(struct device_t *dev) {
 }
 
 void device_close(struct device_t *dev) {
+	dev->run->n_workers = 0;
+
 	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;
+		for (unsigned index = 0; index < dev->run->n_buffers; ++index) {
+			picture_destroy(dev->run->pictures[index]);
 		}
 		free(dev->run->pictures);
 		dev->run->pictures = NULL;
 	}
 
 	if (dev->run->hw_buffers) {
-		LOG_DEBUG("Unmapping HW buffers ...");
+		LOG_DEBUG("Releasing device buffers ...");
 		for (unsigned index = 0; index < dev->run->n_buffers; ++index) {
 #			define HW_BUFFER(_next) dev->run->hw_buffers[index]._next
 
-			if (HW_BUFFER(size) > 0 && HW_BUFFER(data) != MAP_FAILED) {
-				if (munmap(HW_BUFFER(data), HW_BUFFER(size)) < 0) {
-					LOG_PERROR("Can't unmap device buffer %u", index);
+			if (dev->io_method == V4L2_MEMORY_MMAP) {
+				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);
+					}
+				}
+			} else { // V4L2_MEMORY_USERPTR
+				if (HW_BUFFER(data)) {
+					free(HW_BUFFER(data));
 				}
 			}
+			A_MUTEX_DESTROY(&HW_BUFFER(grabbed_mutex));
 
 #			undef HW_BUFFER
 		}
@@ -201,6 +245,137 @@ void device_close(struct device_t *dev) {
 	}
 }
 
+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_select(struct device_t *dev, bool *has_read, bool *has_write, bool *has_error) {
+	struct timeval timeout;
+	int retval;
+
+#	define INIT_FD_SET(_set) \
+		fd_set _set; FD_ZERO(&_set); FD_SET(dev->run->fd, &_set);
+
+	INIT_FD_SET(read_fds);
+	INIT_FD_SET(write_fds);
+	INIT_FD_SET(error_fds);
+
+#	undef INIT_FD_SET
+
+	timeout.tv_sec = dev->timeout;
+	timeout.tv_usec = 0;
+
+	LOG_DEBUG("Calling select() on video device ...");
+
+	retval = select(dev->run->fd + 1, &read_fds, &write_fds, &error_fds, &timeout);
+	if (retval > 0) {
+		*has_read = FD_ISSET(dev->run->fd, &read_fds);
+		*has_write = FD_ISSET(dev->run->fd, &write_fds);
+		*has_error = FD_ISSET(dev->run->fd, &error_fds);
+	} else {
+		*has_read = false;
+		*has_write = false;
+		*has_error = false;
+	}
+
+	LOG_DEBUG("Device select() --> %d", retval);
+	return retval;
+}
+
+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 = dev->io_method;
+
+	LOG_DEBUG("Grabbing device buffer ...");
+	if (xioctl(dev->run->fd, VIDIOC_DQBUF, &buf_info) < 0) {
+		LOG_PERROR("Unable to grab device buffer");
+		return -1;
+	}
+
+	LOG_DEBUG("Grabbed new frame in device buffer: index=%u, bytesused=%u",
+		buf_info.index, buf_info.bytesused);
+
+	if (buf_info.index >= dev->run->n_buffers) {
+		LOG_ERROR("V4L2 error: grabbed invalid device buffer: index=%u, nbuffers=%u",
+			buf_info.index, dev->run->n_buffers);
+		return -1;
+	}
+
+#	define HW_BUFFER(_next) dev->run->hw_buffers[buf_info.index]._next
+
+	A_MUTEX_LOCK(&HW_BUFFER(grabbed_mutex));
+	if (HW_BUFFER(grabbed)) {
+		LOG_ERROR("V4L2 error: grabbed device buffer is already used: index=%u, bytesused=%u",
+			buf_info.index, buf_info.bytesused);
+		A_MUTEX_UNLOCK(&HW_BUFFER(grabbed_mutex));
+		return -1;
+	}
+	HW_BUFFER(grabbed) = true;
+	A_MUTEX_UNLOCK(&HW_BUFFER(grabbed_mutex));
+
+	HW_BUFFER(used) = buf_info.bytesused;
+	memcpy(&HW_BUFFER(buf_info), &buf_info, sizeof(struct v4l2_buffer));
+	dev->run->pictures[buf_info.index]->grab_ts = get_now_monotonic();
+
+#	undef HW_BUFFER
+	return buf_info.index;
+}
+
+int device_release_buffer(struct device_t *dev, unsigned index) {
+#	define HW_BUFFER(_next) dev->run->hw_buffers[index]._next
+
+	LOG_DEBUG("Releasing device buffer index=%u ...", index);
+
+	A_MUTEX_LOCK(&HW_BUFFER(grabbed_mutex));
+	if (xioctl(dev->run->fd, VIDIOC_QBUF, &HW_BUFFER(buf_info)) < 0) {
+		LOG_PERROR("Unable to release device buffer index=%u", index);
+		A_MUTEX_UNLOCK(&HW_BUFFER(grabbed_mutex));
+		return -1;
+	}
+	HW_BUFFER(grabbed) = false;
+	A_MUTEX_UNLOCK(&HW_BUFFER(grabbed_mutex));
+	HW_BUFFER(used) = 0;
+
+#	undef HW_BUFFER
+	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) == 0) {
+		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()
@@ -214,7 +389,7 @@ static int _device_open_check_cap(struct device_t *dev) {
 	}
 
 	if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
-		LOG_ERROR("Video capture not supported by our device");
+		LOG_ERROR("Video capture not supported by the device");
 		return -1;
 	}
 
@@ -244,7 +419,7 @@ static int _device_open_check_cap(struct device_t *dev) {
 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");
+		LOG_DEBUG("Using DV timings");
 
 		if (_device_apply_dv_timings(dev) < 0) {
 			return -1;
@@ -265,24 +440,22 @@ static int _device_open_dv_timings(struct device_t *dev) {
 }
 
 static int _device_apply_dv_timings(struct device_t *dev) {
-	struct v4l2_dv_timings dv_timings;
+	struct v4l2_dv_timings dv;
 
-	MEMSET_ZERO(dv_timings);
+	MEMSET_ZERO(dv);
 
 	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);
+	if (xioctl(dev->run->fd, VIDIOC_QUERY_DV_TIMINGS, &dv) == 0) {
+		LOG_INFO("Got new DV timings: resolution=%ux%u, pixclk=%llu",
+			dv.bt.width, dv.bt.height, (unsigned long long)dv.bt.pixelclock); // Issue #11
 
 		LOG_DEBUG("Calling ioctl(VIDIOC_S_DV_TIMINGS) ...");
-		if (xioctl(dev->run->fd, VIDIOC_S_DV_TIMINGS, &dv_timings) < 0) {
+		if (xioctl(dev->run->fd, VIDIOC_S_DV_TIMINGS, &dv) < 0) {
 			LOG_PERROR("Failed to set DV timings");
 			return -1;
 		}
 
-		if (_device_apply_resolution(dev, dv_timings.bt.width, dv_timings.bt.height) < 0) {
+		if (_device_apply_resolution(dev, dv.bt.width, dv.bt.height) < 0) {
 			return -1;
 		}
 
@@ -312,7 +485,7 @@ static int _device_open_format(struct device_t *dev) {
 	// 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",
+		LOG_PERROR("Unable to set pixelformat=%s, resolution=%ux%u",
 			_format_to_string_supported(dev->format),
 			dev->run->width,
 			dev->run->height);
@@ -348,10 +521,77 @@ static int _device_open_format(struct device_t *dev) {
 
 	dev->run->format = fmt.fmt.pix.pixelformat;
 	LOG_INFO("Using pixelformat: %s", _format_to_string_supported(dev->run->format));
+
+	dev->run->raw_size = fmt.fmt.pix.sizeimage; // Only for userptr
 	return 0;
 }
 
-static int _device_open_mmap(struct device_t *dev) {
+static void _device_open_hw_fps(struct device_t *dev) {
+	struct v4l2_streamparm setfps;
+
+	dev->run->hw_fps = 0;
+
+	MEMSET_ZERO(setfps);
+	setfps.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+	LOG_DEBUG("Calling ioctl(VIDIOC_G_PARM) ...");
+	if (xioctl(dev->run->fd, VIDIOC_G_PARM, &setfps) < 0) {
+		if (errno == ENOTTY) { // Quiet message for Auvidea B101
+			LOG_INFO("Querying HW FPS changing is not supported");
+		} else {
+			LOG_PERROR("Unable to query HW FPS changing");
+		}
+		return;
+	}
+
+	if (!(setfps.parm.capture.capability & V4L2_CAP_TIMEPERFRAME)) {
+		LOG_INFO("Changing HW FPS is not supported");
+		return;
+	}
+
+#	define SETFPS_TPF(_next) setfps.parm.capture.timeperframe._next
+
+	MEMSET_ZERO(setfps);
+	setfps.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+	SETFPS_TPF(numerator) = 1;
+	SETFPS_TPF(denominator) = (dev->desired_fps == 0 ? 255 : dev->desired_fps);
+
+	if (xioctl(dev->run->fd, VIDIOC_S_PARM, &setfps) < 0) {
+		LOG_PERROR("Unable to set HW FPS");
+		return;
+	}
+
+	if (SETFPS_TPF(numerator) != 1) {
+		LOG_ERROR("Invalid HW FPS numerator: %u != 1", SETFPS_TPF(numerator));
+		return;
+	}
+
+	if (SETFPS_TPF(denominator) == 0) { // Не знаю, бывает ли так, но пускай на всякий случай
+		LOG_ERROR("Invalid HW FPS denominator: 0");
+		return;
+	}
+
+	dev->run->hw_fps = SETFPS_TPF(denominator);
+	if (dev->desired_fps != dev->run->hw_fps) {
+		LOG_INFO("Using HW FPS: %u -> %u (coerced)", dev->desired_fps, dev->run->hw_fps);
+	} else {
+		LOG_INFO("Using HW FPS: %u", dev->run->hw_fps);
+	}
+
+#	undef SETFPS_TPF
+}
+
+static int _device_open_io_method(struct device_t *dev) {
+	LOG_INFO("Using IO method: %s", _io_method_to_string_supported(dev->io_method));
+	switch (dev->io_method) {
+		case V4L2_MEMORY_MMAP: return _device_open_io_method_mmap(dev);
+		case V4L2_MEMORY_USERPTR: return _device_open_io_method_userptr(dev);
+		default: assert(0 && "Unsupported IO method");
+	}
+	return -1;
+}
+
+static int _device_open_io_method_mmap(struct device_t *dev) {
 	struct v4l2_requestbuffers req;
 
 	MEMSET_ZERO(req);
@@ -359,9 +599,9 @@ static int _device_open_mmap(struct device_t *dev) {
 	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);
+	LOG_DEBUG("Calling ioctl(VIDIOC_REQBUFS) for V4L2_MEMORY_MMAP ...");
+	if (xioctl(dev->run->fd, VIDIOC_REQBUFS, &req) < 0) {
+		LOG_PERROR("Device '%s' doesn't support V4L2_MEMORY_MMAP", dev->path);
 		return -1;
 	}
 
@@ -369,10 +609,10 @@ static int _device_open_mmap(struct device_t *dev) {
 		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_INFO("Requested %u device buffers, got %u", dev->n_buffers, req.count);
 	}
 
-	LOG_DEBUG("Allocating HW buffers ...");
+	LOG_DEBUG("Allocating device 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) {
@@ -391,13 +631,53 @@ static int _device_open_mmap(struct device_t *dev) {
 
 #		define HW_BUFFER(_next) dev->run->hw_buffers[dev->run->n_buffers]._next
 
+		A_MUTEX_INIT(&HW_BUFFER(grabbed_mutex));
+
 		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(size) = buf_info.length;
+		HW_BUFFER(allocated) = buf_info.length;
+
+#		undef HW_BUFFER
+	}
+	return 0;
+}
+
+static int _device_open_io_method_userptr(struct device_t *dev) {
+	struct v4l2_requestbuffers req;
+	unsigned page_size = getpagesize();
+	unsigned buf_size = align_size(dev->run->raw_size, page_size);
+
+	MEMSET_ZERO(req);
+	req.count = dev->n_buffers;
+	req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+	req.memory = V4L2_MEMORY_USERPTR;
+
+	LOG_DEBUG("Calling ioctl(VIDIOC_REQBUFS) for V4L2_MEMORY_USERPTR ...");
+	if (xioctl(dev->run->fd, VIDIOC_REQBUFS, &req) < 0) {
+		LOG_PERROR("Device '%s' doesn't support V4L2_MEMORY_USERPTR", dev->path);
+		return -1;
+	}
+
+	if (req.count < 1) {
+		LOG_ERROR("Insufficient buffer memory: %u", req.count);
+		return -1;
+	} else {
+		LOG_INFO("Requested %u device buffers, got %u", dev->n_buffers, req.count);
+	}
+
+	LOG_DEBUG("Allocating device 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) {
+#       define HW_BUFFER(_next) dev->run->hw_buffers[dev->run->n_buffers]._next
+
+		assert(HW_BUFFER(data) = aligned_alloc(page_size, buf_size));
+		memset(HW_BUFFER(data), 0, buf_size);
+		HW_BUFFER(allocated) = buf_size;
 
 #		undef HW_BUFFER
 	}
@@ -410,8 +690,12 @@ static int _device_open_queue_buffers(struct device_t *dev) {
 
 		MEMSET_ZERO(buf_info);
 		buf_info.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-		buf_info.memory = V4L2_MEMORY_MMAP;
+		buf_info.memory = dev->io_method;
 		buf_info.index = index;
+		if (dev->io_method == V4L2_MEMORY_USERPTR) {
+			buf_info.m.userptr = (unsigned long)dev->run->hw_buffers[index].data;
+			buf_info.length = dev->run->hw_buffers[index].allocated;
+		}
 
 		LOG_DEBUG("Calling ioctl(VIDIOC_QBUF) for buffer %u ...", index);
 		if (xioctl(dev->run->fd, VIDIOC_QBUF, &buf_info) < 0) {
@@ -423,14 +707,15 @@ static int _device_open_queue_buffers(struct device_t *dev) {
 }
 
 static void _device_open_alloc_picbufs(struct device_t *dev) {
+	size_t picture_size = picture_get_generous_size(dev->run->width, dev->run->height);
+
 	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;
+		dev->run->pictures[index] = picture_init();
+		LOG_DEBUG("Pre-allocating picture buffer %u sized %zu bytes... ", index, picture_size);
+		picture_realloc_data(dev->run->pictures[index], picture_size);
 	}
 }
 
@@ -441,7 +726,7 @@ static int _device_apply_resolution(struct device_t *dev, unsigned width, unsign
 		width == 0 || width > VIDEO_MAX_WIDTH
 		|| height == 0 || height > VIDEO_MAX_HEIGHT
 	) {
-		LOG_ERROR("Requested forbidden resolution=%ux%u: min=1x1; max=%ux%u",
+		LOG_ERROR("Requested forbidden resolution=%ux%u: min=1x1, max=%ux%u",
 			width, height, VIDEO_MAX_WIDTH, VIDEO_MAX_HEIGHT);
 		return -1;
 	}
@@ -451,65 +736,85 @@ static int _device_apply_resolution(struct device_t *dev, unsigned width, unsign
 }
 
 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_VALUE(_cid, _field, _value, _quiet) { \
+			struct v4l2_queryctrl query; \
+			if (_device_query_control(dev, &query, #_field, _cid, _quiet) == 0) { \
+				_device_set_control(dev, &query, #_field, _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_DEFAULT(_cid, _field, _quiet) { \
+			struct v4l2_queryctrl query; \
+			if (_device_query_control(dev, &query, #_field, _cid, _quiet) == 0) { \
+				_device_set_control(dev, &query, #_field, _cid, query.default_value, _quiet); \
 			} \
 		}
 
-#	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); \
+#	define CONTROL_MANUAL_CID(_cid, _field) { \
+			if (dev->ctl._field.mode == CTL_MODE_VALUE) { \
+				SET_CID_VALUE(_cid, _field, dev->ctl._field.value, false); \
+			} else if (dev->ctl._field.mode == CTL_MODE_DEFAULT) { \
+				SET_CID_DEFAULT(_cid, _field, false); \
 			} \
 		}
 
-	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);
+#	define CONTROL_AUTO_CID(_cid_auto, _cid_manual, _field) { \
+			if (dev->ctl._field.mode == CTL_MODE_VALUE) { \
+				SET_CID_VALUE(_cid_auto, _field##_auto, 0, true); \
+				SET_CID_VALUE(_cid_manual, _field, dev->ctl._field.value, false); \
+			} else if (dev->ctl._field.mode == CTL_MODE_AUTO) { \
+				SET_CID_VALUE(_cid_auto, _field##_auto, 1, false); \
+			} else if (dev->ctl._field.mode == CTL_MODE_DEFAULT) { \
+				SET_CID_VALUE(_cid_auto, _field##_auto, 0, true); /* Reset inactive flag */ \
+				SET_CID_DEFAULT(_cid_manual, _field, false); \
+				SET_CID_DEFAULT(_cid_auto, _field##_auto, false); \
+			} \
+		}
 
-#	undef SET_CID_AUTO
-#	undef SET_CID_MANUAL
-#	undef SET_CID
+	CONTROL_AUTO_CID	(V4L2_CID_AUTOBRIGHTNESS,		V4L2_CID_BRIGHTNESS,				brightness);
+	CONTROL_MANUAL_CID	(								V4L2_CID_CONTRAST,					contrast);
+	CONTROL_MANUAL_CID	(								V4L2_CID_SATURATION,				saturation);
+	CONTROL_AUTO_CID	(V4L2_CID_HUE_AUTO,				V4L2_CID_HUE,						hue);
+	CONTROL_MANUAL_CID	(								V4L2_CID_GAMMA,						gamma);
+	CONTROL_MANUAL_CID	(								V4L2_CID_SHARPNESS,					sharpness);
+	CONTROL_MANUAL_CID	(								V4L2_CID_BACKLIGHT_COMPENSATION,	backlight_compensation);
+	CONTROL_AUTO_CID	(V4L2_CID_AUTO_WHITE_BALANCE,	V4L2_CID_WHITE_BALANCE_TEMPERATURE,	white_balance);
+	CONTROL_AUTO_CID	(V4L2_CID_AUTOGAIN,				V4L2_CID_GAIN,						gain);
+	CONTROL_MANUAL_CID	(								V4L2_CID_COLORFX,					color_effect);
+	CONTROL_MANUAL_CID	(								V4L2_CID_VFLIP,						flip_vertical);
+	CONTROL_MANUAL_CID	(								V4L2_CID_HFLIP,						flip_horizontal);
+
+#	undef CONTROL_AUTO_CID
+#	undef CONTROL_MANUAL_CID
+#	undef SET_CID_DEFAULT
+#	undef SET_CID_VALUE
 }
 
-static int _device_check_control(struct device_t *dev, const char *name, unsigned cid, int value, bool quiet) {
-	struct v4l2_queryctrl query;
+static int _device_query_control(struct device_t *dev, struct v4l2_queryctrl *query, const char *name, unsigned cid, bool quiet) {
+	// cppcheck-suppress redundantPointerOp
+	MEMSET_ZERO(*query);
+	query->id = cid;
 
-	MEMSET_ZERO(query);
-	query.id = cid;
-
-	if (xioctl(dev->run->fd, VIDIOC_QUERYCTRL, &query) < 0 || query.flags & V4L2_CTRL_FLAG_DISABLED) {
+	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) {
+static void _device_set_control(struct device_t *dev, struct v4l2_queryctrl *query, const char *name, unsigned cid, int value, bool quiet) {
 	struct v4l2_control ctl;
 
+	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;
+	}
+
 	MEMSET_ZERO(ctl);
 	ctl.id = cid;
 	ctl.value = value;
@@ -519,7 +824,7 @@ static void _device_set_control(struct device_t *dev, const char *name, unsigned
 			LOG_PERROR("Can't set control %s", name);
 		}
 	} else if (!quiet) {
-		LOG_INFO("Using control %s: %d", name, ctl.value);
+		LOG_INFO("Applying control %s: %d", name, ctl.value);
 	}
 }
 
@@ -529,7 +834,7 @@ static const char *_format_to_string_fourcc(char *buf, size_t size, unsigned for
 	buf[1] = (format >> 8) & 0x7F;
 	buf[2] = (format >> 16) & 0x7F;
 	buf[3] = (format >> 24) & 0x7F;
-	if (format & (1 << 31)) {
+	if (format & ((unsigned)1 << 31)) {
 		buf[4] = '-';
 		buf[5] = 'B';
 		buf[6] = 'E';
@@ -562,3 +867,12 @@ static const char *_standard_to_string(v4l2_std_id standard) {
 	}
 	return _STANDARDS[0].name;
 }
+
+static const char *_io_method_to_string_supported(enum v4l2_memory io_method) {
+	for (unsigned index = 0; index < ARRAY_LEN(_IO_METHODS); ++index) {
+		if (io_method == _IO_METHODS[index].io_method) {
+			return _IO_METHODS[index].name;
+		}
+	}
+	return "unsupported";
+}

src/device.h

@@ -25,14 +25,19 @@
 #include <stddef.h>
 #include <stdbool.h>
 
+#include <pthread.h>
 #include <linux/videodev2.h>
 
+#include "picture.h"
 
-#define VIDEO_MIN_WIDTH		320
-#define VIDEO_MAX_WIDTH		1920
 
-#define VIDEO_MIN_HEIGHT	180
-#define VIDEO_MAX_HEIGHT	1200
+#define VIDEO_MIN_WIDTH		((unsigned)160)
+#define VIDEO_MAX_WIDTH		((unsigned)10240)
+
+#define VIDEO_MIN_HEIGHT	((unsigned)120)
+#define VIDEO_MAX_HEIGHT	((unsigned)4320)
+
+#define VIDEO_MAX_FPS		((unsigned)120)
 
 #define STANDARD_UNKNOWN	V4L2_STD_UNKNOWN
 #define STANDARDS_STR		"PAL, NTSC, SECAM"
@@ -40,19 +45,18 @@
 #define FORMAT_UNKNOWN	-1
 #define FORMATS_STR		"YUYV, UYVY, RGB565, RGB24, JPEG"
 
+#define IO_METHOD_UNKNOWN	-1
+#define IO_METHODS_STR		"MMAP, USERPTR"
+
 
 struct hw_buffer_t {
-	unsigned char	*data;
-	size_t			size;
-};
+	unsigned char		*data;
+	size_t				used;
+	size_t				allocated;
+	struct v4l2_buffer	buf_info;
 
-struct picture_t {
-	unsigned char	*data;
-	size_t			size;
-	size_t			allocated;
-	long double		grab_time;
-	long double		encode_begin_time;
-	long double		encode_end_time;
+	pthread_mutex_t grabbed_mutex;
+	bool			grabbed;
 };
 
 struct device_runtime_t {
@@ -60,18 +64,25 @@ struct device_runtime_t {
 	unsigned			width;
 	unsigned			height;
 	unsigned			format;
+	unsigned			hw_fps;
+	size_t				raw_size;
 	unsigned			n_buffers;
-//	unsigned			n_workers; // FIXME
+	unsigned			n_workers;
 	struct hw_buffer_t	*hw_buffers;
-	struct picture_t	*pictures;
-	size_t				max_picture_size;
+	struct picture_t	**pictures;
 	bool				capturing;
 };
 
+enum control_mode_t {
+	CTL_MODE_NONE = 0,
+	CTL_MODE_VALUE,
+	CTL_MODE_AUTO,
+	CTL_MODE_DEFAULT,
+};
+
 struct control_t {
-	int		value;
-	bool	value_set;
-	bool	auto_set;
+	enum control_mode_t	mode;
+	int					value;
 };
 
 struct controls_t {
@@ -84,6 +95,9 @@ struct controls_t {
 	struct control_t backlight_compensation;
 	struct control_t white_balance;
 	struct control_t gain;
+	struct control_t color_effect;
+	struct control_t flip_vertical;
+	struct control_t flip_horizontal;
 };
 
 struct device_t {
@@ -93,6 +107,7 @@ struct device_t {
 	unsigned		height;
 	unsigned		format;
 	v4l2_std_id		standard;
+	enum v4l2_memory	io_method;
 	bool			dv_timings;
 	unsigned		n_buffers;
 	unsigned		n_workers;
@@ -102,17 +117,24 @@ struct device_t {
 	unsigned		timeout;
 	unsigned		error_delay;
 
-	struct controls_t *ctl;
+	struct controls_t ctl;
 
 	struct device_runtime_t *run;
 };
 
 
-struct device_t *device_init();
+struct device_t *device_init(void);
 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_parse_io_method(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_select(struct device_t *dev, bool *has_read, bool *has_write, bool *has_error);
+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/encoder.c

@@ -20,20 +20,23 @@
 *****************************************************************************/
 
 
+#include "encoder.h"
+
+#include <stdlib.h>
+#include <stdbool.h>
 #include <strings.h>
 #include <assert.h>
 
 #include <linux/videodev2.h>
 
 #include "tools.h"
+#include "threading.h"
 #include "logging.h"
 #include "device.h"
-#include "encoder.h"
 
 #include "encoders/cpu/encoder.h"
 #include "encoders/hw/encoder.h"
-
-#ifdef WITH_OMX_ENCODER
+#ifdef WITH_OMX
 #	include "encoders/omx/encoder.h"
 #endif
 
@@ -44,13 +47,13 @@ static const struct {
 } _ENCODER_TYPES[] = {
 	{"CPU",	ENCODER_TYPE_CPU},
 	{"HW",	ENCODER_TYPE_HW},
-#	ifdef WITH_OMX_ENCODER
+#	ifdef WITH_OMX
 	{"OMX",	ENCODER_TYPE_OMX},
 #	endif
 };
 
 
-struct encoder_t *encoder_init() {
+struct encoder_t *encoder_init(void) {
 	struct encoder_runtime_t *run;
 	struct encoder_t *encoder;
 
@@ -66,50 +69,8 @@ struct encoder_t *encoder_init() {
 	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
+#	ifdef WITH_OMX
 	if (encoder->run->omxs) {
 		for (unsigned index = 0; index < encoder->run->n_omxs; ++index) {
 			if (encoder->run->omxs[index]) {
@@ -142,80 +103,138 @@ const char *encoder_type_to_string(enum encoder_type_t type) {
 	return _ENCODER_TYPES[0].name;
 }
 
-void encoder_prepare_live(struct encoder_t *encoder, struct device_t *dev) {
-	assert(encoder->run->type != ENCODER_TYPE_UNKNOWN);
+void encoder_prepare(struct encoder_t *encoder, struct device_t *dev) {
+	enum encoder_type_t type = (encoder->run->cpu_forced ? ENCODER_TYPE_CPU : encoder->type);
+	unsigned quality = encoder->quality;
+	bool cpu_forced = false;
 
-	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 ((dev->run->format == V4L2_PIX_FMT_MJPEG || dev->run->format == V4L2_PIX_FMT_JPEG) && type != ENCODER_TYPE_HW) {
+		LOG_INFO("Switching to HW encoder because the input format is (M)JPEG");
+		type = ENCODER_TYPE_HW;
 	}
 
-	if (encoder->run->type == ENCODER_TYPE_HW) {
+	if (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;
+			LOG_INFO("Switching to CPU encoder because the input format is not (M)JPEG");
+			goto use_cpu;
 		}
-		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");
+
+		if (hw_encoder_prepare(dev, quality) < 0) {
+			quality = 0;
 		}
+
+		dev->run->n_workers = 1;
 	}
-#	ifdef WITH_OMX_ENCODER
-	else if (encoder->run->type == ENCODER_TYPE_OMX) {
+#	ifdef WITH_OMX
+	else if (type == ENCODER_TYPE_OMX) {
+		for (unsigned index = 0; index < encoder->n_glitched_resolutions; ++index) {
+			if (
+				encoder->glitched_resolutions[index][0] == dev->run->width
+				&& encoder->glitched_resolutions[index][1] == dev->run->height
+			) {
+				LOG_INFO("Switching to CPU encoder the resolution %ux%u marked as glitchy for OMX",
+					dev->run->width, dev->run->height);
+				goto use_cpu;
+			}
+		}
+
+		LOG_DEBUG("Preparing OMX encoder ...");
+
+		if (dev->run->n_workers > OMX_MAX_ENCODERS) {
+			LOG_INFO("OMX encoder sets limit for worker threads: %u", OMX_MAX_ENCODERS);
+			dev->run->n_workers = OMX_MAX_ENCODERS;
+		}
+
+		if (encoder->run->omxs == NULL) {
+			A_CALLOC(encoder->run->omxs, OMX_MAX_ENCODERS);
+		}
+
+		// Начинаем с нуля и доинициализируем на следующих заходах при необходимости
+		for (; encoder->run->n_omxs < dev->run->n_workers; ++encoder->run->n_omxs) {
+			if ((encoder->run->omxs[encoder->run->n_omxs] = omx_encoder_init()) == NULL) {
+				LOG_ERROR("Can't initialize OMX encoder, falling back to CPU");
+				goto force_cpu;
+			}
+		}
+
 		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;
+			if (omx_encoder_prepare(encoder->run->omxs[index], dev, quality) < 0) {
+				LOG_ERROR("Can't prepare OMX encoder, falling back to CPU");
+				goto force_cpu;
 			}
 		}
 	}
 #	endif
 
-	return;
+	goto ok;
+
+#	pragma GCC diagnostic ignored "-Wunused-label"
+#	pragma GCC diagnostic push
+	// cppcheck-suppress unusedLabel
+	force_cpu:
+		cpu_forced = true;
+#	pragma GCC diagnostic pop
+
+	use_cpu:
+		type = ENCODER_TYPE_CPU;
+		quality = encoder->quality;
+
+	ok:
+		if (quality == 0) {
+			LOG_INFO("Using JPEG quality: encoder default");
+		} else {
+			LOG_INFO("Using JPEG quality: %u%%", quality);
+		}
 
-	use_fallback:
 		A_MUTEX_LOCK(&encoder->run->mutex);
-		encoder->run->type = ENCODER_TYPE_CPU;
-		encoder->run->quality = encoder->quality;
+		encoder->run->type = type;
+		encoder->run->quality = quality;
+		if (cpu_forced) {
+			encoder->run->cpu_forced = true;
+		}
 		A_MUTEX_UNLOCK(&encoder->run->mutex);
 }
 
-#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
 #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);
+	assert(dev->run->hw_buffers[buf_index].used > 0);
+
+	dev->run->pictures[buf_index]->encode_begin_ts = get_now_monotonic();
 
 	if (encoder->run->type == ENCODER_TYPE_CPU) {
-		cpu_encoder_compress_buffer(dev, buf_index, encoder->quality);
+		LOG_VERBOSE("Compressing buffer %u using CPU", buf_index);
+		cpu_encoder_compress_buffer(dev, buf_index, encoder->run->quality);
 	} else if (encoder->run->type == ENCODER_TYPE_HW) {
+		LOG_VERBOSE("Compressing buffer %u using HW (just copying)", buf_index);
 		hw_encoder_compress_buffer(dev, buf_index);
 	}
-#	ifdef WITH_OMX_ENCODER
+#	ifdef WITH_OMX
 	else if (encoder->run->type == ENCODER_TYPE_OMX) {
+		LOG_VERBOSE("Compressing buffer %u using OMX", buf_index);
 		if (omx_encoder_compress_buffer(encoder->run->omxs[worker_number], dev, buf_index) < 0) {
-			goto use_fallback;
+			goto error;
 		}
 	}
 #	endif
 
+	dev->run->pictures[buf_index]->encode_end_ts = get_now_monotonic();
+
+	dev->run->pictures[buf_index]->width = dev->run->width;
+	dev->run->pictures[buf_index]->height = dev->run->height;
+
 	return 0;
 
 #	pragma GCC diagnostic ignored "-Wunused-label"
 #	pragma GCC diagnostic push
-	use_fallback:
-		LOG_INFO("Error while compressing, falling back to CPU");
+	// cppcheck-suppress unusedLabel
+	error:
+		LOG_INFO("Error while compressing buffer, falling back to CPU");
 		A_MUTEX_LOCK(&encoder->run->mutex);
-		encoder->run->type = ENCODER_TYPE_CPU;
-		encoder->run->quality = encoder->quality;
+		encoder->run->cpu_forced = true;
 		A_MUTEX_UNLOCK(&encoder->run->mutex);
 		return -1;
 #	pragma GCC diagnostic pop

src/encoder.h

@@ -22,14 +22,21 @@
 
 #pragma once
 
-#include "pthread.h"
+#include <stdbool.h>
+
+#include <pthread.h>
 
-#include "tools.h"
 #include "device.h"
 
-#ifdef WITH_OMX_ENCODER
+#ifdef WITH_OMX
 #	include "encoders/omx/encoder.h"
+
 #	define ENCODER_TYPES_OMX_HINT ", OMX"
+
+#	ifndef CFG_MAX_GLITCHED_RESOLUTIONS
+#		define CFG_MAX_GLITCHED_RESOLUTIONS 1024
+#	endif
+#	define MAX_GLITCHED_RESOLUTIONS ((unsigned)(CFG_MAX_GLITCHED_RESOLUTIONS))
 #else
 #	define ENCODER_TYPES_OMX_HINT ""
 #endif
@@ -43,7 +50,7 @@ enum encoder_type_t {
 	ENCODER_TYPE_UNKNOWN, // Only for encoder_parse_type() and main()
 	ENCODER_TYPE_CPU,
 	ENCODER_TYPE_HW,
-#	ifdef WITH_OMX_ENCODER
+#	ifdef WITH_OMX
 	ENCODER_TYPE_OMX,
 #	endif
 };
@@ -51,9 +58,10 @@ enum encoder_type_t {
 struct encoder_runtime_t {
 	enum encoder_type_t	type;
 	unsigned			quality;
+	bool				cpu_forced;
 	pthread_mutex_t		mutex;
 
-#	ifdef WITH_OMX_ENCODER
+#	ifdef WITH_OMX
 	unsigned				n_omxs;
 	struct omx_encoder_t	**omxs;
 #	endif
@@ -62,18 +70,20 @@ struct encoder_runtime_t {
 struct encoder_t {
 	enum encoder_type_t	type;
 	unsigned			quality;
+#	ifdef WITH_OMX
+	unsigned	n_glitched_resolutions;
+	unsigned	glitched_resolutions[2][MAX_GLITCHED_RESOLUTIONS];
+#	endif
 
 	struct encoder_runtime_t *run;
 };
 
 
-struct encoder_t *encoder_init();
+struct encoder_t *encoder_init(void);
 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);

src/encoders/cpu/encoder.c

@@ -25,29 +25,29 @@
 *****************************************************************************/
 
 
+#include "encoder.h"
+
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 #include <assert.h>
 
 #include <jpeglib.h>
+
 #include <linux/videodev2.h>
 
 #include "../../tools.h"
+#include "../../picture.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;
+	struct				jpeg_destination_mgr mgr; // Default manager
+	JOCTET				*buffer; // Start of buffer
+	struct picture_t	*picture;
 };
 
 
-static void _jpeg_set_dest_picture(j_compress_ptr jpeg, unsigned char *picture, size_t *written);
+static void _jpeg_set_picture(j_compress_ptr jpeg, struct picture_t *picture);
 
 static void _jpeg_write_scanlines_yuyv(
 	struct jpeg_compress_struct *jpeg, const unsigned char *data,
@@ -79,10 +79,7 @@ void cpu_encoder_compress_buffer(struct device_t *dev, unsigned index, unsigned
 	jpeg.err = jpeg_std_error(&jpeg_error);
 	jpeg_create_compress(&jpeg);
 
-#	define PICTURE(_next) dev->run->pictures[index]._next
-
-	PICTURE(size) = 0;
-	_jpeg_set_dest_picture(&jpeg, PICTURE(data), &PICTURE(size));
+	_jpeg_set_picture(&jpeg, dev->run->pictures[index]);
 
 	jpeg.image_width = dev->run->width;
 	jpeg.image_height = dev->run->height;
@@ -103,20 +100,18 @@ void cpu_encoder_compress_buffer(struct device_t *dev, unsigned index, unsigned
 		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");
+		default: assert(0 && "Unsupported input format for CPU 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(size) > 0);
-	assert(PICTURE(size) <= dev->run->max_picture_size);
+
+	assert(dev->run->pictures[index]->used > 0);
 }
 
-static void _jpeg_set_dest_picture(j_compress_ptr jpeg, unsigned char *picture, size_t *written) {
+static void _jpeg_set_picture(j_compress_ptr jpeg, struct picture_t *picture) {
 	struct _jpeg_dest_manager_t *dest;
 
 	if (jpeg->dest == NULL) {
@@ -129,8 +124,9 @@ static void _jpeg_set_dest_picture(j_compress_ptr jpeg, unsigned char *picture,
 	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;
+	dest->picture = picture;
+
+	picture->used = 0;
 }
 
 #define YUV_R(_y, _, _v)	(((_y) + (359 * (_v))) >> 8)
@@ -262,7 +258,7 @@ static void _jpeg_write_scanlines_rgb24(
 	}
 }
 
-#define JPEG_OUTPUT_BUFFER_SIZE  4096
+#define JPEG_OUTPUT_BUFFER_SIZE ((size_t)4096)
 
 static void _jpeg_init_destination(j_compress_ptr jpeg) {
 	struct _jpeg_dest_manager_t *dest = (struct _jpeg_dest_manager_t *)jpeg->dest;
@@ -281,9 +277,7 @@ static boolean _jpeg_empty_output_buffer(j_compress_ptr jpeg) {
 
 	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;
+	picture_append_data(dest->picture, dest->buffer, JPEG_OUTPUT_BUFFER_SIZE);
 
 	dest->mgr.next_output_byte = dest->buffer;
 	dest->mgr.free_in_buffer = JPEG_OUTPUT_BUFFER_SIZE;
@@ -293,15 +287,13 @@ static boolean _jpeg_empty_output_buffer(j_compress_ptr jpeg) {
 
 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
+	// 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;
+	size_t final = 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;
+	// Write any data remaining in the buffer.
+	picture_append_data(dest->picture, dest->buffer, final);
 }
 
 #undef JPEG_OUTPUT_BUFFER_SIZE

src/encoders/hw/encoder.c

@@ -25,6 +25,8 @@
 *****************************************************************************/
 
 
+#include "encoder.h"
+
 #include <stdbool.h>
 #include <string.h>
 #include <assert.h>
@@ -34,28 +36,28 @@
 #include "../../tools.h"
 #include "../../logging.h"
 #include "../../xioctl.h"
+#include "../../picture.h"
 #include "../../device.h"
 
 #include "huffman.h"
-#include "encoder.h"
 
 
+void _copy_plus_huffman(const struct hw_buffer_t *src, struct picture_t *dest);
 static bool _is_huffman(const unsigned char *data);
-static size_t _memcpy_with_huffman(unsigned char *dest, const unsigned char *src, size_t size);
 
 
-int hw_encoder_prepare_live(struct device_t *dev, unsigned quality) {
+int hw_encoder_prepare(struct device_t *dev, unsigned quality) {
 	struct v4l2_jpegcompression comp;
 
 	MEMSET_ZERO(comp);
 
 	if (xioctl(dev->run->fd, VIDIOC_G_JPEGCOMP, &comp) < 0) {
-		LOG_ERROR("Can't query HW JPEG encoder params and set quality (unsupported)");
+		LOG_ERROR("Device does not support setting of HW encoding quality parameters");
 		return -1;
 	}
 	comp.quality = quality;
 	if (xioctl(dev->run->fd, VIDIOC_S_JPEGCOMP, &comp) < 0) {
-		LOG_ERROR("Can't set HW JPEG encoder quality (unsopported)");
+		LOG_ERROR("Unable to change MJPG quality for JPEG source with HW pass-through encoder");
 		return -1;
 	}
 	return 0;
@@ -63,17 +65,32 @@ int hw_encoder_prepare_live(struct device_t *dev, unsigned quality) {
 
 void hw_encoder_compress_buffer(struct device_t *dev, unsigned index) {
 	if (dev->run->format != V4L2_PIX_FMT_MJPEG && dev->run->format != V4L2_PIX_FMT_JPEG) {
-		assert(0 && "Unsupported input format for HW JPEG encoder");
+		assert(0 && "Unsupported input format for HW encoder");
 	}
+	_copy_plus_huffman(&dev->run->hw_buffers[index], dev->run->pictures[index]);
+}
 
-#	define PICTURE(_next)	dev->run->pictures[index]._next
-#	define HW_BUFFER(_next)	dev->run->hw_buffers[index]._next
+void _copy_plus_huffman(const struct hw_buffer_t *src, struct picture_t *dest) {
+	if (!_is_huffman(src->data)) {
+		const unsigned char *src_ptr = src->data;
+		const unsigned char *src_end = src->data + src->used;
+		size_t paste;
 
-	assert(PICTURE(allocated) >= HW_BUFFER(size) + sizeof(HUFFMAN_TABLE));
-	PICTURE(size) = _memcpy_with_huffman(PICTURE(data), HW_BUFFER(data), HW_BUFFER(size));
+		while ((((src_ptr[0] << 8) | src_ptr[1]) != 0xFFC0) && (src_ptr < src_end)) {
+			src_ptr += 1;
+		}
+		if (src_ptr >= src_end) {
+			dest->used = 0; // Error
+			return;
+		}
+		paste = src_ptr - src->data;
 
-#	undef HW_BUFFER
-#	undef PICTURE
+		picture_set_data(dest, src->data, paste);
+		picture_append_data(dest, HUFFMAN_TABLE, sizeof(HUFFMAN_TABLE));
+		picture_append_data(dest, src_ptr, src->used - paste);
+	} else {
+		picture_set_data(dest, src->data, src->used);
+	}
 }
 
 static bool _is_huffman(const unsigned char *data) {
@@ -90,27 +107,3 @@ static bool _is_huffman(const unsigned char *data) {
 	}
 	return false;
 }
-
-static size_t _memcpy_with_huffman(unsigned char *dest, const unsigned char *src, size_t size) {
-	if (!_is_huffman(src)) {
-		const unsigned char *src_ptr = src;
-		const unsigned char *src_end = src + size;
-		size_t paste;
-
-		while ((((src_ptr[0] << 8) | src_ptr[1]) != 0xFFC0) && (src_ptr < src_end)) {
-			src_ptr += 1;
-		}
-		if (src_ptr >= src_end) {
-			return 0;
-		}
-		paste = src_ptr - src;
-
-		memcpy(dest, src, paste);
-		memcpy(dest + paste, HUFFMAN_TABLE, sizeof(HUFFMAN_TABLE));
-		memcpy(dest + paste + sizeof(HUFFMAN_TABLE), src_ptr, size - paste);
-		return (size + sizeof(HUFFMAN_TABLE));
-	} else {
-		memcpy(dest, src, size);
-		return size;
-	}
-}

src/encoders/hw/encoder.h

@@ -25,5 +25,5 @@
 #include "../../device.h"
 
 
-int hw_encoder_prepare_live(struct device_t *dev, unsigned quality);
+int hw_encoder_prepare(struct device_t *dev, unsigned quality);
 void hw_encoder_compress_buffer(struct device_t *dev, unsigned index);

src/encoders/omx/component.c

@@ -20,6 +20,8 @@
 *****************************************************************************/
 
 
+#include "component.h"
+
 #include <unistd.h>
 
 #include <IL/OMX_Core.h>
@@ -28,7 +30,6 @@
 #include "../../logging.h"
 
 #include "formatters.h"
-#include "component.h"
 
 
 static int _component_wait_port_changed(OMX_HANDLETYPE *component, OMX_U32 port, OMX_BOOL enabled);
@@ -40,7 +41,7 @@ int component_enable_port(OMX_HANDLETYPE *component, OMX_U32 port) {
 
 	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);
+		LOG_ERROR_OMX(error, "Can't enable OMX port %u", port);
 		return -1;
 	}
 	return _component_wait_port_changed(component, port, OMX_TRUE);
@@ -51,7 +52,7 @@ int component_disable_port(OMX_HANDLETYPE *component, OMX_U32 port) {
 
 	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);
+		LOG_ERROR_OMX(error, "Can't disable OMX port %u", port);
 		return -1;
 	}
 	return _component_wait_port_changed(component, port, OMX_FALSE);
@@ -60,12 +61,13 @@ int component_disable_port(OMX_HANDLETYPE *component, OMX_U32 port) {
 int component_get_portdef(OMX_HANDLETYPE *component, OMX_PARAM_PORTDEFINITIONTYPE *portdef, OMX_U32 port) {
 	OMX_ERRORTYPE error;
 
+	// cppcheck-suppress redundantPointerOp
 	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);
+		LOG_ERROR_OMX(error, "Can't get OMX port %u definition", port);
 		return -1;
 	}
 	return 0;
@@ -76,7 +78,7 @@ int component_set_portdef(OMX_HANDLETYPE *component, OMX_PARAM_PORTDEFINITIONTYP
 
 	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);
+		LOG_ERROR_OMX(error, "Can't set OMX port %u definition", portdef->nPortIndex);
 		return -1;
 	}
 	return 0;
@@ -95,7 +97,7 @@ int component_set_state(OMX_HANDLETYPE *component, OMX_STATETYPE state) {
 			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);
+			LOG_ERROR_OMX(error, "Can't switch OMX component state to %s, need to retry", state_str);
 			retries -= 1;
 			usleep(8000);
 		} else {
@@ -103,7 +105,7 @@ int component_set_state(OMX_HANDLETYPE *component, OMX_STATETYPE state) {
 		}
 	} while (retries);
 
-	LOG_OMX_ERROR(error, "Can't switch OMX component state to %s", state_str);
+	LOG_ERROR_OMX(error, "Can't switch OMX component state to %s", state_str);
 	return -1;
 }
 
@@ -118,7 +120,7 @@ static int _component_wait_port_changed(OMX_HANDLETYPE *component, OMX_U32 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);
+			LOG_ERROR_OMX(error, "Can't get OMX port %u definition for waiting", port);
 			return -1;
 		}
 
@@ -140,7 +142,7 @@ static int _component_wait_state_changed(OMX_HANDLETYPE *component, OMX_STATETYP
 
 	do {
 		if ((error = OMX_GetState(*component, &state)) != OMX_ErrorNone) {
-			LOG_OMX_ERROR(error, "Failed to get OMX component state");
+			LOG_ERROR_OMX(error, "Failed to get OMX component state");
 			return -1;
 		}
 

src/encoders/omx/encoder.c

@@ -20,7 +20,10 @@
 *****************************************************************************/
 
 
+#include "encoder.h"
+
 #include <stdlib.h>
+#include <stdbool.h>
 #include <string.h>
 #include <unistd.h>
 #include <assert.h>
@@ -35,20 +38,21 @@
 
 #include "../../logging.h"
 #include "../../tools.h"
+#include "../../picture.h"
 #include "../../device.h"
 
 #include "formatters.h"
 #include "component.h"
-#include "encoder.h"
 
 
-#define INPUT_PORT 340
-#define OUTPUT_PORT 341
+static const OMX_U32 _INPUT_PORT = 340;
+static const OMX_U32 _OUTPUT_PORT = 341;
 
 
 static int _i_omx = 0;
 
 
+static int _vcos_semwait(VCOS_SEMAPHORE_T *sem);
 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);
@@ -69,7 +73,7 @@ static OMX_ERRORTYPE _omx_output_available_handler(
 	OMX_PTR v_omx, UNUSED OMX_BUFFERHEADERTYPE *buffer);
 
 
-struct omx_encoder_t *omx_encoder_init() {
+struct omx_encoder_t *omx_encoder_init(void) {
 	// Some theory:
 	//   - http://www.fourcc.org/yuv.php
 	//   - https://kwasi-ich.de/blog/2017/11/26/omx/
@@ -78,6 +82,7 @@ struct omx_encoder_t *omx_encoder_init() {
 	//   - 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
+	//   - http://home.nouwen.name/RaspberryPi/documentation/ilcomponents/image_encode.html
 
 	struct omx_encoder_t *omx;
 	OMX_ERRORTYPE error;
@@ -91,19 +96,19 @@ struct omx_encoder_t *omx_encoder_init() {
 
 		LOG_INFO("Initializing OMX ...");
 		if ((error = OMX_Init()) != OMX_ErrorNone) {
-			LOG_OMX_ERROR(error, "Can't initialize OMX");
+			LOG_ERROR_OMX(error, "Can't initialize OMX");
 			goto error;
 		}
 	}
 	_i_omx += 1;
 
-	LOG_INFO("Initializing OMX JPEG encoder ...");
+	LOG_INFO("Initializing OMX encoder ...");
 
-	if (vcos_semaphore_create(&omx->handler_lock, "handler_lock", 0) != VCOS_SUCCESS) {
+	if (vcos_semaphore_create(&omx->handler_sem, "handler_sem", 0) != VCOS_SUCCESS) {
 		LOG_ERROR("Can't create VCOS semaphore");
 		goto error;
 	}
-	omx->i_handler_lock = true;
+	omx->i_handler_sem = true;
 
 	if (_omx_init_component(omx) < 0) {
 		goto error;
@@ -123,19 +128,19 @@ struct omx_encoder_t *omx_encoder_init() {
 void omx_encoder_destroy(struct omx_encoder_t *omx) {
 	OMX_ERRORTYPE error;
 
-	LOG_INFO("Destroying OMX JPEG encoder ...");
+	LOG_INFO("Destroying OMX 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_handler_sem) {
+		vcos_semaphore_delete(&omx->handler_sem);
 	}
 
 	if (omx->i_encoder) {
 		if ((error = OMX_FreeHandle(omx->encoder)) != OMX_ErrorNone) {
-			LOG_OMX_ERROR(error, "Can't free OMX.broadcom.image_encode");
+			LOG_ERROR_OMX(error, "Can't free OMX.broadcom.image_encode");
 		}
 	}
 
@@ -152,7 +157,7 @@ void omx_encoder_destroy(struct omx_encoder_t *omx) {
 	free(omx);
 }
 
-int omx_encoder_prepare_live(struct omx_encoder_t *omx, struct device_t *dev, unsigned quality) {
+int omx_encoder_prepare(struct omx_encoder_t *omx, struct device_t *dev, unsigned quality) {
 	if (component_set_state(&omx->encoder, OMX_StateIdle) < 0) {
 		return -1;
 	}
@@ -172,21 +177,20 @@ int omx_encoder_prepare_live(struct omx_encoder_t *omx, struct device_t *dev, un
 }
 
 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);
+	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");
+		LOG_ERROR_OMX(error, "Failed to request filling of the output buffer on encoder");
 		return -1;
 	}
 
-	PICTURE(size) = 0;
+	dev->run->pictures[index]->used = 0;
 	omx->output_available = false;
 	omx->input_required = true;
 
@@ -198,9 +202,7 @@ int omx_encoder_compress_buffer(struct omx_encoder_t *omx, struct device_t *dev,
 		if (omx->output_available) {
 			omx->output_available = false;
 
-			assert(PICTURE(size) + OUT(nFilledLen) <= dev->run->max_picture_size);
-			memcpy(PICTURE(data) + PICTURE(size), OUT(pBuffer) + OUT(nOffset), OUT(nFilledLen));
-			PICTURE(size) += OUT(nFilledLen);
+			picture_append_data(dev->run->pictures[index], OUT(pBuffer) + OUT(nOffset), OUT(nFilledLen));
 
 			if (OUT(nFlags) & OMX_BUFFERFLAG_ENDOFFRAME) {
 				OUT(nFlags) = 0;
@@ -208,7 +210,7 @@ int omx_encoder_compress_buffer(struct omx_encoder_t *omx, struct device_t *dev,
 			}
 
 			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");
+				LOG_ERROR_OMX(error, "Failed to request filling of the output buffer on encoder");
 				return -1;
 			}
 		}
@@ -216,7 +218,7 @@ int omx_encoder_compress_buffer(struct omx_encoder_t *omx, struct device_t *dev,
 		if (omx->input_required) {
 			omx->input_required = false;
 
-			if (pos == HW_BUFFER(size)) {
+			if (pos == HW_BUFFER(used)) {
 				continue;
 			}
 
@@ -226,29 +228,62 @@ int omx_encoder_compress_buffer(struct omx_encoder_t *omx, struct device_t *dev,
 
 			pos += slice_size;
 
-			if (pos + slice_size > HW_BUFFER(size)) {
-				slice_size = HW_BUFFER(size) - pos;
+			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");
+				LOG_ERROR_OMX(error, "Failed to request emptying of the input buffer on encoder");
 				return -1;
 			}
 		}
 
-		vcos_semaphore_wait(&omx->handler_lock);
+		if (_vcos_semwait(&omx->handler_sem) != 0) {
+			return -1;
+		}
 	}
 
 #	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
+static int _vcos_semwait(VCOS_SEMAPHORE_T *sem) {
+	// vcos_semaphore_wait() can wait infinite
+	// vcos_semaphore_wait_timeout() is broken by design:
+	//   - https://github.com/pikvm/ustreamer/issues/56
+	//   - https://github.com/raspberrypi/userland/issues/658
+	// CFG_OMX_SEMWAIT_TIMEOUT is ugly busyloop
+	// Три стула.
 
+#	ifdef CFG_OMX_SEMWAIT_TIMEOUT
+	long double deadline_ts = get_now_monotonic() + (long double)CFG_OMX_SEMWAIT_TIMEOUT; // Seconds
+	VCOS_STATUS_T sem_status;
+
+	while (true) {
+		sem_status = vcos_semaphore_trywait(sem);
+		if (sem_status == VCOS_SUCCESS) {
+			return 0;
+		} else if (sem_status != VCOS_EAGAIN || get_now_monotonic() > deadline_ts) {
+			goto error;
+		}
+		usleep(1000);
+	}
+
+	error:
+		switch (sem_status) {
+			case VCOS_EAGAIN: LOG_ERROR("Can't wait VCOS semaphore: EAGAIN (timeout)"); break;
+			case VCOS_EINVAL: LOG_ERROR("Can't wait VCOS semaphore: EINVAL"); break;
+			default: LOG_ERROR("Can't wait VCOS semaphore: %d", sem_status); break;
+		}
+		return -1;
+#	else
+	return (vcos_semaphore_wait(sem) == VCOS_SUCCESS ? 0 : -1);
+#	endif
+}
+
+static int _omx_init_component(struct omx_encoder_t *omx) {
 	OMX_ERRORTYPE error;
 
 	OMX_CALLBACKTYPE callbacks;
@@ -259,7 +294,7 @@ static int _omx_init_component(struct omx_encoder_t *omx) {
 
 	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");
+		LOG_ERROR_OMX(error, "Can't initialize OMX.broadcom.image_encode");
 		return -1;
 	}
 	omx->i_encoder = true;
@@ -276,13 +311,13 @@ static int _omx_init_disable_ports(struct omx_encoder_t *omx) {
 
 	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)");
+		LOG_ERROR_OMX(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);
+			LOG_ERROR_OMX(error, "Can't OMX_GetParameter(types[%u])", index);
 			return -1;
 		}
 		for (OMX_U32 port = ports.nStartPortNumber; port < ports.nStartPortNumber + ports.nPorts; ++port) {
@@ -300,7 +335,7 @@ static int _omx_setup_input(struct omx_encoder_t *omx, struct device_t *dev) {
 
 	LOG_DEBUG("Setting up OMX JPEG input port ...");
 
-	if (component_get_portdef(&omx->encoder, &portdef, INPUT_PORT) < 0) {
+	if (component_get_portdef(&omx->encoder, &portdef, _INPUT_PORT) < 0) {
 		LOG_ERROR("... first");
 		return -1;
 	}
@@ -308,12 +343,10 @@ static int _omx_setup_input(struct omx_encoder_t *omx, struct device_t *dev) {
 	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.nSliceHeight = align_size(dev->run->height, 16);
 	portdef.format.image.bFlagErrorConcealment = OMX_FALSE;
 	portdef.format.image.eCompressionFormat = OMX_IMAGE_CodingUnused;
-	portdef.nBufferSize = dev->run->max_picture_size;
+	portdef.nBufferSize = picture_get_generous_size(dev->run->width, dev->run->height);
 
 #	define MAP_FORMAT(_v4l2_format, _omx_format) \
 		case _v4l2_format: { portdef.format.image.eColorFormat = _omx_format; break; }
@@ -329,7 +362,7 @@ static int _omx_setup_input(struct omx_encoder_t *omx, struct device_t *dev) {
 		// FIXME: RGB24 не работает нормально, нижняя половина экрана зеленая.
 		// FIXME: Китайский EasyCap тоже не работает, мусор на экране.
 		// Вероятно обе проблемы вызваны некорректной реализацией OMX на пае.
-		default: assert(0 && "Unsupported input format for OMX JPEG encoder");
+		default: assert(0 && "Unsupported input format for OMX encoder");
 	}
 
 #	undef MAP_FORMAT
@@ -338,18 +371,18 @@ static int _omx_setup_input(struct omx_encoder_t *omx, struct device_t *dev) {
 		return -1;
 	}
 
-	if (component_get_portdef(&omx->encoder, &portdef, INPUT_PORT) < 0) {
+	if (component_get_portdef(&omx->encoder, &portdef, _INPUT_PORT) < 0) {
 		LOG_ERROR("... second");
 		return -1;
 	}
 
-	if (component_enable_port(&omx->encoder, INPUT_PORT) < 0) {
+	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");
+	if ((error = OMX_AllocateBuffer(omx->encoder, &omx->input_buffer, _INPUT_PORT, NULL, portdef.nBufferSize)) != OMX_ErrorNone) {
+		LOG_ERROR_OMX(error, "Can't allocate OMX JPEG input buffer");
 		return -1;
 	}
 	return 0;
@@ -361,7 +394,7 @@ static int _omx_setup_output(struct omx_encoder_t *omx, unsigned quality) {
 
 	LOG_DEBUG("Setting up OMX JPEG output port ...");
 
-	if (component_get_portdef(&omx->encoder, &portdef, OUTPUT_PORT) < 0) {
+	if (component_get_portdef(&omx->encoder, &portdef, _OUTPUT_PORT) < 0) {
 		LOG_ERROR("... first");
 		return -1;
 	}
@@ -374,7 +407,7 @@ static int _omx_setup_output(struct omx_encoder_t *omx, unsigned quality) {
 		return -1;
 	}
 
-	if (component_get_portdef(&omx->encoder, &portdef, OUTPUT_PORT) < 0) {
+	if (component_get_portdef(&omx->encoder, &portdef, _OUTPUT_PORT) < 0) {
 		LOG_ERROR("... second");
 		return -1;
 	}
@@ -386,7 +419,7 @@ static int _omx_setup_output(struct omx_encoder_t *omx, unsigned quality) {
 		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");
+			LOG_ERROR_OMX(error, "Can't disable EXIF on OMX JPEG");
 			return -1;
 		}
 	}
@@ -395,11 +428,11 @@ static int _omx_setup_output(struct omx_encoder_t *omx, unsigned quality) {
 		OMX_PARAM_IJGSCALINGTYPE ijg;
 
 		OMX_INIT_STRUCTURE(ijg);
-		ijg.nPortIndex = OUTPUT_PORT;
+		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");
+			LOG_ERROR_OMX(error, "Can't set OMX JPEG IJG settings");
 			return -1;
 		}
 	}
@@ -408,22 +441,22 @@ static int _omx_setup_output(struct omx_encoder_t *omx, unsigned quality) {
 		OMX_IMAGE_PARAM_QFACTORTYPE qfactor;
 
 		OMX_INIT_STRUCTURE(qfactor);
-		qfactor.nPortIndex = OUTPUT_PORT;
+		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");
+			LOG_ERROR_OMX(error, "Can't set OMX JPEG quality");
 			return -1;
 		}
 	}
 
-	if (component_enable_port(&omx->encoder, OUTPUT_PORT) < 0) {
+	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");
+	if ((error = OMX_AllocateBuffer(omx->encoder, &omx->output_buffer, _OUTPUT_PORT, NULL, portdef.nBufferSize)) != OMX_ErrorNone) {
+		LOG_ERROR_OMX(error, "Can't allocate OMX JPEG output buffer");
 		return -1;
 	}
 	return 0;
@@ -431,32 +464,32 @@ static int _omx_setup_output(struct omx_encoder_t *omx, unsigned quality) {
 
 static int _omx_encoder_clear_ports(struct omx_encoder_t *omx) {
 	OMX_ERRORTYPE error;
-	int retcode = 0;
+	int retval = 0;
 
 	if (omx->i_output_port_enabled) {
-		retcode -= component_disable_port(&omx->encoder, OUTPUT_PORT);
+		retval -= 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);
+		retval -= 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;
+		if ((error = OMX_FreeBuffer(omx->encoder, _INPUT_PORT, omx->input_buffer)) != OMX_ErrorNone) {
+			LOG_ERROR_OMX(error, "Can't free OMX JPEG input buffer");
+			// retval -= 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;
+		if ((error = OMX_FreeBuffer(omx->encoder, _OUTPUT_PORT, omx->output_buffer)) != OMX_ErrorNone) {
+			LOG_ERROR_OMX(error, "Can't free OMX JPEG output buffer");
+			// retval -= 1;
 		}
 		omx->output_buffer = NULL;
 	}
-	return retcode;
+	return retval;
 }
 
 static OMX_ERRORTYPE _omx_event_handler(
@@ -469,9 +502,9 @@ static OMX_ERRORTYPE _omx_event_handler(
 	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");
+		LOG_ERROR_OMX((OMX_ERRORTYPE)data1, "OMX error event received");
 		omx->failed = true;
-		vcos_semaphore_post(&omx->handler_lock);
+		assert(vcos_semaphore_post(&omx->handler_sem) == VCOS_SUCCESS);
 	}
 	return OMX_ErrorNone;
 }
@@ -486,7 +519,7 @@ static OMX_ERRORTYPE _omx_input_required_handler(
 	struct omx_encoder_t *omx = (struct omx_encoder_t *)v_omx;
 
 	omx->input_required = true;
-	vcos_semaphore_post(&omx->handler_lock);
+	assert(vcos_semaphore_post(&omx->handler_sem) == VCOS_SUCCESS);
 	return OMX_ErrorNone;
 }
 
@@ -500,6 +533,6 @@ static OMX_ERRORTYPE _omx_output_available_handler(
 	struct omx_encoder_t *omx = (struct omx_encoder_t *)v_omx;
 
 	omx->output_available = true;
-	vcos_semaphore_post(&omx->handler_lock);
+	assert(vcos_semaphore_post(&omx->handler_sem) == VCOS_SUCCESS);
 	return OMX_ErrorNone;
 }

src/encoders/omx/encoder.h

@@ -29,9 +29,10 @@
 
 #include "../../device.h"
 
-#ifndef OMX_MAX_ENCODERS
-#	define OMX_MAX_ENCODERS 3 // Raspberry Pi limitation
+#ifndef CFG_OMX_MAX_ENCODERS
+#	define CFG_OMX_MAX_ENCODERS 3 // Raspberry Pi limitation
 #endif
+#define OMX_MAX_ENCODERS ((unsigned)(CFG_OMX_MAX_ENCODERS))
 
 
 struct omx_encoder_t {
@@ -41,17 +42,17 @@ struct omx_encoder_t {
 	bool					input_required;
 	bool					output_available;
 	bool					failed;
-	VCOS_SEMAPHORE_T		handler_lock;
+	VCOS_SEMAPHORE_T		handler_sem;
 
-	bool	i_handler_lock;
+	bool	i_handler_sem;
 	bool	i_encoder;
 	bool	i_input_port_enabled;
 	bool	i_output_port_enabled;
 };
 
 
-struct omx_encoder_t *omx_encoder_init();
+struct omx_encoder_t *omx_encoder_init(void);
 void omx_encoder_destroy(struct omx_encoder_t *omx);
 
-int omx_encoder_prepare_live(struct omx_encoder_t *omx, struct device_t *dev, unsigned quality);
+int omx_encoder_prepare(struct omx_encoder_t *omx, struct device_t *dev, unsigned quality);
 int omx_encoder_compress_buffer(struct omx_encoder_t *omx, struct device_t *dev, unsigned index);

src/encoders/omx/formatters.c

@@ -20,6 +20,8 @@
 *****************************************************************************/
 
 
+#include "formatters.h"
+
 #include <stdio.h>
 #include <assert.h>
 
@@ -27,16 +29,15 @@
 #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); \
+		char *_assert_buf; A_CALLOC(_assert_buf, 128); \
+		sprintf(_assert_buf, _msg ": 0x%08x", _value); \
+		assert(0 && _assert_buf); \
 	}
 
 const char *omx_error_to_string(OMX_ERRORTYPE error) {
@@ -66,15 +67,40 @@ const char *omx_error_to_string(OMX_ERRORTYPE error) {
 		CASE_TO_STRING(OMX_ErrorPortUnresponsiveDuringDeallocation);
 		CASE_TO_STRING(OMX_ErrorPortUnresponsiveDuringStop);
 		CASE_TO_STRING(OMX_ErrorIncorrectStateTransition);
+		CASE_TO_STRING(OMX_ErrorIncorrectStateOperation);
+		CASE_TO_STRING(OMX_ErrorUnsupportedSetting);
+		CASE_TO_STRING(OMX_ErrorUnsupportedIndex);
+		CASE_TO_STRING(OMX_ErrorBadPortIndex);
+		CASE_TO_STRING(OMX_ErrorPortUnpopulated);
+		CASE_TO_STRING(OMX_ErrorComponentSuspended);
+		CASE_TO_STRING(OMX_ErrorDynamicResourcesUnavailable);
+		CASE_TO_STRING(OMX_ErrorMbErrorsInFrame);
+		CASE_TO_STRING(OMX_ErrorFormatNotDetected);
+		CASE_TO_STRING(OMX_ErrorContentPipeOpenFailed);
+		CASE_TO_STRING(OMX_ErrorContentPipeCreationFailed);
+		CASE_TO_STRING(OMX_ErrorSeperateTablesUsed);
+		CASE_TO_STRING(OMX_ErrorTunnelingUnsupported);
+		CASE_TO_STRING(OMX_ErrorKhronosExtensions);
+		CASE_TO_STRING(OMX_ErrorVendorStartUnused);
+		CASE_TO_STRING(OMX_ErrorDiskFull);
+		CASE_TO_STRING(OMX_ErrorMaxFileSize);
+		CASE_TO_STRING(OMX_ErrorDrmUnauthorised);
+		CASE_TO_STRING(OMX_ErrorDrmExpired);
+		CASE_TO_STRING(OMX_ErrorDrmGeneral);
 		default: return "Unknown OMX error";
 	}
 }
 
 const char *omx_state_to_string(OMX_STATETYPE state) {
 	switch (state) {
+		CASE_TO_STRING(OMX_StateInvalid);
 		CASE_TO_STRING(OMX_StateLoaded);
 		CASE_TO_STRING(OMX_StateIdle);
 		CASE_TO_STRING(OMX_StateExecuting);
+		CASE_TO_STRING(OMX_StatePause);
+		CASE_TO_STRING(OMX_StateWaitForResources);
+		// cppcheck-suppress constArgument
+		// cppcheck-suppress knownArgument
 		CASE_ASSERT("Unsupported OMX state", state);
 	}
 }

src/encoders/omx/formatters.h

@@ -22,23 +22,15 @@
 
 #pragma once
 
-#include <stdio.h>
-
-#include <sys/syscall.h>
-
 #include <IL/OMX_IVCommon.h>
 #include <IL/OMX_Core.h>
 #include <IL/OMX_Image.h>
 
 #include "../../logging.h"
-#include "../../tools.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; \
+#define LOG_ERROR_OMX(_error, _msg, ...) { \
+		LOG_ERROR(_msg ": %s", ##__VA_ARGS__, omx_error_to_string(_error)); \
 	}
 
 

src/gpio/gpio.c

@@ -0,0 +1,142 @@
+/*****************************************************************************
+#                                                                            #
+#    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 "gpio.h"
+
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include <assert.h>
+
+#include <pthread.h>
+#include <gpiod.h>
+
+#include "../tools.h"
+#include "../logging.h"
+#include "../threading.h"
+
+
+struct gpio_t gpio = {
+	.path = "/dev/gpiochip0",
+	.consumer_prefix = "ustreamer",
+
+#	define MAKE_OUTPUT(_role) { \
+		.pin = -1, \
+		.role = _role, \
+		.consumer = NULL, \
+		.line = NULL, \
+		.state = false \
+	}
+
+	.prog_running = MAKE_OUTPUT("prog-running"),
+	.stream_online = MAKE_OUTPUT("stream-online"),
+	.has_http_clients = MAKE_OUTPUT("has-http-clients"),
+
+#	undef MAKE_OUTPUT
+
+	// mutex uninitialized
+	.chip = NULL
+};
+
+
+static void _gpio_output_init(struct gpio_output_t *output);
+static void _gpio_output_destroy(struct gpio_output_t *output);
+
+
+void gpio_init(void) {
+	assert(gpio.chip == NULL);
+	if (
+		gpio.prog_running.pin >= 0
+		|| gpio.stream_online.pin >= 0
+		|| gpio.has_http_clients.pin >= 0
+	) {
+		A_MUTEX_INIT(&gpio.mutex);
+		LOG_INFO("GPIO: Using chip device: %s", gpio.path);
+		if ((gpio.chip = gpiod_chip_open(gpio.path)) != NULL) {
+			_gpio_output_init(&gpio.prog_running);
+			_gpio_output_init(&gpio.stream_online);
+			_gpio_output_init(&gpio.has_http_clients);
+		} else {
+			LOG_PERROR("GPIO: Can't initialize chip device %s", gpio.path);
+		}
+	}
+}
+
+void gpio_destroy(void) {
+	_gpio_output_destroy(&gpio.prog_running);
+	_gpio_output_destroy(&gpio.stream_online);
+	_gpio_output_destroy(&gpio.has_http_clients);
+	if (gpio.chip) {
+		gpiod_chip_close(gpio.chip);
+		gpio.chip = NULL;
+		A_MUTEX_DESTROY(&gpio.mutex);
+	}
+}
+
+int gpio_inner_set(struct gpio_output_t *output, bool state) {
+	int retval = 0;
+
+	assert(gpio.chip);
+	assert(output->line);
+	assert(output->state != state); // Must be checked in macro for the performance
+	A_MUTEX_LOCK(&gpio.mutex);
+
+	if (gpiod_line_set_value(output->line, (int)state) < 0) { \
+		LOG_PERROR("GPIO: Can't write value %d to line %s (will be disabled)", state, output->consumer); \
+		_gpio_output_destroy(output);
+		retval = -1;
+	}
+
+	A_MUTEX_UNLOCK(&gpio.mutex);
+	return retval;
+}
+
+static void _gpio_output_init(struct gpio_output_t *output) {
+	assert(gpio.chip);
+	assert(output->line == NULL);
+
+	A_CALLOC(output->consumer, strlen(gpio.consumer_prefix) + strlen(output->role) + 16);
+	sprintf(output->consumer, "%s::%s", gpio.consumer_prefix, output->role);
+
+	if (output->pin >= 0) {
+		if ((output->line = gpiod_chip_get_line(gpio.chip, output->pin)) != NULL) {
+			if (gpiod_line_request_output(output->line, output->consumer, 0) < 0) {
+				LOG_PERROR("GPIO: Can't request pin=%d as %s", output->pin, output->consumer);
+				_gpio_output_destroy(output);
+			}
+		} else {
+			LOG_PERROR("GPIO: Can't get pin=%d as %s", output->pin, output->consumer);
+		}
+	}
+}
+
+static void _gpio_output_destroy(struct gpio_output_t *output) {
+	if (output->line) {
+		gpiod_line_release(output->line);
+		output->line = NULL;
+	}
+	if (output->consumer) {
+		free(output->consumer);
+		output->consumer = NULL;
+	}
+	output->state = false;
+}

src/gpio/gpio.h

@@ -0,0 +1,83 @@
+/*****************************************************************************
+#                                                                            #
+#    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 <stdbool.h>
+
+#include <pthread.h>
+#include <gpiod.h>
+
+#include "../tools.h"
+#include "../logging.h"
+
+
+struct gpio_output_t {
+	int					pin;
+	const char			*role;
+	char 				*consumer;
+	struct gpiod_line	*line;
+	bool				state;
+};
+
+struct gpio_t {
+	char *path;
+	char *consumer_prefix;
+
+	struct gpio_output_t prog_running;
+	struct gpio_output_t stream_online;
+	struct gpio_output_t has_http_clients;
+
+	pthread_mutex_t		mutex;
+	struct gpiod_chip	*chip;
+};
+
+
+extern struct gpio_t gpio;
+
+
+void gpio_init(void);
+void gpio_destroy(void);
+int gpio_inner_set(struct gpio_output_t *output, bool state);
+
+
+#define SET_STATE(_output, _state) { \
+		if (_output.line && _output.state != _state) { \
+			if (!gpio_inner_set(&_output, _state)) { \
+				_output.state = _state; \
+			} \
+		} \
+	}
+
+INLINE void gpio_set_prog_running(bool state) {
+	SET_STATE(gpio.prog_running, state);
+}
+
+INLINE void gpio_set_stream_online(bool state) {
+	SET_STATE(gpio.stream_online, state);
+}
+
+INLINE void gpio_set_has_http_clients(bool state) {
+	SET_STATE(gpio.has_http_clients, state);
+}
+
+#undef SET_STATE

src/http/base64.c

@@ -0,0 +1,71 @@
+/*****************************************************************************
+#                                                                            #
+#    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 "base64.h"
+
+#include <stdlib.h>
+#include <string.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 unsigned _MOD_TABLE[] = {0, 2, 1};
+
+
+char *base64_encode(const unsigned char *str) {
+	size_t str_len = strlen((const char *)str);
+	size_t encoded_size = 4 * ((str_len + 2) / 3) + 1; // +1 for '\0'
+	char *encoded;
+
+	A_CALLOC(encoded, encoded_size);
+
+	for (unsigned str_index = 0, encoded_index = 0; str_index < str_len;) {
+		unsigned octet_a = (str_index < str_len ? (unsigned char)str[str_index++] : 0);
+		unsigned octet_b = (str_index < str_len ? (unsigned char)str[str_index++] : 0);
+		unsigned octet_c = (str_index < str_len ? (unsigned char)str[str_index++] : 0);
+
+		unsigned triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;
+
+		encoded[encoded_index++] = _ENCODING_TABLE[(triple >> 3 * 6) & 0x3F];
+		encoded[encoded_index++] = _ENCODING_TABLE[(triple >> 2 * 6) & 0x3F];
+		encoded[encoded_index++] = _ENCODING_TABLE[(triple >> 1 * 6) & 0x3F];
+		encoded[encoded_index++] = _ENCODING_TABLE[(triple >> 0 * 6) & 0x3F];
+	}
+
+	for (unsigned index = 0; index < _MOD_TABLE[str_len % 3]; index++) {
+		encoded[encoded_size - 2 - index] = '=';
+	}
+
+	encoded[encoded_size - 1] = '\0';
+	return encoded;
+}

src/http/base64.h

@@ -0,0 +1,26 @@
+/*****************************************************************************
+#                                                                            #
+#    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
+
+
+char *base64_encode(const unsigned char *str);

src/http/blank.c

@@ -0,0 +1,161 @@
+/*****************************************************************************
+#                                                                            #
+#    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 "blank.h"
+
+#include <stdio.h>
+#include <stdbool.h>
+#include <setjmp.h>
+
+#include <jpeglib.h>
+
+#include "../tools.h"
+#include "../logging.h"
+#include "../picture.h"
+
+#include "data/blank_jpeg.h"
+
+
+struct _jpeg_error_manager_t {
+	struct jpeg_error_mgr	mgr; // Default manager
+	jmp_buf					jmp;
+};
+
+
+static struct picture_t *_init_internal(void);
+static struct picture_t *_init_external(const char *path);
+
+static int _jpeg_read_geometry(FILE *fp, unsigned *width, unsigned *height);
+static void _jpeg_error_handler(j_common_ptr jpeg);
+
+
+struct picture_t *blank_picture_init(const char *path) {
+	struct picture_t *blank = NULL;
+
+	if (path) {
+		blank = _init_external(path);
+	}
+
+	if (blank) {
+		LOG_INFO("Using external blank placeholder: %s", path);
+	} else {
+		blank = _init_internal();
+		LOG_INFO("Using internal blank placeholder");
+	}
+	return blank;
+}
+
+static struct picture_t *_init_internal(void) {
+	struct picture_t *blank;
+
+	blank = picture_init();
+	picture_set_data(blank, BLANK_JPEG_DATA, ARRAY_LEN(BLANK_JPEG_DATA));
+	blank->width = BLANK_JPEG_WIDTH;
+	blank->height = BLANK_JPEG_HEIGHT;
+	return blank;
+}
+
+static struct picture_t *_init_external(const char *path) {
+	FILE *fp = NULL;
+	struct picture_t *blank;
+
+	blank = picture_init();
+
+	if ((fp = fopen(path, "rb")) == NULL) {
+		LOG_PERROR("Can't open blank placeholder '%s'", path);
+		goto error;
+	}
+
+	if (_jpeg_read_geometry(fp, &blank->width, &blank->height) < 0) {
+		goto error;
+	}
+
+	if (fseek(fp, 0, SEEK_SET) < 0) {
+		LOG_PERROR("Can't seek to begin of the blank placeholder");
+		goto error;
+	}
+
+#	define CHUNK_SIZE ((size_t)(100 * 1024))
+	while (true) {
+		if (blank->used + CHUNK_SIZE >= blank->allocated) {
+			picture_realloc_data(blank, blank->used + CHUNK_SIZE * 2);
+		}
+
+		size_t readed = fread(blank->data + blank->used, 1, CHUNK_SIZE, fp);
+		blank->used += readed;
+
+		if (readed < CHUNK_SIZE) {
+			if (feof(fp)) {
+				goto ok;
+			} else {
+				LOG_PERROR("Can't read blank placeholder");
+				goto error;
+			}
+		}
+	}
+#	undef CHUNK_SIZE
+
+	error:
+		picture_destroy(blank);
+		blank = NULL;
+
+	ok:
+		if (fp) {
+			fclose(fp);
+		}
+
+	return blank;
+}
+
+static int _jpeg_read_geometry(FILE *fp, unsigned *width, unsigned *height) {
+	struct jpeg_decompress_struct jpeg;
+	struct _jpeg_error_manager_t jpeg_error;
+
+	jpeg_create_decompress(&jpeg);
+
+	// https://stackoverflow.com/questions/19857766/error-handling-in-libjpeg
+	jpeg.err = jpeg_std_error((struct jpeg_error_mgr *)&jpeg_error);
+	jpeg_error.mgr.error_exit = _jpeg_error_handler;
+	if (setjmp(jpeg_error.jmp) < 0) {
+		jpeg_destroy_decompress(&jpeg);
+		return -1;
+	}
+
+	jpeg_stdio_src(&jpeg, fp);
+	jpeg_read_header(&jpeg, TRUE);
+	jpeg_start_decompress(&jpeg);
+
+	*width = jpeg.output_width;
+	*height = jpeg.output_height;
+
+	jpeg_destroy_decompress(&jpeg);
+	return 0;
+}
+
+static void _jpeg_error_handler(j_common_ptr jpeg) {
+	struct _jpeg_error_manager_t *jpeg_error = (struct _jpeg_error_manager_t *)jpeg->err;
+	char msg[JMSG_LENGTH_MAX];
+
+	(*jpeg_error->mgr.format_message)(jpeg, msg);
+	LOG_ERROR("Invalid blank placeholder: %s", msg);
+	longjmp(jpeg_error->jmp, -1);
+}

src/http/blank.h

@@ -0,0 +1,28 @@
+/*****************************************************************************
+#                                                                            #
+#    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 "../picture.h"
+
+
+struct picture_t *blank_picture_init(const char *path);

src/http/data/blank_jpeg.h

@@ -0,0 +1,723 @@
+/*****************************************************************************
+#                                                                            #
+#    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
+
+
+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/http/data/index.html

@@ -0,0 +1,70 @@
+<!DOCTYPE html>
+
+<html>
+<head>
+	<meta charset="utf-8" />
+	<title>uStreamer</title>
+	<style>body {font-family: monospace;}</style>
+</head>
+
+<body>
+	<h3>&micro;Streamer v%VERSION%</h3>
+	<hr>
+	<ul>
+		<li>
+			<a href="/state"><b>/state</b></a><br>
+			Get JSON structure with the state of the server.
+		</li>
+		<br>
+		<li>
+			<a href="/snapshot"><b>/snapshot</b></a><br>
+			Get a current actual image from the server.
+		</li>
+		<br>
+		<li>
+			<a href="/stream"><b>/stream</b></a><br>
+			Get a live stream. Query params:<br>
+			<br>
+			<ul>
+				<li>
+					<b>key=abc123</b><br>
+					The user-defined key, which is part of cookie <i>stream_client</i>, which allows<br>
+					the stream client to determine its identifier and view statistics using <a href="/state">/state</a>.
+				</li>
+				<br>
+				<li>
+					<b>extra_headers=1</b><br>
+					Add <i>X-UStreamer-*</i> headers to the <a href="/stream">/stream</a> handle
+					(like with the <a href="/snapshot">/snapshot</a>).
+				</li>
+				<br>
+				<li>
+					<b>advance_headers=1</b><br>
+					Enable workaround for the Chromium/Blink bug
+					<a href="https://bugs.chromium.org/p/chromium/issues/detail?id=527446">#527446</a>.
+				</li>
+				<br>
+				<li>
+					<b>dual_final_frames=1</b><br>
+					Enable workaround for the Safari/WebKit bug when using option <i>--drop-same-frames</i>.<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>
+		<li>
+			The mjpg-streamer compatibility layer:<br>
+			<br>
+			<ul>
+				<li><a href="/?action=snapshot">/?action=snapshot</a> as alias to the <a href="/snapshot">/snapshot</a>.</li>
+				<br>
+				<li><a href="/?action=stream">/?action=stream</a> as alias to the <a href="/stream">/stream</a>.</li>
+			</ul>
+		</li>
+	</ul>
+	<br>
+	<hr>
+	<a href="https://github.com/pikvm/ustreamer">Sources &amp; docs</a>
+</body>
+</html>

src/http/data/index_html.h

@@ -22,7 +22,7 @@
 
 #pragma once
 
-#include "../config.h"
+#include "../../config.h"
 
 
 const char HTML_INDEX_PAGE[] = " \
@@ -32,6 +32,7 @@ const char HTML_INDEX_PAGE[] = " \
 	<head> \
 		<meta charset=\"utf-8\" /> \
 		<title>uStreamer</title> \
+		<style>body {font-family: monospace;}</style> \
 	</head> \
 	\
 	<body> \
@@ -39,50 +40,60 @@ const char HTML_INDEX_PAGE[] = " \
 		<hr> \
 		<ul> \
 			<li> \
-				<a href=\"/state\"><b><samp>/state</samp></b></a><br> \
-				Get JSON structure with state of the server. \
+				<a href=\"/state\"><b>/state</b></a><br> \
+				Get JSON structure with the state of the server. \
 			</li> \
 			<br> \
 			<li> \
-				<a href=\"/snapshot\"><b><samp>/snapshot</samp></b></a><br> \
+				<a href=\"/snapshot\"><b>/snapshot</b></a><br> \
 				Get a current actual image from the server. \
 			</li> \
 			<br> \
 			<li> \
-				<a href=\"/stream\"><b><samp>/stream</samp></b></a><br> \
+				<a href=\"/stream\"><b>/stream</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>. \
+						<b>key=abc123</b><br> \
+						The user-defined key, which is part of cookie <i>stream_client</i>, which allows<br> \
+						the stream client to determine its identifier and view statistics using <a href=\"/state\">/state</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>). \
+						<b>extra_headers=1</b><br> \
+						Add <i>X-UStreamer-*</i> headers to the <a href=\"/stream\">/stream</a> handle \
+						(like with the <a href=\"/snapshot\">/snapshot</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>. \
+						<b>advance_headers=1</b><br> \
+						Enable workaround for the Chromium/Blink bug \
+						<a href=\"https://bugs.chromium.org/p/chromium/issues/detail?id=527446\">#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> \
+						<b>dual_final_frames=1</b><br> \
+						Enable workaround for the Safari/WebKit bug when using option <i>--drop-same-frames</i>.<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> \
+			<li> \
+				The mjpg-streamer compatibility layer:<br> \
+				<br> \
+				<ul> \
+					<li><a href=\"/?action=snapshot\">/?action=snapshot</a> as alias to the <a href=\"/snapshot\">/snapshot</a>.</li> \
+					<br> \
+					<li><a href=\"/?action=stream\">/?action=stream</a> as alias to the <a href=\"/stream\">/stream</a>.</li> \
+				</ul> \
+			</li> \
 		</ul> \
 		<br> \
 		<hr> \
-		<a href=\"https://github.com/pi-kvm/ustreamer\">Sources &amp; docs</a> \
+		<a href=\"https://github.com/pikvm/ustreamer\">Sources &amp; docs</a> \
 	</body> \
 	</html> \
 ";

src/http/mime.c

@@ -0,0 +1,73 @@
+/*****************************************************************************
+#                                                                            #
+#    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 "mime.h"
+
+#include <string.h>
+
+#include <event2/util.h>
+
+#include "../tools.h"
+
+
+static const struct {
+	const char *ext;
+	const char *mime;
+} _MIME_TYPES[] = {
+	{"html",	"text/html"},
+	{"htm",		"text/html"},
+	{"css",		"text/css"},
+	{"js",		"text/javascript"},
+	{"txt",		"text/plain"},
+	{"jpg",		"image/jpeg"},
+	{"jpeg",	"image/jpeg"},
+	{"png",		"image/png"},
+	{"gif",		"image/gif"},
+	{"ico",		"image/x-icon"},
+	{"bmp",		"image/bmp"},
+	{"svg",		"image/svg+xml"},
+	{"swf",		"application/x-shockwave-flash"},
+	{"cab",		"application/x-shockwave-flash"},
+	{"jar",		"application/java-archive"},
+	{"json",	"application/json"},
+};
+
+
+const char *guess_mime_type(const char *path) {
+	char *dot;
+	char *ext;
+
+	dot = strrchr(path, '.');
+	if (dot == NULL || strchr(dot, '/') != NULL) {
+		goto misc;
+	}
+
+	ext = dot + 1;
+	for (unsigned index = 0; index < ARRAY_LEN(_MIME_TYPES); ++index) {
+		if (!evutil_ascii_strcasecmp(ext, _MIME_TYPES[index].ext)) {
+			return _MIME_TYPES[index].mime;
+		}
+	}
+
+	misc:
+		return "application/misc";
+}

src/http/mime.h

@@ -0,0 +1,26 @@
+/*****************************************************************************
+#                                                                            #
+#    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
+
+
+const char *guess_mime_type(const char *str);

src/http/path.c

@@ -0,0 +1,184 @@
+/*****************************************************************************
+#                                                                            #
+#    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 "path.h"
+
+#ifdef TEST_HTTP_PATH
+#	include <stdio.h>
+#	include <stdlib.h>
+#endif
+#include <string.h>
+
+#include "../tools.h"
+
+
+char *simplify_request_path(const char *str) {
+	// Based on Lighttpd sources:
+	//   - https://github.com/lighttpd/lighttpd1.4/blob/b31e7840d5403bc640579135b7004793b9ccd6c0/src/buffer.c#L840
+	//   - https://github.com/lighttpd/lighttpd1.4/blob/77c01f981725512653c01cde5ca74c11633dfec4/src/t/test_buffer.c
+
+	char ch; // Current character
+	char pre1; // The one before
+	char pre2; // The one before that
+	char *simplified;
+	char *start;
+	char *out;
+	char *slash;
+
+	A_CALLOC(simplified, strlen(str) + 1);
+
+	if (str[0] == '\0') {
+		simplified[0] = '\0';
+		return simplified;
+	}
+
+	start = simplified;
+	out = simplified;
+	slash = simplified;
+
+	// Skip leading spaces
+	for (; *str == ' '; ++str);
+
+	if (*str == '.') {
+		if (str[1] == '/' || str[1] == '\0') {
+			++str;
+		} else if (str[1] == '.' && (str[2] == '/' || str[2] == '\0')) {
+			str += 2;
+		}
+	}
+
+	pre1 = '\0';
+	ch = *(str++);
+
+	while (ch != '\0') {
+		pre2 = pre1;
+		pre1 = ch;
+
+		// Possibly: out == str - need to read first
+		ch = *str;
+		*out = pre1;
+
+		out++;
+		str++;
+		// (out <= str) still true; also now (slash < out)
+
+		if (ch == '/' || ch == '\0') {
+			size_t toklen = out - slash;
+
+			if (toklen == 3 && pre2 == '.' && pre1 == '.' && *slash == '/') {
+				// "/../" or ("/.." at end of string)
+				out = slash;
+				// If there is something before "/..", there is at least one
+				// component, which needs to be removed
+				if (out > start) {
+					--out;
+					for (; out > start && *out != '/'; --out);
+				}
+
+				// Don't kill trailing '/' at end of path
+				if (ch == '\0') {
+					++out;
+				}
+				// slash < out before, so out_new <= slash + 1 <= out_before <= str
+			} else if (toklen == 1 || (pre2 == '/' && pre1 == '.')) {
+				// "//" or "/./" or (("/" or "/.") at end of string)
+				out = slash;
+				// Don't kill trailing '/' at end of path
+				if (ch == '\0') {
+					++out;
+				}
+				// Slash < out before, so out_new <= slash + 1 <= out_before <= str
+			}
+
+			slash = out;
+		}
+	}
+
+	*out = '\0';
+	return simplified;
+}
+
+#ifdef TEST_HTTP_PATH
+
+int test_simplify_request_path(const char *sample, const char *expected) {
+	char *result = simplify_request_path(sample);
+	int retval = -!!strcmp(result, expected);
+
+	printf("Testing '%s' -> '%s' ... ", sample, expected);
+	if (retval == 0) {
+		printf("ok\n");
+	} else {
+		printf("FAILED; got '%s'\n", result);
+	}
+	free(result);
+	return retval;
+}
+
+int main(void) {
+	int retval = 0;
+
+#	define TEST_SIMPLIFY_REQUEST_PATH(_sample, _expected) { \
+			retval += test_simplify_request_path(_sample, _expected); \
+		}
+
+	TEST_SIMPLIFY_REQUEST_PATH("", "");
+	TEST_SIMPLIFY_REQUEST_PATH("   ", "");
+	TEST_SIMPLIFY_REQUEST_PATH("/", "/");
+	TEST_SIMPLIFY_REQUEST_PATH("//", "/");
+	TEST_SIMPLIFY_REQUEST_PATH("abc", "abc");
+	TEST_SIMPLIFY_REQUEST_PATH("abc//", "abc/");
+	TEST_SIMPLIFY_REQUEST_PATH("abc/./xyz", "abc/xyz");
+	TEST_SIMPLIFY_REQUEST_PATH("abc/.//xyz", "abc/xyz");
+	TEST_SIMPLIFY_REQUEST_PATH("abc/../xyz", "/xyz");
+	TEST_SIMPLIFY_REQUEST_PATH("/abc/./xyz", "/abc/xyz");
+	TEST_SIMPLIFY_REQUEST_PATH("/abc//./xyz", "/abc/xyz");
+	TEST_SIMPLIFY_REQUEST_PATH("/abc/../xyz", "/xyz");
+	TEST_SIMPLIFY_REQUEST_PATH("abc/../xyz/.", "/xyz/");
+	TEST_SIMPLIFY_REQUEST_PATH("/abc/../xyz/.", "/xyz/");
+	TEST_SIMPLIFY_REQUEST_PATH("abc/./xyz/..", "abc/");
+	TEST_SIMPLIFY_REQUEST_PATH("/abc/./xyz/..", "/abc/");
+	TEST_SIMPLIFY_REQUEST_PATH(".", "");
+	TEST_SIMPLIFY_REQUEST_PATH("..", "");
+	TEST_SIMPLIFY_REQUEST_PATH("...", "...");
+	TEST_SIMPLIFY_REQUEST_PATH("....", "....");
+	TEST_SIMPLIFY_REQUEST_PATH(".../", ".../");
+	TEST_SIMPLIFY_REQUEST_PATH("./xyz/..", "/");
+	TEST_SIMPLIFY_REQUEST_PATH(".//xyz/..", "/");
+	TEST_SIMPLIFY_REQUEST_PATH("/./xyz/..", "/");
+	TEST_SIMPLIFY_REQUEST_PATH(".././xyz/..", "/");
+	TEST_SIMPLIFY_REQUEST_PATH("/.././xyz/..", "/");
+	TEST_SIMPLIFY_REQUEST_PATH("/.././xyz/..", "/");
+	TEST_SIMPLIFY_REQUEST_PATH("../../../etc/passwd", "/etc/passwd");
+	TEST_SIMPLIFY_REQUEST_PATH("/../../../etc/passwd", "/etc/passwd");
+	TEST_SIMPLIFY_REQUEST_PATH("   ../../../etc/passwd", "/etc/passwd");
+	TEST_SIMPLIFY_REQUEST_PATH("   /../../../etc/passwd", "/etc/passwd");
+	TEST_SIMPLIFY_REQUEST_PATH("   /foo/bar/../../../etc/passwd", "/etc/passwd");
+
+#	undef TEST_SIMPLIFY_REQUEST_PATH
+
+	if (retval < 0) {
+		printf("===== TEST FAILED =====\n");
+	}
+	return retval;
+}
+
+#endif

src/http/path.h

@@ -0,0 +1,26 @@
+/*****************************************************************************
+#                                                                            #
+#    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
+
+
+char *simplify_request_path(const char *str);

src/http/server.c

@@ -20,17 +20,23 @@
 *****************************************************************************/
 
 
+#include "server.h"
+
+#include <stdio.h>
 #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/types.h>
 #include <sys/stat.h>
+#include <sys/time.h>
+#include <netinet/tcp.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
 
 #include <event2/event.h>
 #include <event2/thread.h>
@@ -45,20 +51,31 @@
 #	error Required libevent-pthreads support
 #endif
 
-#include "tools.h"
-#include "logging.h"
-#include "encoder.h"
-#include "stream.h"
-#include "http.h"
+#include "../tools.h"
+#include "../threading.h"
+#include "../logging.h"
+#include "../process.h"
+#include "../picture.h"
+#include "../encoder.h"
+#include "../stream.h"
+#ifdef WITH_GPIO
+#	include "../gpio/gpio.h"
+#endif
+
+#include "unix.h"
+#include "uri.h"
+#include "base64.h"
+#include "mime.h"
+#include "static.h"
+#include "blank.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 int _http_preprocess_request(struct evhttp_request *request, struct http_server_t *server);
 
-static void _http_callback_root(struct evhttp_request *request, void *arg);
+static void _http_callback_root(struct evhttp_request *request, void *v_server);
+static void _http_callback_static(struct evhttp_request *request, void *v_server);
 static void _http_callback_state(struct evhttp_request *request, void *v_server);
 static void _http_callback_snapshot(struct evhttp_request *request, void *v_server);
 
@@ -69,9 +86,11 @@ static void _http_callback_stream_error(struct bufferevent *buf_event, short wha
 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_new_picture_unsafe(struct http_server_t *server);
 static bool _expose_blank_picture(struct http_server_t *server);
 
+static void _format_bufferevent_reason(short what, char *reason);
+
 
 struct http_server_t *http_server_init(struct stream_t *stream) {
 	struct http_server_runtime_t *run;
@@ -79,6 +98,7 @@ struct http_server_t *http_server_init(struct stream_t *stream) {
 	struct exposed_t *exposed;
 
 	A_CALLOC(exposed, 1);
+	exposed->picture = picture_init();
 
 	A_CALLOC(run, 1);
 	run->stream = stream;
@@ -88,21 +108,19 @@ struct http_server_t *http_server_init(struct stream_t *stream) {
 	A_CALLOC(server, 1);
 	server->host = "127.0.0.1";
 	server->port = 8080;
+	server->unix_path = "";
+	server->user = "";
+	server->passwd = "";
+	server->static_path = "";
+	server->allow_origin = "";
 	server->timeout = 10;
+	server->last_as_blank = -1;
 	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;
 }
 
@@ -117,7 +135,10 @@ void http_server_destroy(struct http_server_t *server) {
 		close(server->run->unix_fd);
 	}
 	event_base_free(server->run->base);
+
+#	if LIBEVENT_VERSION_NUMBER >= 0x02010100
 	libevent_global_shutdown();
+#	endif
 
 	for (struct stream_client_t *client = server->run->stream_clients; client != NULL;) {
 		struct stream_client_t *next = client->next;
@@ -127,25 +148,60 @@ void http_server_destroy(struct http_server_t *server) {
 		client = next;
 	}
 
-	free(server->run->exposed->picture.data);
+	if (server->run->auth_token) {
+		free(server->run->auth_token);
+	}
+
+	if (server->run->blank) {
+		picture_destroy(server->run->blank);
+	}
+
+	picture_destroy(server->run->exposed->picture);
 	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
+	{
+		if (server->static_path[0] != '\0') {
+			LOG_INFO("Enabling HTTP file server: %s", server->static_path);
+			evhttp_set_gencb(server->run->http, _http_callback_static, (void *)server);
+		} else {
+			assert(!evhttp_set_cb(server->run->http, "/", _http_callback_root, (void *)server));
+		}
+		assert(!evhttp_set_cb(server->run->http, "/state", _http_callback_state, (void *)server));
+		assert(!evhttp_set_cb(server->run->http, "/snapshot", _http_callback_snapshot, (void *)server));
+		assert(!evhttp_set_cb(server->run->http, "/stream", _http_callback_stream, (void *)server));
 	}
-	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);
+	server->run->blank = blank_picture_init(server->blank_path);
+
+#	define EXPOSED(_next) server->run->exposed->_next
+	// See _expose_blank_picture()
+	picture_copy(server->run->blank, EXPOSED(picture));
+	EXPOSED(expose_begin_ts) = get_now_monotonic();
+	EXPOSED(expose_cmp_ts) = EXPOSED(expose_begin_ts);
+	EXPOSED(expose_end_ts) = EXPOSED(expose_begin_ts);
+	// See _http_exposed_refresh()
+	EXPOSED(notify_last_width) = EXPOSED(picture->width);
+	EXPOSED(notify_last_height) = EXPOSED(picture->height);
+#	undef EXPOSED
+
+	{
+		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));
+	}
 
 	if (server->slowdown) {
 		stream_switch_slowdown(server->run->stream, true);
@@ -153,46 +209,36 @@ int http_server_listen(struct http_server_t *server) {
 
 	evhttp_set_timeout(server->run->http, server->timeout);
 
-	if (server->unix_path) {
-		struct sockaddr_un unix_addr;
-		int unix_fd_flags;
+	if (server->user[0] != '\0') {
+		char *raw_token;
+		char *encoded_token;
 
+		A_CALLOC(raw_token, strlen(server->user) + strlen(server->passwd) + 2);
+		sprintf(raw_token, "%s:%s", server->user, server->passwd);
+		encoded_token = base64_encode((unsigned char *)raw_token);
+		free(raw_token);
+
+		A_CALLOC(server->run->auth_token, strlen(encoded_token) + 16);
+		sprintf(server->run->auth_token, "Basic %s", encoded_token);
+		free(encoded_token);
+
+		LOG_INFO("Using HTTP basic auth");
+	}
+
+	if (server->unix_path[0] != '\0') {
 		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);
+		if ((server->run->unix_fd = evhttp_my_bind_unix(
+			server->run->http,
+			server->unix_path,
+			server->unix_rm,
+			server->unix_mode)) < 0
+		) {
 			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);
-
+		if (server->tcp_nodelay) {
+			LOG_ERROR("TCP_NODELAY flag can't be used with UNIX socket and will be ignored");
+		}
 	} else {
 		LOG_DEBUG("Binding HTTP to [%s]:%u ...", server->host, server->port);
 		if (evhttp_bind_socket(server->run->http, server->host, server->port) < 0) {
@@ -215,47 +261,131 @@ 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); \
+static int _http_preprocess_request(struct evhttp_request *request, struct http_server_t *server) {
+	if (server->run->auth_token) {
+		const char *token = evhttp_find_header(evhttp_request_get_input_headers(request), "Authorization");
+
+		if (token == NULL || strcmp(token, server->run->auth_token) != 0) {
+			ADD_HEADER("WWW-Authenticate", "Basic realm=\"Restricted area\"");
+			evhttp_send_reply(request, 401, "Unauthorized", NULL);
+			return -1;
+		}
+	}
+
+	if (evhttp_request_get_command(request) == EVHTTP_REQ_HEAD) { \
+		evhttp_send_reply(request, HTTP_OK, "OK", NULL); \
+		return -1;
+	}
+
+	return 0;
+}
+
+#define PREPROCESS_REQUEST { \
+		if (_http_preprocess_request(request, server) < 0) { \
 			return; \
 		} \
 	}
 
-static void _http_callback_root(struct evhttp_request *request, UNUSED void *arg) {
+static void _http_callback_root(struct evhttp_request *request, void *v_server) {
+	struct http_server_t *server = (struct http_server_t *)v_server;
 	struct evbuffer *buf;
+	struct evkeyvalq params; // For mjpg-streamer compatibility
+	const char *action; // Ditto
 
-	PROCESS_HEAD_REQUEST;
+	PREPROCESS_REQUEST;
+
+	evhttp_parse_query(evhttp_request_get_uri(request), &params);
+	action = evhttp_find_header(&params, "action");
+
+	if (action && !strcmp(action, "snapshot")) {
+		_http_callback_snapshot(request, v_server);
+	} else if (action && !strcmp(action, "stream")) {
+		_http_callback_stream(request, v_server);
+	} else {
+		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);
+	}
+
+	evhttp_clear_headers(&params);
+}
+
+static void _http_callback_static(struct evhttp_request *request, void *v_server) {
+	struct http_server_t *server = (struct http_server_t *)v_server;
+	struct evbuffer *buf = NULL;
+	struct evhttp_uri *uri = NULL;
+	char *uri_path;
+	char *decoded_path = NULL;
+	char *static_path = NULL;
+	int fd = -1;
+	struct stat st;
+
+	PREPROCESS_REQUEST;
+
+	if ((uri = evhttp_uri_parse(evhttp_request_get_uri(request))) == NULL) {
+		goto bad_request;
+	}
+	if ((uri_path = (char *)evhttp_uri_get_path(uri)) == NULL) {
+		uri_path = "/";
+	}
+
+	if ((decoded_path = evhttp_uridecode(uri_path, 0, NULL)) == NULL) {
+		goto bad_request;
+	}
 
 	assert((buf = evbuffer_new()));
-	assert(evbuffer_add_printf(buf, "%s", HTML_INDEX_PAGE));
-	ADD_HEADER("Content-Type", "text/html");
+
+	if ((static_path = find_static_file_path(server->static_path, decoded_path)) == NULL) {
+		goto not_found;
+	}
+
+	if ((fd = open(static_path, O_RDONLY)) < 0) {
+		LOG_PERROR("HTTP: Can't open found static file %s", static_path);
+		goto not_found;
+	}
+
+	if (fstat(fd, &st) < 0) {
+		LOG_PERROR("HTTP: Can't stat() found static file %s", static_path);
+		goto not_found;
+	}
+
+	if (st.st_size > 0 && evbuffer_add_file(buf, fd, 0, st.st_size) < 0) {
+		LOG_ERROR("HTTP: Can't serve static file %s", static_path);
+		goto not_found;
+	}
+	ADD_HEADER("Content-Type", guess_mime_type(static_path));
 	evhttp_send_reply(request, HTTP_OK, "OK", buf);
-	evbuffer_free(buf);
+	goto cleanup;
+
+	bad_request:
+		evhttp_send_error(request, HTTP_BADREQUEST, NULL);
+		goto cleanup;
+
+	not_found:
+		evhttp_send_error(request, HTTP_NOTFOUND, NULL);
+		goto cleanup;
+
+	cleanup:
+		if (fd >= 0) {
+			close(fd);
+		}
+		if (static_path) {
+			free(static_path);
+		}
+		if (buf) {
+			evbuffer_free(buf);
+		}
+		if (decoded_path) {
+			free(decoded_path);
+		}
+		if (uri) {
+			evhttp_uri_free(uri);
+		}
 }
 
 static void _http_callback_state(struct evhttp_request *request, void *v_server) {
@@ -264,9 +394,10 @@ static void _http_callback_state(struct evhttp_request *request, void *v_server)
 	enum encoder_type_t encoder_run_type;
 	unsigned encoder_run_quality;
 
-	PROCESS_HEAD_REQUEST;
+	PREPROCESS_REQUEST;
 
 #	define ENCODER(_next) server->run->stream->encoder->_next
+#	define EXPOSED(_next) server->run->exposed->_next
 
 	A_MUTEX_LOCK(&ENCODER(run->mutex));
 	encoder_run_type = ENCODER(run->type);
@@ -283,15 +414,16 @@ static void _http_callback_state(struct evhttp_request *request, void *v_server)
 		" \"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->fake_width ? server->fake_width : EXPOSED(picture->width)),
+		(server->fake_height ? server->fake_height : EXPOSED(picture->height)),
+		bool_to_string(EXPOSED(online)),
 		server->run->stream->dev->desired_fps,
-		server->run->exposed->captured_fps,
-		server->run->exposed->queued_fps,
+		EXPOSED(captured_fps),
+		EXPOSED(queued_fps),
 		server->run->stream_clients_count
 	));
 
+#	undef EXPOSED
 #	undef ENCODER
 
 	for (struct stream_client_t * client = server->run->stream_clients; client != NULL; client = client->next) {
@@ -318,47 +450,52 @@ static void _http_callback_snapshot(struct evhttp_request *request, void *v_serv
 	struct evbuffer *buf;
 	char header_buf[64];
 
-	PROCESS_HEAD_REQUEST;
+	PREPROCESS_REQUEST;
 
 #	define EXPOSED(_next) server->run->exposed->_next
 
 	assert((buf = evbuffer_new()));
-	assert(!evbuffer_add(buf, (const void *)EXPOSED(picture.data), EXPOSED(picture.size)));
+	assert(!evbuffer_add(buf, (const void *)EXPOSED(picture->data), EXPOSED(picture->used)));
 
-	ADD_HEADER("Access-Control-Allow-Origin:", "*");
+	if (server->allow_origin[0] != '\0') {
+		ADD_HEADER("Access-Control-Allow-Origin", server->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_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); }
+#	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());
+	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(picture->width));
+	ADD_UNSIGNED_HEADER("X-UStreamer-Height",				EXPOSED(picture->height));
+	ADD_TIME_HEADER("X-UStreamer-Grab-Timestamp",			EXPOSED(picture->grab_ts));
+	ADD_TIME_HEADER("X-UStreamer-Encode-Begin-Timestamp",	EXPOSED(picture->encode_begin_ts));
+	ADD_TIME_HEADER("X-UStreamer-Encode-End-Timestamp",		EXPOSED(picture->encode_end_ts));
+	ADD_TIME_HEADER("X-UStreamer-Expose-Begin-Timestamp",	EXPOSED(expose_begin_ts));
+	ADD_TIME_HEADER("X-UStreamer-Expose-Cmp-Timestamp",		EXPOSED(expose_cmp_ts));
+	ADD_TIME_HEADER("X-UStreamer-Expose-End-Timestamp",		EXPOSED(expose_end_ts));
+	ADD_TIME_HEADER("X-UStreamer-Send-Timestamp",			get_now_monotonic());
 
 #	undef ADD_UNSUGNED_HEADER
 #	undef ADD_TIME_HEADER
+#	undef EXPOSED
 
 	ADD_HEADER("Content-Type", "image/jpeg");
 
 	evhttp_send_reply(request, HTTP_OK, "OK", buf);
 	evbuffer_free(buf);
-
-#	undef EXPOSED
 }
 
 #undef ADD_HEADER
@@ -379,10 +516,10 @@ static void _http_callback_stream(struct evhttp_request *request, void *v_server
 	unsigned short client_port;
 	uuid_t uuid;
 
-	PROCESS_HEAD_REQUEST;
+	PREPROCESS_REQUEST;
 
 	conn = evhttp_request_get_connection(request);
-	if (conn != NULL) {
+	if (conn) {
 		A_CALLOC(client, 1);
 		client->server = server;
 		client->request = request;
@@ -390,10 +527,10 @@ static void _http_callback_stream(struct evhttp_request *request, void *v_server
 		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");
+		client->key = uri_get_string(&params, "key");
+		client->extra_headers = uri_get_true(&params, "extra_headers");
+		client->advance_headers = uri_get_true(&params, "advance_headers");
+		client->dual_final_frames = uri_get_true(&params, "dual_final_frames");
 		evhttp_clear_headers(&params);
 
 		uuid_generate(uuid);
@@ -410,20 +547,31 @@ static void _http_callback_stream(struct evhttp_request *request, void *v_server
 		}
 		server->run->stream_clients_count += 1;
 
-		if (server->slowdown && server->run->stream_clients_count == 1) {
-			stream_switch_slowdown(server->run->stream, false);
+		if (server->run->stream_clients_count == 1) {
+			if (server->slowdown) {
+				stream_switch_slowdown(server->run->stream, false);
+			}
+
+#			ifdef WITH_GPIO
+			gpio_set_has_http_clients(true);
+#			endif
 		}
 
 		evhttp_connection_get_peer(conn, &client_addr, &client_port);
-		LOG_INFO("HTTP: Registered the new stream client: [%s]:%u; id=%s; advance_headers=%s; dual_final_frames=%s; clients now: %u",
-			client_addr,
-			client_port,
-			client->id,
-			bool_to_string(client->advance_headers),
-			bool_to_string(client->dual_final_frames),
-			server->run->stream_clients_count);
+		LOG_INFO("HTTP: Registered 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);
+		if (server->tcp_nodelay && !server->run->unix_fd) {
+			evutil_socket_t fd;
+			int on = 1;
+
+			LOG_DEBUG("HTTP: Setting up TCP_NODELAY to the client [%s]:%u ...", client_addr, client_port);
+			assert((fd = bufferevent_getfd(buf_event)) >= 0);
+			if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (void *)&on, sizeof(on)) != 0) {
+				LOG_PERROR("HTTP: Can't set TCP_NODELAY to the client [%s]:%u", client_addr, client_port);
+			}
+		}
 		bufferevent_setcb(buf_event, NULL, NULL, _http_callback_stream_error, (void *)client);
 		bufferevent_enable(buf_event, EV_READ);
 	} else {
@@ -431,7 +579,7 @@ static void _http_callback_stream(struct evhttp_request *request, void *v_server
 	}
 }
 
-#undef PROCESS_HEAD_REQUEST
+#undef PREPROCESS_REQUEST
 
 static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_client) {
 #	define BOUNDARY "boundarydonotcross"
@@ -471,13 +619,15 @@ static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_c
 	// по тем же причинам, по которым у нас нет Content-Length.
 
 #	define ADD_ADVANCE_HEADERS \
-		{ assert(evbuffer_add_printf(buf, \
-		"Content-Type: image/jpeg" RN "X-Timestamp: %.06Lf" RN RN, get_now_real())); }
+		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));
+		if (client->server->allow_origin[0] != '\0') {
+			assert(evbuffer_add_printf(buf, "Access-Control-Allow-Origin: %s" RN, client->server->allow_origin));
+		}
 		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
@@ -505,8 +655,9 @@ static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_c
 			"Content-Length: %zu" RN
 			"X-Timestamp: %.06Lf" RN
 			"%s",
-			EXPOSED(picture.size) * sizeof(*EXPOSED(picture.data)),
-			get_now_real(), (client->extra_headers ? "" : RN)
+			EXPOSED(picture->used),
+			get_now_real(),
+			(client->extra_headers ? "" : RN)
 		));
 		if (client->extra_headers) {
 			assert(evbuffer_add_printf(buf,
@@ -525,24 +676,21 @@ static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_c
 				RN,
 				bool_to_string(EXPOSED(online)),
 				EXPOSED(dropped),
-				EXPOSED(width),
-				EXPOSED(height),
+				EXPOSED(picture->width),
+				EXPOSED(picture->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),
+				EXPOSED(picture->grab_ts),
+				EXPOSED(picture->encode_begin_ts),
+				EXPOSED(picture->encode_end_ts),
+				EXPOSED(expose_begin_ts),
+				EXPOSED(expose_cmp_ts),
+				EXPOSED(expose_end_ts),
 				now
 			));
 		}
 	}
 
-	assert(!evbuffer_add(buf,
-		(void *)EXPOSED(picture.data),
-		EXPOSED(picture.size) * sizeof(*EXPOSED(picture.data))
-	));
+	assert(!evbuffer_add(buf, (void *)EXPOSED(picture->data), EXPOSED(picture->used)));
 	assert(evbuffer_add_printf(buf, RN "--" BOUNDARY RN));
 
 	if (client->advance_headers) {
@@ -566,21 +714,33 @@ static void _http_callback_stream_error(UNUSED struct bufferevent *buf_event, UN
 	struct evhttp_connection *conn;
 	char *client_addr = "???";
 	unsigned short client_port = 0;
+	char reason[2048] = {0};
+
+	_format_bufferevent_reason(what, reason);
 
 #	define RUN(_next) client->server->run->_next
 
+	assert(RUN(stream_clients_count) > 0);
 	RUN(stream_clients_count) -= 1;
-	if (client->server->slowdown && RUN(stream_clients_count) <= 0) {
-		stream_switch_slowdown(RUN(stream), true);
+
+	if (RUN(stream_clients_count) == 0) {
+		if (client->server->slowdown) {
+			stream_switch_slowdown(RUN(stream), true);
+		}
+
+#		ifdef WITH_GPIO
+		gpio_set_has_http_clients(false);
+#		endif
 	}
 
 	conn = evhttp_request_get_connection(client->request);
-	if (conn != NULL) {
+	if (conn) {
 		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) {
+
+	LOG_INFO("HTTP: Disconnected client: [%s]:%u, id=%s, %s; clients now: %u",
+		client_addr, client_port, client->id, reason, RUN(stream_clients_count));
+	if (conn) {
 		evhttp_connection_free(conn);
 	}
 
@@ -602,13 +762,12 @@ static void _http_queue_send_stream(struct http_server_t *server, bool stream_up
 	struct evhttp_connection *conn;
 	struct bufferevent *buf_event;
 	long long now;
+	bool has_clients = false;
 	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) {
+		if (conn) {
 			// Фикс для бага WebKit. При включенной опции дропа одинаковых фреймов,
 			// WebKit отрисовывает последний фрейм в серии с некоторой задержкой,
 			// и нужно послать два фрейма, чтобы серия была вовремя завершена.
@@ -634,16 +793,23 @@ static void _http_queue_send_stream(struct http_server_t *server, bool stream_up
 			} else if (stream_updated) { // Для dual
 				client->updated_prev = false;
 			}
+
+			has_clients = true;
 		}
 	}
 
 	if (queued) {
+		static unsigned queued_fps_accum = 0;
+		static long long queued_fps_second = 0;
+
 		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;
+	} else if (!has_clients) {
+		server->run->exposed->queued_fps = 0;
 	}
 }
 
@@ -652,14 +818,16 @@ static void _http_exposed_refresh(UNUSED int fd, UNUSED short what, void *v_serv
 	bool stream_updated = false;
 	bool picture_updated = false;
 
-#	define UNLOCK_STREAM \
-		{ server->run->stream->updated = false; A_MUTEX_UNLOCK(&server->run->stream->mutex); }
+#	define UNLOCK_STREAM { \
+			atomic_store(&server->run->stream->updated, false); \
+			A_MUTEX_UNLOCK(&server->run->stream->mutex); \
+		}
 
-	if (server->run->stream->updated) {
+	if (atomic_load(&server->run->stream->updated)) {
 		LOG_DEBUG("Refreshing HTTP exposed ...");
 		A_MUTEX_LOCK(&server->run->stream->mutex);
-		if (server->run->stream->picture.size > 0) { // If online
-			picture_updated = _expose_new_picture(server);
+		if (server->run->stream->online) {
+			picture_updated = _expose_new_picture_unsafe(server);
 			UNLOCK_STREAM;
 		} else {
 			UNLOCK_STREAM;
@@ -675,110 +843,146 @@ static void _http_exposed_refresh(UNUSED int fd, UNUSED short what, void *v_serv
 #	undef UNLOCK_STREAM
 
 	_http_queue_send_stream(server, stream_updated, picture_updated);
-}
 
-static bool _expose_new_picture(struct http_server_t *server) {
-#	define STREAM(_next) server->run->stream->_next
 #	define EXPOSED(_next) server->run->exposed->_next
 
-	assert(STREAM(picture.size) > 0);
-	EXPOSED(captured_fps) = STREAM(captured_fps);
-	EXPOSED(expose_begin_time) = get_now_monotonic();
+	if (
+		picture_updated
+		&& server->notify_parent
+		&& (
+			EXPOSED(notify_last_online) != EXPOSED(online)
+			|| EXPOSED(notify_last_width) != EXPOSED(picture->width)
+			|| EXPOSED(notify_last_height) != EXPOSED(picture->height)
+		)
+	) {
+		EXPOSED(notify_last_online) = EXPOSED(online);
+		EXPOSED(notify_last_width) = EXPOSED(picture->width);
+		EXPOSED(notify_last_height) = EXPOSED(picture->height);
+		process_notify_parent();
+	}
 
-#	define MEM_STREAM_TO_EXPOSED \
-		EXPOSED(picture.data), STREAM(picture.data), \
-		STREAM(picture.size) * sizeof(*STREAM(picture.data))
+#	undef EXPOSED
+}
+
+static bool _expose_new_picture_unsafe(struct http_server_t *server) {
+#	define EXPOSED(_next) server->run->exposed->_next
+#	define STREAM(_next) server->run->stream->_next
+
+	EXPOSED(captured_fps) = STREAM(captured_fps);
+	EXPOSED(expose_begin_ts) = get_now_monotonic();
 
 	if (server->drop_same_frames) {
 		if (
 			EXPOSED(online)
 			&& EXPOSED(dropped) < server->drop_same_frames
-			&& EXPOSED(picture.size) == STREAM(picture.size)
-			&& !memcmp(MEM_STREAM_TO_EXPOSED)
+			&& picture_compare(EXPOSED(picture), STREAM(picture))
 		) {
-			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(expose_cmp_ts) = get_now_monotonic();
+			EXPOSED(expose_end_ts) = EXPOSED(expose_cmp_ts);
+			LOG_VERBOSE("HTTP: Dropped same frame number %u; cmp_time=%.06Lf",
+				EXPOSED(dropped), EXPOSED(expose_cmp_ts) - EXPOSED(expose_begin_ts));
 			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));
+			EXPOSED(expose_cmp_ts) = get_now_monotonic();
+			LOG_VERBOSE("HTTP: Passed same frame check (frames are differ); cmp_time=%.06Lf",
+				EXPOSED(expose_cmp_ts) - EXPOSED(expose_begin_ts));
 		}
 	}
 
-	if (EXPOSED(picture.allocated) < STREAM(picture.allocated)) {
-		A_REALLOC(EXPOSED(picture.data), STREAM(picture.allocated));
-		EXPOSED(picture.allocated) = STREAM(picture.allocated);
-	}
+	picture_copy(STREAM(picture), EXPOSED(picture));
 
-	memcpy(MEM_STREAM_TO_EXPOSED);
+#	undef STREAM
 
-#	undef MEM_STREAM_TO_EXPOSED
-
-	EXPOSED(picture.size) = STREAM(picture.size);
-
-	EXPOSED(picture.grab_time) = STREAM(picture.grab_time);
-	EXPOSED(picture.encode_begin_time) = STREAM(picture.encode_begin_time);
-	EXPOSED(picture.encode_end_time) = STREAM(picture.encode_end_time);
-
-	EXPOSED(width) = STREAM(width);
-	EXPOSED(height) = STREAM(height);
 	EXPOSED(online) = true;
 	EXPOSED(dropped) = 0;
-	EXPOSED(expose_cmp_time) = EXPOSED(expose_begin_time);
-	EXPOSED(expose_end_time) = get_now_monotonic();
+	EXPOSED(expose_cmp_ts) = EXPOSED(expose_begin_ts);
+	EXPOSED(expose_end_ts) = get_now_monotonic();
 
-	LOG_VERBOSE("HTTP: exposed new frame; full exposition time =  %.06Lf",
-		 EXPOSED(expose_end_time) - EXPOSED(expose_begin_time));
+	LOG_VERBOSE("HTTP: Exposed new frame; full exposition time = %.06Lf",
+		 EXPOSED(expose_end_ts) - EXPOSED(expose_begin_ts));
 
 #	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)
+#	define EXPOSED(_next) server->run->exposed->_next
 
-	EXPOSED(expose_begin_time) = get_now_monotonic();
-	EXPOSED(expose_cmp_time) = EXPOSED(expose_begin_time);
+	EXPOSED(expose_begin_ts) = get_now_monotonic();
+	EXPOSED(expose_cmp_ts) = EXPOSED(expose_begin_ts);
 
-	if (EXPOSED(online) || EXPOSED(picture.size) == 0) {
-		if (EXPOSED(picture.allocated) < BLANK_JPEG_LEN) {
-			A_REALLOC(EXPOSED(picture.data), BLANK_JPEG_LEN);
-			EXPOSED(picture.allocated) = BLANK_JPEG_LEN;
+#	define EXPOSE_BLANK picture_copy(server->run->blank, EXPOSED(picture))
+
+	if (EXPOSED(online)) { // Если переходим из online в offline
+		if (server->last_as_blank < 0) { // Если last_as_blank выключено, просто покажем картинку
+			LOG_INFO("HTTP: Changed picture to BLANK");
+			EXPOSE_BLANK;
+		} else if (server->last_as_blank > 0) { // Если нужен таймер - запустим
+			LOG_INFO("HTTP: Freezing last alive frame for %d seconds", server->last_as_blank);
+			EXPOSED(last_as_blank_ts) = get_now_monotonic();
+		} else { // last_as_blank == 0 - показываем последний фрейм вечно
+			LOG_INFO("HTTP: Freezing last alive frame forever");
 		}
-
-		memcpy(EXPOSED(picture.data), BLANK_JPEG_DATA, BLANK_JPEG_LEN * sizeof(*EXPOSED(picture.data)));
-
-		EXPOSED(picture.size) = 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 ( // Если уже оффлайн, включена фича last_as_blank с таймером и он запущен
+		server->last_as_blank > 0
+		&& EXPOSED(last_as_blank_ts) > 0
+		&& EXPOSED(last_as_blank_ts) + server->last_as_blank < EXPOSED(expose_begin_ts)
+	) {
+		LOG_INFO("HTTP: Changed last alive frame to BLANK");
+		EXPOSE_BLANK;
+		EXPOSED(last_as_blank_ts) = 0; // Останавливаем таймер
+		goto updated;
+	}
+
+#	undef EXPOSE_BLANK
+
 	if (EXPOSED(dropped) < server->run->drop_same_frames_blank) {
-		LOG_PERF("HTTP: dropped same frame (BLANK) number %u", EXPOSED(dropped));
+		LOG_PERF("HTTP: Dropped same frame (BLANK) number %u", EXPOSED(dropped));
 		EXPOSED(dropped) += 1;
-		EXPOSED(expose_end_time) = get_now_monotonic();
+		EXPOSED(expose_end_ts) = get_now_monotonic();
 		return false; // Not updated
 	}
 
 	updated:
+		EXPOSED(captured_fps) = 0;
+		EXPOSED(online) = false;
 		EXPOSED(dropped) = 0;
-		EXPOSED(expose_end_time) = get_now_monotonic();
+		EXPOSED(expose_end_ts) = get_now_monotonic();
 		return true; // Updated
 
-#	undef BLANK_JPEG_LEN
 #	undef EXPOSED
 }
+
+static void _format_bufferevent_reason(short what, char *reason) {
+	char perror_buf[1024] = {0};
+	char *perror_ptr = errno_to_string(EVUTIL_SOCKET_ERROR(), perror_buf, 1024); // evutil_socket_error_to_string() is not thread-sage
+	bool first = true;
+
+	strcat(reason, perror_ptr);
+	strcat(reason, " (");
+
+#	define FILL_REASON(_bev, _name) { \
+			if (what & _bev) { \
+				if (first) { \
+					first = false; \
+				} else { \
+					strcat(reason, ","); \
+				} \
+				strcat(reason, _name); \
+			} \
+		}
+
+	FILL_REASON(BEV_EVENT_READING, "reading");
+	FILL_REASON(BEV_EVENT_WRITING, "writing");
+	FILL_REASON(BEV_EVENT_ERROR, "error");
+	FILL_REASON(BEV_EVENT_TIMEOUT, "timeout");
+	FILL_REASON(BEV_EVENT_EOF, "eof"); // cppcheck-suppress unreadVariable
+
+#	undef FILL_REASON
+
+	strcat(reason, ")");
+}

src/http/server.h

@@ -20,6 +20,8 @@
 *****************************************************************************/
 
 
+#pragma once
+
 #include <stdbool.h>
 
 #include <sys/stat.h>
@@ -28,8 +30,8 @@
 #include <event2/http.h>
 #include <event2/util.h>
 
-#include "tools.h"
-#include "stream.h"
+#include "../picture.h"
+#include "../stream.h"
 
 
 struct stream_client_t {
@@ -54,27 +56,32 @@ struct stream_client_t {
 };
 
 struct exposed_t {
-	struct picture_t	picture;
-	unsigned			width;
-	unsigned			height;
+	struct picture_t	*picture;
 	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;
+	long double			expose_begin_ts;
+	long double			expose_cmp_ts;
+	long double			expose_end_ts;
+	long double			last_as_blank_ts;
+
+	bool		notify_last_online;
+	unsigned	notify_last_width;
+	unsigned	notify_last_height;
 };
 
 struct http_server_runtime_t {
 	struct event_base		*base;
 	struct evhttp			*http;
 	evutil_socket_t			unix_fd;
+	char					*auth_token;
 	struct event			*refresh;
 	struct stream_t			*stream;
 	struct exposed_t		*exposed;
 	struct stream_client_t	*stream_clients;
 	unsigned				stream_clients_count;
+	struct picture_t		*blank;
 	unsigned				drop_same_frames_blank;
 };
 
@@ -84,11 +91,22 @@ struct http_server_t {
 	char		*unix_path;
 	bool		unix_rm;
 	mode_t		unix_mode;
+	bool		tcp_nodelay;
+	unsigned	timeout;
+
+	char		*user;
+	char		*passwd;
+	char		*static_path;
+	char		*allow_origin;
+
+	char		*blank_path;
+	int			last_as_blank;
 	unsigned	drop_same_frames;
 	bool		slowdown;
 	unsigned	fake_width;
 	unsigned	fake_height;
-	unsigned	timeout;
+
+	bool		notify_parent;
 
 	struct http_server_runtime_t *run;
 };

src/http/static.c

@@ -0,0 +1,90 @@
+/*****************************************************************************
+#                                                                            #
+#    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 "static.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <sys/stat.h>
+
+#include "../tools.h"
+#include "../logging.h"
+
+#include "path.h"
+
+
+char *find_static_file_path(const char *root_path, const char *request_path) {
+	char *simplified_path;
+	char *path = NULL;
+	struct stat st;
+
+	simplified_path = simplify_request_path(request_path);
+	if (simplified_path[0] == '\0') {
+		LOG_VERBOSE("HTTP: Invalid request path %s to static", request_path);
+		goto error;
+	}
+
+	A_CALLOC(path, strlen(root_path) + strlen(simplified_path) + 32);
+	sprintf(path, "%s/%s", root_path, simplified_path);
+
+#	define LOAD_STAT { \
+			if (lstat(path, &st) < 0) { \
+				LOG_VERBOSE_PERROR("HTTP: Can't stat() static path %s", path); \
+				goto error; \
+			} \
+		}
+
+	LOAD_STAT;
+	if (S_ISDIR(st.st_mode)) {
+		LOG_VERBOSE("HTTP: Requested static path %s is a directory, trying %s/index.html", path, path);
+		strcat(path, "/index.html");
+		LOAD_STAT;
+	}
+
+#	undef LOAD_STAT
+
+	if (!S_ISREG(st.st_mode)) {
+		LOG_VERBOSE("HTTP: Not a regular file: %s", path);
+		goto error;
+	}
+
+	if (access(path, R_OK) < 0) {
+		LOG_VERBOSE_PERROR("HTTP: Can't access() R_OK file %s", path);
+		goto error;
+	}
+
+	goto ok;
+
+	error:
+		if (path) {
+			free(path);
+		}
+		path = NULL;
+
+	ok:
+		free(simplified_path);
+
+	return path;
+}

src/http/static.h

@@ -0,0 +1,26 @@
+/*****************************************************************************
+#                                                                            #
+#    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
+
+
+char *find_static_file_path(const char *root_path, const char *request_path);

src/http/unix.c

@@ -0,0 +1,85 @@
+/*****************************************************************************
+#                                                                            #
+#    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 "unix.h"
+
+#include <stdbool.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <assert.h>
+
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/stat.h>
+
+#include <event2/http.h>
+#include <event2/util.h>
+
+#include "../tools.h"
+#include "../logging.h"
+
+
+evutil_socket_t evhttp_my_bind_unix(struct evhttp *http, const char *path, bool rm, mode_t mode) {
+	evutil_socket_t fd = -1;
+	struct sockaddr_un addr;
+
+#	define MAX_SUN_PATH (sizeof(addr.sun_path) - 1)
+
+	if (strlen(path) > MAX_SUN_PATH) {
+		LOG_ERROR("UNIX socket path is too long; max=%zu", MAX_SUN_PATH);
+		return -1;
+	}
+
+	MEMSET_ZERO(addr);
+	strncpy(addr.sun_path, path, MAX_SUN_PATH);
+	addr.sun_family = AF_UNIX;
+
+#	undef MAX_SUN_PATH
+
+	assert((fd = socket(AF_UNIX, SOCK_STREAM, 0)) >= 0);
+	assert(!evutil_make_socket_nonblocking(fd));
+
+	if (rm && unlink(path) < 0) {
+		if (errno != ENOENT) {
+			LOG_PERROR("Can't remove old UNIX socket '%s'", path);
+			return -1;
+		}
+	}
+	if (bind(fd, (struct sockaddr *)&addr, sizeof(struct sockaddr_un)) < 0) {
+		LOG_PERROR("Can't bind HTTP to UNIX socket '%s'", path);
+		return -1;
+	}
+	if (mode && chmod(path, mode) < 0) {
+		LOG_PERROR("Can't set permissions %o to UNIX socket '%s'", mode, path);
+		return -1;
+	}
+	if (listen(fd, 128) < 0) {
+		LOG_PERROR("Can't listen UNIX socket '%s'", path);
+		return -1;
+	}
+	if (evhttp_accept_socket(http, fd) < 0) {
+		LOG_PERROR("Can't evhttp_accept_socket() UNIX socket '%s'", path);
+		return -1;
+	}
+	return fd;
+}

src/http/unix.h

@@ -0,0 +1,33 @@
+/*****************************************************************************
+#                                                                            #
+#    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 <stdbool.h>
+
+#include <sys/stat.h>
+
+#include <event2/http.h>
+#include <event2/util.h>
+
+
+evutil_socket_t evhttp_my_bind_unix(struct evhttp *http, const char *path, bool rm, mode_t mode);

src/http/uri.c

@@ -0,0 +1,54 @@
+/*****************************************************************************
+#                                                                            #
+#    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 "uri.h"
+
+#include <stdbool.h>
+
+#include <event2/http.h>
+#include <event2/util.h>
+#include <event2/keyvalq_struct.h>
+
+
+bool uri_get_true(struct evkeyvalq *params, const char *key) {
+	const char *value_str;
+
+	if ((value_str = evhttp_find_header(params, key)) != NULL) {
+		if (
+			value_str[0] == '1'
+			|| !evutil_ascii_strcasecmp(value_str, "true")
+			|| !evutil_ascii_strcasecmp(value_str, "yes")
+		) {
+			return true;
+		}
+	}
+	return false;
+}
+
+char *uri_get_string(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;
+}

src/http/uri.h

@@ -0,0 +1,32 @@
+/*****************************************************************************
+#                                                                            #
+#    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 <stdbool.h>
+
+#include <event2/http.h>
+#include <event2/keyvalq_struct.h>
+
+
+bool uri_get_true(struct evkeyvalq *params, const char *key);
+char *uri_get_string(struct evkeyvalq *params, const char *key);

src/logging.c

@@ -0,0 +1,34 @@
+/*****************************************************************************
+#                                                                            #
+#    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 <pthread.h>
+
+#include "logging.h"
+
+
+enum log_level_t log_level;
+
+bool log_colored;
+
+pthread_mutex_t log_mutex;

src/logging.h

@@ -23,6 +23,7 @@
 #pragma once
 
 #include <stdio.h>
+#include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
@@ -32,27 +33,44 @@
 
 #include <pthread.h>
 
-#include <sys/types.h>
-#include <sys/syscall.h>
-
 #include "tools.h"
+#include "threading.h"
 
 
-unsigned log_level;
-pthread_mutex_t log_mutex;
+enum log_level_t {
+    LOG_LEVEL_INFO,
+    LOG_LEVEL_PERF,
+    LOG_LEVEL_VERBOSE,
+    LOG_LEVEL_DEBUG,
+};
 
 
-#define LOG_LEVEL_INFO		0
-#define LOG_LEVEL_PERF		1
-#define LOG_LEVEL_VERBOSE	2
-#define LOG_LEVEL_DEBUG		3
+extern enum log_level_t log_level;
+
+extern bool log_colored;
+
+extern pthread_mutex_t log_mutex;
 
 
-#define LOGGING_INIT	assert(!pthread_mutex_init(&log_mutex, NULL))
-#define LOGGING_DESTROY	assert(!pthread_mutex_destroy(&log_mutex))
+#define LOGGING_INIT { \
+		log_level = LOG_LEVEL_INFO; \
+		log_colored = isatty(1); \
+		A_MUTEX_INIT(&log_mutex); \
+	}
 
-#define LOGGING_LOCK	assert(!pthread_mutex_lock(&log_mutex))
-#define LOGGING_UNLOCK	assert(!pthread_mutex_unlock(&log_mutex))
+#define LOGGING_DESTROY A_MUTEX_DESTROY(&log_mutex)
+
+#define LOGGING_LOCK	A_MUTEX_LOCK(&log_mutex)
+#define LOGGING_UNLOCK	A_MUTEX_UNLOCK(&log_mutex)
+
+
+#define COLOR_GRAY		"\x1b[30;1m"
+#define COLOR_RED		"\x1b[31;1m"
+#define COLOR_GREEN		"\x1b[32;1m"
+#define COLOR_YELLOW	"\x1b[33;1m"
+#define COLOR_BLUE		"\x1b[34;1m"
+#define COLOR_CYAN		"\x1b[36;1m"
+#define COLOR_RESET		"\x1b[0m"
 
 
 #define SEP_INFO(_ch) { \
@@ -71,56 +89,83 @@ pthread_mutex_t log_mutex;
 		} \
 	}
 
-#define LOG_PRINTF_NOLOCK(_label, _msg, ...) { \
-		printf("-- " _label " [%.03Lf tid=%ld] -- " _msg "\n", get_now_monotonic(), syscall(SYS_gettid), ##__VA_ARGS__); \
+
+#define LOG_PRINTF_NOLOCK(_label_color, _label, _msg_color, _msg, ...) { \
+		char _tname_buf[MAX_THREAD_NAME] = {0}; \
+		thread_get_name(_tname_buf); \
+		if (log_colored) { \
+			printf(COLOR_GRAY "-- " _label_color _label COLOR_GRAY " [%.03Lf %9s]" " -- " COLOR_RESET _msg_color _msg COLOR_RESET, \
+				get_now_monotonic(), _tname_buf, ##__VA_ARGS__); \
+		} else { \
+			printf("-- " _label " [%.03Lf %9s] -- " _msg, \
+				get_now_monotonic(), _tname_buf, ##__VA_ARGS__); \
+		} \
+		putchar('\n'); \
 		fflush(stdout); \
 	}
 
+#define LOG_PRINTF(_label_color, _label, _msg_color, _msg, ...) { \
+		LOGGING_LOCK; \
+		LOG_PRINTF_NOLOCK(_label_color, _label, _msg_color, _msg, ##__VA_ARGS__); \
+		LOGGING_UNLOCK; \
+	}
+
 #define LOG_ERROR(_msg, ...) { \
-		LOGGING_LOCK; \
-		LOG_PRINTF_NOLOCK("ERROR", _msg, ##__VA_ARGS__); \
-		LOGGING_UNLOCK; \
+		LOG_PRINTF(COLOR_RED, "ERROR", COLOR_RED, _msg, ##__VA_ARGS__); \
 	}
 
 #define LOG_PERROR(_msg, ...) { \
-		char _buf[1024] = ""; \
-		char *_ptr = strerror_r(errno, _buf, 1024); \
-		LOGGING_LOCK; \
-		printf("-- ERROR [%.03Lf tid=%ld] -- " _msg ": %s\n", get_now_monotonic(), syscall(SYS_gettid), ##__VA_ARGS__, _ptr); \
-		fflush(stdout); \
-		LOGGING_UNLOCK; \
+		char _perror_buf[1024] = {0}; \
+		char *_perror_ptr = errno_to_string(errno, _perror_buf, 1024); \
+		LOG_ERROR(_msg ": %s", ##__VA_ARGS__, _perror_ptr); \
 	}
 
 #define LOG_INFO(_msg, ...) { \
-		LOGGING_LOCK; \
-		LOG_PRINTF_NOLOCK("INFO ", _msg, ##__VA_ARGS__); \
-		LOGGING_UNLOCK; \
+		LOG_PRINTF(COLOR_GREEN, "INFO ", "", _msg, ##__VA_ARGS__); \
 	}
 
 #define LOG_INFO_NOLOCK(_msg, ...) { \
-		LOG_PRINTF_NOLOCK("INFO ", _msg, ##__VA_ARGS__); \
+		LOG_PRINTF_NOLOCK(COLOR_GREEN, "INFO ", "", _msg, ##__VA_ARGS__); \
 	}
 
 #define LOG_PERF(_msg, ...) { \
 		if (log_level >= LOG_LEVEL_PERF) { \
-			LOGGING_LOCK; \
-			LOG_PRINTF_NOLOCK("PERF ", _msg, ##__VA_ARGS__); \
-			LOGGING_UNLOCK; \
+			LOG_PRINTF(COLOR_CYAN, "PERF ", COLOR_CYAN, _msg, ##__VA_ARGS__); \
+		} \
+	}
+
+#define LOG_PERF_FPS(_msg, ...) { \
+		if (log_level >= LOG_LEVEL_PERF) { \
+			LOG_PRINTF(COLOR_YELLOW, "PERF ", COLOR_YELLOW, _msg, ##__VA_ARGS__); \
 		} \
 	}
 
 #define LOG_VERBOSE(_msg, ...) { \
 		if (log_level >= LOG_LEVEL_VERBOSE) { \
-			LOGGING_LOCK; \
-			LOG_PRINTF_NOLOCK("VERB ", _msg, ##__VA_ARGS__); \
-			LOGGING_UNLOCK; \
+			LOG_PRINTF(COLOR_BLUE, "VERB ", COLOR_BLUE, _msg, ##__VA_ARGS__); \
+		} \
+	}
+
+#define LOG_VERBOSE_PERROR(_msg, ...) { \
+		if (log_level >= LOG_LEVEL_VERBOSE) { \
+			char _perror_buf[1024] = {0}; \
+			char *_perror_ptr = errno_to_string(errno, _perror_buf, 1024); \
+			LOG_PRINTF(COLOR_BLUE, "VERB ", COLOR_BLUE, _msg ": %s", ##__VA_ARGS__, _perror_ptr); \
 		} \
 	}
 
 #define LOG_DEBUG(_msg, ...) { \
 		if (log_level >= LOG_LEVEL_DEBUG) { \
-			LOGGING_LOCK; \
-			LOG_PRINTF_NOLOCK("DEBUG", _msg, ##__VA_ARGS__); \
-			LOGGING_UNLOCK; \
+			LOG_PRINTF(COLOR_GRAY, "DEBUG", COLOR_GRAY, _msg, ##__VA_ARGS__); \
 		} \
 	}
+
+
+INLINE char *errno_to_string(int error, char *buf, size_t size) {
+#	if defined(__GLIBC__) && defined(_GNU_SOURCE)
+	return strerror_r(error, buf, size);
+#	else
+	strerror_r(error, buf, size);
+	return buf;
+#	endif
+}

src/main.c

@@ -25,289 +25,38 @@
 #	error WTF dude? Asserts are good things!
 #endif
 
+#include <limits.h>
+#if CHAR_BIT != 8
+#	error There are not 8 bits in a char!
+#endif
+
 #include <stdio.h>
 #include <stdbool.h>
 #include <signal.h>
-#include <getopt.h>
 
 #include <pthread.h>
 
-#include "config.h"
 #include "tools.h"
+#include "threading.h"
 #include "logging.h"
+#include "options.h"
 #include "device.h"
 #include "encoder.h"
 #include "stream.h"
-#include "http.h"
+#include "http/server.h"
+#ifdef WITH_GPIO
+#	include "gpio/gpio.h"
+#endif
 
 
-static const char _short_opts[] = "d:i:x:y:m:a:f:z:tb:w:q:c:s:p:u:ro:e:h";
-static const struct option _long_opts[] = {
-	{"device",					required_argument,	NULL,	'd'},
-	{"input",					required_argument,	NULL,	'i'},
-	{"width",					required_argument,	NULL,	'x'},
-	{"height",					required_argument,	NULL,	'y'},
-	{"format",					required_argument,	NULL,	'm'},
-	{"tv-standard",				required_argument,	NULL,	'a'},
-	{"desired-fps",				required_argument,	NULL,	'f'},
-	{"min-frame-size",			required_argument,	NULL,	'z'},
-	{"dv-timings",				no_argument,		NULL,	't'},
-	{"buffers",					required_argument,	NULL,	'b'},
-	{"workers",					required_argument,	NULL,	'w'},
-	{"quality",					required_argument,	NULL,	'q'},
-	{"encoder",					required_argument,	NULL,	'c'},
-	{"device-timeout",			required_argument,	NULL,	1000},
-	{"device-persistent",		no_argument,		NULL,	1001},
-	{"device-error-delay",		required_argument,	NULL,	1002},
-
-	{"brightness",				required_argument,	NULL,	2000},
-	{"brightness-auto",			no_argument,		NULL,	2001},
-	{"contrast",				required_argument,	NULL,	2002},
-	{"saturation",				required_argument,	NULL,	2003},
-	{"hue",						required_argument,	NULL,	2004},
-	{"hue-auto",				no_argument,		NULL,	2005},
-	{"gamma",					required_argument,	NULL,	2006},
-	{"sharpness",				required_argument,	NULL,	2007},
-	{"backlight-compensation",	required_argument,	NULL,	2008},
-	{"white-balance",			required_argument,	NULL,	2009},
-	{"white-balance-auto",		no_argument,		NULL,	2010},
-	{"gain",					required_argument,	NULL,	2011},
-	{"gain-auto",				no_argument,		NULL,	2012},
-
-	{"host",					required_argument,	NULL,	's'},
-	{"port",					required_argument,	NULL,	'p'},
-	{"unix",					required_argument,	NULL,	'u'},
-	{"unix-rm",					no_argument,		NULL,	'r'},
-	{"unix-mode",				required_argument,	NULL,	'o'},
-	{"drop-same-frames",		required_argument,	NULL,	'e'},
-	{"slowdown",				no_argument,		NULL,	3000},
-	{"fake-width",				required_argument,	NULL,	3001},
-	{"fake-height",				required_argument,	NULL,	3002},
-	{"server-timeout",			required_argument,	NULL,	3003},
-
-	{"perf",					no_argument,		NULL,	5000},
-	{"verbose",					no_argument,		NULL,	5001},
-	{"debug",					no_argument,		NULL,	5002},
-	{"log-level",				required_argument,	NULL,	5010},
-	{"help",					no_argument,		NULL,	'h'},
-	{"version",					no_argument,		NULL,	6000},
-	{NULL, 0, NULL, 0},
-};
-
-static void _version(bool nl) {
-	printf(VERSION);
-#	ifdef WITH_OMX_ENCODER
-	printf(" + OMX");
-#	endif
-	if (nl) {
-		putchar('\n');
-	}
-}
-
-static void _help(struct device_t *dev, struct encoder_t *encoder, struct http_server_t *server) {
-	printf("\nuStreamer - Lightweight and fast MJPG-HTTP streamer\n");
-	printf("===================================================\n\n");
-	printf("Version: ");
-	_version(false);
-	printf("; license: GPLv3\n");
-	printf("Copyright (C) 2018 Maxim Devaev <mdevaev@gmail.com>\n\n");
-	printf("Capturing options:\n");
-	printf("------------------\n");
-	printf("    -d|--device </dev/path>          -- Path to V4L2 device. Default: %s.\n\n", dev->path);
-	printf("    -i|--input <N>                   -- Input channel. Default: %u.\n\n", dev->input);
-	printf("    -x|--width <N>                   -- Initial image width. Default: %u.\n\n", dev->width);
-	printf("    -y|--height <N>                  -- Initial image height. Default: %u.\n\n", dev->height);
-	printf("    -m|--format <fmt>                -- Image format.\n");
-	printf("                                        Available: %s; default: YUYV.\n\n", FORMATS_STR);
-	printf("    -a|--tv-standard <std>           -- Force TV standard.\n");
-	printf("                                        Available: %s; default: disabled.\n\n", STANDARDS_STR);
-	printf("    -f|--desired-fps <N>             -- Desired FPS. Default: maximum as possible.\n\n");
-	printf("    -z|--min-frame-size <N>          -- Drop frames smaller then this limit.\n");
-	printf("                                        Useful if the device produces small-sized garbage frames.\n\n");
-	printf("    -t|--dv-timings                  -- Enable DV timings queriyng and events processing.\n");
-	printf("                                        Supports automatic resolution changing. Default: disabled.\n\n");
-	printf("    -b|--buffers <N>                 -- The number of buffers to receive data from the device.\n");
-	printf("                                        Each buffer may processed using an intermediate thread.\n");
-	printf("                                        Default: %u (number of CPU cores + 1)\n\n", dev->n_buffers);
-	printf("    -w|--workers <N>                 -- The number of compressing threads. Default: %u (== --buffers).\n\n", dev->n_workers);
-	printf("    -q|--quality <N>                 -- Set quality of JPEG encoding from 1 to 100 (best). Default: %u.\n\n", encoder->quality);
-	printf("    -c|--encoder <type>              -- Use specified encoder. It may affects to workers number.\n");
-	printf("                                     -- Available: %s; default: CPU.\n\n", ENCODER_TYPES_STR);
-	printf("    --device-timeout <seconds>       -- Timeout for device querying. Default: %u\n\n", dev->timeout);
-	printf("    --device-persistent              -- Don't re-initialize device on timeout. Default: disabled.\n\n");
-	printf("    --device-error-delay <seconds>   -- Delay before trying to connect to the device again\n");
-	printf("                                        after a timeout. Default: %u\n\n", dev->error_delay);
-	printf("Image control options:\n");
-	printf("---------------\n");
-	printf("    --brightness <N>             -- Set brightness. Default: no change.\n\n");
-	printf("    --brightness-auto            -- Enable automatic brightness control. Default: no change.\n\n");
-	printf("    --contrast <N>               -- Set contrast. Default: no change.\n\n");
-	printf("    --saturation <N>             -- Set saturation. Default: no change.\n\n");
-	printf("    --hue <N>                    -- Set hue. Default: no change.\n\n");
-	printf("    --hue-auto                   -- Enable automatic hue control. Default: no change.\n\n");
-	printf("    --gamma <N>                  -- Set gamma. Default: no change.\n\n");
-	printf("    --sharpness <N>              -- Set sharpness. Default: no change.\n\n");
-	printf("    --backlight-compensation <N> -- Set backlight compensation. Default: no change.\n\n");
-	printf("    --white-balance <N>          -- Set white balance. Default: no change.\n\n");
-	printf("    --white-balance-auto         -- Enable automatic white balance control. Default: no change.\n\n");
-	printf("    --gain <N>                   -- Set gain. Default: no change.\n\n");
-	printf("    --gain-auto                  -- Enable automatic gain control. Default: no change.\n\n");
-	printf("HTTP server options:\n");
-	printf("--------------------\n");
-	printf("    -s|--host <address>        -- Listen on Hostname or IP. Default: %s\n\n", server->host);
-	printf("    -p|--port <N>              -- Bind to this TCP port. Default: %u\n\n", server->port);
-	printf("    -u|--unix <path>           -- Bind to UNIX domain socket. Default: disabled\n\n");
-	printf("    -r|--unix-rm               -- Try to remove old UNIX socket file before binding. Default: disabled\n\n");
-	printf("    -o|--unix-mode <mode>      -- Set UNIX socket file permissions (like 777). Default: disabled\n\n");
-	printf("    -e|--drop-same-frames <N>  -- Don't send same frames to clients, but no more than specified number.\n");
-	printf("                                  It can significantly reduce the outgoing traffic, but will increase\n");
-	printf("                                  the CPU loading. Don't use this option with analog signal sources\n");
-	printf("                                  or webcams, it's useless. Default: disabled.\n\n");
-	printf("    --slowdown                 -- Slowdown capturing to 1 FPS or less when no stream clients connected.\n");
-	printf("                                  Useful to reduce CPU cosumption. Default: disabled.\n\n");
-	printf("    --fake-width <N>           -- Override image width for /state. Default: disabled\n\n");
-	printf("    --fake-height <N>          -- Override image height for /state. Default: disabled.\n\n");
-	printf("    --server-timeout <seconds> -- Timeout for client connections. Default: %u\n\n", server->timeout);
-	printf("Misc options:\n");
-	printf("-------------\n");
-	printf("    --log-level <N> -- Verbosity level of messages from 0 (info) to 3 (debug).\n");
-	printf("                       Enabling debugging messages can slow down the program.\n");
-	printf("                       Available levels: 0=info, 1=performance, 2=verbose, 3=debug.\n");
-	printf("                       Default: %u.\n\n", log_level);
-	printf("    --perf          -- Enable performance messages (same as --log-level=1). Default: disabled.\n\n");
-	printf("    --verbose       -- Enable verbose messages and lower (same as --log-level=2). Default: disabled.\n\n");
-	printf("    --debug         -- Enable debug messages and lower (same as --log-level=3). Default: disabled.\n\n");
-	printf("    -h|--help       -- Print this messages and exit.\n\n");
-}
-
-static int _parse_options(int argc, char *argv[], struct device_t *dev, struct encoder_t *encoder, struct http_server_t *server) {
-#	define OPT_SET(_dest, _value) \
-		{ _dest = _value; break; }
-
-#	define OPT_UNSIGNED(_dest, _name, _min, _max) { \
-			errno = 0; char *_end = NULL; int _tmp = strtol(optarg, &_end, 0); \
-			if (errno || *_end || _tmp < _min || _tmp > _max) { \
-				printf("Invalid value for '%s=%s'; min=%u; max=%u\n", _name, optarg, _min, _max); \
-				return -1; \
-			} \
-			_dest = _tmp; \
-			break; \
-		}
-
-#	define OPT_PARSE(_dest, _func, _invalid, _name) { \
-			if ((_dest = _func(optarg)) == _invalid) { \
-				printf("Unknown " _name ": %s\n", optarg); \
-				return -1; \
-			} \
-			break; \
-		}
-
-#	define OPT_INT(_dest, _name, _base) { \
-			errno = 0; char *_end = NULL; int _tmp = strtol(optarg, &_end, _base); \
-			if (errno || *_end) { \
-				printf("Invalid value for '%s=%s'\n", _name, optarg); \
-				return -1; \
-			} \
-			_dest = _tmp; \
-			break; \
-		}
-
-#	define OPT_CHMOD(_dest, _name) \
-		OPT_INT(_dest, _name, 8)
-
-#	define OPT_CTL(_dest) { \
-			dev->ctl->_dest.value_set = true; \
-			dev->ctl->_dest.auto_set = false; \
-			OPT_INT(dev->ctl->_dest.value, "--"#_dest, 10); \
-			break; \
-		}
-
-#	define OPT_CTL_AUTO(_dest) { \
-			dev->ctl->_dest.value_set = false; \
-			dev->ctl->_dest.auto_set = true; \
-			break; \
-		}
-
-	int index;
-	int ch;
-
-	log_level = LOG_LEVEL_INFO;
-	while ((ch = getopt_long(argc, argv, _short_opts, _long_opts, &index)) >= 0) {
-		switch (ch) {
-			case 'd':	OPT_SET(dev->path, optarg);
-			case 'i':	OPT_UNSIGNED(dev->input, "--input", 0, 128);
-			case 'x':	OPT_UNSIGNED(dev->width, "--width", VIDEO_MIN_WIDTH, VIDEO_MAX_WIDTH);
-			case 'y':	OPT_UNSIGNED(dev->height, "--height", VIDEO_MIN_HEIGHT, VIDEO_MAX_HEIGHT);
-#			pragma GCC diagnostic ignored "-Wsign-compare"
-#			pragma GCC diagnostic push
-			case 'm':	OPT_PARSE(dev->format, device_parse_format, FORMAT_UNKNOWN, "pixel format");
-#			pragma GCC diagnostic pop
-			case 'a':	OPT_PARSE(dev->standard, device_parse_standard, STANDARD_UNKNOWN, "TV standard");
-			case 'f':	OPT_UNSIGNED(dev->desired_fps, "--desired-fps", 0, 30);
-			case 'z':	OPT_UNSIGNED(dev->min_frame_size, "--min-frame-size", 0, 8192);
-			case 't':	OPT_SET(dev->dv_timings, true);
-			case 'b':	OPT_UNSIGNED(dev->n_buffers, "--buffers", 1, 32);
-			case 'w':	OPT_UNSIGNED(dev->n_workers, "--workers", 1, 32);
-			case 'q':	OPT_UNSIGNED(encoder->quality, "--quality", 1, 100);
-			case 'c':	OPT_PARSE(encoder->type, encoder_parse_type, ENCODER_TYPE_UNKNOWN, "encoder type");
-			case 1000:	OPT_UNSIGNED(dev->timeout, "--device-timeout", 1, 60);
-			case 1001:	OPT_SET(dev->persistent, true);
-			case 1002:	OPT_UNSIGNED(dev->error_delay, "--device-error-delay", 1, 60);
-
-			case 2000:	OPT_CTL(brightness);
-			case 2001:	OPT_CTL_AUTO(brightness);
-			case 2002:	OPT_CTL(contrast);
-			case 2003:	OPT_CTL(saturation);
-			case 2004:	OPT_CTL(hue);
-			case 2005:	OPT_CTL_AUTO(hue);
-			case 2006:	OPT_CTL(gamma);
-			case 2007:	OPT_CTL(sharpness);
-			case 2008:	OPT_CTL(backlight_compensation);
-			case 2009:	OPT_CTL(white_balance);
-			case 2010:	OPT_CTL_AUTO(white_balance);
-			case 2011:	OPT_CTL(gain);
-			case 2012:	OPT_CTL_AUTO(gain);
-
-			case 's':	OPT_SET(server->host, optarg);
-			case 'p':	OPT_UNSIGNED(server->port, "--port", 1, 65535);
-			case 'u':	OPT_SET(server->unix_path, optarg);
-			case 'r':	OPT_SET(server->unix_rm, true);
-			case 'o':	OPT_CHMOD(server->unix_mode, "--unix-mode");
-			case 'e':	OPT_UNSIGNED(server->drop_same_frames, "--drop-same-frames", 0, 30);
-			case 3000:	OPT_SET(server->slowdown, true);
-			case 3001:	OPT_UNSIGNED(server->fake_width, "--fake-width", 0, 1920);
-			case 3002:	OPT_UNSIGNED(server->fake_height, "--fake-height", 0, 1200);
-			case 3003:	OPT_UNSIGNED(server->timeout, "--server-timeout", 1, 60);
-
-			case 5000:	OPT_SET(log_level, LOG_LEVEL_PERF);
-			case 5001:	OPT_SET(log_level, LOG_LEVEL_VERBOSE);
-			case 5002:	OPT_SET(log_level, LOG_LEVEL_DEBUG);
-			case 5010:	OPT_UNSIGNED(log_level, "--log-level", 0, 3);
-			case 'h':	_help(dev, encoder, server); return 1;
-			case 6000:	_version(true); return 1;
-			case 0:		break;
-			default:	_help(dev, encoder, server); return -1;
-		}
-	}
-
-#	undef OPT_CTL_AUTO
-#	undef OPT_CTL
-#	undef OPT_CHMOD
-#	undef OPT_INT
-#	undef OPT_PARSE
-#	undef OPT_UNSIGNED
-#	undef OPT_SET
-	return 0;
-}
-
-struct main_context_t {
+struct _main_context_t {
 	struct stream_t			*stream;
 	struct http_server_t	*server;
 };
 
-static struct main_context_t *_ctx;
+static struct _main_context_t *_ctx;
 
-static void _block_thread_signals() {
+static void _block_thread_signals(void) {
 	sigset_t mask;
 	assert(!sigemptyset(&mask));
 	assert(!sigaddset(&mask, SIGINT));
@@ -316,12 +65,14 @@ static void _block_thread_signals() {
 }
 
 static void *_stream_loop_thread(UNUSED void *arg) {
+	A_THREAD_RENAME("stream");
 	_block_thread_signals();
 	stream_loop(_ctx->stream);
 	return NULL;
 }
 
 static void *_server_loop_thread(UNUSED void *arg) {
+	A_THREAD_RENAME("http");
 	_block_thread_signals();
 	http_server_loop(_ctx->server);
 	return NULL;
@@ -333,7 +84,7 @@ static void _signal_handler(int signum) {
 	http_server_loop_break(_ctx->server);
 }
 
-static void _install_signal_handlers() {
+static void _install_signal_handlers(void) {
 	struct sigaction sig_act;
 
 	MEMSET_ZERO(sig_act);
@@ -353,6 +104,7 @@ static void _install_signal_handlers() {
 }
 
 int main(int argc, char *argv[]) {
+	struct options_t *options;
 	struct device_t *dev;
 	struct encoder_t *encoder;
 	struct stream_t *stream;
@@ -360,30 +112,44 @@ int main(int argc, char *argv[]) {
 	int exit_code = 0;
 
 	LOGGING_INIT;
+	A_THREAD_RENAME("main");
+	options = options_init(argc, argv);
 
 	dev = device_init();
 	encoder = encoder_init();
 	stream = stream_init(dev, encoder);
 	server = http_server_init(stream);
 
-	if ((exit_code = _parse_options(argc, argv, dev, encoder, server)) == 0) {
+	if ((exit_code = options_parse(options, dev, encoder, server)) == 0) {
+#		ifdef WITH_GPIO
+		gpio_init();
+#		endif
+
 		_install_signal_handlers();
-		encoder_prepare(encoder, dev);
 
 		pthread_t stream_loop_tid;
 		pthread_t server_loop_tid;
-		struct main_context_t ctx;
+		struct _main_context_t ctx;
 
 		ctx.stream = stream;
 		ctx.server = server;
 		_ctx = &ctx;
 
 		if ((exit_code = http_server_listen(server)) == 0) {
+#			ifdef WITH_GPIO
+			gpio_set_prog_running(true);
+#			endif
+
 			A_THREAD_CREATE(&stream_loop_tid, _stream_loop_thread, NULL);
 			A_THREAD_CREATE(&server_loop_tid, _server_loop_thread, NULL);
 			A_THREAD_JOIN(server_loop_tid);
 			A_THREAD_JOIN(stream_loop_tid);
 		}
+
+#		ifdef WITH_GPIO
+		gpio_set_prog_running(false);
+		gpio_destroy();
+#		endif
 	}
 
 	http_server_destroy(server);
@@ -391,6 +157,10 @@ int main(int argc, char *argv[]) {
 	encoder_destroy(encoder);
 	device_destroy(dev);
 
+	options_destroy(options);
+	if (exit_code == 0) {
+		LOG_INFO("Bye-bye");
+	}
 	LOGGING_DESTROY;
 	return (exit_code < 0 ? 1 : 0);
 }

src/options.c

@@ -0,0 +1,691 @@
+/*****************************************************************************
+#                                                                            #
+#    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 "options.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include <strings.h>
+#include <ctype.h>
+#include <limits.h>
+#include <getopt.h>
+#include <errno.h>
+#include <assert.h>
+
+#include "config.h"
+#include "logging.h"
+#include "process.h"
+#include "device.h"
+#include "encoder.h"
+#include "http/server.h"
+#ifdef WITH_GPIO
+#	include "gpio/gpio.h"
+#endif
+
+
+enum _OPT_VALUES {
+	_O_DEVICE = 'd',
+	_O_INPUT = 'i',
+	_O_RESOLUTION = 'r',
+	_O_FORMAT = 'm',
+	_O_TV_STANDARD = 'a',
+	_O_IO_METHOD = 'I',
+	_O_DESIRED_FPS = 'f',
+	_O_MIN_FRAME_SIZE = 'z',
+	_O_PERSISTENT = 'n',
+	_O_DV_TIMINGS = 't',
+	_O_BUFFERS = 'b',
+	_O_WORKERS = 'w',
+	_O_QUALITY = 'q',
+	_O_ENCODER = 'c',
+#ifdef WITH_OMX
+	_O_GLITCHED_RESOLUTIONS = 'g',
+#endif
+
+	_O_HOST = 's',
+	_O_PORT = 'p',
+	_O_UNIX = 'U',
+	_O_UNIX_RM = 'D',
+	_O_UNIX_MODE = 'M',
+	_O_BLANK = 'k',
+	_O_LAST_AS_BLANK = 'K',
+	_O_DROP_SAME_FRAMES = 'e',
+	_O_SLOWDOWN = 'l',
+	_O_FAKE_RESOLUTION = 'R',
+
+	_O_HELP = 'h',
+	_O_VERSION = 'v',
+
+	// Longs only
+
+	_O_DEVICE_TIMEOUT = 10000,
+	_O_DEVICE_ERROR_DELAY,
+
+	_O_IMAGE_DEFAULT,
+	_O_BRIGHTNESS,
+	_O_CONTRAST,
+	_O_SATURATION,
+	_O_HUE,
+	_O_GAMMA,
+	_O_SHARPNESS,
+	_O_BACKLIGHT_COMPENSATION,
+	_O_WHITE_BALANCE,
+	_O_GAIN,
+	_O_COLOR_EFFECT,
+	_O_FLIP_VERTICAL,
+	_O_FLIP_HORIZONTAL,
+
+	_O_USER,
+	_O_PASSWD,
+	_O_STATIC,
+	_O_ALLOW_ORIGIN,
+	_O_TCP_NODELAY,
+	_O_SERVER_TIMEOUT,
+
+#ifdef WITH_GPIO
+	_O_GPIO_DEVICE,
+	_O_GPIO_CONSUMER_PREFIX,
+	_O_GPIO_PROG_RUNNING,
+	_O_GPIO_STREAM_ONLINE,
+	_O_GPIO_HAS_HTTP_CLIENTS,
+#endif
+
+#ifdef HAS_PDEATHSIG
+	_O_EXIT_ON_PARENT_DEATH,
+#endif
+#ifdef WITH_SETPROCTITLE
+	_O_PROCESS_NAME_PREFIX,
+#endif
+	_O_NOTIFY_PARENT,
+
+	_O_LOG_LEVEL,
+	_O_PERF,
+	_O_VERBOSE,
+	_O_DEBUG,
+	_O_FORCE_LOG_COLORS,
+	_O_NO_LOG_COLORS,
+
+	_O_FEATURES,
+};
+
+static const struct option _LONG_OPTS[] = {
+	{"device",					required_argument,	NULL,	_O_DEVICE},
+	{"input",					required_argument,	NULL,	_O_INPUT},
+	{"resolution",				required_argument,	NULL,	_O_RESOLUTION},
+	{"format",					required_argument,	NULL,	_O_FORMAT},
+	{"tv-standard",				required_argument,	NULL,	_O_TV_STANDARD},
+	{"io-method",				required_argument,	NULL,	_O_IO_METHOD},
+	{"desired-fps",				required_argument,	NULL,	_O_DESIRED_FPS},
+	{"min-frame-size",			required_argument,	NULL,	_O_MIN_FRAME_SIZE},
+	{"persistent",				no_argument,		NULL,	_O_PERSISTENT},
+	{"dv-timings",				no_argument,		NULL,	_O_DV_TIMINGS},
+	{"buffers",					required_argument,	NULL,	_O_BUFFERS},
+	{"workers",					required_argument,	NULL,	_O_WORKERS},
+	{"quality",					required_argument,	NULL,	_O_QUALITY},
+	{"encoder",					required_argument,	NULL,	_O_ENCODER},
+#	ifdef WITH_OMX
+	{"glitched-resolutions",	required_argument,	NULL,	_O_GLITCHED_RESOLUTIONS},
+#	endif
+	{"device-timeout",			required_argument,	NULL,	_O_DEVICE_TIMEOUT},
+	{"device-error-delay",		required_argument,	NULL,	_O_DEVICE_ERROR_DELAY},
+
+	{"image-default",			no_argument,		NULL,	_O_IMAGE_DEFAULT},
+	{"brightness",				required_argument,	NULL,	_O_BRIGHTNESS},
+	{"contrast",				required_argument,	NULL,	_O_CONTRAST},
+	{"saturation",				required_argument,	NULL,	_O_SATURATION},
+	{"hue",						required_argument,	NULL,	_O_HUE},
+	{"gamma",					required_argument,	NULL,	_O_GAMMA},
+	{"sharpness",				required_argument,	NULL,	_O_SHARPNESS},
+	{"backlight-compensation",	required_argument,	NULL,	_O_BACKLIGHT_COMPENSATION},
+	{"white-balance",			required_argument,	NULL,	_O_WHITE_BALANCE},
+	{"gain",					required_argument,	NULL,	_O_GAIN},
+	{"color-effect",			required_argument,	NULL,	_O_COLOR_EFFECT},
+	{"flip-vertical",			required_argument,	NULL,	_O_FLIP_VERTICAL},
+	{"flip-horizontal",			required_argument,	NULL,	_O_FLIP_HORIZONTAL},
+
+	{"host",					required_argument,	NULL,	_O_HOST},
+	{"port",					required_argument,	NULL,	_O_PORT},
+	{"unix",					required_argument,	NULL,	_O_UNIX},
+	{"unix-rm",					no_argument,		NULL,	_O_UNIX_RM},
+	{"unix-mode",				required_argument,	NULL,	_O_UNIX_MODE},
+	{"user",					required_argument,	NULL,	_O_USER},
+	{"passwd",					required_argument,	NULL,	_O_PASSWD},
+	{"static",					required_argument,	NULL,	_O_STATIC},
+	{"blank",					required_argument,	NULL,	_O_BLANK},
+	{"last-as-blank",			required_argument,	NULL,	_O_LAST_AS_BLANK},
+	{"drop-same-frames",		required_argument,	NULL,	_O_DROP_SAME_FRAMES},
+	{"slowdown",				no_argument,		NULL,	_O_SLOWDOWN},
+	{"allow-origin",			required_argument,	NULL,	_O_ALLOW_ORIGIN},
+	{"fake-resolution",			required_argument,	NULL,	_O_FAKE_RESOLUTION},
+	{"tcp-nodelay",				no_argument,		NULL,	_O_TCP_NODELAY},
+	{"server-timeout",			required_argument,	NULL,	_O_SERVER_TIMEOUT},
+
+#ifdef WITH_GPIO
+	{"gpio-device",				required_argument,	NULL,	_O_GPIO_DEVICE},
+	{"gpio-consumer-prefix",	required_argument,	NULL,	_O_GPIO_CONSUMER_PREFIX},
+	{"gpio-prog-running",		required_argument,	NULL,	_O_GPIO_PROG_RUNNING},
+	{"gpio-stream-online",		required_argument,	NULL,	_O_GPIO_STREAM_ONLINE},
+	{"gpio-has-http-clients",	required_argument,	NULL,	_O_GPIO_HAS_HTTP_CLIENTS},
+#endif
+
+#ifdef HAS_PDEATHSIG
+	{"exit-on-parent-death",	no_argument,		NULL,	_O_EXIT_ON_PARENT_DEATH},
+#endif
+#ifdef WITH_SETPROCTITLE
+	{"process-name-prefix",		required_argument,	NULL,	_O_PROCESS_NAME_PREFIX},
+#endif
+	{"notify-parent",			no_argument,		NULL,	_O_NOTIFY_PARENT},
+
+	{"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},
+	{"features",				no_argument,		NULL,	_O_FEATURES},
+
+	{NULL, 0, NULL, 0},
+};
+
+
+static int _parse_resolution(const char *str, unsigned *width, unsigned *height, bool limited);
+#ifdef WITH_OMX
+static int _parse_glitched_resolutions(const char *str, struct encoder_t *encoder);
+#endif
+
+static void _features(void);
+static void _help(struct device_t *dev, struct encoder_t *encoder, struct http_server_t *server);
+
+
+struct options_t *options_init(int argc, char *argv[]) {
+	struct options_t *options;
+
+	A_CALLOC(options, 1);
+	options->argc = argc;
+	options->argv = argv;
+
+	A_CALLOC(options->argv_copy, argc);
+	for (int index = 0; index < argc; ++index) {
+		assert(options->argv_copy[index] = strdup(argv[index]));
+	}
+
+	return options;
+}
+
+void options_destroy(struct options_t *options) {
+	for (int index = 0; index < options->argc; ++index) {
+		free(options->argv_copy[index]);
+	}
+	free(options->argv_copy);
+	free(options);
+}
+
+
+int options_parse(struct options_t *options, struct device_t *dev, struct encoder_t *encoder, struct http_server_t *server) {
+#	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_RESOLUTION(_name, _dest_width, _dest_height, _limited) { \
+			switch (_parse_resolution(optarg, &_dest_width, &_dest_height, _limited)) { \
+				case -1: \
+					printf("Invalid resolution format for '%s=%s'\n", _name, optarg); \
+					return -1; \
+				case -2: \
+					printf("Invalid width of '%s=%s': min=%u, max=%u\n", _name, optarg, VIDEO_MIN_WIDTH, VIDEO_MAX_WIDTH); \
+					return -1; \
+				case -3: \
+					printf("Invalid height of '%s=%s': min=%u, max=%u\n", _name, optarg, VIDEO_MIN_HEIGHT, VIDEO_MAX_HEIGHT); \
+					return -1; \
+				case 0: break; \
+				default: assert(0 && "Unknown error"); \
+			} \
+			break; \
+		}
+
+#	define OPT_PARSE(_name, _dest, _func, _invalid, _available) { \
+			if ((_dest = _func(optarg)) == _invalid) { \
+				printf("Unknown " _name ": %s; available: %s\n", optarg, _available); \
+				return -1; \
+			} \
+			break; \
+		}
+
+#	define OPT_CTL_DEFAULT_NOBREAK(_dest) { \
+			dev->ctl._dest.mode = CTL_MODE_DEFAULT; \
+		}
+
+#	define OPT_CTL_MANUAL(_dest) { \
+			if (!strcasecmp(optarg, "default")) { \
+				OPT_CTL_DEFAULT_NOBREAK(_dest); \
+			} else { \
+				dev->ctl._dest.mode = CTL_MODE_VALUE; \
+				OPT_NUMBER("--"#_dest, dev->ctl._dest.value, INT_MIN, INT_MAX, 0); \
+			} \
+			break; \
+		}
+
+#	define OPT_CTL_AUTO(_dest) { \
+			if (!strcasecmp(optarg, "default")) { \
+				OPT_CTL_DEFAULT_NOBREAK(_dest); \
+			} else if (!strcasecmp(optarg, "auto")) { \
+				dev->ctl._dest.mode = CTL_MODE_AUTO; \
+			} else { \
+				dev->ctl._dest.mode = CTL_MODE_VALUE; \
+				OPT_NUMBER("--"#_dest, dev->ctl._dest.value, INT_MIN, INT_MAX, 0); \
+			} \
+			break; \
+		}
+
+	int ch;
+	int short_index;
+	int opt_index;
+	char short_opts[1024] = {0};
+#	ifdef WITH_SETPROCTITLE
+	char *process_name_prefix = NULL;
+#	endif
+
+	for (short_index = 0, opt_index = 0; _LONG_OPTS[opt_index].name != NULL; ++opt_index) {
+		if (isalpha(_LONG_OPTS[opt_index].val)) {
+			short_opts[short_index] = _LONG_OPTS[opt_index].val;
+			++short_index;
+			if (_LONG_OPTS[opt_index].has_arg == required_argument) {
+				short_opts[short_index] = ':';
+				++short_index;
+			}
+		}
+	}
+
+	while ((ch = getopt_long(options->argc, options->argv_copy, short_opts, _LONG_OPTS, NULL)) >= 0) {
+		switch (ch) {
+			case _O_DEVICE:			OPT_SET(dev->path, optarg);
+			case _O_INPUT:			OPT_NUMBER("--input", dev->input, 0, 128, 0);
+			case _O_RESOLUTION:		OPT_RESOLUTION("--resolution", dev->width, dev->height, true);
+#			pragma GCC diagnostic ignored "-Wsign-compare"
+#			pragma GCC diagnostic push
+			case _O_FORMAT:			OPT_PARSE("pixel format", dev->format, device_parse_format, FORMAT_UNKNOWN, FORMATS_STR);
+#			pragma GCC diagnostic pop
+			case _O_TV_STANDARD:	OPT_PARSE("TV standard", dev->standard, device_parse_standard, STANDARD_UNKNOWN, STANDARDS_STR);
+			case _O_IO_METHOD:		OPT_PARSE("IO method", dev->io_method, device_parse_io_method, IO_METHOD_UNKNOWN, IO_METHODS_STR);
+			case _O_DESIRED_FPS:	OPT_NUMBER("--desired-fps", dev->desired_fps, 0, VIDEO_MAX_FPS, 0);
+			case _O_MIN_FRAME_SIZE:	OPT_NUMBER("--min-frame-size", dev->min_frame_size, 1, 8192, 0);
+			case _O_PERSISTENT:		OPT_SET(dev->persistent, true);
+			case _O_DV_TIMINGS:		OPT_SET(dev->dv_timings, true);
+			case _O_BUFFERS:		OPT_NUMBER("--buffers", dev->n_buffers, 1, 32, 0);
+			case _O_WORKERS:		OPT_NUMBER("--workers", dev->n_workers, 1, 32, 0);
+			case _O_QUALITY:		OPT_NUMBER("--quality", encoder->quality, 1, 100, 0);
+			case _O_ENCODER:		OPT_PARSE("encoder type", encoder->type, encoder_parse_type, ENCODER_TYPE_UNKNOWN, ENCODER_TYPES_STR);
+#			ifdef WITH_OMX
+			case _O_GLITCHED_RESOLUTIONS:
+				if (_parse_glitched_resolutions(optarg, encoder) < 0) {
+					return -1;
+				}
+				break;
+#			endif
+			case _O_DEVICE_TIMEOUT:		OPT_NUMBER("--device-timeout", dev->timeout, 1, 60, 0);
+			case _O_DEVICE_ERROR_DELAY:	OPT_NUMBER("--device-error-delay", dev->error_delay, 1, 60, 0);
+
+			case _O_IMAGE_DEFAULT:
+				OPT_CTL_DEFAULT_NOBREAK(brightness);
+				OPT_CTL_DEFAULT_NOBREAK(contrast);
+				OPT_CTL_DEFAULT_NOBREAK(saturation);
+				OPT_CTL_DEFAULT_NOBREAK(hue);
+				OPT_CTL_DEFAULT_NOBREAK(gamma);
+				OPT_CTL_DEFAULT_NOBREAK(sharpness);
+				OPT_CTL_DEFAULT_NOBREAK(backlight_compensation);
+				OPT_CTL_DEFAULT_NOBREAK(white_balance);
+				OPT_CTL_DEFAULT_NOBREAK(gain);
+				OPT_CTL_DEFAULT_NOBREAK(color_effect);
+				OPT_CTL_DEFAULT_NOBREAK(flip_vertical);
+				OPT_CTL_DEFAULT_NOBREAK(flip_horizontal);
+				break;
+			case _O_BRIGHTNESS:				OPT_CTL_AUTO(brightness);
+			case _O_CONTRAST:				OPT_CTL_MANUAL(contrast);
+			case _O_SATURATION:				OPT_CTL_MANUAL(saturation);
+			case _O_HUE:					OPT_CTL_AUTO(hue);
+			case _O_GAMMA:					OPT_CTL_MANUAL(gamma);
+			case _O_SHARPNESS:				OPT_CTL_MANUAL(sharpness);
+			case _O_BACKLIGHT_COMPENSATION:	OPT_CTL_MANUAL(backlight_compensation);
+			case _O_WHITE_BALANCE:			OPT_CTL_AUTO(white_balance);
+			case _O_GAIN:					OPT_CTL_AUTO(gain);
+			case _O_COLOR_EFFECT:			OPT_CTL_MANUAL(color_effect);
+			case _O_FLIP_VERTICAL:			OPT_CTL_MANUAL(flip_vertical);
+			case _O_FLIP_HORIZONTAL:		OPT_CTL_MANUAL(flip_horizontal);
+
+			case _O_HOST:				OPT_SET(server->host, optarg);
+			case _O_PORT:				OPT_NUMBER("--port", server->port, 1, 65535, 0);
+			case _O_UNIX:				OPT_SET(server->unix_path, optarg);
+			case _O_UNIX_RM:			OPT_SET(server->unix_rm, true);
+			case _O_UNIX_MODE:			OPT_NUMBER("--unix-mode", server->unix_mode, INT_MIN, INT_MAX, 8);
+			case _O_USER:				OPT_SET(server->user, optarg);
+			case _O_PASSWD:				OPT_SET(server->passwd, optarg);
+			case _O_STATIC:				OPT_SET(server->static_path, optarg);
+			case _O_BLANK:				OPT_SET(server->blank_path, optarg);
+			case _O_LAST_AS_BLANK:		OPT_NUMBER("--last-as-blank", server->last_as_blank, 0, 86400, 0);
+			case _O_DROP_SAME_FRAMES:	OPT_NUMBER("--drop-same-frames", server->drop_same_frames, 0, VIDEO_MAX_FPS, 0);
+			case _O_SLOWDOWN:			OPT_SET(server->slowdown, true);
+			case _O_FAKE_RESOLUTION:	OPT_RESOLUTION("--fake-resolution", server->fake_width, server->fake_height, false);
+			case _O_ALLOW_ORIGIN:		OPT_SET(server->allow_origin, optarg);
+			case _O_TCP_NODELAY:		OPT_SET(server->tcp_nodelay, true);
+			case _O_SERVER_TIMEOUT:		OPT_NUMBER("--server-timeout", server->timeout, 1, 60, 0);
+
+#			ifdef WITH_GPIO
+			case _O_GPIO_DEVICE:			OPT_SET(gpio.path, optarg);
+			case _O_GPIO_CONSUMER_PREFIX:	OPT_SET(gpio.consumer_prefix, optarg);
+			case _O_GPIO_PROG_RUNNING:		OPT_NUMBER("--gpio-prog-running", gpio.prog_running.pin, 0, 256, 0);
+			case _O_GPIO_STREAM_ONLINE:		OPT_NUMBER("--gpio-stream-online", gpio.stream_online.pin, 0, 256, 0);
+			case _O_GPIO_HAS_HTTP_CLIENTS:	OPT_NUMBER("--gpio-has-http-clients", gpio.has_http_clients.pin, 0, 256, 0);
+#			endif
+
+#			ifdef HAS_PDEATHSIG
+			case _O_EXIT_ON_PARENT_DEATH:
+				if (process_track_parent_death() < 0) {
+					return -1;
+				};
+				break;
+#			endif
+#			ifdef WITH_SETPROCTITLE
+			case _O_PROCESS_NAME_PREFIX:	OPT_SET(process_name_prefix, optarg);
+#			endif
+			case _O_NOTIFY_PARENT:			OPT_SET(server->notify_parent, true);
+
+			case _O_LOG_LEVEL:			OPT_NUMBER("--log-level", log_level, LOG_LEVEL_INFO, LOG_LEVEL_DEBUG, 0);
+			case _O_PERF:				OPT_SET(log_level, LOG_LEVEL_PERF);
+			case _O_VERBOSE:			OPT_SET(log_level, LOG_LEVEL_VERBOSE);
+			case _O_DEBUG:				OPT_SET(log_level, LOG_LEVEL_DEBUG);
+			case _O_FORCE_LOG_COLORS:	OPT_SET(log_colored, true);
+			case _O_NO_LOG_COLORS:		OPT_SET(log_colored, false);
+
+			case _O_HELP:		_help(dev, encoder, server); return 1;
+			case _O_VERSION:	puts(VERSION); return 1;
+			case _O_FEATURES:	_features(); return 1;
+
+			case 0:		break;
+			default:	_help(dev, encoder, server); return -1;
+		}
+	}
+
+#	ifdef WITH_SETPROCTITLE
+	if (process_name_prefix != NULL) {
+		process_set_name_prefix(options->argc, options->argv, process_name_prefix);
+	}
+#	endif
+
+#	undef OPT_CTL_AUTO
+#	undef OPT_CTL_MANUAL
+#	undef OPT_CTL_DEFAULT_NOBREAK
+#	undef OPT_PARSE
+#	undef OPT_RESOLUTION
+#	undef OPT_NUMBER
+#	undef OPT_SET
+	return 0;
+}
+
+static int _parse_resolution(const char *str, unsigned *width, unsigned *height, bool limited) {
+	unsigned tmp_width;
+	unsigned tmp_height;
+
+	if (sscanf(str, "%ux%u", &tmp_width, &tmp_height) != 2) {
+		return -1;
+	}
+	if (limited) {
+		if (tmp_width < VIDEO_MIN_WIDTH || tmp_width > VIDEO_MAX_WIDTH) {
+			return -2;
+		}
+		if (tmp_height < VIDEO_MIN_HEIGHT || tmp_height > VIDEO_MAX_HEIGHT) {
+			return -3;
+		}
+	}
+	*width = tmp_width;
+	*height = tmp_height;
+	return 0;
+}
+
+#ifdef WITH_OMX
+static int _parse_glitched_resolutions(const char *str, struct encoder_t *encoder) {
+	char *str_copy;
+	char *ptr;
+	unsigned count = 0;
+	unsigned width;
+	unsigned height;
+
+	assert((str_copy = strdup(str)) != NULL);
+
+	ptr = strtok(str_copy, ",;:\n\t ");
+	while (ptr != NULL) {
+		if (count >= MAX_GLITCHED_RESOLUTIONS) {
+			printf("Too big '--glitched-resolutions' list: maxlen=%u\n", MAX_GLITCHED_RESOLUTIONS);
+			goto error;
+		}
+
+		switch (_parse_resolution(ptr, &width, &height, true)) {
+			case -1:
+				printf("Invalid resolution format of '%s' in '--glitched-resolutions=%s\n", ptr, str_copy);
+				goto error;
+			case -2:
+				printf("Invalid width of '%s' in '--glitched-resolutions=%s: min=%u, max=%u\n",
+					ptr, str_copy, VIDEO_MIN_WIDTH, VIDEO_MIN_HEIGHT);
+				goto error;
+			case -3:
+				printf("Invalid width of '%s' in '--glitched-resolutions=%s: min=%u, max=%u\n",
+					ptr, str_copy, VIDEO_MIN_WIDTH, VIDEO_MIN_HEIGHT);
+				goto error;
+			case 0: break;
+			default: assert(0 && "Unknown error");
+		}
+
+		encoder->glitched_resolutions[count][0] = width;
+		encoder->glitched_resolutions[count][1] = height;
+		count += 1;
+
+		ptr = strtok(NULL, ",;:\n\t ");
+	}
+
+	encoder->n_glitched_resolutions = count;
+	free(str_copy);
+	return 0;
+
+	error:
+		free(str_copy);
+		return -1;
+}
+#endif
+
+static void _features(void) {
+#	ifdef WITH_OMX
+	puts("+ WITH_OMX");
+#	else
+	puts("- WITH_OMX");
+#	endif
+
+#	ifdef WITH_GPIO
+	puts("+ WITH_GPIO");
+#	else
+	puts("- WITH_GPIO");
+#	endif
+
+#	ifdef WITH_PTHREAD_NP
+	puts("+ WITH_PTHREAD_NP");
+#	else
+	puts("- WITH_PTHREAD_NP");
+#	endif
+
+#	ifdef WITH_SETPROCTITLE
+	puts("+ WITH_SETPROCTITLE");
+#	else
+	puts("- WITH_SETPROCTITLE");
+#	endif
+
+#	ifdef HAS_PDEATHSIG
+	puts("+ HAS_PDEATHSIG");
+#	else
+	puts("- HAS_PDEATHSIG");
+#	endif
+}
+
+static void _help(struct device_t *dev, struct encoder_t *encoder, struct http_server_t *server) {
+	printf("\nuStreamer - Lightweight and fast MJPG-HTTP streamer\n");
+	printf("═══════════════════════════════════════════════════\n\n");
+	printf("Version: %s; license: GPLv3\n", VERSION);
+	printf("Copyright (C) 2018 Maxim Devaev <mdevaev@gmail.com>\n\n");
+	printf("Capturing options:\n");
+	printf("══════════════════\n");
+	printf("    -d|--device </dev/path>  ───────────── Path to V4L2 device. Default: %s.\n\n", dev->path);
+	printf("    -i|--input <N>  ────────────────────── Input channel. Default: %u.\n\n", dev->input);
+	printf("    -r|--resolution <WxH>  ─────────────── Initial image resolution. Default: %ux%u.\n\n", dev->width, dev->height);
+	printf("    -m|--format <fmt>  ─────────────────── Image format.\n");
+	printf("                                           Available: %s; default: YUYV.\n\n", FORMATS_STR);
+	printf("    -a|--tv-standard <std>  ────────────── Force TV standard.\n");
+	printf("                                           Available: %s; default: disabled.\n\n", STANDARDS_STR);
+	printf("    -I|--io-method <method>  ───────────── Set V4L2 IO method (see kernel documentation).\n");
+	printf("                                           Changing of this parameter may increase the performance. Or not.\n");
+	printf("                                           Available: %s; default: MMAP\n\n", IO_METHODS_STR);
+	printf("    -f|--desired-fps <N>  ──────────────── Desired FPS. Default: maximum possible.\n\n");
+	printf("    -z|--min-frame-size <N>  ───────────── Drop frames smaller then this limit. Useful if the device\n");
+	printf("                                           produces small-sized garbage frames. Default: %zu bytes.\n\n", dev->min_frame_size);
+	printf("    -n|--persistent  ───────────────────── Don't re-initialize device on timeout. Default: disabled.\n\n");
+	printf("    -t|--dv-timings  ───────────────────── Enable DV timings querying and events processing\n");
+	printf("                                           to automatic resolution change. Default: disabled.\n\n");
+	printf("    -b|--buffers <N>  ──────────────────── The number of buffers to receive data from the device.\n");
+	printf("                                           Each buffer may processed using an independent thread.\n");
+	printf("                                           Default: %u (the number of CPU cores (but not more than 4) + 1).\n\n", dev->n_buffers);
+	printf("    -w|--workers <N>  ──────────────────── The number of worker threads but not more than buffers.\n");
+	printf("                                           Default: %u (the number of CPU cores (but not more than 4)).\n\n", dev->n_workers);
+	printf("    -q|--quality <N>  ──────────────────── Set quality of JPEG encoding from 1 to 100 (best). Default: %u.\n", encoder->quality);
+	printf("                                           Note: If HW encoding is used (JPEG source format selected),\n");
+	printf("                                           this parameter attempts to configure the camera\n");
+	printf("                                           or capture device hardware's internal encoder.\n");
+	printf("                                           It does not re-encode MJPG to MJPG to change the quality level\n");
+	printf("                                           for sources that already output MJPG.\n\n");
+	printf("    -c|--encoder <type>  ───────────────── Use specified encoder. It may affect the number of workers.\n");
+	printf("                                           Available:\n");
+	printf("                                             * CPU  ─ Software MJPG encoding (default);\n");
+#	ifdef WITH_OMX
+	printf("                                             * OMX  ─ GPU hardware accelerated MJPG encoding with OpenMax;\n");
+#	endif
+	printf("                                             * HW  ── Use pre-encoded MJPG frames directly from camera hardware.\n\n");
+#	ifdef WITH_OMX
+	printf("    -g|--glitched-resolutions <WxH,...>  ─ Comma-separated list of resolutions that require forced\n");
+	printf("                                           encoding on CPU instead of OMX. Default: disabled.\n\n");
+#	endif
+	printf("    --device-timeout <sec>  ────────────── Timeout for device querying. Default: %u.\n\n", dev->timeout);
+	printf("    --device-error-delay <sec>  ────────── Delay before trying to connect to the device again\n");
+	printf("                                           after an error (timeout for example). Default: %u.\n\n", dev->error_delay);
+	printf("Image control options:\n");
+	printf("══════════════════════\n");
+	printf("    --image-default  ────────────────────── Reset all image settings bellow to default. Default: no change.\n\n");
+	printf("    --brightness <N|auto|default>  ──────── Set brightness. Default: no change.\n\n");
+	printf("    --contrast <N|default>  ─────────────── Set contrast. Default: no change.\n\n");
+	printf("    --saturation <N|default>  ───────────── Set saturation. Default: no change.\n\n");
+	printf("    --hue <N|auto|default>  ─────────────── Set hue. Default: no change.\n\n");
+	printf("    --gamma <N|default> ─────────────────── Set gamma. Default: no change.\n\n");
+	printf("    --sharpness <N|default>  ────────────── Set sharpness. Default: no change.\n\n");
+	printf("    --backlight-compensation <N|default>  ─ Set backlight compensation. Default: no change.\n\n");
+	printf("    --white-balance <N|auto|default>  ───── Set white balance. Default: no change.\n\n");
+	printf("    --gain <N|auto|default>  ────────────── Set gain. Default: no change.\n\n");
+	printf("    --color-effect <N|default>  ─────────── Set color effect. Default: no change.\n\n");
+	printf("    --flip-vertical <1|0|default>  ──────── Set vertical flip. Default: no change.\n\n");
+	printf("    --flip-horizontal <1|0|default>  ────── Set horizontal flip. Default: no change.\n\n");
+	printf("    Hint: use v4l2-ctl --list-ctrls-menus to query available controls of the device.\n\n");
+	printf("HTTP server options:\n");
+	printf("════════════════════\n");
+	printf("    -s|--host <address>  ──────── Listen on Hostname or IP. Default: %s.\n\n", server->host);
+	printf("    -p|--port <N>  ────────────── Bind to this TCP port. Default: %u.\n\n", server->port);
+	printf("    -U|--unix <path>  ─────────── Bind to UNIX domain socket. Default: disabled.\n\n");
+	printf("    -D|--unix-rm  ─────────────── Try to remove old UNIX socket file before binding. Default: disabled.\n\n");
+	printf("    -M|--unix-mode <mode>  ────── Set UNIX socket file permissions (like 777). Default: disabled.\n\n");
+	printf("    --user <name>  ────────────── HTTP basic auth user. Default: disabled.\n\n");
+	printf("    --passwd <str>  ───────────── HTTP basic auth passwd. Default: empty.\n\n");
+	printf("    --static <path> ───────────── Path to dir with static files instead of embedded root index page.\n");
+	printf("                                  Symlinks are not supported for security reasons. Default: disabled.\n\n");
+	printf("    -k|--blank <path>  ────────── Path to JPEG file that will be shown when the device is disconnected\n");
+	printf("                                  during the streaming. Default: black screen 640x480 with 'NO SIGNAL'.\n\n");
+	printf("    -K|--last-as-blank <sec>  ─── Show the last frame received from the camera after it was disconnected,\n");
+	printf("                                  but no more than specified time (or endlessly if 0 is specified).\n");
+	printf("                                  If the device has not yet been online, display 'NO SIGNAL' or the image\n");
+	printf("                                  specified by option --blank. Default: disabled.\n\n");
+	printf("    -e|--drop-same-frames <N>  ── Don't send identical frames to clients, but no more than specified number.\n");
+	printf("                                  It can significantly reduce the outgoing traffic, but will increase\n");
+	printf("                                  the CPU loading. Don't use this option with analog signal sources\n");
+	printf("                                  or webcams, it's useless. Default: disabled.\n\n");
+	printf("    -l|--slowdown  ────────────── Slowdown capturing to 1 FPS or less when no stream clients are connected.\n");
+	printf("                                  Useful to reduce CPU consumption. Default: disabled.\n\n");
+	printf("    -R|--fake-resolution <WxH>  ─ Override image resolution for the /state. Default: disabled.\n\n");
+	printf("    --tcp-nodelay  ────────────── Set TCP_NODELAY flag to the client /stream socket. Ignored for --unix.\n");
+	printf("                                  Default: disabled.\n\n");
+	printf("    --allow-origin <str>  ─────── Set Access-Control-Allow-Origin header. Default: disabled.\n\n");
+	printf("    --server-timeout <sec>  ───── Timeout for client connections. Default: %u.\n\n", server->timeout);
+#ifdef WITH_GPIO
+	printf("GPIO options:\n");
+	printf("═════════════\n");
+	printf("    --gpio-device </dev/path>  ───── Path to GPIO character device. Default: %s.\n\n", gpio.path);
+	printf("    --gpio-consumer-prefix <str>  ── Consumer prefix for GPIO outputs. Default: %s.\n\n", gpio.consumer_prefix);
+	printf("    --gpio-prog-running <pin>  ───── Set 1 on GPIO pin while uStreamer is running. Default: disabled.\n\n");
+	printf("    --gpio-stream-online <pin>  ──── Set 1 while streaming. Default: disabled\n\n");
+	printf("    --gpio-has-http-clients <pin>  ─ Set 1 while stream has at least one client. Default: disabled.\n\n");
+#endif
+#if (defined(HAS_PDEATHSIG) || defined(WITH_SETPROCTITLE))
+	printf("Process options:\n");
+	printf("════════════════\n");
+#endif
+#ifdef HAS_PDEATHSIG
+	printf("    --exit-on-parent-death  ─────── Exit the program if the parent process is dead. Default: disabled.\n\n");
+#endif
+#ifdef WITH_SETPROCTITLE
+	printf("    --process-name-prefix <str>  ── Set process name prefix which will be displayed in the process list\n");
+	printf("                                    like '<str>: ustreamer --blah-blah-blah'. Default: disabled.\n\n");
+	printf("    --notify-parent  ────────────── Send SIGUSR2 to the parent process when the stream parameters are changed.\n");
+	printf("                                    Checking changes is performed for the online flag and image resolution.\n\n");
+#endif
+	printf("Logging options:\n");
+	printf("════════════════\n");
+	printf("    --log-level <N>  ──── Verbosity level of messages from 0 (info) to 3 (debug).\n");
+	printf("                          Enabling debugging messages can slow down the program.\n");
+	printf("                          Available levels: 0 (info), 1 (performance), 2 (verbose), 3 (debug).\n");
+	printf("                          Default: %d.\n\n", log_level);
+	printf("    --perf  ───────────── Enable performance messages (same as --log-level=1). Default: disabled.\n\n");
+	printf("    --verbose  ────────── Enable verbose messages and lower (same as --log-level=2). Default: disabled.\n\n");
+	printf("    --debug  ──────────── Enable debug messages and lower (same as --log-level=3). Default: disabled.\n\n");
+	printf("    --force-log-colors  ─ Force color logging. Default: colored if stdout is a TTY.\n\n");
+	printf("    --no-log-colors  ──── Disable color logging. Default: ditto.\n\n");
+	printf("Help options:\n");
+	printf("═════════════\n");
+	printf("    -h|--help  ─────── Print this text and exit.\n\n");
+	printf("    -v|--version  ──── Print version and exit.\n\n");
+	printf("    --features  ────── Print list of supported features.\n\n");
+}

src/options.h

@@ -0,0 +1,40 @@
+/*****************************************************************************
+#                                                                            #
+#    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 "device.h"
+#include "encoder.h"
+#include "http/server.h"
+
+
+struct options_t {
+	int		argc;
+	char	**argv;
+	char	**argv_copy;
+};
+
+
+struct options_t *options_init(int argc, char *argv[]);
+void options_destroy(struct options_t *options);
+
+int options_parse(struct options_t *options, struct device_t *dev, struct encoder_t *encoder, struct http_server_t *server);

src/picture.c

@@ -0,0 +1,98 @@
+/*****************************************************************************
+#                                                                            #
+#    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 "picture.h"
+
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include <assert.h>
+
+#include "tools.h"
+#include "logging.h"
+
+
+struct picture_t *picture_init(void) {
+	struct picture_t *picture;
+
+	A_CALLOC(picture, 1);
+	return picture;
+}
+
+void picture_destroy(struct picture_t *picture) {
+	if (picture->data) {
+		free(picture->data);
+	}
+	free(picture);
+}
+
+size_t picture_get_generous_size(unsigned width, unsigned height) {
+	return ((width * height) << 1) * 2;
+}
+
+void picture_realloc_data(struct picture_t *picture, size_t size) {
+	if (picture->allocated < size) {
+		LOG_DEBUG("Increasing picture %p buffer: %zu -> %zu (+%zu)",
+			picture, picture->allocated, size, size - picture->allocated);
+		A_REALLOC(picture->data, size);
+		picture->allocated = size;
+	}
+}
+
+void picture_set_data(struct picture_t *picture, const unsigned char *data, size_t size) {
+	picture_realloc_data(picture, size);
+	memcpy(picture->data, data, size);
+	picture->used = size;
+}
+
+void picture_append_data(struct picture_t *picture, const unsigned char *data, size_t size) {
+	size_t new_used = picture->used + size;
+
+	picture_realloc_data(picture, new_used);
+	memcpy(picture->data + picture->used, data, size);
+	picture->used = new_used;
+}
+
+void picture_copy(const struct picture_t *src, struct picture_t *dest) {
+	picture_set_data(dest, src->data, src->used);
+
+#	define COPY(_field) dest->_field = src->_field
+
+	COPY(used);
+
+	COPY(width);
+	COPY(height);
+
+	COPY(grab_ts);
+	COPY(encode_begin_ts);
+	COPY(encode_end_ts);
+
+#	undef COPY
+}
+
+bool picture_compare(const struct picture_t *a, const struct picture_t *b) {
+	return (
+		a->allocated && b->allocated
+		&& a->used == b->used
+		&& !memcmp(a->data, b->data, b->used)
+	);
+}

src/picture.h

@@ -0,0 +1,51 @@
+/*****************************************************************************
+#                                                                            #
+#    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>
+
+
+struct picture_t {
+	unsigned char	*data;
+	size_t			used;
+	size_t			allocated;
+	unsigned		width;
+	unsigned		height;
+	long double		grab_ts;
+	long double		encode_begin_ts;
+	long double		encode_end_ts;
+};
+
+
+struct picture_t *picture_init(void);
+void picture_destroy(struct picture_t *picture);
+
+size_t picture_get_generous_size(unsigned width, unsigned height);
+
+void picture_realloc_data(struct picture_t *picture, size_t size);
+void picture_set_data(struct picture_t *picture, const unsigned char *data, size_t size);
+void picture_append_data(struct picture_t *picture, const unsigned char *data, size_t size);
+
+void picture_copy(const struct picture_t *src, struct picture_t *dest);
+bool picture_compare(const struct picture_t *a, const struct picture_t *b);

src/process.h

@@ -0,0 +1,139 @@
+/*****************************************************************************
+#                                                                            #
+#    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 <signal.h>
+#include <unistd.h>
+
+#include <sys/types.h>
+
+
+#if defined(__linux__)
+#	define HAS_PDEATHSIG
+#elif defined(__FreeBSD__)
+#	include <sys/param.h>
+#	if __FreeBSD_version >= 1102000
+#		define HAS_PDEATHSIG
+#	endif
+#endif
+
+
+#ifdef WITH_SETPROCTITLE
+#	include <stdlib.h>
+#	include <string.h>
+#	if defined(__linux__)
+#		include <bsd/unistd.h>
+#	elif (defined(__FreeBSD__) || defined(__DragonFly__))
+//#		include <unistd.h>
+//#		include <sys/types.h>
+#	elif (defined(__NetBSD__) || defined(__OpenBSD__)) // setproctitle() placed in stdlib.h
+#	else
+#		error setproctitle() not implemented, you can disable it using WITH_SETPROCTITLE=0
+#	endif
+#endif
+#ifdef HAS_PDEATHSIG
+#	if defined(__linux__)
+#		include <sys/prctl.h>
+#	elif defined(__FreeBSD__)
+#		include <sys/procctl.h>
+#	endif
+#endif
+#ifdef WITH_SETPROCTITLE
+#	include "tools.h"
+#endif
+#ifdef HAS_PDEATHSIG
+#	include "logging.h"
+#endif
+
+
+#ifdef WITH_SETPROCTITLE
+extern char **environ;
+#endif
+
+
+#ifdef HAS_PDEATHSIG
+INLINE int process_track_parent_death(void) {
+	pid_t parent = getppid();
+	int signum = SIGTERM;
+#	if defined(__linux__)
+	int retval = prctl(PR_SET_PDEATHSIG, signum);
+#	elif defined(__FreeBSD__)
+	int retval = procctl(P_PID, 0, PROC_PDEATHSIG_CTL, &signum);
+#	else
+#		error WTF?
+#	endif
+	if (retval < 0) {
+		LOG_PERROR("Can't set to receive SIGTERM on parent process death");
+		return -1;
+	}
+
+	if (kill(parent, 0) < 0) {
+		LOG_PERROR("The parent process %d is already dead", parent);
+		return -1;
+	}
+
+	return 0;
+}
+#endif
+
+#ifdef WITH_SETPROCTITLE
+#	pragma GCC diagnostic ignored "-Wunused-parameter"
+#	pragma GCC diagnostic push
+INLINE void process_set_name_prefix(int argc, char *argv[], const char *prefix) {
+#	pragma GCC diagnostic pop
+
+	char *cmdline = NULL;
+	size_t allocated = 2048;
+	size_t used = 0;
+
+	A_REALLOC(cmdline, allocated);
+	cmdline[0] = '\0';
+
+	for (int index = 0; index < argc; ++index) {
+		size_t arg_len = strlen(argv[index]);
+		if (used + arg_len + 16 >= allocated) {
+			allocated += arg_len + 2048;
+			A_REALLOC(cmdline, allocated); // cppcheck-suppress memleakOnRealloc // False-positive (ok with assert)
+		}
+
+		strcat(cmdline, " ");
+		strcat(cmdline, argv[index]);
+		used = strlen(cmdline); // Не считаем вручную, так надежнее
+	}
+
+#	ifdef __linux__
+	setproctitle_init(argc, argv, environ);
+#	endif
+	setproctitle("-%s:%s", prefix, cmdline);
+
+	free(cmdline);
+}
+#endif
+
+INLINE void process_notify_parent(void) {
+	pid_t parent = getppid();
+
+	if (kill(parent, SIGUSR2) < 0) {
+		LOG_PERROR("Can't send SIGUSR2 to the parent process %d", parent);
+	}
+}

src/stream.c

@@ -20,38 +20,85 @@
 *****************************************************************************/
 
 
+#include "stream.h"
+
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdatomic.h>
 #include <unistd.h>
 #include <errno.h>
-#include <time.h>
 #include <assert.h>
 
 #include <pthread.h>
 
-#include <sys/select.h>
-#include <linux/videodev2.h>
-
 #include "tools.h"
+#include "threading.h"
 #include "logging.h"
-#include "xioctl.h"
+#include "picture.h"
 #include "device.h"
 #include "encoder.h"
-#include "stream.h"
+#ifdef WITH_GPIO
+#	include "gpio/gpio.h"
+#endif
 
 
-static long double _stream_get_fluency_delay(struct device_t *dev, struct workers_pool_t *pool);
-static void _stream_expose_picture(struct stream_t *stream, unsigned buf_index);
+struct _worker_t {
+	pthread_t			tid;
+	unsigned			number;
+	atomic_bool			*proc_stop;
+	atomic_bool			*workers_stop;
 
-static int _stream_init_loop(struct stream_t *stream, struct workers_pool_t *pool);
-static int _stream_init(struct stream_t *stream, struct workers_pool_t *pool);
+	long double			last_comp_time;
 
-static void _stream_init_workers(struct stream_t *stream, struct workers_pool_t *pool);
-static void *_stream_worker_thread(void *v_worker);
-static void _stream_destroy_workers(struct stream_t *stream, struct workers_pool_t *pool);
+	pthread_mutex_t		has_job_mutex;
+	unsigned			buf_index;
+	atomic_bool			has_job;
+	bool				job_timely;
+	bool				job_failed;
+	long double			job_start_ts;
+	pthread_cond_t		has_job_cond;
 
-static int _stream_control(struct device_t *dev, bool enable);
-static int _stream_grab_buffer(struct device_t *dev, struct v4l2_buffer *buf_info);
-static int _stream_release_buffer(struct device_t *dev, struct v4l2_buffer *buf_info);
-static int _stream_handle_event(struct device_t *dev);
+	pthread_mutex_t		*free_workers_mutex;
+	unsigned			*free_workers;
+	pthread_cond_t		*free_workers_cond;
+
+	struct _worker_t	*order_prev;
+	struct _worker_t	*order_next;
+
+	struct device_t		*dev;
+	struct encoder_t	*encoder;
+};
+
+struct _workers_pool_t {
+	unsigned			n_workers;
+	struct _worker_t	*workers;
+	struct _worker_t	*oldest_worker;
+	struct _worker_t	*latest_worker;
+
+	long double			approx_comp_time;
+
+	pthread_mutex_t		free_workers_mutex;
+	unsigned			free_workers;
+	pthread_cond_t		free_workers_cond;
+
+	atomic_bool			workers_stop;
+
+	long double			desired_frames_interval;
+};
+
+
+static struct _workers_pool_t *_stream_init_loop(struct stream_t *stream);
+static struct _workers_pool_t *_stream_init_one(struct stream_t *stream);
+static void _stream_expose_picture(struct stream_t *stream, unsigned buf_index, unsigned captured_fps);
+
+static struct _workers_pool_t *_workers_pool_init(struct stream_t *stream);
+static void _workers_pool_destroy(struct _workers_pool_t *pool);
+
+static void *_worker_thread(void *v_worker);
+
+static struct _worker_t *_workers_pool_wait(struct _workers_pool_t *pool);
+static void _workers_pool_assign(struct _workers_pool_t *pool, struct _worker_t *ready_worker, unsigned buf_index);
+static long double _workers_pool_get_fluency_delay(struct _workers_pool_t *pool, struct _worker_t *ready_worker);
 
 
 struct stream_t *stream_init(struct device_t *dev, struct encoder_t *encoder) {
@@ -59,10 +106,14 @@ struct stream_t *stream_init(struct device_t *dev, struct encoder_t *encoder) {
 	struct stream_t *stream;
 
 	A_CALLOC(proc, 1);
+	atomic_init(&proc->stop, false);
+	atomic_init(&proc->slowdown, false);
 
 	A_CALLOC(stream, 1);
+	stream->picture = picture_init();
 	stream->dev = dev;
 	stream->encoder = encoder;
+	atomic_init(&stream->updated, false);
 	A_MUTEX_INIT(&stream->mutex);
 	stream->proc = proc;
 	return stream;
@@ -70,112 +121,79 @@ struct stream_t *stream_init(struct device_t *dev, struct encoder_t *encoder) {
 
 void stream_destroy(struct stream_t *stream) {
 	A_MUTEX_DESTROY(&stream->mutex);
+	picture_destroy(stream->picture);
 	free(stream->proc);
 	free(stream);
 }
 
 void stream_loop(struct stream_t *stream) {
-	struct workers_pool_t pool;
-	bool workers_stop;
-
-	MEMSET_ZERO(pool);
-	pool.encoder = stream->encoder;
-	pool.workers_stop = &workers_stop;
+	struct _workers_pool_t *pool;
 
 	LOG_INFO("Using V4L2 device: %s", stream->dev->path);
 	LOG_INFO("Using desired FPS: %u", stream->dev->desired_fps);
 
-	while (_stream_init_loop(stream, &pool) == 0) {
-		struct worker_t *oldest_worker = NULL;
-		struct worker_t *last_worker = NULL;
+	while ((pool = _stream_init_loop(stream)) != NULL) {
 		long double grab_after = 0;
 		unsigned fluency_passed = 0;
+		unsigned captured_fps = 0;
 		unsigned captured_fps_accum = 0;
 		long long captured_fps_second = 0;
 		bool persistent_timeout_reported = false;
 
-		LOG_DEBUG("Allocation memory for stream picture ...");
-		A_CALLOC(stream->picture.data, stream->dev->run->max_picture_size);
-
 		LOG_INFO("Capturing ...");
 
-		while (!stream->proc->stop) {
-			int free_worker_number = -1;
+		LOG_DEBUG("Pre-allocating memory for stream picture ...");
+		picture_realloc_data(stream->picture, picture_get_generous_size(stream->dev->run->width, stream->dev->run->height));
+
+		while (!atomic_load(&stream->proc->stop)) {
+			struct _worker_t *ready_worker;
 
 			SEP_DEBUG('-');
+			LOG_DEBUG("Waiting for worker ...");
 
-			LOG_DEBUG("Waiting for workers ...");
-			A_MUTEX_LOCK(&pool.free_workers_mutex);
-			A_COND_WAIT_TRUE(pool.free_workers, &pool.free_workers_cond, &pool.free_workers_mutex);
-			A_MUTEX_UNLOCK(&pool.free_workers_mutex);
+			ready_worker = _workers_pool_wait(pool);
 
-			if (oldest_worker && !oldest_worker->has_job && oldest_worker->buf_index >= 0) {
-				if (oldest_worker->job_failed) {
-					break;
+			if (!ready_worker->job_failed) {
+				if (ready_worker->job_timely) {
+					_stream_expose_picture(stream, ready_worker->buf_index, captured_fps);
+					LOG_PERF("##### Encoded picture exposed; worker=%u", ready_worker->number);
+				} else {
+					LOG_PERF("----- Encoded picture dropped; worker=%u", ready_worker->number);
 				}
-
-				_stream_expose_picture(stream, oldest_worker->buf_index);
-
-				free_worker_number = oldest_worker->number;
-				oldest_worker = oldest_worker->order_next;
-
-				LOG_PERF("##### Raw frame accepted; worker = %u", free_worker_number);
 			} else {
-				for (unsigned number = 0; number < stream->dev->n_workers; ++number) {
-					if (
-						!pool.workers[number].has_job && (
-							free_worker_number == -1
-							|| pool.workers[free_worker_number].job_start_time < pool.workers[number].job_start_time
-						)
-					) {
-						free_worker_number = number;
-						break;
-					}
-				}
-
-				assert(free_worker_number >= 0);
-				assert(!pool.workers[free_worker_number].has_job);
-
-				LOG_PERF("----- Raw frame dropped;  worker = %u", free_worker_number);
-			}
-
-			if (stream->proc->stop) {
 				break;
 			}
 
-			if (stream->proc->slowdown) {
+			if (atomic_load(&stream->proc->stop)) {
+				break;
+			}
+
+			if (atomic_load(&stream->proc->slowdown)) {
 				usleep(1000000);
 			}
 
-#			define INIT_FD_SET(_set) \
-				fd_set _set; FD_ZERO(&_set); FD_SET(stream->dev->run->fd, &_set);
+			bool has_read;
+			bool has_write;
+			bool has_error;
+			int selected = device_select(stream->dev, &has_read, &has_write, &has_error);
 
-			INIT_FD_SET(read_fds);
-			INIT_FD_SET(write_fds);
-			INIT_FD_SET(error_fds);
-
-#			undef INIT_FD_SET
-
-			struct timeval timeout;
-			timeout.tv_sec = stream->dev->timeout;
-			timeout.tv_usec = 0;
-
-			LOG_DEBUG("Calling select() on video device ...");
-			int retval = select(stream->dev->run->fd + 1, &read_fds, &write_fds, &error_fds, &timeout);
-			LOG_DEBUG("Device select() --> %d", retval);
-
-			if (retval < 0) {
+			if (selected < 0) {
 				if (errno != EINTR) {
 					LOG_PERROR("Mainloop select() error");
 					break;
 				}
 
-			} else if (retval == 0) {
+			} else if (selected == 0) {
+#				ifdef WITH_GPIO
+				gpio_set_stream_online(false);
+#				endif
+
 				if (stream->dev->persistent) {
 					if (!persistent_timeout_reported) {
 						LOG_ERROR("Mainloop select() timeout, polling ...")
 						persistent_timeout_reported = true;
 					}
+
 					continue;
 				} else {
 					LOG_ERROR("Mainloop select() timeout");
@@ -185,102 +203,75 @@ void stream_loop(struct stream_t *stream) {
 			} else {
 				persistent_timeout_reported = false;
 
-				if (FD_ISSET(stream->dev->run->fd, &read_fds)) {
+				if (has_read) {
 					LOG_DEBUG("Frame is ready");
 
-					struct v4l2_buffer buf_info;
+#					ifdef WITH_GPIO
+					gpio_set_stream_online(true);
+#					endif
+
+					int buf_index;
 					long double now = get_now_monotonic();
 					long long now_second = floor_ms(now);
 
-					if (_stream_grab_buffer(stream->dev, &buf_info) < 0) {
+					if ((buf_index = device_grab_buffer(stream->dev)) < 0) {
 						break;
 					}
-					stream->dev->run->pictures[buf_info.index].grab_time = now;
 
 					// Workaround for broken, corrupted frames:
 					// Under low light conditions corrupted frames may get captured.
 					// The good thing is such frames are quite small compared to the regular pictures.
 					// For example a VGA (640x480) webcam picture is normally >= 8kByte large,
 					// corrupted frames are smaller.
-					if (buf_info.bytesused < stream->dev->min_frame_size) {
-						LOG_DEBUG("Dropping too small frame sized %u bytes, assuming it as broken", buf_info.bytesused);
+					if (stream->dev->run->hw_buffers[buf_index].used < stream->dev->min_frame_size) {
+						LOG_DEBUG("Dropped too small frame sized %zu bytes, assuming it was broken",
+							stream->dev->run->hw_buffers[buf_index].used);
 						goto pass_frame;
 					}
 
 					{
 						if (now < grab_after) {
 							fluency_passed += 1;
-							LOG_VERBOSE("Passed %u frames for fluency: now=%.03Lf; grab_after=%.03Lf", fluency_passed, now, grab_after);
+							LOG_VERBOSE("Passed %u frames for fluency: now=%.03Lf, grab_after=%.03Lf", fluency_passed, now, grab_after);
 							goto pass_frame;
 						}
 						fluency_passed = 0;
 
 						if (now_second != captured_fps_second) {
-							stream->captured_fps = captured_fps_accum;
+							captured_fps = captured_fps_accum;
 							captured_fps_accum = 0;
 							captured_fps_second = now_second;
-							LOG_PERF("Oldest worker complete, Captured-FPS = %u", stream->captured_fps);
+							LOG_PERF_FPS("A new second has come; captured_fps=%u", captured_fps);
 						}
 						captured_fps_accum += 1;
 
-						long double fluency_delay = _stream_get_fluency_delay(stream->dev, &pool);
+						long double fluency_delay = _workers_pool_get_fluency_delay(pool, ready_worker);
 
 						grab_after = now + fluency_delay;
-						LOG_VERBOSE("Fluency: delay=%.03Lf; grab_after=%.03Lf", fluency_delay, grab_after);
+						LOG_VERBOSE("Fluency: delay=%.03Lf, grab_after=%.03Lf", fluency_delay, grab_after);
 					}
 
-#					define FREE_WORKER(_next) pool.workers[free_worker_number]._next
-
-					LOG_DEBUG("Grabbed a new frame to buffer %u", buf_info.index);
-					FREE_WORKER(buf_info) = buf_info;
-
-					if (!oldest_worker) {
-						oldest_worker = &pool.workers[free_worker_number];
-						last_worker = oldest_worker;
-					} else {
-						if (FREE_WORKER(order_next)) {
-							FREE_WORKER(order_next->order_prev) = FREE_WORKER(order_prev);
-						}
-						if (FREE_WORKER(order_prev)) {
-							FREE_WORKER(order_prev->order_next) = FREE_WORKER(order_next);
-						}
-						FREE_WORKER(order_prev) = last_worker;
-						last_worker->order_next = &pool.workers[free_worker_number];
-						last_worker = &pool.workers[free_worker_number];
-					}
-					last_worker->order_next = NULL;
-
-					A_MUTEX_LOCK(&FREE_WORKER(has_job_mutex));
-					FREE_WORKER(buf_index) = buf_info.index;
-					FREE_WORKER(has_job) = true;
-					A_MUTEX_UNLOCK(&FREE_WORKER(has_job_mutex));
-					A_COND_SIGNAL(&FREE_WORKER(has_job_cond));
-
-#					undef FREE_WORKER
-
-					A_MUTEX_LOCK(&pool.free_workers_mutex);
-					pool.free_workers -= 1;
-					A_MUTEX_UNLOCK(&pool.free_workers_mutex);
+					_workers_pool_assign(pool, ready_worker, buf_index);
 
 					goto next_handlers; // Поток сам освободит буфер
 
 					pass_frame:
 
-					if (_stream_release_buffer(stream->dev, &buf_info) < 0) {
+					if (device_release_buffer(stream->dev, buf_index) < 0) {
 						break;
 					}
 				}
 
 				next_handlers:
 
-				if (FD_ISSET(stream->dev->run->fd, &write_fds)) {
+				if (has_write) {
 					LOG_ERROR("Got unexpected writing event, seems device was disconnected");
 					break;
 				}
 
-				if (FD_ISSET(stream->dev->run->fd, &error_fds)) {
+				if (has_error) {
 					LOG_INFO("Got V4L2 event");
-					if (_stream_handle_event(stream->dev) < 0) {
+					if (device_consume_event(stream->dev) < 0) {
 						break;
 					}
 				}
@@ -288,193 +279,201 @@ void stream_loop(struct stream_t *stream) {
 		}
 
 		A_MUTEX_LOCK(&stream->mutex);
-		stream->picture.size = 0; // On stream offline
-		free(stream->picture.data);
-		stream->width = 0;
-		stream->height = 0;
-		stream->updated = true;
+		stream->online = false;
+		atomic_store(&stream->updated, true);
 		A_MUTEX_UNLOCK(&stream->mutex);
-	}
 
-	_stream_destroy_workers(stream, &pool);
-	_stream_control(stream->dev, false);
-	device_close(stream->dev);
+		_workers_pool_destroy(pool);
+		device_switch_capturing(stream->dev, false);
+		device_close(stream->dev);
+
+#		ifdef WITH_GPIO
+		gpio_set_stream_online(false);
+#		endif
+	}
 }
 
 void stream_loop_break(struct stream_t *stream) {
-	stream->proc->stop = 1;
+	atomic_store(&stream->proc->stop, true);
 }
 
 void stream_switch_slowdown(struct stream_t *stream, bool slowdown) {
-	stream->proc->slowdown = slowdown;
+	atomic_store(&stream->proc->slowdown, slowdown);
 }
 
-static void _stream_expose_picture(struct stream_t *stream, unsigned buf_index) {
-#	define PICTURE(_next) stream->dev->run->pictures[buf_index]._next
+static struct _workers_pool_t *_stream_init_loop(struct stream_t *stream) {
+	struct _workers_pool_t *pool = NULL;
+	int access_error = 0;
 
-	A_MUTEX_LOCK(&stream->mutex);
+	LOG_DEBUG("%s: stream->proc->stop=%d", __FUNCTION__, atomic_load(&stream->proc->stop));
 
-	stream->picture.size = PICTURE(size);
-	stream->picture.allocated = PICTURE(allocated);
-
-	memcpy(stream->picture.data, PICTURE(data), stream->picture.size * sizeof(*stream->picture.data));
-
-	stream->picture.grab_time = PICTURE(grab_time);
-	stream->picture.encode_begin_time = PICTURE(encode_begin_time);
-	stream->picture.encode_end_time = PICTURE(encode_end_time);
-
-	stream->width = stream->dev->run->width;
-	stream->height = stream->dev->run->height;
-	stream->updated = true;
-
-	A_MUTEX_UNLOCK(&stream->mutex);
-
-#	undef PICTURE
-}
-
-static long double _stream_get_fluency_delay(struct device_t *dev, struct workers_pool_t *pool) {
-	long double sum_comp_time = 0;
-	long double avg_comp_time;
-	long double min_delay;
-	long double soft_delay;
-
-	for (unsigned number = 0; number < dev->n_workers; ++number) {
-#		define WORKER(_next) pool->workers[number]._next
-
-		A_MUTEX_LOCK(&WORKER(last_comp_time_mutex));
-		if (WORKER(last_comp_time) > 0) {
-			sum_comp_time += WORKER(last_comp_time);
+	while (!atomic_load(&stream->proc->stop)) {
+		if (access(stream->dev->path, R_OK|W_OK) < 0) {
+			if (access_error != errno) {
+				SEP_INFO('=');
+				LOG_PERROR("Can't access device");
+				LOG_INFO("Waiting for the device access ...");
+				access_error = errno;
+			}
+			sleep(stream->dev->error_delay);
+			continue;
+		} else {
+			SEP_INFO('=');
+			access_error = 0;
 		}
-		A_MUTEX_UNLOCK(&WORKER(last_comp_time_mutex));
 
-#		undef WORKER
-	}
-	avg_comp_time = sum_comp_time / dev->n_workers; // Среднее время работы воркеров
-
-	min_delay = avg_comp_time / dev->n_workers; // Среднее время работы размазывается на N воркеров
-
-	if (dev->desired_fps > 0 && min_delay > 0) {
-		// Искусственное время задержки на основе желаемого FPS, если включен --desired-fps
-		soft_delay = ((long double) 1) / dev->desired_fps - sum_comp_time;
-		return (min_delay > soft_delay ? min_delay : soft_delay);
-	}
-
-	return min_delay;
-}
-
-static int _stream_init_loop(struct stream_t *stream, struct workers_pool_t *pool) {
-	int retval = -1;
-
-	LOG_DEBUG("%s: *stream->proc->stop = %d", __FUNCTION__, stream->proc->stop);
-	while (!stream->proc->stop) {
-		if ((retval = _stream_init(stream, pool)) < 0) {
+		if ((pool = _stream_init_one(stream)) == NULL) {
 			LOG_INFO("Sleeping %u seconds before new stream init ...", stream->dev->error_delay);
 			sleep(stream->dev->error_delay);
 		} else {
 			break;
 		}
 	}
-	return retval;
+	return pool;
 }
 
-static int _stream_init(struct stream_t *stream, struct workers_pool_t *pool) {
-	SEP_INFO('=');
-
-	_stream_destroy_workers(stream, pool);
-	_stream_control(stream->dev, false);
-	device_close(stream->dev);
-
+static struct _workers_pool_t *_stream_init_one(struct stream_t *stream) {
 	if (device_open(stream->dev) < 0) {
 		goto error;
 	}
-	if (_stream_control(stream->dev, true) < 0) {
+	if (device_switch_capturing(stream->dev, true) < 0) {
 		goto error;
 	}
 
-	encoder_prepare_live(pool->encoder, stream->dev);
-
-	_stream_init_workers(stream, pool);
-
-	return 0;
+	encoder_prepare(stream->encoder, stream->dev);
+	return _workers_pool_init(stream);
 
 	error:
 		device_close(stream->dev);
-		return -1;
+		return NULL;
 }
 
-static void _stream_init_workers(struct stream_t *stream, struct workers_pool_t *pool) {
-	LOG_INFO("Spawning %u workers ...", stream->dev->n_workers);
+static void _stream_expose_picture(struct stream_t *stream, unsigned buf_index, unsigned captured_fps) {
+	A_MUTEX_LOCK(&stream->mutex);
 
-	*pool->workers_stop = false;
-	A_CALLOC(pool->workers, stream->dev->n_workers);
+	picture_copy(stream->dev->run->pictures[buf_index], stream->picture);
+
+	stream->online = true;
+	stream->captured_fps = captured_fps;
+	atomic_store(&stream->updated, true);
+
+	A_MUTEX_UNLOCK(&stream->mutex);
+}
+
+static struct _workers_pool_t *_workers_pool_init(struct stream_t *stream) {
+	struct _workers_pool_t *pool;
+
+#	define DEV(_next) stream->dev->_next
+#	define RUN(_next) stream->dev->run->_next
+
+	LOG_INFO("Creating pool with %u workers ...", RUN(n_workers));
+
+	A_CALLOC(pool, 1);
+
+	pool->n_workers = RUN(n_workers);
+	A_CALLOC(pool->workers, pool->n_workers);
 
 	A_MUTEX_INIT(&pool->free_workers_mutex);
 	A_COND_INIT(&pool->free_workers_cond);
 
-	for (unsigned number = 0; number < stream->dev->n_workers; ++number) {
-#		define WORKER(_next)	pool->workers[number]._next
+	atomic_init(&pool->workers_stop, false);
+
+	if (DEV(desired_fps) > 0 && (DEV(desired_fps) < RUN(hw_fps) || RUN(hw_fps) == 0)) {
+		pool->desired_frames_interval = (long double)1 / DEV(desired_fps);
+	}
+
+#	undef RUN
+#	undef DEV
+
+	for (unsigned number = 0; number < pool->n_workers; ++number) {
+#		define WORKER(_next) pool->workers[number]._next
+
+		A_MUTEX_INIT(&WORKER(has_job_mutex));
+		atomic_init(&WORKER(has_job), false);
+		A_COND_INIT(&WORKER(has_job_cond));
+
+		WORKER(number) = number;
+		WORKER(proc_stop) = &stream->proc->stop;
+		WORKER(workers_stop) = &pool->workers_stop;
+
+		WORKER(free_workers_mutex) = &pool->free_workers_mutex;
+		WORKER(free_workers) = &pool->free_workers;
+		WORKER(free_workers_cond) = &pool->free_workers_cond;
+
+		WORKER(dev) = stream->dev;
+		WORKER(encoder) = stream->encoder;
+
+		A_THREAD_CREATE(&WORKER(tid), _worker_thread, (void *)&(pool->workers[number]));
 
 		pool->free_workers += 1;
 
-		A_MUTEX_INIT(&WORKER(has_job_mutex));
-		A_COND_INIT(&WORKER(has_job_cond));
+#		undef WORKER
+	}
+	return pool;
+}
 
-		WORKER(number)			= number;
-		WORKER(proc_stop)		= (sig_atomic_t *volatile)&(stream->proc->stop);
-		WORKER(workers_stop)	= pool->workers_stop;
+static void _workers_pool_destroy(struct _workers_pool_t *pool) {
+	LOG_INFO("Destroying workers pool ...");
 
-		WORKER(free_workers_mutex)	= &pool->free_workers_mutex;
-		WORKER(free_workers)		= &pool->free_workers;
-		WORKER(free_workers_cond)	= &pool->free_workers_cond;
+	atomic_store(&pool->workers_stop, true);
+	for (unsigned number = 0; number < pool->n_workers; ++number) {
+#		define WORKER(_next) pool->workers[number]._next
 
-		WORKER(dev)		= stream->dev;
-		WORKER(encoder)	= pool->encoder;
+		A_MUTEX_LOCK(&WORKER(has_job_mutex));
+		atomic_store(&WORKER(has_job), true); // Final job: die
+		A_MUTEX_UNLOCK(&WORKER(has_job_mutex));
+		A_COND_SIGNAL(&WORKER(has_job_cond));
 
-		A_THREAD_CREATE(&WORKER(tid), _stream_worker_thread, (void *)&(pool->workers[number]));
+		A_THREAD_JOIN(WORKER(tid));
+		A_MUTEX_DESTROY(&WORKER(has_job_mutex));
+		A_COND_DESTROY(&WORKER(has_job_cond));
 
 #		undef WORKER
 	}
+
+	A_MUTEX_DESTROY(&pool->free_workers_mutex);
+	A_COND_DESTROY(&pool->free_workers_cond);
+
+	free(pool->workers);
+	free(pool);
 }
 
-static void *_stream_worker_thread(void *v_worker) {
-	struct worker_t *worker = (struct worker_t *)v_worker;
+static void *_worker_thread(void *v_worker) {
+	struct _worker_t *worker = (struct _worker_t *)v_worker;
 
+	A_THREAD_RENAME("worker-%u", worker->number);
 	LOG_DEBUG("Hello! I am a worker #%u ^_^", worker->number);
 
-	while (!*worker->proc_stop && !*worker->workers_stop) {
+	while (!atomic_load(worker->proc_stop) && !atomic_load(worker->workers_stop)) {
 		LOG_DEBUG("Worker %u waiting for a new job ...", worker->number);
+
 		A_MUTEX_LOCK(&worker->has_job_mutex);
-		A_COND_WAIT_TRUE(worker->has_job, &worker->has_job_cond, &worker->has_job_mutex);
+		A_COND_WAIT_TRUE(atomic_load(&worker->has_job), &worker->has_job_cond, &worker->has_job_mutex);
 		A_MUTEX_UNLOCK(&worker->has_job_mutex);
 
-		if (!*worker->workers_stop) {
-#			define PICTURE(_next) worker->dev->run->pictures[worker->buf_index]._next
+		if (!atomic_load(worker->workers_stop)) {
+#			define PICTURE(_next) worker->dev->run->pictures[worker->buf_index]->_next
 
 			LOG_DEBUG("Worker %u compressing JPEG from buffer %u ...", worker->number, worker->buf_index);
 
-			PICTURE(encode_begin_time) = get_now_monotonic();
-			if (encoder_compress_buffer(worker->encoder, worker->dev, worker->number, worker->buf_index) < 0) {
-				worker->job_failed = true;
-			}
-			PICTURE(encode_end_time) = get_now_monotonic();
+			worker->job_failed = (bool)encoder_compress_buffer(worker->encoder, worker->dev, worker->number, worker->buf_index);
 
-			if (_stream_release_buffer(worker->dev, &worker->buf_info) == 0) {
-				worker->job_start_time = PICTURE(encode_begin_time);
-				worker->has_job = false;
+			if (device_release_buffer(worker->dev, worker->buf_index) == 0) {
+				if (!worker->job_failed) {
+					worker->job_start_ts = PICTURE(encode_begin_ts);
+					worker->last_comp_time = PICTURE(encode_end_ts) - worker->job_start_ts;
 
-				long double last_comp_time = PICTURE(encode_end_time) - worker->job_start_time;
-
-				A_MUTEX_LOCK(&worker->last_comp_time_mutex);
-				worker->last_comp_time = last_comp_time;
-				A_MUTEX_UNLOCK(&worker->last_comp_time_mutex);
-
-				LOG_VERBOSE("Compressed JPEG size=%zu; time=%0.3Lf; worker=%u; buffer=%u",
-					PICTURE(size), last_comp_time, worker->number, worker->buf_index);
+					LOG_VERBOSE("Compressed new JPEG: size=%zu, time=%0.3Lf, worker=%u, buffer=%u",
+						PICTURE(used), worker->last_comp_time, worker->number, worker->buf_index);
+				} else {
+					LOG_VERBOSE("Compression failed: worker=%u, buffer=%u", worker->number, worker->buf_index);
+				}
 			} else {
 				worker->job_failed = true;
-				worker->has_job = false;
 			}
 
+			atomic_store(&worker->has_job, false);
+
 #			undef PICTURE
 		}
 
@@ -488,96 +487,82 @@ static void *_stream_worker_thread(void *v_worker) {
 	return NULL;
 }
 
-static void _stream_destroy_workers(struct stream_t *stream, struct workers_pool_t *pool) {
-	if (pool->workers) {
-		LOG_INFO("Destroying workers ...");
+static struct _worker_t *_workers_pool_wait(struct _workers_pool_t *pool) {
+	struct _worker_t *ready_worker = NULL;
 
-		*pool->workers_stop = true;
-		for (unsigned number = 0; number < stream->dev->n_workers; ++number) {
-#			define WORKER(_next) pool->workers[number]._next
+	A_MUTEX_LOCK(&pool->free_workers_mutex);
+	A_COND_WAIT_TRUE(pool->free_workers, &pool->free_workers_cond, &pool->free_workers_mutex);
+	A_MUTEX_UNLOCK(&pool->free_workers_mutex);
 
-			A_MUTEX_LOCK(&WORKER(has_job_mutex));
-			WORKER(has_job) = true; // Final job: die
-			A_MUTEX_UNLOCK(&WORKER(has_job_mutex));
-			A_COND_SIGNAL(&WORKER(has_job_cond));
-
-			A_THREAD_JOIN(WORKER(tid));
-			A_MUTEX_DESTROY(&WORKER(has_job_mutex));
-			A_COND_DESTROY(&WORKER(has_job_cond));
-
-#			undef WORKER
-		}
-
-		A_MUTEX_DESTROY(&pool->free_workers_mutex);
-		A_COND_DESTROY(&pool->free_workers_cond);
-
-		free(pool->workers);
-	}
-	pool->free_workers = 0;
-	pool->workers = NULL;
-}
-
-static int _stream_control(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;
+	if (pool->oldest_worker && !atomic_load(&pool->oldest_worker->has_job)) {
+		ready_worker = pool->oldest_worker;
+		ready_worker->job_timely = true;
+		pool->oldest_worker = pool->oldest_worker->order_next;
+	} else {
+		for (unsigned number = 0; number < pool->n_workers; ++number) {
+			if (
+				!atomic_load(&pool->workers[number].has_job) && (
+					ready_worker == NULL
+					|| ready_worker->job_start_ts < pool->workers[number].job_start_ts
+				)
+			) {
+				ready_worker = &pool->workers[number];
+				break;
 			}
 		}
-
-		dev->run->capturing = enable;
-		LOG_INFO("Capturing %s", (enable ? "started" : "stopped"));
+		assert(ready_worker != NULL);
+		ready_worker->job_timely = false; // Освободился воркер, получивший задание позже (или самый первый при самом первом захвате)
 	}
-    return 0;
+	return ready_worker;
 }
 
-static int _stream_grab_buffer(struct device_t *dev, struct v4l2_buffer *buf_info) {
-	MEMSET_ZERO_PTR(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;
-	}
-	return 0;
-}
-
-static int _stream_release_buffer(struct device_t *dev, struct v4l2_buffer *buf_info) {
-	LOG_DEBUG("Calling ioctl(VIDIOC_QBUF) ...");
-	if (xioctl(dev->run->fd, VIDIOC_QBUF, buf_info) < 0) {
-		LOG_PERROR("Unable to requeue buffer");
-		return -1;
-	}
-	return 0;
-}
-
-static int _stream_handle_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;
-		}
+static void _workers_pool_assign(struct _workers_pool_t *pool, struct _worker_t *ready_worker, unsigned buf_index) {
+	if (pool->oldest_worker == NULL) {
+		pool->oldest_worker = ready_worker;
+		pool->latest_worker = pool->oldest_worker;
 	} else {
-		LOG_PERROR("Got some V4L2 device event, but where is it? ");
+		if (ready_worker->order_next) {
+			ready_worker->order_next->order_prev = ready_worker->order_prev;
+		}
+		if (ready_worker->order_prev) {
+			ready_worker->order_prev->order_next = ready_worker->order_next;
+		}
+		ready_worker->order_prev = pool->latest_worker;
+		pool->latest_worker->order_next = ready_worker;
+		pool->latest_worker = ready_worker;
 	}
-	return 0;
+	pool->latest_worker->order_next = NULL;
+
+	A_MUTEX_LOCK(&ready_worker->has_job_mutex);
+	ready_worker->buf_index = buf_index;
+	atomic_store(&ready_worker->has_job, true);
+	A_MUTEX_UNLOCK(&ready_worker->has_job_mutex);
+	A_COND_SIGNAL(&ready_worker->has_job_cond);
+
+	A_MUTEX_LOCK(&pool->free_workers_mutex);
+	pool->free_workers -= 1;
+	A_MUTEX_UNLOCK(&pool->free_workers_mutex);
+
+	LOG_DEBUG("Assigned new frame in buffer %u to worker %u", buf_index, ready_worker->number);
+}
+
+static long double _workers_pool_get_fluency_delay(struct _workers_pool_t *pool, struct _worker_t *ready_worker) {
+	long double approx_comp_time;
+	long double min_delay;
+
+	approx_comp_time = pool->approx_comp_time * 0.9 + ready_worker->last_comp_time * 0.1;
+
+	LOG_VERBOSE("Correcting approx_comp_time: %.3Lf -> %.3Lf (last_comp_time=%.3Lf)",
+		pool->approx_comp_time, approx_comp_time, ready_worker->last_comp_time);
+
+	pool->approx_comp_time = approx_comp_time;
+
+	min_delay = pool->approx_comp_time / pool->n_workers; // Среднее время работы размазывается на N воркеров
+
+	if (pool->desired_frames_interval > 0 && min_delay > 0 && pool->desired_frames_interval > min_delay) {
+		// Искусственное время задержки на основе желаемого FPS, если включен --desired-fps
+		// и аппаратный fps не попадает точно в желаемое значение
+		return pool->desired_frames_interval;
+	}
+	return min_delay;
 }

src/stream.h

@@ -23,64 +23,25 @@
 #pragma once
 
 #include <stdbool.h>
-#include <signal.h>
+#include <stdatomic.h>
 
 #include <pthread.h>
 
+#include "picture.h"
 #include "device.h"
 #include "encoder.h"
 
 
-struct worker_t {
-	pthread_t			tid;
-	unsigned			number;
-	sig_atomic_t		*volatile proc_stop;
-	bool				*workers_stop;
-
-	pthread_mutex_t		last_comp_time_mutex;
-	long double			last_comp_time;
-
-	pthread_mutex_t		has_job_mutex;
-	int					buf_index;
-	struct v4l2_buffer	buf_info;
-	bool				has_job;
-	bool				job_failed;
-	long double			job_start_time;
-	pthread_cond_t		has_job_cond;
-
-	pthread_mutex_t		*free_workers_mutex;
-	unsigned			*free_workers;
-	pthread_cond_t		*free_workers_cond;
-
-	struct worker_t		*order_prev;
-	struct worker_t		*order_next;
-
-	struct device_t		*dev;
-	struct encoder_t	*encoder;
-};
-
-struct workers_pool_t {
-	struct worker_t		*workers;
-	bool				*workers_stop;
-
-	pthread_mutex_t		free_workers_mutex;
-	unsigned			free_workers;
-	pthread_cond_t		free_workers_cond;
-
-	struct encoder_t	*encoder;
-};
-
 struct process_t {
-	sig_atomic_t volatile	stop;
-	bool					slowdown;
+	atomic_bool stop;
+	atomic_bool slowdown;
 };
 
 struct stream_t {
-	struct picture_t	picture;
-	unsigned			width;
-	unsigned			height;
+	struct picture_t	*picture;
+	bool				online;
 	unsigned			captured_fps;
-	bool				updated;
+	atomic_bool			updated;
 	pthread_mutex_t		mutex;
 
 	struct process_t	*proc;

src/threading.h

@@ -0,0 +1,125 @@
+/*****************************************************************************
+#                                                                            #
+#    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 <stdio.h>
+#include <unistd.h>
+#include <assert.h>
+
+#include <sys/types.h>
+#include <sys/syscall.h>
+
+#include <pthread.h>
+#ifdef WITH_PTHREAD_NP
+#	if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
+#		include <pthread_np.h>
+#		include <sys/param.h>
+#	endif
+#endif
+
+#include "tools.h"
+
+
+#ifdef PTHREAD_MAX_NAMELEN_NP
+#	define MAX_THREAD_NAME ((size_t)(PTHREAD_MAX_NAMELEN_NP))
+#else
+#	define MAX_THREAD_NAME ((size_t)16)
+#endif
+
+#define A_THREAD_CREATE(_tid, _func, _arg)	assert(!pthread_create(_tid, NULL, _func, _arg))
+#define A_THREAD_JOIN(_tid)					assert(!pthread_join(_tid, NULL))
+
+#ifdef WITH_PTHREAD_NP
+#	define A_THREAD_RENAME(_fmt, ...) { \
+			char _new_tname_buf[MAX_THREAD_NAME] = {0}; \
+			assert(snprintf(_new_tname_buf, MAX_THREAD_NAME, _fmt, ##__VA_ARGS__) > 0); \
+			thread_set_name(_new_tname_buf); \
+		}
+#else
+#	define A_THREAD_RENAME(_fmt, ...)
+#endif
+
+#define A_MUTEX_INIT(_mutex)	assert(!pthread_mutex_init(_mutex, NULL))
+#define A_MUTEX_DESTROY(_mutex)	assert(!pthread_mutex_destroy(_mutex))
+#define A_MUTEX_LOCK(_mutex)	assert(!pthread_mutex_lock(_mutex))
+#define A_MUTEX_UNLOCK(_mutex)	assert(!pthread_mutex_unlock(_mutex))
+
+#define A_COND_INIT(_cond)		assert(!pthread_cond_init(_cond, NULL))
+#define A_COND_DESTROY(_cond)	assert(!pthread_cond_destroy(_cond))
+#define A_COND_SIGNAL(...)		assert(!pthread_cond_signal(__VA_ARGS__))
+#define A_COND_WAIT_TRUE(_var, _cond, _mutex) { while(!_var) assert(!pthread_cond_wait(_cond, _mutex)); }
+
+
+#ifdef WITH_PTHREAD_NP
+INLINE void thread_set_name(const char *name) {
+#	if defined(__linux__)
+	pthread_setname_np(pthread_self(), name);
+#	elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
+	pthread_set_name_np(pthread_self(), name);
+#	elif defined(__NetBSD__)
+	pthread_setname_np(pthread_self(), "%s", (void *)name);
+#	else
+#		error thread_set_name() not implemented, you can disable it using WITH_PTHREAD_NP=0
+#	endif
+}
+#endif
+
+INLINE void thread_get_name(char *name) { // Always required for logging
+#ifdef WITH_PTHREAD_NP
+	int retval = -1;
+#	if defined(__linux__) || defined (__NetBSD__)
+	retval = pthread_getname_np(pthread_self(), name, MAX_THREAD_NAME);
+#	elif \
+		(defined(__FreeBSD__) && defined(__FreeBSD_version) && __FreeBSD_version >= 1103500) \
+		|| (defined(__OpenBSD__) && defined(OpenBSD) && OpenBSD >= 201905) \
+		|| defined(__DragonFly__)
+	pthread_get_name_np(pthread_self(), name, MAX_THREAD_NAME);
+	if (name[0] != '\0') {
+		retval = 0;
+	}
+#	else
+#		error thread_get_name() not implemented, you can disable it using WITH_PTHREAD_NP=0
+#	endif
+	if (retval < 0) {
+#endif
+
+#if defined(__linux__)
+		pid_t tid = syscall(SYS_gettid);
+#elif defined(__FreeBSD__)
+		pid_t tid = syscall(SYS_thr_self);
+#elif defined(__OpenBSD__)
+		pid_t tid = syscall(SYS_getthrid);
+#elif defined(__NetBSD__)
+		pid_t tid = syscall(SYS__lwp_self);
+#elif defined(__DragonFly__)
+		pid_t tid = syscall(SYS_lwp_gettid);
+#else
+		pid_t tid = 0; // Makes cppcheck happy
+#	warning gettid() not implemented
+#endif
+		assert(snprintf(name, MAX_THREAD_NAME, "tid=%d", tid) > 0);
+
+#ifdef WITH_PTHREAD_NP
+	}
+#endif
+}

src/tools.h

@@ -27,31 +27,13 @@
 #include <stdbool.h>
 #include <errno.h>
 #include <math.h>
-#include <pthread.h>
 #include <time.h>
 #include <assert.h>
 
-#include <sys/ioctl.h>
-#include <sys/syscall.h>
-
-
-#define A_THREAD_CREATE(_tid, _func, _arg)	assert(!pthread_create(_tid, NULL, _func, _arg))
-#define A_THREAD_JOIN(_tid)					assert(!pthread_join(_tid, NULL))
-
-#define A_MUTEX_INIT(_mutex)	assert(!pthread_mutex_init(_mutex, NULL))
-#define A_MUTEX_DESTROY(_mutex)	assert(!pthread_mutex_destroy(_mutex))
-#define A_MUTEX_LOCK(_mutex)	assert(!pthread_mutex_lock(_mutex))
-#define A_MUTEX_UNLOCK(_mutex)	assert(!pthread_mutex_unlock(_mutex))
-
-#define A_COND_INIT(_cond)		assert(!pthread_cond_init(_cond, NULL))
-#define A_COND_DESTROY(_cond)	assert(!pthread_cond_destroy(_cond))
-#define A_COND_SIGNAL(...)		assert(!pthread_cond_signal(__VA_ARGS__))
-#define A_COND_WAIT_TRUE(_var, _cond, _mutex) { while(!_var) assert(!pthread_cond_wait(_cond, _mutex)); }
 
 #define A_CALLOC(_dest, _nmemb)		assert((_dest = calloc(_nmemb, sizeof(*(_dest)))))
 #define A_REALLOC(_dest, _nmemb)	assert((_dest = realloc(_dest, _nmemb * sizeof(*(_dest)))))
 #define MEMSET_ZERO(_obj)			memset(&(_obj), 0, sizeof(_obj))
-#define MEMSET_ZERO_PTR(_ptr)		memset(_ptr, 0, sizeof(*(_ptr)))
 
 #define ARRAY_LEN(_array) (sizeof(_array) / sizeof(_array[0]))
 
@@ -63,12 +45,20 @@ INLINE char *bool_to_string(bool flag) {
 	return (flag ? "true" : "false");
 }
 
+INLINE size_t align_size(size_t size, size_t to) {
+	return ((size + (to - 1)) & ~(to - 1));
+}
+
+INLINE unsigned min_u(unsigned a, unsigned b) {
+	return (a < b ? a : b);
+}
+
 INLINE unsigned max_u(unsigned a, unsigned b) {
 	return (a > b ? a : b);
 }
 
 INLINE long long floor_ms(long double now) {
-	return (long long) now - (now < (long long) now); // floor()
+	return (long long)now - (now < (long long)now); // floor()
 }
 
 INLINE void get_now(clockid_t clk_id, time_t *sec, long *msec) {
@@ -88,7 +78,13 @@ INLINE long double get_now_monotonic(void) {
 	time_t sec;
 	long msec;
 
+#	if defined(CLOCK_MONOTONIC_RAW)
 	get_now(CLOCK_MONOTONIC_RAW, &sec, &msec);
+#	elif defined(CLOCK_MONOTONIC_FAST)
+	get_now(CLOCK_MONOTONIC_FAST, &sec, &msec);
+#	else
+	get_now(CLOCK_MONOTONIC, &sec, &msec);
+#	endif
 	return (long double)sec + ((long double)msec) / 1000;
 }
 

src/xioctl.h

@@ -30,7 +30,10 @@
 #include "logging.h"
 
 
-#define XIOCTL_RETRIES 4
+#ifndef CFG_XIOCTL_RETRIES
+#	define CFG_XIOCTL_RETRIES 4
+#endif
+#define XIOCTL_RETRIES ((unsigned)(CFG_XIOCTL_RETRIES))
 
 
 INLINE int xioctl(int fd, int request, void *arg) {
@@ -49,8 +52,9 @@ INLINE int xioctl(int fd, int request, void *arg) {
 		)
 	);
 
+	// cppcheck-suppress knownConditionTrueFalse
 	if (retval && retries <= 0) {
-		LOG_PERROR("ioctl(%d) retried %d times; giving up", request, XIOCTL_RETRIES);
+		LOG_PERROR("ioctl(%d) retried %u times; giving up", request, XIOCTL_RETRIES);
 	}
 	return retval;
 }

tools/common.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+# ========================================================================== #
+#                                                                            #
+#    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/>.  #
+#                                                                            #
+# ========================================================================== #
+
+
+import textwrap
+
+
+# =====
+C_PREPEND = textwrap.dedent("""
+        /*****************************************************************************
+        #                                                                            #
+        #    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
+    """).strip() + "\n"

tools/make-html-h.py

@@ -1,5 +1,5 @@
-#!/usr/bin/env python3
-#============================================================================#
+#!/usr/bin/env -S python3 -B
+# ========================================================================== #
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
@@ -18,60 +18,39 @@
 #    You should have received a copy of the GNU General Public License       #
 #    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
 #                                                                            #
-#============================================================================#
+# ========================================================================== #
 
 
 import sys
 import textwrap
 
+import common
+
 
 # =====
-def main():
-    assert len(sys.argv) == 4, "%s <src> <dest> <name>" % (sys.argv[0])
-
-    src = sys.argv[1]
-    dest = sys.argv[2]
+def main() -> None:
+    assert len(sys.argv) == 4, f"{sys.argv[0]} <file.html> <file.h> <name>"
+    html_path = sys.argv[1]
+    header_path = sys.argv[2]
     name = sys.argv[3]
 
-    with open(src, "r") as html_file:
-        text = html_file.read()
+    with open(html_path, "r") as html_file:
+        html = html_file.read()
 
-    text = text.strip()
-    text = text.replace("\"", "\\\"")
-    text = text.replace("%VERSION%", "\" VERSION \"")
-    text = textwrap.indent(text, "\t", (lambda line: True))
-    text = "\n".join(("%s \\" if line.strip() else "%s\\") % (line) for line in text.split("\n"))
-    text = "const char %s[] = \" \\\n%s\n\";\n" % (name, text)
-    text = textwrap.dedent("""
-        /*****************************************************************************
-        #                                                                            #
-        #    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/>.  #
-        #                                                                            #
-        *****************************************************************************/
+    html = html.strip()
+    html = html.replace("\"", "\\\"")
+    html = html.replace("%VERSION%", "\" VERSION \"")
+    html = textwrap.indent(html, "\t", (lambda line: True))
+    html = "\n".join(
+        (f"{line} \\" if line.strip() else f"{line}\\")
+        for line in html.split("\n")
+    )
 
+    text = f"{common.C_PREPEND}\n#include \"../../config.h\"\n\n\n"
+    text += f"const char HTML_{name}_PAGE[] = \" \\\n{html}\n\";\n"
 
-        #pragma once
-
-        #include "../config.h"
-    """).strip() + "\n\n\n" + text
-
-    with open(dest, "w") as h_file:
-        h_file.write(text)
+    with open(header_path, "w") as header_file:
+        header_file.write(text)
 
 
 # =====

tools/make-jpeg-h.py

@@ -1,5 +1,5 @@
-#!/usr/bin/env python3
-#============================================================================#
+#!/usr/bin/env -S python3 -B
+# ========================================================================== #
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
@@ -18,61 +18,73 @@
 #    You should have received a copy of the GNU General Public License       #
 #    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
 #                                                                            #
-#============================================================================#
+# ========================================================================== #
 
 
 import sys
-import textwrap
+import io
+import struct
+
+from typing import Tuple
+
+import common
 
 
 # =====
-def main():
-    assert len(sys.argv) == 6, "%s <src> <dest> <prefix> <width> <height>" % (sys.argv[0])
+def _get_jpeg_size(data: bytes) -> Tuple[int, int]:
+    # https://sheep.horse/2013/9/finding_the_dimensions_of_a_jpeg_file_in_python.html
 
-    src = sys.argv[1]
-    dest = sys.argv[2]
-    prefix = sys.argv[3]
-    width = int(sys.argv[4])
-    height = int(sys.argv[5])
+    stream = io.BytesIO(data)
+    while True:
+        marker = struct.unpack(">H", stream.read(2))[0]
+        if marker == 0xFFD9:
+            raise RuntimeError("Can't find jpeg size")
 
-    with open(src, "rb") as jpeg_file:
+        if (
+            marker == 0xFFD8  # Start of image
+            or marker == 0xFF01  # Private marker
+            or 0xFFD0 <= marker <= 0xFFD7  # Restart markers
+        ):
+            continue
+
+        # All other markers specify chunks with lengths
+        length = struct.unpack(">H", stream.read(2))[0]
+
+        if marker == 0xFFC0:  # Baseline DCT chunk, has the info we want
+            (_, height, width) = struct.unpack(">BHH", stream.read(5))
+            return (width, height)
+
+        # Not the chunk we want, skip it
+        stream.seek(length - 2, 1)
+
+
+# =====
+def main() -> None:
+    assert len(sys.argv) == 4, f"{sys.argv[0]} <file.jpeg> <file.h> <name>"
+    jpeg_path = sys.argv[1]
+    header_path = sys.argv[2]
+    name = sys.argv[3]
+
+    with open(jpeg_path, "rb") as jpeg_file:
         jpeg_data = jpeg_file.read()
 
-    rows = [[]]
-    for ch in jpeg_data:
-        if len(rows[-1]) > 20:
-            rows.append([])
-        rows[-1].append("0x%.2X" % (ch))
+    (width, height) = _get_jpeg_size(jpeg_data)
 
-    text = ",\n\t".join(", ".join(row) for row in rows)
-    text = "const unsigned char %s_JPEG_DATA[] = {\n\t%s\n};\n" % (prefix, text)
-    text = "const unsigned %s_JPEG_HEIGHT = %d;\n\n" % (prefix, height) + text
-    text = "const unsigned %s_JPEG_WIDTH = %d;\n" % (prefix, width) + text
-    text = textwrap.dedent("""
-        /*****************************************************************************
-        #                                                                            #
-        #    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/>.  #
-        #                                                                            #
-        *****************************************************************************/
-    """).strip() + "\n\n\n" + text
+    jpeg_data_text = "{\n\t" + ",\n\t".join(
+        ", ".join(
+            f"0x{ch:02X}"
+            for ch in jpeg_data[index:index + 20]
+        )
+        for index in range(0, len(jpeg_data), 20)
+    ) + ",\n}"
 
-    with open(dest, "w") as h_file:
-        h_file.write(text)
+    text = f"{common.C_PREPEND}\n\n"
+    text += f"const unsigned {name}_JPEG_WIDTH = {width};\n"
+    text += f"const unsigned {name}_JPEG_HEIGHT = {height};\n\n"
+    text += f"const unsigned char {name}_JPEG_DATA[] = {jpeg_data_text};\n"
+
+    with open(header_path, "w") as header_file:
+        header_file.write(text)
 
 
 # =====