Bump version: 1.9 → 1.10

.bumpversion.cfg

@@ -1,7 +1,7 @@
 [bumpversion]
 commit = True
 tag = True
-current_version = 1.5
+current_version = 1.10
 parse = (?P<major>\d+)\.(?P<minor>\d+)(\.(?P<patch>\d+)(\-(?P<release>[a-z]+))?)?
 serialize = 
 	{major}.{minor}

.gitignore

@@ -2,6 +2,7 @@
 /pkg/arch/src/
 /pkg/arch/v*.tar.gz
 /pkg/arch/ustreamer-*.pkg.tar.xz
+/pkg/arch/ustreamer-*.pkg.tar.zst
 /build/
 /config.mk
 /vgcore.*

Makefile

@@ -44,6 +44,15 @@ override CFLAGS += -DWITH_PTHREAD_NP
 endif
 
 
+WITH_SETPROCTITLE ?= 1
+ifneq ($(call optbool,$(WITH_SETPROCTITLE)),)
+ifeq ($(shell uname -s | tr A-Z a-z),linux)
+_LIBS += -lbsd
+endif
+override CFLAGS += -DWITH_SETPROCTITLE
+endif
+
+
 # =====
 all: $(PROG)
 
@@ -100,5 +109,5 @@ push:
 
 clean-all: clean
 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

README.md

@@ -12,7 +12,7 @@
 | [OpenMAX IL](https://www.khronos.org/openmaxil) hardware acceleration<br>on Raspberry Pi | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) No |
 | Behavior when the device<br>is disconnected while streaming | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Shows a black screen<br>with ```NO SIGNAL``` on it<br>until reconnected | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Stops the broadcast <sup>1</sup> |
 | [DV-timings](https://linuxtv.org/downloads/v4l-dvb-apis/uapi/v4l/dv-timings.html) support -<br>the ability to change resolution<br>on the fly by source signal | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes | ![#ffaa00](https://placehold.it/15/ffaa00/000000?text=+) Partially yes <sup>1</sup> |
-| Option to skip frames when streaming<br>static images by HTTP to save traffic | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Yes <sup>2</sup> | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) No |
+| 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 |
 | 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 |
@@ -30,9 +30,9 @@ If you're going to live-stream from your backyard webcam and need to control it,
 
 -----
 # Building
-You'll need  ```make```, ```gcc```, ```libevent``` with ```pthreads``` support, ```libjpeg8```/```libjpeg-turbo``` and ```libuuid```.
+You'll need  ```make```, ```gcc```, ```libevent``` with ```pthreads``` support, ```libjpeg8```/```libjpeg-turbo```, ```libuuid``` and ```libbsd``` (only for Linux).
 
-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).
+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```.
 
 ```
 $ git clone --depth=1 https://github.com/pikvm/ustreamer
@@ -59,7 +59,7 @@ $ ./ustreamer \
     --workers=3 \ # Maximum workers for OpenMAX
     --persistent \ # Don't re-initialize device on timeout (for example when HDMI cable was disconnected)
     --dv-timings \ # Use DV-timings
-    --drop-same-frames=30 # Save that traffic
+    --drop-same-frames=30 # Save the traffic
 ```
 
 You can always view the full list of options with ```ustreamer --help```.

README.ru.md

@@ -30,9 +30,9 @@
 
 -----
 # Сборка
-Для сборки вам понадобятся ```make```, ```gcc```, ```libevent``` с поддержкой ```pthreads```, ```libjpeg8```/```libjpeg-turbo``` и ```libuuid```.
+Для сборки вам понадобятся ```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``` (по умолчанию он включен).
+На 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```.
 
 ```
 $ git clone --depth=1 https://github.com/pikvm/ustreamer

pkg/arch/PKGBUILD

@@ -3,13 +3,13 @@
 
 
 pkgname=ustreamer
-pkgver=1.5
+pkgver=1.10
 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)
+depends=(libjpeg libevent libutil-linux libbsd)
 # optional: raspberrypi-firmware for OMX encoder
 # optional: wiringpi for GPIO support
 makedepends=(gcc make)

pkg/gentoo/ustreamer-9999.ebuild

@@ -18,6 +18,7 @@ DEPEND="
 	>=dev-libs/libevent-2.1.8
 	>=media-libs/libjpeg-turbo-1.5.3
 	>=sys-apps/util-linux-2.33
+	>=dev-libs/libbsd-0.9.1
 "
 RDEPEND="${DEPEND}"
 BDEPEND=""

pkg/openwrt/Makefile

@@ -6,7 +6,7 @@
 include $(TOPDIR)/rules.mk
 
 PKG_NAME:=ustreamer
-PKG_VERSION:=1.5
+PKG_VERSION:=1.10
 PKG_RELEASE:=1
 PKG_MAINTAINER:=Maxim Devaev <mdevaev@gmail.com>
 
@@ -25,7 +25,7 @@ define Package/ustreamer
   SECTION:=multimedia
   CATEGORY:=Multimedia
   TITLE:=uStreamer
-  DEPENDS:=+libpthread +libjpeg +libv4l +libuuid +libevent2 +libevent2-core +libevent2-extra +libevent2-pthreads
+  DEPENDS:=+libpthread +libjpeg +libv4l +libuuid +libbsd +libevent2 +libevent2-core +libevent2-extra +libevent2-pthreads
   URL:=https://github.com/pikvm/ustreamer
 endef
 

src/config.h

@@ -23,5 +23,5 @@
 #pragma once
 
 #ifndef VERSION
-#	define VERSION "1.5"
+#	define VERSION "1.10"
 #endif

src/device.c

@@ -286,7 +286,7 @@ int device_grab_buffer(struct device_t *dev) {
 
 	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();
+	dev->run->pictures[buf_info.index]->grab_ts = get_now_monotonic();
 	return buf_info.index;
 }
 

src/encoder.c

@@ -201,7 +201,7 @@ int encoder_compress_buffer(struct encoder_t *encoder, struct device_t *dev, uns
 
 	assert(encoder->run->type != ENCODER_TYPE_UNKNOWN);
 
-	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) {
 		cpu_encoder_compress_buffer(dev, buf_index, encoder->run->quality);
@@ -216,7 +216,7 @@ int encoder_compress_buffer(struct encoder_t *encoder, struct device_t *dev, uns
 	}
 #	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;

src/http/path.c

@@ -117,7 +117,7 @@ char *simplify_request_path(const char *str) {
 	return simplified;
 }
 
-#if TEST_HTTP_PATH
+#ifdef TEST_HTTP_PATH
 
 int test_simplify_request_path(const char *sample, const char *expected) {
 	char *result = simplify_request_path(sample);

src/http/server.c

@@ -172,9 +172,9 @@ 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);
 #	undef EXPOSED
 
 	{
@@ -446,17 +446,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
@@ -637,12 +637,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
 			));
 		}
@@ -797,7 +797,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 +805,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 +824,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 +837,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 +848,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 +857,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 +871,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,7 +879,7 @@ 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

src/http/server.h

@@ -61,10 +61,10 @@ 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;
 };
 
 struct http_server_runtime_t {

src/main.c

@@ -98,6 +98,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,8 +106,8 @@ int main(int argc, char *argv[]) {
 	int exit_code = 0;
 
 	LOGGING_INIT;
-
 	A_THREAD_RENAME("main");
+	options = options_init(argc, argv);
 
 #	ifdef WITH_GPIO
 	GPIO_INIT;
@@ -117,7 +118,7 @@ int main(int argc, char *argv[]) {
 	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;
 #		endif
@@ -153,6 +154,7 @@ int main(int argc, char *argv[]) {
 	GPIO_SET_LOW(prog_running);
 #	endif
 
+	options_destroy(options);
 	if (exit_code == 0) {
 		LOG_INFO("Bye-bye");
 	}

src/options.c

@@ -25,9 +25,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdbool.h>
-#ifdef WITH_OMX
-#	include <string.h>
-#endif
+#include <string.h>
 #include <ctype.h>
 #include <limits.h>
 #include <getopt.h>
@@ -36,6 +34,7 @@
 
 #include "config.h"
 #include "logging.h"
+#include "process.h"
 #include "device.h"
 #include "encoder.h"
 #include "http/server.h"
@@ -107,12 +106,21 @@ enum _OPT_VALUES {
 	_O_GPIO_WORKERS_BUSY_AT,
 #endif
 
+#ifdef HAS_PDEATHSIG
+	_O_EXIT_ON_PARENT_DEATH,
+#endif
+#ifdef WITH_SETPROCTITLE
+	_O_PROCESS_NAME_PREFIX,
+#endif
+
 	_O_LOG_LEVEL,
 	_O_PERF,
 	_O_VERBOSE,
 	_O_DEBUG,
 	_O_FORCE_LOG_COLORS,
 	_O_NO_LOG_COLORS,
+
+	_O_FEATURES,
 };
 
 static const struct option _LONG_OPTS[] = {
@@ -171,6 +179,13 @@ static const struct option _LONG_OPTS[] = {
 	{"gpio-workers-busy-at",	required_argument,	NULL,	_O_GPIO_WORKERS_BUSY_AT},
 #endif
 
+#ifdef HAS_PDEATHSIG
+	{"exit-on-parent-death",	no_argument,		NULL,	_O_EXIT_ON_PARENT_DEATH},
+#endif
+#ifdef WITH_SETPROCTITLE
+	{"process-name-prefix",		required_argument,	NULL,	_O_PROCESS_NAME_PREFIX},
+#endif
+
 	{"log-level",				required_argument,	NULL,	_O_LOG_LEVEL},
 	{"perf",					no_argument,		NULL,	_O_PERF},
 	{"verbose",					no_argument,		NULL,	_O_VERBOSE},
@@ -180,6 +195,7 @@ static const struct option _LONG_OPTS[] = {
 
 	{"help",					no_argument,		NULL,	_O_HELP},
 	{"version",					no_argument,		NULL,	_O_VERSION},
+	{"features",				no_argument,		NULL,	_O_FEATURES},
 
 	{NULL, 0, NULL, 0},
 };
@@ -190,11 +206,35 @@ static int _parse_resolution(const char *str, unsigned *width, unsigned *height,
 static int _parse_glitched_resolutions(const char *str, struct encoder_t *encoder);
 #endif
 
-static void _version(bool nl);
+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; \
@@ -227,15 +267,6 @@ int parse_options(int argc, char *argv[], struct device_t *dev, struct encoder_t
 			break; \
 		}
 
-#	ifdef WITH_OMX
-#		define OPT_GLITCHED_RESOLUTIONS { \
-				if (_parse_glitched_resolutions(optarg, encoder) < 0) { \
-					return -1; \
-				} \
-				break; \
-			}
-#	endif
-
 #	define OPT_PARSE(_name, _dest, _func, _invalid, _available) { \
 			if ((_dest = _func(optarg)) == _invalid) { \
 				printf("Unknown " _name ": %s; available: %s\n", optarg, _available); \
@@ -261,6 +292,9 @@ int parse_options(int argc, char *argv[], struct device_t *dev, struct encoder_t
 	int short_index;
 	int opt_index;
 	char short_opts[1024] = {0};
+#	ifdef WITH_SETPROCTITLE
+	char *process_name_prefix = NULL;
+#	endif
 
 	for (short_index = 0, opt_index = 0; _LONG_OPTS[opt_index].name != NULL; ++opt_index) {
 		if (isalpha(_LONG_OPTS[opt_index].val)) {
@@ -273,7 +307,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);
@@ -292,7 +326,11 @@ int parse_options(int argc, char *argv[], struct device_t *dev, struct encoder_t
 			case _O_QUALITY:		OPT_NUMBER("--quality", encoder->quality, 1, 100, 0);
 			case _O_ENCODER:		OPT_PARSE("encoder type", encoder->type, encoder_parse_type, ENCODER_TYPE_UNKNOWN, ENCODER_TYPES_STR);
 #			ifdef WITH_OMX
-			case _O_GLITCHED_RESOLUTIONS:	OPT_GLITCHED_RESOLUTIONS;
+			case _O_GLITCHED_RESOLUTIONS:
+				if (_parse_glitched_resolutions(optarg, encoder) < 0) {
+					return -1;
+				}
+				break;
 #			endif
 			case _O_DEVICE_TIMEOUT:		OPT_NUMBER("--device-timeout", dev->timeout, 1, 60, 0);
 			case _O_DEVICE_ERROR_DELAY:	OPT_NUMBER("--device-error-delay", dev->error_delay, 1, 60, 0);
@@ -333,6 +371,17 @@ int parse_options(int argc, char *argv[], struct device_t *dev, struct encoder_t
 			case _O_GPIO_WORKERS_BUSY_AT:	OPT_NUMBER("--gpio-workers-busy-at", gpio_pin_workers_busy_at, 0, 256, 0);
 #			endif
 
+#			ifdef HAS_PDEATHSIG
+			case _O_EXIT_ON_PARENT_DEATH:
+				if (process_track_parent_death() < 0) {
+					return -1;
+				};
+				break;
+#			endif
+#			ifdef WITH_SETPROCTITLE
+			case _O_PROCESS_NAME_PREFIX:	OPT_SET(process_name_prefix, optarg);
+#			endif
+
 			case _O_LOG_LEVEL:			OPT_NUMBER("--log-level", log_level, LOG_LEVEL_INFO, LOG_LEVEL_DEBUG, 0);
 			case _O_PERF:				OPT_SET(log_level, LOG_LEVEL_PERF);
 			case _O_VERBOSE:			OPT_SET(log_level, LOG_LEVEL_VERBOSE);
@@ -341,19 +390,23 @@ int parse_options(int argc, char *argv[], struct device_t *dev, struct encoder_t
 			case _O_NO_LOG_COLORS:		OPT_SET(log_colored, false);
 
 			case _O_HELP:		_help(dev, encoder, server); return 1;
-			case _O_VERSION:	_version(true); return 1;
+			case _O_VERSION:	puts(VERSION); return 1;
+			case _O_FEATURES:	_features(); return 1;
 
 			case 0:		break;
 			default:	_help(dev, encoder, server); return -1;
 		}
 	}
 
+#	ifdef WITH_SETPROCTITLE
+	if (process_name_prefix != NULL) {
+		process_set_name_prefix(options->argc, options->argv, process_name_prefix);
+	}
+#	endif
+
 #	undef OPT_CTL_AUTO
 #	undef OPT_CTL
 #	undef OPT_PARSE
-#	ifdef WITH_OMX
-#		undef OPT_GLITCHED_RESOLUTIONS
-#	endif
 #	undef OPT_RESOLUTION
 #	undef OPT_NUMBER
 #	undef OPT_SET
@@ -430,25 +483,42 @@ static int _parse_glitched_resolutions(const char *str, struct encoder_t *encode
 }
 #endif
 
-static void _version(bool nl) {
-	printf(VERSION);
+static void _features(void) {
 #	ifdef WITH_OMX
-	printf(" + OMX");
+	puts("+ WITH_OMX");
+#	else
+	puts("- WITH_OMX");
 #	endif
+
 #	ifdef WITH_GPIO
-	printf(" + GPIO");
+	puts("+ WITH_GPIO");
+#	else
+	puts("- WITH_GPIO");
+#	endif
+
+#	ifdef WITH_PTHREAD_NP
+	puts("+ WITH_PTHREAD_NP");
+#	else
+	puts("- WITH_PTHREAD_NP");
+#	endif
+
+#	ifdef WITH_SETPROCTITLE
+	puts("+ WITH_SETPROCTITLE");
+#	else
+	puts("- WITH_SETPROCTITLE");
+#	endif
+
+#	ifdef HAS_PDEATHSIG
+	puts("+ HAS_PDEATHSIG");
+#	else
+	puts("- HAS_PDEATHSIG");
 #	endif
-	if (nl) {
-		putchar('\n');
-	}
 }
 
 static void _help(struct device_t *dev, struct encoder_t *encoder, struct http_server_t *server) {
 	printf("\nuStreamer - Lightweight and fast MJPG-HTTP streamer\n");
 	printf("═══════════════════════════════════════════════════\n\n");
-	printf("Version: ");
-	_version(false);
-	printf("; license: GPLv3\n");
+	printf("Version: %s; license: GPLv3\n", VERSION);
 	printf("Copyright (C) 2018 Maxim Devaev <mdevaev@gmail.com>\n\n");
 	printf("Capturing options:\n");
 	printf("══════════════════\n");
@@ -538,6 +608,17 @@ static void _help(struct device_t *dev, struct encoder_t *encoder, struct http_s
 	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");
+	printf("════════════════\n");
+#endif
+#ifdef HAS_PDEATHSIG
+	printf("    --exit-on-parent-death  ─────── Exit the program if the parent process is dead. Default: disabled.\n\n");
+#endif
+#ifdef WITH_SETPROCTITLE
+	printf("    --process-name-prefix <str>  ── Set process name prefix which will be displayed in the process list\n");
+	printf("                                    like '<str>: ustreamer --blah-blah-blah'. Default: disabled.\n\n");
 #endif
 	printf("Logging options:\n");
 	printf("════════════════\n");
@@ -554,4 +635,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");
 }

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

src/picture.c

@@ -84,9 +84,9 @@ 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
 }

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

src/process.h

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

src/stream.c

@@ -55,7 +55,7 @@ struct _worker_t {
 	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;
@@ -454,10 +454,10 @@ static void *_worker_thread(void *v_worker) {
 			}
 
 			if (device_release_buffer(worker->dev, worker->buf_index) == 0) {
-				worker->job_start_time = PICTURE(encode_begin_time);
+				worker->job_start_ts = PICTURE(encode_begin_ts);
 				atomic_store(&worker->has_job, false);
 
-				worker->last_comp_time = PICTURE(encode_end_time) - worker->job_start_time;
+				worker->last_comp_time = PICTURE(encode_end_ts) - worker->job_start_ts;
 
 				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);
@@ -498,7 +498,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];