Bump version: 1.11 → 1.12

.bumpversion.cfg

@@ -1,7 +1,7 @@
 [bumpversion]
 commit = True
 tag = True
-current_version = 1.7
+current_version = 1.12
 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

@@ -87,7 +87,7 @@ $(PROG): $(_SRCS:%.c=$(BUILD)/%.o)
 $(BUILD)/%.o: %.c
 	$(info -- CC $<)
 	@ mkdir -p $(dir $@) || true
-	@ $(CC) $< -o $@ $(CFLAGS) $(_LIBS)
+	@ $(CC) $< -o $@ $(CFLAGS)
 
 
 release:
@@ -109,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

@@ -64,6 +64,10 @@ $ ./ustreamer \
 
 You can always view the full list of options with ```ustreamer --help```.
 
+-----
+# Tips
+* [Running uStreamer via systemd service](https://github.com/pikvm/ustreamer/issues/16)
+
 -----
 # License
 Copyright (C) 2018 by Maxim Devaev mdevaev@gmail.com

README.ru.md

@@ -64,6 +64,10 @@ $ ./ustreamer \
 
 За полным списком опций обращайтесь ко встроенной справке: ```ustreamer --help```.
 
+-----
+# Советы
+* [Запуск с помощью systemd-сервиса](https://github.com/pikvm/ustreamer/issues/16)
+
 -----
 # Лицензия
 Copyright (C) 2018 by Maxim Devaev mdevaev@gmail.com

pkg/arch/PKGBUILD

@@ -3,7 +3,7 @@
 
 
 pkgname=ustreamer
-pkgver=1.7
+pkgver=1.12
 pkgrel=1
 pkgdesc="Lightweight and fast MJPG-HTTP streamer"
 url="https://github.com/pikvm/ustreamer"

pkg/openwrt/Makefile

@@ -6,7 +6,7 @@
 include $(TOPDIR)/rules.mk
 
 PKG_NAME:=ustreamer
-PKG_VERSION:=1.7
+PKG_VERSION:=1.12
 PKG_RELEASE:=1
 PKG_MAINTAINER:=Maxim Devaev <mdevaev@gmail.com>
 

src/config.h

@@ -23,5 +23,5 @@
 #pragma once
 
 #ifndef VERSION
-#	define VERSION "1.7"
+#	define VERSION "1.12"
 #endif

src/device.c

@@ -77,9 +77,10 @@ static int _device_open_mmap(struct device_t *dev);
 static int _device_open_queue_buffers(struct device_t *dev);
 static void _device_open_alloc_picbufs(struct device_t *dev);
 static int _device_apply_resolution(struct device_t *dev, unsigned width, unsigned height);
+
 static void _device_apply_controls(struct device_t *dev);
-static int _device_check_control(struct device_t *dev, const char *name, unsigned cid, int value, bool quiet);
-static void _device_set_control(struct device_t *dev, const char *name, unsigned cid, int value, bool quiet);
+static 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);
@@ -286,7 +287,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;
 }
 
@@ -390,7 +391,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) {
@@ -610,65 +611,81 @@ 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);
+
+#	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) {
+	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 +695,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);
 	}
 }
 

src/device.h

@@ -64,10 +64,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 {

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

src/http/server.c

@@ -157,6 +157,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 +173,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
 
 	{
@@ -326,7 +327,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;
 	}
@@ -446,17 +447,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 +638,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 +798,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 +806,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 +825,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 +838,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 +849,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 +858,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 +872,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 +880,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

@@ -25,6 +25,11 @@
 #	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 <signal.h>
 
@@ -98,6 +103,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 +111,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 +123,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 +159,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,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>
@@ -82,19 +81,16 @@ 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_USER,
 	_O_PASSWD,
@@ -145,19 +141,16 @@ 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},
 
 	{"host",					required_argument,	NULL,	_O_HOST},
 	{"port",					required_argument,	NULL,	_O_PORT},
@@ -212,7 +205,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; \
@@ -253,16 +270,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 +315,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);
@@ -313,19 +343,26 @@ 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);
+				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_HOST:				OPT_SET(server->host, optarg);
 			case _O_PORT:				OPT_NUMBER("--port", server->port, 1, 65535, 0);
@@ -378,12 +415,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
@@ -540,19 +578,17 @@ 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("    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);

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/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];