Bump version: 2.0 → 2.1

added info about mjpg-streamer compat and prettify
better access checking
2026-02-19 16:26:30 +00:00 · 2020-09-29 01:42:40 +03:00 · 2020-09-28 13:54:38 +03:00 · 2020-09-28 10:28:42 +03:00 · 2020-09-28 04:29:02 +03:00 · 2020-09-28 04:23:41 +03:00
54 changed files with 1526 additions and 507 deletions
--- a/.bumpversion.cfg
+++ b/.bumpversion.cfg
@@ -1,7 +1,7 @@
 [bumpversion]
 commit = True
 tag = True
-current_version = 1.8
+current_version = 2.1
 parse = (?P<major>\d+)\.(?P<minor>\d+)(\.(?P<patch>\d+)(\-(?P<release>[a-z]+))?)?
 serialize = 
 	{major}.{minor}
@@ -17,4 +17,3 @@ replace = pkgver={new_version}
 [bumpversion:file:pkg/openwrt/Makefile]
 search = PKG_VERSION:={current_version}
 replace = PKG_VERSION:={new_version}
-
--- a/.dockerignore
+++ b/.dockerignore
@@ -0,0 +1,6 @@
+# Ignore everything
+*
+
+# Allow source code
+!Makefile
+!src/**
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -0,0 +1,4 @@
+# These are supported funding model platforms
+
+patreon: pikvm
+custom: https://www.paypal.me/mdevaev
--- a/.github/workflows/dockerimage.yml
+++ b/.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
--- a/.gitignore
+++ b/.gitignore
@@ -1,7 +1,10 @@
+/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.*
--- a/51
+++ b/51
@@ -13,6 +13,8 @@ RPI_VC_LIBS ?= /opt/vc/lib

 BUILD ?= build

+LINTERS_IMAGE ?= $(PROG)-linters
+

 # =====
 _LIBS = -lm -ljpeg -pthread -levent -levent_pthreads -luuid
@@ -33,8 +35,9 @@ endif


 ifneq ($(call optbool,$(WITH_GPIO)),)
-_LIBS += -lwiringPi
+_LIBS += -lgpiod
 override CFLAGS += -DWITH_GPIO
+_SRCS += $(shell ls src/gpio/*.c)
 endif


@@ -44,13 +47,13 @@ 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
+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


 # =====
@@ -87,17 +90,36 @@ $(PROG): $(_SRCS:%.c=$(BUILD)/%.o)
 $(BUILD)/%.o: %.c
 	$(info -- CC $<)
 	@ mkdir -p $(dir $@) || true
-	@ $(CC) $< -o $@ $(CFLAGS) $(_LIBS)
+	@ $(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 $(if $(V),$(V),minor)

@@ -107,7 +129,12 @@ 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 -rf pkg/arch/pkg pkg/arch/src pkg/arch/v*.tar.gz pkg/arch/ustreamer-*.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
--- a/README.md
+++ b/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/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 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,19 +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>1</sup> |
+| 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 to GPIO<br>on Raspberry Pi using [wiringPi](http://wiringpi.com) | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) No |
+| 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 |
+| 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()```.
+  * ```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
@@ -32,7 +36,11 @@ 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```, ```libuuid``` and ```libbsd``` (only for Linux).

-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 [wiringPi](http://wiringpi.com) 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```.
+* 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`.
+
+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/pikvm/ustreamer
@@ -41,16 +49,18 @@ $ make
 $ ./ustreamer --help
 ```

-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```. Same with GPIO.  
+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 \
@@ -62,8 +72,15 @@ $ ./ustreamer \
    --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
--- a/README.ru.md
+++ b/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/pikvm) специально для стриминга с устройств видеозахвата [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```, однако имеет ряд серьезных отличий. Основные приведены в этой таблице:

@@ -11,13 +14,14 @@
 | Многопоточное кодирование 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>трансляции на лету по сигналу<br>источника (устройства видеозахвата) | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть | ![#ffaa00](https://placehold.it/15/ffaa00/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>на Raspberry Pi с помощью [wiringPi](http://wiringpi.com) | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть | ![#f03c15](https://placehold.it/15/f03c15/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=+) Есть |
+| Совместимость с 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, было принято решение написать свой стрим-сервер с нуля, чтобы не тратить силы на поддержку лишнего легаси.
@@ -32,7 +36,11 @@
 # Сборка
 Для сборки вам понадобятся ```make```, ```gcc```, ```libevent``` с поддержкой ```pthreads```, ```libjpeg8```/```libjpeg-turbo```, ```libuuid``` и ```libbsd``` (только для Linux).

-На Raspberry Pi программу можно собрать с поддержкой OpenMAX IL. Для этого передайте ```make``` параметр ```WITH_OMX=1```. Для включения сборки с поддержкой GPIO установите [wiringPi](http://wiringpi.com) и добавьте параметр ```WITH_GPIO=1```. Если при сборке компилятор ругается на отсутствие функции ```pthread_get_name_np()``` или другой подобной, добавьте параметр ```WITH_PTHREAD_NP=0``` (по умолчанию он включен). При аналогичной ошибке с функцией ```setproctitle()``` добавьте параметр ```WITH_SETPROCTITLE=0```.
+* 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`.
+
+На 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/pikvm/ustreamer
@@ -41,7 +49,7 @@ $ make
 $ ./ustreamer --help
 ```

-Для Arch Linux в AUR есть готовый пакет: https://aur.archlinux.org/packages/ustreamer. На Raspberry Pi програма автоматически собирается с поддержкой OpenMAX IL, если обнаружит нужные хедеры в ```/opt/vc/include```. То же самое и с GPIO.  
+Для Arch Linux в AUR есть готовый пакет: https://aur.archlinux.org/packages/ustreamer. На Raspberry Pi програма автоматически собирается с поддержкой OpenMAX IL, если обнаружит нужные хедеры в ```/opt/vc/include```.  
 Порт для FreeBSD: https://www.freshports.org/multimedia/ustreamer.

 -----
@@ -51,6 +59,8 @@ $ ./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 \
@@ -62,8 +72,15 @@ $ ./ustreamer \
    --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
--- a/linters/.dockerignore
+++ b/linters/.dockerignore
@@ -0,0 +1,2 @@
+/.tox/
+/.mypy_cache/
--- a/linters/Dockerfile
+++ b/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
--- a/linters/flake8.ini
+++ b/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
--- a/linters/mypy.ini
+++ b/linters/mypy.ini
@@ -0,0 +1,5 @@
+[mypy]
+python_version = 3.8
+ignore_missing_imports = true
+disallow_untyped_defs = true
+strict_optional = true
--- a/linters/pylint.ini
+++ b/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}$
--- a/linters/tox.ini
+++ b/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
--- a/pkg/arch/PKGBUILD
+++ b/pkg/arch/PKGBUILD
@@ -3,15 +3,14 @@


 pkgname=ustreamer
-pkgver=1.8
+pkgver=2.1
 pkgrel=1
 pkgdesc="Lightweight and fast MJPG-HTTP streamer"
 url="https://github.com/pikvm/ustreamer"
 license=(GPL)
-arch=(i686 x86_64 armv6h armv7h)
-depends=(libjpeg libevent libutil-linux libbsd)
+arch=(i686 x86_64 armv6h armv7h aarch64)
+depends=(libjpeg libevent libutil-linux libbsd libgpiod)
 # optional: raspberrypi-firmware for OMX encoder
-# optional: wiringpi for GPIO support
 makedepends=(gcc make)
 source=(${pkgname}::"git+https://github.com/pikvm/ustreamer#commit=v${pkgver}")
 md5sums=(SKIP)
@@ -23,9 +22,8 @@ build() {
 	cp -r $pkgname $pkgname-build
 	cd $pkgname-build

-	local _options=""
+	local _options="WITH_GPIO=1"
 	[ -e /opt/vc/include/IL/OMX_Core.h ] && _options="$_options WITH_OMX=1"
-	[ -e /usr/include/wiringPi.h ] && _options="$_options WITH_GPIO=1"

 	make $_options CFLAGS="$CFLAGS" LDFLAGS="$LDFLAGS" $MAKEFLAGS
 }
--- a/pkg/docker/Dockerfile.arm.cross
+++ b/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
--- a/pkg/docker/Dockerfile.arm.native
+++ b/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
--- a/pkg/docker/Dockerfile.x64.native
+++ b/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
--- a/pkg/openwrt/Makefile
+++ b/pkg/openwrt/Makefile
@@ -6,7 +6,7 @@
 include $(TOPDIR)/rules.mk

 PKG_NAME:=ustreamer
-PKG_VERSION:=1.8
+PKG_VERSION:=2.1
 PKG_RELEASE:=1
 PKG_MAINTAINER:=Maxim Devaev <mdevaev@gmail.com>

--- a/src/config.h
+++ b/src/config.h
@@ -23,5 +23,5 @@
 #pragma once

 #ifndef VERSION
-#	define VERSION "1.8"
+#	define VERSION "2.1"
 #endif
--- a/src/device.c
+++ b/src/device.c
@@ -41,6 +41,7 @@

 #include "tools.h"
 #include "logging.h"
+#include "threading.h"
 #include "xioctl.h"
 #include "picture.h"

@@ -67,24 +68,36 @@ 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 void _device_open_hw_fps(struct device_t *dev);
-static int _device_open_mmap(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(void) {
@@ -108,8 +121,10 @@ struct device_t *device_init(void) {
 	dev->standard = V4L2_STD_UNKNOWN;
 	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->io_method = V4L2_MEMORY_MMAP;
 	dev->run = run;
 	return dev;
 }
@@ -137,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");
@@ -154,7 +178,7 @@ int device_open(struct device_t *dev) {
 		goto error;
 	}
 	_device_open_hw_fps(dev);
-	if (_device_open_mmap(dev) < 0) {
+	if (_device_open_io_method(dev) < 0) {
 		goto error;
 	}
 	if (_device_open_queue_buffers(dev) < 0) {
@@ -186,15 +210,22 @@ void device_close(struct device_t *dev) {
 	}

 	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(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);
+			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
 		}
@@ -256,9 +287,9 @@ int device_select(struct device_t *dev, bool *has_read, bool *has_write, bool *h
 		*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;
+		*has_read = false;
+		*has_write = false;
+		*has_error = false;
 	}

 	LOG_DEBUG("Device select() --> %d", retval);
@@ -270,33 +301,59 @@ int device_grab_buffer(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;

-	LOG_DEBUG("Calling ioctl(VIDIOC_DQBUF) ...");
+	LOG_DEBUG("Grabbing device buffer ...");
 	if (xioctl(dev->run->fd, VIDIOC_DQBUF, &buf_info) < 0) {
-		LOG_PERROR("Unable to dequeue buffer");
+		LOG_PERROR("Unable to grab device buffer");
 		return -1;
 	}

-	LOG_DEBUG("Got a new frame in buffer: index=%u, bytesused=%u", buf_info.index, buf_info.bytesused);
+	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("Got invalid buffer: index=%u, nbuffers=%u", 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;
 	}

-	dev->run->hw_buffers[buf_info.index].used = buf_info.bytesused;
-	memcpy(&dev->run->hw_buffers[buf_info.index].buf_info, &buf_info, sizeof(struct v4l2_buffer));
-	dev->run->pictures[buf_info.index]->grab_time = get_now_monotonic();
+#	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) {
-	LOG_DEBUG("Calling ioctl(VIDIOC_QBUF) ...");
-	if (xioctl(dev->run->fd, VIDIOC_QBUF, &dev->run->hw_buffers[index].buf_info) < 0) {
-		LOG_PERROR("Unable to requeue buffer");
+#	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;
 	}
-	dev->run->hw_buffers[index].used = 0;
+	HW_BUFFER(grabbed) = false;
+	A_MUTEX_UNLOCK(&HW_BUFFER(grabbed_mutex));
+	HW_BUFFER(used) = 0;
+
+#	undef HW_BUFFER
 	return 0;
 }

@@ -390,7 +447,7 @@ static int _device_apply_dv_timings(struct device_t *dev) {
 	LOG_DEBUG("Calling ioctl(VIDIOC_QUERY_DV_TIMINGS) ...");
 	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, dv.bt.pixelclock);
+			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) < 0) {
@@ -464,12 +521,16 @@ 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 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;

@@ -500,16 +561,37 @@ static void _device_open_hw_fps(struct device_t *dev) {
 		return;
 	}

-	if (dev->desired_fps != SETFPS_TPF(denominator)) {
-		LOG_INFO("Using HW FPS: %u -> %u (coerced)", dev->desired_fps, SETFPS_TPF(denominator));
+	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->desired_fps);
+		LOG_INFO("Using HW FPS: %u", dev->run->hw_fps);
 	}

 #	undef SETFPS_TPF
 }

-static int _device_open_mmap(struct device_t *dev) {
+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);
@@ -517,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) ...");
+	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 memory mapping", dev->path);
+		LOG_PERROR("Device '%s' doesn't support V4L2_MEMORY_MMAP", dev->path);
 		return -1;
 	}

@@ -527,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) {
@@ -549,6 +631,8 @@ 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) {
@@ -562,14 +646,56 @@ static int _device_open_mmap(struct device_t *dev) {
 	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
+	}
+	return 0;
+}
+
 static int _device_open_queue_buffers(struct device_t *dev) {
 	for (unsigned index = 0; index < dev->run->n_buffers; ++index) {
 		struct v4l2_buffer buf_info;

 		MEMSET_ZERO(buf_info);
 		buf_info.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-		buf_info.memory = V4L2_MEMORY_MMAP;
+		buf_info.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) {
@@ -610,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;
@@ -678,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);
 	}
 }

@@ -688,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';
@@ -721,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";
+}
--- a/src/device.h
+++ b/src/device.h
@@ -25,18 +25,19 @@
 #include <stddef.h>
 #include <stdbool.h>

+#include <pthread.h>
 #include <linux/videodev2.h>

 #include "picture.h"


-#define VIDEO_MIN_WIDTH		160
-#define VIDEO_MAX_WIDTH		10240
+#define VIDEO_MIN_WIDTH		((unsigned)160)
+#define VIDEO_MAX_WIDTH		((unsigned)10240)

-#define VIDEO_MIN_HEIGHT	120
-#define VIDEO_MAX_HEIGHT	4320
+#define VIDEO_MIN_HEIGHT	((unsigned)120)
+#define VIDEO_MAX_HEIGHT	((unsigned)4320)

-#define VIDEO_MAX_FPS		120
+#define VIDEO_MAX_FPS		((unsigned)120)

 #define STANDARD_UNKNOWN	V4L2_STD_UNKNOWN
 #define STANDARDS_STR		"PAL, NTSC, SECAM"
@@ -44,12 +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				used;
 	size_t				allocated;
 	struct v4l2_buffer	buf_info;
+
+	pthread_mutex_t grabbed_mutex;
+	bool			grabbed;
 };

 struct device_runtime_t {
@@ -57,6 +64,8 @@ struct device_runtime_t {
 	unsigned			width;
 	unsigned			height;
 	unsigned			format;
+	unsigned			hw_fps;
+	size_t				raw_size;
 	unsigned			n_buffers;
 	unsigned			n_workers;
 	struct hw_buffer_t	*hw_buffers;
@@ -64,10 +73,16 @@ struct device_runtime_t {
 	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 {
@@ -80,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 {
@@ -89,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;
@@ -109,6 +128,7 @@ 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);
--- a/src/encoder.c
+++ b/src/encoder.c
@@ -170,6 +170,7 @@ void encoder_prepare(struct encoder_t *encoder, struct device_t *dev) {

 #	pragma GCC diagnostic ignored "-Wunused-label"
 #	pragma GCC diagnostic push
+	// cppcheck-suppress unusedLabel
 	force_cpu:
 		cpu_forced = true;
 #	pragma GCC diagnostic pop
@@ -200,23 +201,27 @@ int encoder_compress_buffer(struct encoder_t *encoder, struct device_t *dev, uns
 #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_time = get_now_monotonic();
+	dev->run->pictures[buf_index]->encode_begin_ts = get_now_monotonic();

 	if (encoder->run->type == ENCODER_TYPE_CPU) {
+		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
 	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 error;
 		}
 	}
 #	endif

-	dev->run->pictures[buf_index]->encode_end_time = get_now_monotonic();
+	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;
@@ -225,6 +230,7 @@ int encoder_compress_buffer(struct encoder_t *encoder, struct device_t *dev, uns

 #	pragma GCC diagnostic ignored "-Wunused-label"
 #	pragma GCC diagnostic push
+	// cppcheck-suppress unusedLabel
 	error:
 		LOG_INFO("Error while compressing buffer, falling back to CPU");
 		A_MUTEX_LOCK(&encoder->run->mutex);
--- a/src/encoder.h
+++ b/src/encoder.h
@@ -33,9 +33,10 @@

 #	define ENCODER_TYPES_OMX_HINT ", OMX"

-#	ifndef MAX_GLITCHED_RESOLUTIONS
-#		define MAX_GLITCHED_RESOLUTIONS 1024
+#	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
--- a/src/encoders/cpu/encoder.c
+++ b/src/encoders/cpu/encoder.c
@@ -258,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;
--- a/src/encoders/omx/component.c
+++ b/src/encoders/omx/component.c
@@ -61,6 +61,7 @@ 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;

--- a/src/encoders/omx/encoder.c
+++ b/src/encoders/omx/encoder.c
@@ -102,11 +102,11 @@ struct omx_encoder_t *omx_encoder_init(void) {

 	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;
@@ -132,8 +132,8 @@ void omx_encoder_destroy(struct omx_encoder_t *omx) {
 	_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) {
@@ -180,6 +180,7 @@ int omx_encoder_compress_buffer(struct omx_encoder_t *omx, struct device_t *dev,
 #	define OUT(_next)		omx->output_buffer->_next

 	OMX_ERRORTYPE error;
+	VCOS_STATUS_T sem_status;
 	size_t slice_size = (IN(nAllocLen) < HW_BUFFER(used) ? IN(nAllocLen) : HW_BUFFER(used));
 	size_t pos = 0;

@@ -236,7 +237,13 @@ int omx_encoder_compress_buffer(struct omx_encoder_t *omx, struct device_t *dev,
 			}
 		}

-		vcos_semaphore_wait(&omx->handler_lock);
+		// vcos_semaphore_wait(&omx->handler_sem);
+		switch (sem_status = vcos_semaphore_wait_timeout(&omx->handler_sem, 3000)) {
+			case VCOS_SUCCESS: break;
+			case VCOS_EAGAIN: LOG_ERROR("Can't wait VCOS semaphore: EAGAIN (timeout)"); return -1;
+			case VCOS_EINVAL: LOG_ERROR("Can't wait VCOS semaphore: EINTVAL"); return -1;
+			default: LOG_ERROR("Can't wait VCOS semaphore: %d", sem_status); return -1;
+		}
 	}

 #	undef OUT
@@ -305,9 +312,7 @@ 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 = picture_get_generous_size(dev->run->width, dev->run->height);
@@ -428,32 +433,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_ERROR_OMX(error, "Can't free OMX JPEG input buffer");
-			// retcode -= 1;
+			// retval -= 1;
 		}
 		omx->input_buffer = NULL;
 	}
 	if (omx->output_buffer) {
 		if ((error = OMX_FreeBuffer(omx->encoder, _OUTPUT_PORT, omx->output_buffer)) != OMX_ErrorNone) {
 			LOG_ERROR_OMX(error, "Can't free OMX JPEG output buffer");
-			// retcode -= 1;
+			// retval -= 1;
 		}
 		omx->output_buffer = NULL;
 	}
-	return retcode;
+	return retval;
 }

 static OMX_ERRORTYPE _omx_event_handler(
@@ -468,7 +473,7 @@ static OMX_ERRORTYPE _omx_event_handler(
 	if (event == OMX_EventError) {
 		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;
 }
@@ -483,7 +488,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;
 }

@@ -497,6 +502,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;
 }
--- a/src/encoders/omx/encoder.h
+++ b/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,9 +42,9 @@ 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;
--- a/src/encoders/omx/formatters.c
+++ b/src/encoders/omx/formatters.c
@@ -35,9 +35,9 @@
 	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) {
@@ -67,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);
 	}
 }
--- a/src/gpio.h
+++ b/src/gpio.h
@@ -1,92 +0,0 @@
-/*****************************************************************************
-#                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
-#                                                                            #
-#    Copyright (C) 2018  Maxim Devaev <mdevaev@gmail.com>                    #
-#                                                                            #
-#    This program is free software: you can redistribute it and/or modify    #
-#    it under the terms of the GNU General Public License as published by    #
-#    the Free Software Foundation, either version 3 of the License, or       #
-#    (at your option) any later version.                                     #
-#                                                                            #
-#    This program is distributed in the hope that it will be useful,         #
-#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
-#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
-#    GNU General Public License for more details.                            #
-#                                                                            #
-#    You should have received a copy of the GNU General Public License       #
-#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
-#                                                                            #
-*****************************************************************************/
-
-
-#pragma once
-
-#include <stdlib.h>
-
-#include <wiringPi.h>
-
-#include "logging.h"
-
-
-int gpio_pin_prog_running;
-int gpio_pin_stream_online;
-int gpio_pin_has_http_clients;
-int gpio_pin_workers_busy_at;
-
-
-#define GPIO_INIT { \
-		gpio_pin_prog_running = -1; \
-		gpio_pin_stream_online = -1; \
-		gpio_pin_has_http_clients = -1; \
-		gpio_pin_workers_busy_at = -1; \
-	}
-
-#define GPIO_INIT_PIN(_role, _offset) { \
-		if (gpio_pin_##_role >= 0) { \
-			pinMode(gpio_pin_##_role + _offset, OUTPUT); \
-			digitalWrite(gpio_pin_##_role + _offset, LOW); \
-			if (_offset == 0) { \
-				LOG_INFO("GPIO: Using pin %d as %s", gpio_pin_##_role, #_role); \
-			} else { \
-				LOG_INFO("GPIO: Using pin %d+%d as %s", gpio_pin_##_role, _offset, #_role); \
-			} \
-		} \
-	}
-
-#define GPIO_INIT_PINOUT { \
-		if ( \
-			gpio_pin_prog_running >= 0 \
-			|| gpio_pin_stream_online >= 0 \
-			|| gpio_pin_has_http_clients >= 0 \
-			|| gpio_pin_workers_busy_at >= 0 \
-		) { \
-			LOG_INFO("GPIO: Using wiringPi"); \
-			if (wiringPiSetupGpio() < 0) { \
-				LOG_PERROR("GPIO: Can't initialize wiringPi"); \
-				exit(1); \
-			} else { \
-				GPIO_INIT_PIN(prog_running, 0); \
-				GPIO_INIT_PIN(stream_online, 0); \
-				GPIO_INIT_PIN(has_http_clients, 0); \
-				GPIO_INIT_PIN(workers_busy_at, 0); \
-			} \
-		} \
-	}
-
-#define GPIO_SET_STATE(_role, _offset, _state) { \
-		if (gpio_pin_##_role >= 0) { \
-			if (_offset == 0) { \
-				LOG_DEBUG("GPIO: Writing %d to pin %d (%s)", _state, gpio_pin_##_role, #_role); \
-			} else { \
-				LOG_DEBUG("GPIO: Writing %d to pin %d+%d (%s)", _state, gpio_pin_##_role, _offset, #_role); \
-			} \
-			digitalWrite(gpio_pin_##_role + _offset, _state); \
-		} \
-	}
-
-#define GPIO_SET_LOW(_role)		GPIO_SET_STATE(_role, 0, LOW)
-#define GPIO_SET_HIGH(_role)	GPIO_SET_STATE(_role, 0, HIGH)
-
-#define GPIO_SET_LOW_AT(_role, _offset)		GPIO_SET_STATE(_role, _offset, LOW)
-#define GPIO_SET_HIGH_AT(_role, _offset)	GPIO_SET_STATE(_role, _offset, HIGH)
--- a/src/gpio/gpio.c
+++ b/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;
+}
--- a/src/gpio/gpio.h
+++ b/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
--- a/src/http/blank.c
+++ b/src/http/blank.c
@@ -94,7 +94,7 @@ static struct picture_t *_init_external(const char *path) {
 		goto error;
 	}

-#	define CHUNK_SIZE (100 * 1024)
+#	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);
--- a/src/http/data/index.html
+++ b/src/http/data/index.html
@@ -4,6 +4,7 @@
 <head>
 	<meta charset="utf-8" />
 	<title>uStreamer</title>
+	<style>body {font-family: monospace;}</style>
 </head>

 <body>
@@ -11,46 +12,56 @@
 	<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/src/http/data/index_html.h
+++ b/src/http/data/index_html.h
@@ -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,46 +40,56 @@ 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/src/http/mime.c
+++ b/src/http/mime.c
@@ -56,7 +56,7 @@ const char *guess_mime_type(const char *path) {
 	char *dot;
 	char *ext;

-	dot = strchr(path, '.');
+	dot = strrchr(path, '.');
 	if (dot == NULL || strchr(dot, '/') != NULL) {
 		goto misc;
 	}
--- a/src/http/server.c
+++ b/src/http/server.c
@@ -31,8 +31,12 @@
 #include <fcntl.h>
 #include <assert.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>
@@ -50,11 +54,12 @@
 #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.h"
+#	include "../gpio/gpio.h"
 #endif

 #include "unix.h"
@@ -84,6 +89,8 @@ static void _http_queue_send_stream(struct http_server_t *server, bool stream_up
 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;
@@ -105,6 +112,7 @@ struct http_server_t *http_server_init(struct stream_t *stream) {
 	server->user = "";
 	server->passwd = "";
 	server->static_path = "";
+	server->allow_origin = "";
 	server->timeout = 10;
 	server->last_as_blank = -1;
 	server->run = run;
@@ -157,6 +165,7 @@ void http_server_destroy(struct http_server_t *server) {
 int http_server_listen(struct http_server_t *server) {
 	{
 		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));
@@ -172,9 +181,12 @@ int http_server_listen(struct http_server_t *server) {
 #	define EXPOSED(_next) server->run->exposed->_next
 	// See _expose_blank_picture()
 	picture_copy(server->run->blank, EXPOSED(picture));
-	EXPOSED(expose_begin_time) = get_now_monotonic();
-	EXPOSED(expose_cmp_time) = EXPOSED(expose_begin_time);
-	EXPOSED(expose_end_time) = EXPOSED(expose_begin_time);
+	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

 	{
@@ -224,6 +236,9 @@ int http_server_listen(struct http_server_t *server) {
 			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) {
@@ -277,14 +292,27 @@ static int _http_preprocess_request(struct evhttp_request *request, struct http_
 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

 	PREPROCESS_REQUEST;

-	assert((buf = evbuffer_new()));
-	assert(evbuffer_add_printf(buf, "%s", HTML_INDEX_PAGE));
-	ADD_HEADER("Content-Type", "text/html");
-	evhttp_send_reply(request, HTTP_OK, "OK", buf);
-	evbuffer_free(buf);
+	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) {
@@ -326,7 +354,7 @@ static void _http_callback_static(struct evhttp_request *request, void *v_server
 		goto not_found;
 	}

-	if (evbuffer_add_file(buf, fd, 0, st.st_size) < 0) {
+	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;
 	}
@@ -429,7 +457,9 @@ static void _http_callback_snapshot(struct evhttp_request *request, void *v_serv
 	assert((buf = evbuffer_new()));
 	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");
@@ -446,17 +476,17 @@ static void _http_callback_snapshot(struct evhttp_request *request, void *v_serv

 	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(picture->width));
-	ADD_UNSIGNED_HEADER("X-UStreamer-Height",			EXPOSED(picture->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
@@ -523,15 +553,25 @@ static void _http_callback_stream(struct evhttp_request *request, void *v_server
 			}

 #			ifdef WITH_GPIO
-			GPIO_SET_HIGH(has_http_clients);
+			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; clients now: %u",
+		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 {
@@ -583,9 +623,11 @@ static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_c
 			"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
@@ -637,12 +679,12 @@ static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_c
 				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
 			));
 		}
@@ -672,18 +714,22 @@ 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 (RUN(stream_clients_count) <= 0) {
+	if (RUN(stream_clients_count) == 0) {
 		if (client->server->slowdown) {
 			stream_switch_slowdown(RUN(stream), true);
 		}

 #		ifdef WITH_GPIO
-		GPIO_SET_LOW(has_http_clients);
+		gpio_set_has_http_clients(false);
 #		endif
 	}

@@ -691,8 +737,9 @@ static void _http_callback_stream_error(UNUSED struct bufferevent *buf_event, UN
 	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));
+
+	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);
 	}
@@ -715,9 +762,8 @@ 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);
@@ -747,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;
 	}
 }

@@ -790,6 +843,25 @@ 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);
+
+#	define EXPOSED(_next) server->run->exposed->_next
+
+	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();
+	}
+
+#	undef EXPOSED
 }

 static bool _expose_new_picture_unsafe(struct http_server_t *server) {
@@ -797,7 +869,7 @@ static bool _expose_new_picture_unsafe(struct http_server_t *server) {
 #	define STREAM(_next) server->run->stream->_next

 	EXPOSED(captured_fps) = STREAM(captured_fps);
-	EXPOSED(expose_begin_time) = get_now_monotonic();
+	EXPOSED(expose_begin_ts) = get_now_monotonic();

 	if (server->drop_same_frames) {
 		if (
@@ -805,16 +877,16 @@ static bool _expose_new_picture_unsafe(struct http_server_t *server) {
 			&& EXPOSED(dropped) < server->drop_same_frames
 			&& picture_compare(EXPOSED(picture), STREAM(picture))
 		) {
-			EXPOSED(expose_cmp_time) = get_now_monotonic();
-			EXPOSED(expose_end_time) = EXPOSED(expose_cmp_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_time) - EXPOSED(expose_begin_time));
+				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();
+			EXPOSED(expose_cmp_ts) = get_now_monotonic();
 			LOG_VERBOSE("HTTP: Passed same frame check (frames are differ); cmp_time=%.06Lf",
-				EXPOSED(expose_cmp_time) - EXPOSED(expose_begin_time));
+				EXPOSED(expose_cmp_ts) - EXPOSED(expose_begin_ts));
 		}
 	}

@@ -824,11 +896,11 @@ static bool _expose_new_picture_unsafe(struct http_server_t *server) {

 	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));
+		 EXPOSED(expose_end_ts) - EXPOSED(expose_begin_ts));

 #	undef EXPOSED
 	return true; // Updated
@@ -837,8 +909,8 @@ static bool _expose_new_picture_unsafe(struct http_server_t *server) {
 static bool _expose_blank_picture(struct http_server_t *server) {
 #	define EXPOSED(_next) server->run->exposed->_next

-	EXPOSED(expose_begin_time) = get_now_monotonic();
-	EXPOSED(expose_cmp_time) = EXPOSED(expose_begin_time);
+	EXPOSED(expose_begin_ts) = get_now_monotonic();
+	EXPOSED(expose_cmp_ts) = EXPOSED(expose_begin_ts);

 #	define EXPOSE_BLANK picture_copy(server->run->blank, EXPOSED(picture))

@@ -848,7 +920,7 @@ static bool _expose_blank_picture(struct http_server_t *server) {
 			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_time) = get_now_monotonic();
+			EXPOSED(last_as_blank_ts) = get_now_monotonic();
 		} else { // last_as_blank == 0 - показываем последний фрейм вечно
 			LOG_INFO("HTTP: Freezing last alive frame forever");
 		}
@@ -857,12 +929,12 @@ static bool _expose_blank_picture(struct http_server_t *server) {

 	if ( // Если уже оффлайн, включена фича last_as_blank с таймером и он запущен
 		server->last_as_blank > 0
-		&& EXPOSED(last_as_blank_time) > 0
-		&& EXPOSED(last_as_blank_time) + server->last_as_blank < EXPOSED(expose_begin_time)
+		&& 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_time) = 0; // Останавливаем таймер
+		EXPOSED(last_as_blank_ts) = 0; // Останавливаем таймер
 		goto updated;
 	}

@@ -871,7 +943,7 @@ static bool _expose_blank_picture(struct http_server_t *server) {
 	if (EXPOSED(dropped) < server->run->drop_same_frames_blank) {
 		LOG_PERF("HTTP: Dropped same frame (BLANK) number %u", EXPOSED(dropped));
 		EXPOSED(dropped) += 1;
-		EXPOSED(expose_end_time) = get_now_monotonic();
+		EXPOSED(expose_end_ts) = get_now_monotonic();
 		return false; // Not updated
 	}

@@ -879,8 +951,38 @@ static bool _expose_blank_picture(struct http_server_t *server) {
 		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 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, ")");
+}
--- a/src/http/server.h
+++ b/src/http/server.h
@@ -61,10 +61,14 @@ struct exposed_t {
 	unsigned			queued_fps;
 	bool				online;
 	unsigned			dropped;
-	long double			expose_begin_time;
-	long double			expose_cmp_time;
-	long double			expose_end_time;
-	long double			last_as_blank_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 {
@@ -87,11 +91,13 @@ 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;
@@ -100,6 +106,8 @@ struct http_server_t {
 	unsigned	fake_width;
 	unsigned	fake_height;

+	bool		notify_parent;
+
 	struct http_server_runtime_t *run;
 };

--- a/src/http/static.c
+++ b/src/http/static.c
@@ -30,7 +30,7 @@
 #include <sys/stat.h>

 #include "../tools.h"
-// #include "../logging.h"
+#include "../logging.h"

 #include "path.h"

@@ -42,6 +42,7 @@ char *find_static_file_path(const char *root_path, const char *request_path) {

 	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;
 	}

@@ -50,13 +51,14 @@ char *find_static_file_path(const char *root_path, const char *request_path) {

 #	define LOAD_STAT { \
 			if (lstat(path, &st) < 0) { \
-				/* LOG_PERROR("Can't stat() file %s", path); */ \
+				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;
 	}
@@ -64,12 +66,12 @@ char *find_static_file_path(const char *root_path, const char *request_path) {
 #	undef LOAD_STAT

 	if (!S_ISREG(st.st_mode)) {
-		// LOG_ERROR("Not a regulary file: %s", path);
+		LOG_VERBOSE("HTTP: Not a regular file: %s", path);
 		goto error;
 	}

 	if (access(path, R_OK) < 0) {
-		// LOG_PERROR("Can't access() R_OK file %s", path);
+		LOG_VERBOSE_PERROR("HTTP: Can't access() R_OK file %s", path);
 		goto error;
 	}

--- a/src/logging.c
+++ b/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;
--- a/src/logging.h
+++ b/src/logging.h
@@ -37,16 +37,19 @@
 #include "threading.h"


-enum {
-	LOG_LEVEL_INFO,
-	LOG_LEVEL_PERF,
-	LOG_LEVEL_VERBOSE,
-	LOG_LEVEL_DEBUG,
-} log_level;
+enum log_level_t {
+    LOG_LEVEL_INFO,
+    LOG_LEVEL_PERF,
+    LOG_LEVEL_VERBOSE,
+    LOG_LEVEL_DEBUG,
+};

-bool log_colored;

-pthread_mutex_t log_mutex;
+extern enum log_level_t log_level;
+
+extern bool log_colored;
+
+extern pthread_mutex_t log_mutex;


 #define LOGGING_INIT { \
@@ -88,14 +91,14 @@ pthread_mutex_t log_mutex;


 #define LOG_PRINTF_NOLOCK(_label_color, _label, _msg_color, _msg, ...) { \
-		char _buf[MAX_THREAD_NAME] = {0}; \
-		thread_get_name(_buf); \
+		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(), _buf, ##__VA_ARGS__); \
+				get_now_monotonic(), _tname_buf, ##__VA_ARGS__); \
 		} else { \
 			printf("-- " _label " [%.03Lf %9s] -- " _msg, \
-				get_now_monotonic(), _buf, ##__VA_ARGS__); \
+				get_now_monotonic(), _tname_buf, ##__VA_ARGS__); \
 		} \
 		putchar('\n'); \
 		fflush(stdout); \
@@ -112,9 +115,9 @@ pthread_mutex_t log_mutex;
 	}

 #define LOG_PERROR(_msg, ...) { \
-		char _buf[1024] = {0}; \
-		char *_ptr = errno_to_string(_buf, 1024); \
-		LOG_ERROR(_msg ": %s", ##__VA_ARGS__, _ptr); \
+		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, ...) { \
@@ -143,6 +146,14 @@ pthread_mutex_t log_mutex;
 		} \
 	}

+#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) { \
 			LOG_PRINTF(COLOR_GRAY, "DEBUG", COLOR_GRAY, _msg, ##__VA_ARGS__); \
@@ -150,11 +161,11 @@ pthread_mutex_t log_mutex;
 	}


-INLINE char *errno_to_string(char *buf, size_t size) {
+INLINE char *errno_to_string(int error, char *buf, size_t size) {
 #	if defined(__GLIBC__) && defined(_GNU_SOURCE)
-	return strerror_r(errno, buf, size);
+	return strerror_r(error, buf, size);
 #	else
-	strerror_r(errno, buf, size);
+	strerror_r(error, buf, size);
 	return buf;
 #	endif
 }
--- a/src/main.c
+++ b/src/main.c
@@ -25,7 +25,13 @@
 #	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 <pthread.h>
@@ -39,7 +45,7 @@
 #include "stream.h"
 #include "http/server.h"
 #ifdef WITH_GPIO
-#	include "gpio.h"
+#	include "gpio/gpio.h"
 #endif


@@ -98,6 +104,7 @@ static void _install_signal_handlers(void) {
 }

 int main(int argc, char *argv[]) {
+	struct options_t *options;
 	struct device_t *dev;
 	struct encoder_t *encoder;
 	struct stream_t *stream;
@@ -105,21 +112,17 @@ int main(int argc, char *argv[]) {
 	int exit_code = 0;

 	LOGGING_INIT;
-
 	A_THREAD_RENAME("main");
-
-#	ifdef WITH_GPIO
-	GPIO_INIT;
-#	endif
+	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_PINOUT;
+		gpio_init();
 #		endif

 		_install_signal_handlers();
@@ -134,7 +137,7 @@ int main(int argc, char *argv[]) {

 		if ((exit_code = http_server_listen(server)) == 0) {
 #			ifdef WITH_GPIO
-			GPIO_SET_HIGH(prog_running);
+			gpio_set_prog_running(true);
 #			endif

 			A_THREAD_CREATE(&stream_loop_tid, _stream_loop_thread, NULL);
@@ -142,6 +145,11 @@ int main(int argc, char *argv[]) {
 			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);
@@ -149,10 +157,7 @@ int main(int argc, char *argv[]) {
 	encoder_destroy(encoder);
 	device_destroy(dev);

-#	ifdef WITH_GPIO
-	GPIO_SET_LOW(prog_running);
-#	endif
-
+	options_destroy(options);
 	if (exit_code == 0) {
 		LOG_INFO("Bye-bye");
 	}
--- a/src/options.c
+++ b/src/options.c
@@ -25,9 +25,8 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdbool.h>
-#ifdef WITH_OMX
-#	include <string.h>
-#endif
+#include <string.h>
+#include <strings.h>
 #include <ctype.h>
 #include <limits.h>
 #include <getopt.h>
@@ -41,7 +40,7 @@
 #include "encoder.h"
 #include "http/server.h"
 #ifdef WITH_GPIO
-#	include "gpio.h"
+#	include "gpio/gpio.h"
 #endif


@@ -51,6 +50,7 @@ enum _OPT_VALUES {
 	_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',
@@ -82,30 +82,33 @@ enum _OPT_VALUES {
 	_O_DEVICE_TIMEOUT = 10000,
 	_O_DEVICE_ERROR_DELAY,

+	_O_IMAGE_DEFAULT,
 	_O_BRIGHTNESS,
-	_O_BRIGHTNESS_AUTO,
 	_O_CONTRAST,
 	_O_SATURATION,
 	_O_HUE,
-	_O_HUE_AUTO,
 	_O_GAMMA,
 	_O_SHARPNESS,
 	_O_BACKLIGHT_COMPENSATION,
 	_O_WHITE_BALANCE,
-	_O_WHITE_BALANCE_AUTO,
 	_O_GAIN,
-	_O_GAIN_AUTO,
+	_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,
-	_O_GPIO_WORKERS_BUSY_AT,
 #endif

 #ifdef HAS_PDEATHSIG
@@ -114,6 +117,7 @@ enum _OPT_VALUES {
 #ifdef WITH_SETPROCTITLE
 	_O_PROCESS_NAME_PREFIX,
 #endif
+	_O_NOTIFY_PARENT,

 	_O_LOG_LEVEL,
 	_O_PERF,
@@ -131,6 +135,7 @@ static const struct option _LONG_OPTS[] = {
 	{"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},
@@ -145,19 +150,19 @@ static const struct option _LONG_OPTS[] = {
 	{"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},
-	{"brightness-auto",			no_argument,		NULL,	_O_BRIGHTNESS_AUTO},
 	{"contrast",				required_argument,	NULL,	_O_CONTRAST},
 	{"saturation",				required_argument,	NULL,	_O_SATURATION},
 	{"hue",						required_argument,	NULL,	_O_HUE},
-	{"hue-auto",				no_argument,		NULL,	_O_HUE_AUTO},
 	{"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},
-	{"white-balance-auto",		no_argument,		NULL,	_O_WHITE_BALANCE_AUTO},
 	{"gain",					required_argument,	NULL,	_O_GAIN},
-	{"gain-auto",				no_argument,		NULL,	_O_GAIN_AUTO},
+	{"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},
@@ -171,14 +176,17 @@ static const struct option _LONG_OPTS[] = {
 	{"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},
-	{"gpio-workers-busy-at",	required_argument,	NULL,	_O_GPIO_WORKERS_BUSY_AT},
 #endif

 #ifdef HAS_PDEATHSIG
@@ -187,6 +195,7 @@ static const struct option _LONG_OPTS[] = {
 #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},
@@ -212,7 +221,31 @@ static void _features(void);
 static void _help(struct device_t *dev, struct encoder_t *encoder, struct http_server_t *server);


-int parse_options(int argc, char *argv[], 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; \
@@ -221,7 +254,7 @@ int parse_options(int argc, char *argv[], struct device_t *dev, struct encoder_t
 #	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=%u, max=%u\n", _name, optarg, _min, _max); \
+				printf("Invalid value for '%s=%s': min=%lld, max=%lld\n", _name, optarg, (long long)_min, (long long)_max); \
 				return -1; \
 			} \
 			_dest = _tmp; \
@@ -253,16 +286,29 @@ int parse_options(int argc, char *argv[], struct device_t *dev, struct encoder_t
 			break; \
 		}

-#	define OPT_CTL(_dest) { \
-			dev->ctl._dest.value_set = true; \
-			dev->ctl._dest.auto_set = false; \
-			OPT_NUMBER("--"#_dest, dev->ctl._dest.value, INT_MIN, INT_MAX, 0); \
+#	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) { \
-			dev->ctl._dest.value_set = false; \
-			dev->ctl._dest.auto_set = true; \
+			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; \
 		}

@@ -285,7 +331,7 @@ int parse_options(int argc, char *argv[], struct device_t *dev, struct encoder_t
 		}
 	}

-	while ((ch = getopt_long(argc, argv, short_opts, _LONG_OPTS, NULL)) >= 0) {
+	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);
@@ -295,8 +341,9 @@ int parse_options(int argc, char *argv[], struct device_t *dev, struct encoder_t
 			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, 0, 8192, 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);
@@ -313,19 +360,32 @@ int parse_options(int argc, char *argv[], struct device_t *dev, struct encoder_t
 			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_BRIGHTNESS:				OPT_CTL(brightness);
-			case _O_BRIGHTNESS_AUTO:		OPT_CTL_AUTO(brightness);
-			case _O_CONTRAST:				OPT_CTL(contrast);
-			case _O_SATURATION:				OPT_CTL(saturation);
-			case _O_HUE:					OPT_CTL(hue);
-			case _O_HUE_AUTO:				OPT_CTL_AUTO(hue);
-			case _O_GAMMA:					OPT_CTL(gamma);
-			case _O_SHARPNESS:				OPT_CTL(sharpness);
-			case _O_BACKLIGHT_COMPENSATION:	OPT_CTL(backlight_compensation);
-			case _O_WHITE_BALANCE:			OPT_CTL(white_balance);
-			case _O_WHITE_BALANCE_AUTO:		OPT_CTL_AUTO(white_balance);
-			case _O_GAIN:					OPT_CTL(gain);
-			case _O_GAIN_AUTO:				OPT_CTL_AUTO(gain);
+			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);
@@ -340,13 +400,16 @@ int parse_options(int argc, char *argv[], struct device_t *dev, struct encoder_t
 			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_PROG_RUNNING:		OPT_NUMBER("--gpio-prog-running", gpio_pin_prog_running, 0, 256, 0);
-			case _O_GPIO_STREAM_ONLINE:		OPT_NUMBER("--gpio-stream-online", gpio_pin_stream_online, 0, 256, 0);
-			case _O_GPIO_HAS_HTTP_CLIENTS:	OPT_NUMBER("--gpio-has-http-clients", gpio_pin_has_http_clients, 0, 256, 0);
-			case _O_GPIO_WORKERS_BUSY_AT:	OPT_NUMBER("--gpio-workers-busy-at", gpio_pin_workers_busy_at, 0, 256, 0);
+			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
@@ -359,6 +422,7 @@ int parse_options(int argc, char *argv[], struct device_t *dev, struct encoder_t
 #			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);
@@ -378,12 +442,13 @@ int parse_options(int argc, char *argv[], struct device_t *dev, struct encoder_t

 #	ifdef WITH_SETPROCTITLE
 	if (process_name_prefix != NULL) {
-		process_set_name_prefix(argc, argv, process_name_prefix);
+		process_set_name_prefix(options->argc, options->argv, process_name_prefix);
 	}
 #	endif

 #	undef OPT_CTL_AUTO
-#	undef OPT_CTL
+#	undef OPT_CTL_MANUAL
+#	undef OPT_CTL_DEFAULT_NOBREAK
 #	undef OPT_PARSE
 #	undef OPT_RESOLUTION
 #	undef OPT_NUMBER
@@ -507,9 +572,12 @@ static void _help(struct device_t *dev, struct encoder_t *encoder, struct http_s
 	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: disabled.\n\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");
@@ -540,19 +608,20 @@ static void _help(struct device_t *dev, struct encoder_t *encoder, struct http_s
 	printf("                                           after an error (timeout for example). 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("    --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);
@@ -576,16 +645,19 @@ static void _help(struct device_t *dev, struct encoder_t *encoder, struct http_s
 	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 state. 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");
-	printf("    --gpio-workers-busy-at <pin>  ── Set 1 on (pin + N) while worker with number N has a job.\n");
-	printf("                                     The worker's numbering starts from 0. Default: disabled\n\n");
 #endif
 #if (defined(HAS_PDEATHSIG) || defined(WITH_SETPROCTITLE))
 	printf("Process options:\n");
@@ -597,13 +669,15 @@ static void _help(struct device_t *dev, struct encoder_t *encoder, struct http_s
 #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: %u.\n\n", log_level);
+	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");
@@ -613,5 +687,5 @@ static void _help(struct device_t *dev, struct encoder_t *encoder, struct http_s
 	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 supporeted features.\n\n");
+	printf("    --features  ────── Print list of supported features.\n\n");
 }
--- a/src/options.h
+++ b/src/options.h
@@ -27,4 +27,14 @@
 #include "http/server.h"


-int parse_options(int argc, char *argv[], struct device_t *dev, struct encoder_t *encoder, struct http_server_t *server);
+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);
--- a/src/picture.c
+++ b/src/picture.c
@@ -51,7 +51,7 @@ size_t picture_get_generous_size(unsigned width, unsigned height) {

 void picture_realloc_data(struct picture_t *picture, size_t size) {
 	if (picture->allocated < size) {
-		LOG_DEBUG("Increasing picture 0x%p buffer: %zu -> %zu (+%zu)",
+		LOG_DEBUG("Increasing picture %p buffer: %zu -> %zu (+%zu)",
 			picture, picture->allocated, size, size - picture->allocated);
 		A_REALLOC(picture->data, size);
 		picture->allocated = size;
@@ -73,9 +73,7 @@ void picture_append_data(struct picture_t *picture, const unsigned char *data, s
 }

 void picture_copy(const struct picture_t *src, struct picture_t *dest) {
-	assert(src->allocated);
-
-	picture_set_data(dest, src->data, src->allocated);
+	picture_set_data(dest, src->data, src->used);

 #	define COPY(_field) dest->_field = src->_field

@@ -84,13 +82,17 @@ void picture_copy(const struct picture_t *src, struct picture_t *dest) {
 	COPY(width);
 	COPY(height);

-	COPY(grab_time);
-	COPY(encode_begin_time);
-	COPY(encode_end_time);
+	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->used == b->used && !memcmp(a->data, b->data, b->used));
+	return (
+		a->allocated && b->allocated
+		&& a->used == b->used
+		&& !memcmp(a->data, b->data, b->used)
+	);
 }
--- a/src/picture.h
+++ b/src/picture.h
@@ -32,9 +32,9 @@ struct picture_t {
 	size_t			allocated;
 	unsigned		width;
 	unsigned		height;
-	long double		grab_time;
-	long double		encode_begin_time;
-	long double		encode_end_time;
+	long double		grab_ts;
+	long double		encode_begin_ts;
+	long double		encode_end_ts;
 };


--- a/src/process.h
+++ b/src/process.h
@@ -22,6 +22,12 @@

 #pragma once

+#include <signal.h>
+#include <unistd.h>
+
+#include <sys/types.h>
+
+
 #if defined(__linux__)
 #	define HAS_PDEATHSIG
 #elif defined(__FreeBSD__)
@@ -32,19 +38,14 @@
 #endif


-#ifdef HAS_PDEATHSIG
-#	include <signal.h>
-#	include <unistd.h>
-#endif
 #ifdef WITH_SETPROCTITLE
 #	include <stdlib.h>
 #	include <string.h>
 #	if defined(__linux__)
 #		include <bsd/unistd.h>
-#		include <sys/types.h>
 #	elif (defined(__FreeBSD__) || defined(__DragonFly__))
-#		include <unistd.h>
-#		include <sys/types.h>
+//#		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
@@ -72,6 +73,7 @@ extern char **environ;

 #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);
@@ -85,8 +87,8 @@ INLINE int process_track_parent_death(void) {
 		return -1;
 	}

-	if (kill(getppid(), 0) < 0) {
-		LOG_PERROR("The parent process is already dead");
+	if (kill(parent, 0) < 0) {
+		LOG_PERROR("The parent process %d is already dead", parent);
 		return -1;
 	}

@@ -103,13 +105,12 @@ INLINE void process_set_name_prefix(int argc, char *argv[], const char *prefix)
 	char *cmdline = NULL;
 	size_t allocated = 2048;
 	size_t used = 0;
-	size_t arg_len = 0;

 	A_REALLOC(cmdline, allocated);
 	cmdline[0] = '\0';

 	for (int index = 0; index < argc; ++index) {
-		arg_len = strlen(argv[index]);
+		size_t arg_len = strlen(argv[index]);
 		if (used + arg_len + 16 >= allocated) {
 			allocated += arg_len + 2048;
 			A_REALLOC(cmdline, allocated);
@@ -128,3 +129,11 @@ INLINE void process_set_name_prefix(int argc, char *argv[], const char *prefix)
 	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);
+	}
+}
--- a/src/stream.c
+++ b/src/stream.c
@@ -38,7 +38,7 @@
 #include "device.h"
 #include "encoder.h"
 #ifdef WITH_GPIO
-#	include "gpio.h"
+#	include "gpio/gpio.h"
 #endif


@@ -51,11 +51,11 @@ struct _worker_t {
 	long double			last_comp_time;

 	pthread_mutex_t		has_job_mutex;
-	int					buf_index;
+	unsigned			buf_index;
 	atomic_bool			has_job;
 	bool				job_timely;
 	bool				job_failed;
-	long double			job_start_time;
+	long double			job_start_ts;
 	pthread_cond_t		has_job_cond;

 	pthread_mutex_t		*free_workers_mutex;
@@ -88,7 +88,7 @@ struct _workers_pool_t {


 static struct _workers_pool_t *_stream_init_loop(struct stream_t *stream);
-static struct _workers_pool_t *_stream_init(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);
@@ -185,7 +185,7 @@ void stream_loop(struct stream_t *stream) {

 			} else if (selected == 0) {
 #				ifdef WITH_GPIO
-				GPIO_SET_LOW(stream_online);
+				gpio_set_stream_online(false);
 #				endif

 				if (stream->dev->persistent) {
@@ -207,7 +207,7 @@ void stream_loop(struct stream_t *stream) {
 					LOG_DEBUG("Frame is ready");

 #					ifdef WITH_GPIO
-					GPIO_SET_HIGH(stream_online);
+					gpio_set_stream_online(true);
 #					endif

 					int buf_index;
@@ -288,7 +288,7 @@ void stream_loop(struct stream_t *stream) {
 		device_close(stream->dev);

 #		ifdef WITH_GPIO
-		GPIO_SET_LOW(stream_online);
+		gpio_set_stream_online(false);
 #		endif
 	}
 }
@@ -303,13 +303,26 @@ void stream_switch_slowdown(struct stream_t *stream, bool slowdown) {

 static struct _workers_pool_t *_stream_init_loop(struct stream_t *stream) {
 	struct _workers_pool_t *pool = NULL;
+	int access_error = 0;

 	LOG_DEBUG("%s: stream->proc->stop=%d", __FUNCTION__, atomic_load(&stream->proc->stop));

 	while (!atomic_load(&stream->proc->stop)) {
-		SEP_INFO('=');
+		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;
+		}

-		if ((pool = _stream_init(stream)) == NULL) {
+		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 {
@@ -319,7 +332,7 @@ static struct _workers_pool_t *_stream_init_loop(struct stream_t *stream) {
 	return pool;
 }

-static struct _workers_pool_t *_stream_init(struct stream_t *stream) {
+static struct _workers_pool_t *_stream_init_one(struct stream_t *stream) {
 	if (device_open(stream->dev) < 0) {
 		goto error;
 	}
@@ -350,11 +363,14 @@ static void _stream_expose_picture(struct stream_t *stream, unsigned buf_index,
 static struct _workers_pool_t *_workers_pool_init(struct stream_t *stream) {
 	struct _workers_pool_t *pool;

-	LOG_INFO("Creating pool with %u workers ...", stream->dev->run->n_workers);
+#	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 = stream->dev->run->n_workers;
+	pool->n_workers = RUN(n_workers);
 	A_CALLOC(pool->workers, pool->n_workers);

 	A_MUTEX_INIT(&pool->free_workers_mutex);
@@ -362,10 +378,13 @@ static struct _workers_pool_t *_workers_pool_init(struct stream_t *stream) {

 	atomic_init(&pool->workers_stop, false);

-	if (stream->dev->desired_fps > 0) {
-		pool->desired_frames_interval = (long double)1 / stream->dev->desired_fps;
+	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

@@ -425,17 +444,9 @@ static void *_worker_thread(void *v_worker) {
 	A_THREAD_RENAME("worker-%u", worker->number);
 	LOG_DEBUG("Hello! I am a worker #%u ^_^", worker->number);

-#	ifdef WITH_GPIO
-	GPIO_INIT_PIN(workers_busy_at, worker->number);
-#	endif
-
 	while (!atomic_load(worker->proc_stop) && !atomic_load(worker->workers_stop)) {
 		LOG_DEBUG("Worker %u waiting for a new job ...", worker->number);

-#		ifdef WITH_GPIO
-		GPIO_SET_LOW_AT(workers_busy_at, worker->number);
-#		endif
-
 		A_MUTEX_LOCK(&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);
@@ -445,27 +456,24 @@ static void *_worker_thread(void *v_worker) {

 			LOG_DEBUG("Worker %u compressing JPEG from buffer %u ...", worker->number, worker->buf_index);

-#			ifdef WITH_GPIO
-			GPIO_SET_HIGH_AT(workers_busy_at, worker->number);
-#			endif
-
-			if (encoder_compress_buffer(worker->encoder, worker->dev, worker->number, worker->buf_index) < 0) {
-				worker->job_failed = false;
-			}
+			worker->job_failed = (bool)encoder_compress_buffer(worker->encoder, worker->dev, worker->number, worker->buf_index);

 			if (device_release_buffer(worker->dev, worker->buf_index) == 0) {
-				worker->job_start_time = PICTURE(encode_begin_time);
-				atomic_store(&worker->has_job, false);
+				if (!worker->job_failed) {
+					worker->job_start_ts = PICTURE(encode_begin_ts);
+					worker->last_comp_time = PICTURE(encode_end_ts) - worker->job_start_ts;

-				worker->last_comp_time = PICTURE(encode_end_time) - worker->job_start_time;
-
-				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);
+					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;
-				atomic_store(&worker->has_job, false);
 			}

+			atomic_store(&worker->has_job, false);
+
 #			undef PICTURE
 		}

@@ -476,9 +484,6 @@ static void *_worker_thread(void *v_worker) {
 	}

 	LOG_DEBUG("Bye-bye (worker %u)", worker->number);
-#	ifdef WITH_GPIO
-	GPIO_SET_LOW_AT(workers_busy_at, worker->number);
-#	endif
 	return NULL;
 }

@@ -489,7 +494,7 @@ static struct _worker_t *_workers_pool_wait(struct _workers_pool_t *pool) {
 	A_COND_WAIT_TRUE(pool->free_workers, &pool->free_workers_cond, &pool->free_workers_mutex);
 	A_MUTEX_UNLOCK(&pool->free_workers_mutex);

-	if (pool->oldest_worker && !atomic_load(&pool->oldest_worker->has_job) && pool->oldest_worker->buf_index >= 0) {
+	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;
@@ -498,7 +503,7 @@ static struct _worker_t *_workers_pool_wait(struct _workers_pool_t *pool) {
 			if (
 				!atomic_load(&pool->workers[number].has_job) && (
 					ready_worker == NULL
-					|| ready_worker->job_start_time < pool->workers[number].job_start_time
+					|| ready_worker->job_start_ts < pool->workers[number].job_start_ts
 				)
 			) {
 				ready_worker = &pool->workers[number];
@@ -556,6 +561,7 @@ static long double _workers_pool_get_fluency_delay(struct _workers_pool_t *pool,

 	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;
--- a/src/threading.h
+++ b/src/threading.h
@@ -41,9 +41,9 @@


 #ifdef PTHREAD_MAX_NAMELEN_NP
-#	define MAX_THREAD_NAME PTHREAD_MAX_NAMELEN_NP
+#	define MAX_THREAD_NAME ((size_t)(PTHREAD_MAX_NAMELEN_NP))
 #else
-#	define MAX_THREAD_NAME 16
+#	define MAX_THREAD_NAME ((size_t)16)
 #endif

 #define A_THREAD_CREATE(_tid, _func, _arg)	assert(!pthread_create(_tid, NULL, _func, _arg))
@@ -51,9 +51,9 @@

 #ifdef WITH_PTHREAD_NP
 #	define A_THREAD_RENAME(_fmt, ...) { \
-			char _buf[MAX_THREAD_NAME] = {0}; \
-			assert(snprintf(_buf, MAX_THREAD_NAME, _fmt, ##__VA_ARGS__) > 0); \
-			thread_set_name(_buf); \
+			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, ...)
@@ -102,7 +102,23 @@ INLINE void thread_get_name(char *name) { // Always required for logging
 #	endif
 	if (retval < 0) {
 #endif
-		assert(snprintf(name, MAX_THREAD_NAME, "tid=%d", (pid_t)syscall(SYS_gettid)) > 0);
+
+#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
--- a/src/tools.h
+++ b/src/tools.h
@@ -45,6 +45,10 @@ 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);
 }
@@ -74,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;
 }

--- a/src/xioctl.h
+++ b/src/xioctl.h
@@ -30,9 +30,10 @@
 #include "logging.h"


-#ifndef XIOCTL_RETRIES
-#	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) {
@@ -51,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;
 }
--- a/tools/common.py
+++ b/tools/common.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-#============================================================================#
+# ========================================================================== #
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
@@ -18,7 +18,7 @@
 #    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
--- a/tools/make-html-h.py
+++ b/tools/make-html-h.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env -S python3 -B
-#============================================================================#
+# ========================================================================== #
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
@@ -18,7 +18,7 @@
 #    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
--- a/tools/make-jpeg-h.py
+++ b/tools/make-jpeg-h.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env -S python3 -B
-#============================================================================#
+# ========================================================================== #
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
 #                                                                            #
@@ -18,7 +18,7 @@
 #    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
@@ -26,7 +26,6 @@ import io
 import struct

 from typing import Tuple
-from typing import List

 import common

@@ -38,14 +37,15 @@ def _get_jpeg_size(data: bytes) -> Tuple[int, int]:
    stream = io.BytesIO(data)
    while True:
        marker = struct.unpack(">H", stream.read(2))[0]
+        if marker == 0xFFD9:
+            raise RuntimeError("Can't find jpeg size")
+
        if (
            marker == 0xFFD8  # Start of image
            or marker == 0xFF01  # Private marker
-            or (marker >= 0xFFD0 and marker <= 0xFFD7)  # Restart markers
+            or 0xFFD0 <= marker <= 0xFFD7  # Restart markers
        ):
            continue
-        elif marker == 0xFFD9:
-            raise RuntimeError("Can't find jpeg size")

        # All other markers specify chunks with lengths
        length = struct.unpack(">H", stream.read(2))[0]
Author	SHA1	Message	Date
Devaev Maxim	d9b91a1d5f	Bump version: 2.0 → 2.1	2020-09-29 01:42:40 +03:00
Devaev Maxim	d682a1c173	added info about mjpg-streamer compat and prettify	2020-09-28 13:54:38 +03:00
Devaev Maxim	ba03333623	better access checking	2020-09-28 10:28:42 +03:00
Devaev Maxim	c7e6e5e006	check for device access before open	2020-09-28 04:29:02 +03:00
Devaev Maxim	45b1e2f285	refactoring	2020-09-28 04:23:41 +03:00
Devaev Maxim	d9bbd8a74d	refactoring	2020-09-27 22:58:13 +03:00
Devaev Maxim	37179184ae	Bump version: 1.26 → 2.0	2020-09-25 00:03:14 +03:00
Devaev Maxim	fc8aba0a12	Bump version: 1.25 → 1.26	2020-09-25 00:01:13 +03:00
Devaev Maxim	0d749eada3	V for make release	2020-09-23 18:11:25 +03:00
Maxim Devaev	da6984d531	Merge pull request #49 from pikvm/allow-origin Disabled cross-domain requests by default	2020-09-23 00:04:45 +03:00
Devaev Maxim	df14031042	readme fix	2020-09-22 21:43:01 +03:00
Maxim Devaev	03975c1a85	Update README.md	2020-09-22 18:02:27 +03:00
Maxim Devaev	214a924da3	Update README.ru.md	2020-09-22 18:01:48 +03:00
Maxim Devaev	9e6a9a2fd4	Update README.md	2020-09-22 17:59:09 +03:00
Devaev Maxim	b498ae7e38	Issue #48 : Disabled cross-domain requests by default	2020-09-22 17:58:10 +03:00
Maxim Devaev	278645ce51	Merge pull request #47 from pikvm/queue-assert Double dequeue error	2020-09-20 00:53:58 +03:00
Devaev Maxim	f1ee5514e3	style fix	2020-09-20 00:44:21 +03:00
Maxim Devaev	3900728f9f	Merge pull request #46 from pikvm/libgpiod moved from wiringpi to libgpiod	2020-09-19 17:01:28 +03:00
Devaev Maxim	3dc083d2ef	Rewrited #44 : fixed memory error and leak	2020-09-19 16:55:39 +03:00
Maxim Devaev	653ebd6e88	Merge pull request #44 from schneemaier/master Added HTTP GET parameter handling to server.c	2020-09-19 13:29:07 +03:00
Devaev Maxim	a770e7675d	Issue #43 : assert for double VIDIOC_DQBUF	2020-09-19 05:54:47 +03:00
Devaev Maxim	6725083be6	moved from wiringpi to libgpiod	2020-09-19 04:06:14 +03:00
Akos Schneemaier	0b39cadaad	Added HTTP GET parameter handling to server.c to make URLcompatibility with mjpg streamer	2020-09-18 00:00:11 -04:00
Devaev Maxim	871b0cf132	improved logs	2020-09-18 04:19:58 +03:00
Maxim Devaev	afa888432a	Update README.ru.md	2020-09-15 23:07:22 +03:00
Maxim Devaev	a42bd147ff	Update README.md	2020-09-15 23:06:47 +03:00
Devaev Maxim	2ad8871a54	Bump version: 1.24 → 1.25	2020-09-01 08:55:28 +03:00
Devaev Maxim	266e210b04	fixed ld error	2020-09-01 08:53:33 +03:00
Devaev Maxim	0ac9f77619	Bump version: 1.23 → 1.24	2020-09-01 07:57:09 +03:00
Devaev Maxim	c1bc1d9506	fixed linter error	2020-09-01 07:52:29 +03:00
Devaev Maxim	deb37986b6	Issue #39 : fixed missing gettid() syscall on *BSD	2020-09-01 06:39:12 +03:00
Devaev Maxim	ee6c555ce0	Issue #32 : refactoring	2020-08-24 10:21:47 +03:00
Maxim Devaev	4395b8487f	Merge pull request #37 from PascalHonegger/master Issue #32: Create Dockerfiles	2020-08-24 00:22:52 +03:00
Pascal Honegger	f622d03d1b	Issue #32 : Create Dockerfiles	2020-08-23 15:36:48 +02:00
Devaev Maxim	36e6fa7b09	added aarch64 to PKGBUILD	2020-08-23 15:56:59 +03:00
Devaev Maxim	8cf6c66f21	Fixed #35 : spell fix	2020-08-22 23:32:06 +03:00
Devaev Maxim	ac9761beb2	Bump version: 1.22 → 1.23	2020-08-22 16:53:29 +03:00
Devaev Maxim	90b7a5600f	Issue #24 : disable software framedrop if hw_fps == desired_fps	2020-08-22 16:17:34 +03:00
Maxim Devaev	4c70baecb1	Update README.ru.md	2020-08-21 23:01:15 +03:00
Maxim Devaev	15c14bfebf	Update README.ru.md	2020-08-21 23:00:14 +03:00
Maxim Devaev	eab8043496	Update README.md	2020-08-21 22:59:11 +03:00
Devaev Maxim	53feba1248	Bump version: 1.21 → 1.22	2020-08-20 05:15:24 +03:00
Devaev Maxim	119821d5af	queued_fps = 0 for no clients	2020-08-19 14:27:52 +03:00
Maxim Devaev	4faabf27ec	Merge pull request #33 from pikvm/sem-timeout Sem timeout	2020-08-19 13:44:23 +03:00
Devaev Maxim	191f6e3c09	non-zero min-frame-size; default = 128	2020-08-19 13:20:22 +03:00
Devaev Maxim	4e51439118	bsd compat	2020-08-18 15:19:09 +03:00
Devaev Maxim	e184e187a2	option --color-effect	2020-08-18 12:15:44 +03:00
Maxim Devaev	592568c9aa	Merge pull request #31 from pikvm/flip Options to flip image	2020-08-17 18:17:01 +03:00
Devaev Maxim	46c5a547a9	options to flip image	2020-08-17 03:49:29 +03:00
Devaev Maxim	3d097a4ffb	more logs	2020-08-15 04:51:00 +03:00
Devaev Maxim	00e32c915c	fixed uninitialized value	2020-08-15 04:40:55 +03:00
Devaev Maxim	d44c340dce	vcos sem timeout	2020-08-15 00:10:07 +03:00
Devaev Maxim	8c18f1dffe	Issue #25 : fixed freebsd build	2020-08-14 03:38:05 +03:00
Devaev Maxim	c3c386ea5b	Bump version: 1.20 → 1.21	2020-08-13 08:59:36 +03:00
Devaev Maxim	fa09992c46	better logging	2020-08-11 06:08:13 +03:00
Devaev Maxim	cefcd0c963	fixed ptr printing	2020-08-11 05:49:03 +03:00
Devaev Maxim	96c806071d	Bump version: 1.19 → 1.20	2020-08-11 02:13:16 +03:00
Devaev Maxim	0775b35ef8	option --tcp-nodelay	2020-08-10 08:12:14 +03:00
Maxim Devaev	138d9a74d8	Update README.ru.md	2020-08-01 14:34:15 +03:00
Maxim Devaev	2a668643dc	Update README.md	2020-08-01 14:33:52 +03:00
Maxim Devaev	56312cffb5	Update README.md	2020-07-24 13:08:53 +03:00
Maxim Devaev	f553b97dba	Update README.md	2020-07-23 22:19:12 +03:00
Maxim Devaev	b619b1e096	Update README.ru.md	2020-07-23 22:18:52 +03:00
Maxim Devaev	06a32fd3ab	Update README.md	2020-07-23 22:18:20 +03:00
Devaev Maxim	8637ff5c09	Bump version: 1.18 → 1.19	2020-07-11 04:43:55 +03:00
Devaev Maxim	bd5cf7d3de	fixed io method parser	2020-07-08 00:38:49 +03:00
Devaev Maxim	e488eec90c	userptr	2020-07-07 09:13:07 +03:00
Devaev Maxim	6615a23361	safer picture_compare(), removed one assert	2020-07-06 14:36:05 +03:00
Devaev Maxim	a91eba8d90	fixed picture_copy(): don't copy garbage	2020-07-06 13:10:49 +03:00
Devaev Maxim	d5aebc1231	Bump version: 1.17 → 1.18	2020-07-03 22:18:48 +03:00
Devaev Maxim	5f4f46bbe6	more omx error codes	2020-07-02 23:02:40 +03:00
Devaev Maxim	61a2fe6546	refactoring	2020-07-02 18:05:41 +03:00
Devaev Maxim	98499b6604	verbose message about disconnecting client	2020-06-28 13:15:24 +03:00
Devaev Maxim	f52d090f9b	updated readme	2020-06-23 07:37:20 +03:00
Maxim Devaev	ebb3df46b9	Merge pull request #21 from mtlynch/ansible-note Add note about uStreamer Ansible role	2020-06-21 03:12:38 +03:00
Michael Lynch	8fd6659cf1	Add note about uStreamer Ansible role	2020-06-20 19:53:22 -04:00
Devaev Maxim	13ce0bbc63	fixed raspbian installation manual	2020-05-30 20:19:03 +03:00
Maxim Devaev	0add4cc25f	Update FUNDING.yml	2020-05-27 03:55:15 +03:00
Devaev Maxim	96d84b33bd	new pyflakes	2020-05-22 15:43:33 +03:00
Maxim Devaev	f2dfe7641e	Create FUNDING.yml	2020-05-19 18:59:08 +03:00
Devaev Maxim	97403cbb75	Bump version: 1.16 → 1.17	2020-05-19 01:08:37 +03:00
Devaev Maxim	0663bb1035	fix for gcc 10 multiple definition errors	2020-05-19 01:07:55 +03:00
Devaev Maxim	06f4017a5b	Bump version: 1.15 → 1.16	2020-05-12 09:42:48 +03:00
Devaev Maxim	6493a62c6c	badges	2020-05-12 09:39:02 +03:00
Devaev Maxim	66c627c682	lint fixes	2020-05-12 09:37:02 +03:00
Devaev Maxim	8d6f5f7f8f	.dockerignore	2020-05-12 09:36:48 +03:00
Devaev Maxim	f1cdfd4223	docker-based linters	2020-05-12 09:26:24 +03:00
Devaev Maxim	972c288df3	action fix	2020-05-12 09:08:23 +03:00
Devaev Maxim	fd1d2dec71	action fix	2020-05-12 09:05:26 +03:00
Devaev Maxim	331bd181bf	action fix	2020-05-12 09:01:44 +03:00
Devaev Maxim	231ff37570	action fix	2020-05-12 08:54:01 +03:00
Devaev Maxim	cec0b203b3	action fix	2020-05-12 08:51:32 +03:00
Devaev Maxim	e5c9d699a3	action fix	2020-05-12 08:50:08 +03:00
Maxim Devaev	198fbc1756	Create ccpp.yml	2020-05-12 08:46:39 +03:00
Devaev Maxim	55aa443d68	linters	2020-05-12 08:43:12 +03:00
Devaev Maxim	44d6288416	lint fixes	2020-05-12 08:42:18 +03:00
Devaev Maxim	aeae342853	lint fixes	2020-05-12 08:19:26 +03:00
Devaev Maxim	d22034da96	lint fixes	2020-05-12 07:45:12 +03:00
Devaev Maxim	43788f812d	type fixes	2020-05-12 07:27:42 +03:00
Devaev Maxim	95318e14d8	lint fixes	2020-05-12 06:44:59 +03:00
Devaev Maxim	67d6f15776	lint fix	2020-05-11 20:02:30 +03:00
Devaev Maxim	6c2353ce2c	Bump version: 1.14 → 1.15	2020-05-03 06:38:11 +03:00
Devaev Maxim	fcdfb2930a	refactoring	2020-05-03 06:38:02 +03:00
Devaev Maxim	dcc90341c9	Bump version: 1.13 → 1.14	2020-05-03 06:32:59 +03:00
Devaev Maxim	7e102c88cd	log static errors as verbose	2020-05-03 06:17:43 +03:00
Devaev Maxim	e131a3ba49	typo	2020-04-30 17:27:55 +03:00
Devaev Maxim	e393be4c63	Bump version: 1.12 → 1.13	2020-03-04 03:04:44 +03:00
Devaev Maxim	cf4f5f5b2a	notify parent using SIGUSR2	2020-03-04 03:04:28 +03:00
Maxim Devaev	1190059359	Update README.ru.md	2020-02-25 16:06:25 +03:00
Maxim Devaev	910b27feb4	Update README.md	2020-02-25 16:05:58 +03:00
Devaev Maxim	60ca92d367	Bump version: 1.11 → 1.12	2020-02-19 16:46:38 +03:00
Devaev Maxim	4f44c5efa1	hint	2020-02-19 16:46:13 +03:00
Devaev Maxim	3504095871	refactoring	2020-02-19 08:56:50 +03:00
Devaev Maxim	6eeb49ef75	merged ctl options	2020-02-19 08:56:50 +03:00
Devaev Maxim	9353b3474a	options to reset image settings to default	2020-02-19 08:56:50 +03:00
Maxim Devaev	dfc98a67f2	Update README.ru.md	2020-02-10 06:40:25 +03:00
Maxim Devaev	904c76fa93	Update README.md	2020-02-10 06:39:37 +03:00
Devaev Maxim	f0a7ca5c94	Issue #14 : added message about fileserver	2020-01-30 03:53:06 +03:00
Devaev Maxim	bb4e9db7e7	fixed serving of empty static files	2020-01-29 20:20:53 +03:00
Devaev Maxim	61f2bfa00e	fixed mime guessing	2020-01-29 20:13:31 +03:00
Devaev Maxim	49eb7f6e51	fixed clang 'linker' input unused	2020-01-19 17:23:41 +03:00
Devaev Maxim	b5375b835a	Fixed #11 : clang warning	2020-01-19 01:07:57 +03:00
Devaev Maxim	e3e2c5cead	Bump version: 1.10 → 1.11	2020-01-14 16:49:50 +03:00
Devaev Maxim	ef4150877b	check for 8 bits	2020-01-14 16:46:31 +03:00
Devaev Maxim	cc00d0fea3	Bump version: 1.9 → 1.10	2019-10-21 08:20:45 +03:00
Devaev Maxim	91a1e48a7c	refactoring; renamed X-UStreamer--Time to X-UStreamer--Timestamp	2019-10-21 08:16:19 +03:00
Devaev Maxim	f381113d50	new arch pkg extension	2019-10-17 02:58:56 +03:00
Devaev Maxim	a6304959f4	Bump version: 1.8 → 1.9	2019-10-11 23:37:25 +03:00
Devaev Maxim	57bc6e160d	keep original argv	2019-10-11 23:37:05 +03:00