Bump version: 0.21 → 0.22

.bumpversion.cfg

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

Makefile

@@ -6,7 +6,7 @@ LDFLAGS ?=
 
 # =====
 CC = gcc
-LIBS = -lm -ljpeg -pthread -levent -levent_pthreads
+LIBS = -lm -ljpeg -pthread -levent -levent_pthreads -luuid
 override CFLAGS += -c -std=c99 -Wall -Wextra -D_GNU_SOURCE
 SOURCES = $(shell ls src/*.c src/jpeg/*.c)
 OBJECTS = $(SOURCES:.c=.o)

PKGBUILD

@@ -3,13 +3,13 @@
 
 
 pkgname=ustreamer
-pkgver=0.14
+pkgver=0.22
 pkgrel=1
 pkgdesc="Lightweight and fast MJPG-HTTP streamer"
 url="https://github.com/pi-kvm/ustreamer"
 license=(GPL)
 arch=(i686 x86_64 armv6h armv7h)
-depends=(libjpeg libevent)
+depends=(libjpeg libevent libutil-linux)
 # optional: raspberrypi-firmware for OMX JPEG compressor
 makedepends=(gcc make)
 source=("$url/archive/v$pkgver.tar.gz")

README.md

@@ -17,9 +17,9 @@
 | Возможность сервить файлы встроенным<br>HTTP-сервером, настройки авторизации | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Нет <sup>4</sup> | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть |
 
 Сносочки:
-  * ```1``` Для mjpg-streamer существует [мой патч](https://github.com/jacksonliam/mjpg-streamer/pull/164), предотвращающий зависание при отключении устройства и добавляющий поддержку DV-таймингов, однако трансляция при этом все равно прерывается. В данный момент этот патч не принят в апстрим, и я даже не гарантирую его стопроцентную работоспособность. Код mjpg-streamer очень плохо структурирован и чрезвычайно запутан, и я мог что-то упустить. Собственно, это одна из причин, почему µStreamer написан с нуля.
+  * ```1``` Для mjpg-streamer существует [мой патч](https://github.com/jacksonliam/mjpg-streamer/pull/164), предотвращающий зависание при отключении устройства и добавляющий поддержку DV-таймингов, однако трансляция при этом все равно прерывается. В данный момент этот патч не принят в апстрим, и я даже не гарантирую его стопроцентную работоспособность. Код mjpg-streamer очень плохо структурирован, чрезвычайно запутан, и я мог что-то упустить. Собственно, это одна из причин, почему µStreamer был написан с нуля.
   
-  * ```2``` Это фича позволяет в несколько раз снизить объем исходящего трафика при трансляции HDMI, однако увеличивает загрузку процессора и добавляет небольшую задержку. Суть в том, что HDMI - полностью цифровой интерфейс, и новый захваченный фрейм может быть идентичен предыдущему в точности до байта. В этом случае нет нужды передавать одну и ту же картинку по сети несколько раз в секунду. При использовании опции `--drop-same-frames=20`, µStreamer будет дропать все одинаковые фреймы, но не более 20. Новый фрейм сравнивается с предыдущим сначала по длине, а затем помощью ```memcmp()```.
+  * ```2``` Это фича позволяет в несколько раз снизить объем исходящего трафика при трансляции HDMI, однако немного увеличивает загрузку процессора. Суть в том, что HDMI - полностью цифровой интерфейс, и новый захваченный фрейм может быть идентичен предыдущему в точности до байта. В этом случае нет нужды передавать одну и ту же картинку по сети несколько раз в секунду. При использовании опции `--drop-same-frames=20`, µStreamer будет дропать все одинаковые фреймы, но не более 20 подряд. Новый фрейм сравнивается с предыдущим сначала по длине, а затем помощью ```memcmp()```.
 
   * ```3``` Поскольку µStreamer писался в первую очередь для устройств видеозахвата, в нем реализованы только те форматы, которые для них были нужны. MJPG в контексте входных данных означает, что устройство умеет самостоятельно сжимать картинку в JPEG и отдавать ее программе, что позволяет значительно снизить загрузку процессора и избавить его от необходимости кодировать картинку софтом. Этот формат поддерживается большинством веб-камер, но не поддерживается ни одним из встреченных мной устройств видеозахвата; его не умеет ни [Auvidea B101](https://auvidea.com/b101-hdmi-to-csi-2-bridge-15-pin-fpc/), ни [EasyCap UTV 007](https://www.amazon.com/dp/B0126O0RDC). Нет никаких технических сложностей добавить поддержку аппаратного MJPG источника, но у меня просто пока не дошли до этого руки.
 
@@ -31,9 +31,9 @@
 
 -----
 # Сборка
-Для сборки вам понадобятся ```make```, ```gcc```, ```libevent``` с поддержкой ```pthreads``` и ```libjpeg8```/```libjpeg-turbo```.
+Для сборки вам понадобятся ```make```, ```gcc```, ```libevent``` с поддержкой ```pthreads```, ```libjpeg8```/```libjpeg-turbo``` и ```libuuid```.
 
-На Raspberry Pi програма автоматически собирается с поддержкой OpenMAX, если обнаружит нужные хедеры в ```/opt/vc/include```.
+На Raspberry Pi програма автоматически собирается с поддержкой OpenMAX IL, если обнаружит нужные хедеры в ```/opt/vc/include```.
 
 ```
 $ git clone --depth=1 https://github.com/pi-kvm/ustreamer
@@ -46,7 +46,7 @@ $ ./ustreamer --help
 
 -----
 # Использование
-Будучи запущенным без аргументов, ```ustremaer``` попробует открыть устройство ```/dev/video0``` с разрешением 640x480 и начать трансляцию на ```http://localhost:8080```. Это поведение может быть изменено с помощью опций ```--device```, ```--host``` и ```--port```. Пример вещания на всю сеть по 80 порту:
+Будучи запущенным без аргументов, ```ustreamer``` попробует открыть устройство ```/dev/video0``` с разрешением 640x480 и начать трансляцию на ```http://localhost:8080```. Это поведение может быть изменено с помощью опций ```--device```, ```--host``` и ```--port```. Пример вещания на всю сеть по 80 порту:
 ```
 # ./ustreamer --device=/dev/video1 --host=0.0.0.0 --port=80
 ```
@@ -57,6 +57,8 @@ $ ./ustreamer \
     --format=uyvy \ # Настройка входного формата устройства
     --encoder=omx \ # Использование аппаратного кодирования с помощью OpenMAX
     --dv-timings # Включение DV-таймингов
+    --quality=20 # У OpenMAX нелинейная шкала качества
+    --drop-same-frames=30 # Экономим трафик
 ```
 
 За полным списком опций обращайтесь ко встроенной справке: ```ustreamer --help```.

src/config.h

@@ -21,4 +21,4 @@
 
 #pragma once
 
-#define VERSION "0.14"
+#define VERSION "0.22"

src/device.c

@@ -185,6 +185,7 @@ void device_close(struct device_t *dev) {
 
 static int _device_open_check_cap(struct device_t *dev) {
 	struct v4l2_capability cap;
+	int input = dev->input; // Needs pointer to int for ioctl()
 
 	MEMSET_ZERO(cap);
 
@@ -204,10 +205,16 @@ static int _device_open_check_cap(struct device_t *dev) {
 		return -1;
 	}
 
+	LOG_INFO("Using input channel: %d", input);
+	if (xioctl(dev->run->fd, VIDIOC_S_INPUT, &input) < 0) {
+		LOG_ERROR("Can't set input channel");
+		return -1;
+	}
+
 	if (dev->standard != V4L2_STD_UNKNOWN) {
 		LOG_INFO("Using TV standard: %s", _standard_to_string(dev->standard));
 		if (xioctl(dev->run->fd, VIDIOC_S_STD, &dev->standard) < 0) {
-			LOG_PERROR("Can't set video standard");
+			LOG_ERROR("Can't set video standard");
 			return -1;
 		}
 	} else {

src/device.h

@@ -64,6 +64,7 @@ struct device_runtime_t {
 
 struct device_t {
 	char			*path;
+	unsigned		input;
 	unsigned		width;
 	unsigned		height;
 	unsigned		format;

src/encoder.c

@@ -131,7 +131,7 @@ void encoder_prepare_for_device(struct encoder_t *encoder, struct device_t *dev)
 int encoder_compress_buffer(struct encoder_t *encoder, struct device_t *dev, const unsigned index) {
 	assert(encoder->type != ENCODER_TYPE_UNKNOWN);
 
-	dev->run->pictures[index].encode_begin_time = now_monotonic_ms();
+	dev->run->pictures[index].encode_begin_time = get_now_monotonic();
 
 	if (encoder->type == ENCODER_TYPE_CPU) {
 		jpeg_encoder_compress_buffer(dev, index, encoder->quality);
@@ -144,7 +144,7 @@ int encoder_compress_buffer(struct encoder_t *encoder, struct device_t *dev, con
 	}
 #	endif
 
-	dev->run->pictures[index].encode_end_time = now_monotonic_ms();
+	dev->run->pictures[index].encode_end_time = get_now_monotonic();
 
 	return 0;
 

src/http.c

@@ -30,6 +30,8 @@
 #include <event2/buffer.h>
 #include <event2/bufferevent.h>
 
+#include <uuid/uuid.h>
+
 #ifndef EVTHREAD_USE_PTHREADS_IMPLEMENTED
 #	error Required libevent-pthreads support
 #endif
@@ -115,7 +117,7 @@ int http_server_listen(struct http_server_t *server) {
 	LOG_DEBUG("Binding HTTP to [%s]:%d ...", server->host, server->port);
 	evhttp_set_timeout(server->run->http, server->timeout);
 
-	if (evhttp_bind_socket(server->run->http, server->host, server->port) != 0) {
+	if (evhttp_bind_socket(server->run->http, server->host, server->port) < 0) {
 		LOG_PERROR("Can't listen HTTP on [%s]:%d", server->host, server->port)
 		return -1;
 	}
@@ -172,13 +174,25 @@ static void _http_callback_ping(struct evhttp_request *request, void *v_server)
 
 	assert((buf = evbuffer_new()));
 	assert(evbuffer_add_printf(buf,
-		"{\"stream\": {\"resolution\":"
-		" {\"width\": %u, \"height\": %u},"
-		" \"fps\": %u, \"online\": %s}}",
+		"{\"source\": {\"resolution\": {\"width\": %u, \"height\": %u},"
+		" \"online\": %s, \"quality\": %u, \"captured_fps\": %u},"
+		" \"stream\": {\"queued_fps\": %u,  \"clients\": %u, \"clients_stat\": {",
 		(server->fake_width ? server->fake_width : server->run->exposed->width),
 		(server->fake_height ? server->fake_height : server->run->exposed->height),
-		server->run->exposed->fps, (server->run->exposed->online ? "true" : "false")
+		(server->run->exposed->online ? "true" : "false"),
+		server->run->stream->encoder->quality,
+		server->run->exposed->captured_fps,
+		server->run->exposed->queued_fps,
+		server->run->stream_clients_count
 	));
+	for (struct stream_client_t * client = server->run->stream_clients; client != NULL; client = client->next) {
+		assert(evbuffer_add_printf(buf,
+			"\"%s\": {\"fps\": %u}%s",
+			client->id, client->fps, (client->next ? ", " : "")
+		));
+	}
+	assert(evbuffer_add_printf(buf, "}}}"));
+
 	ADD_HEADER("Content-Type", "application/json");
 	evhttp_send_reply(request, HTTP_OK, "OK", buf);
 	evbuffer_free(buf);
@@ -204,16 +218,16 @@ static void _http_callback_snapshot(struct evhttp_request *request, void *v_serv
 #	define ADD_TIME_HEADER(_key, _value) \
 		{ sprintf(time_buf, "%.06Lf", _value); ADD_HEADER(_key, time_buf); }
 
-	ADD_TIME_HEADER("X-Timestamp", now_real_ms());
+	ADD_TIME_HEADER("X-Timestamp", get_now_real());
 
-	if (server->add_x_timings) {
-		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-End-Time",		EXPOSED(expose_end_time));
-		ADD_TIME_HEADER("X-UStreamer-Send-Time",			now_monotonic_ms());
-	}
+	ADD_HEADER("X-UStreamer-Online",					(EXPOSED(online) ? "true" : "false"));
+	ADD_TIME_HEADER("X-UStreamer-Grab-Time",			EXPOSED(picture.grab_time));
+	ADD_TIME_HEADER("X-UStreamer-Encode-Begin-Time",	EXPOSED(picture.encode_begin_time));
+	ADD_TIME_HEADER("X-UStreamer-Encode-End-Time",		EXPOSED(picture.encode_end_time));
+	ADD_TIME_HEADER("X-UStreamer-Expose-Begin-Time",	EXPOSED(expose_begin_time));
+	ADD_TIME_HEADER("X-UStreamer-Expose-Cmp-Time",		EXPOSED(expose_cmp_time));
+	ADD_TIME_HEADER("X-UStreamer-Expose-End-Time",		EXPOSED(expose_end_time));
+	ADD_TIME_HEADER("X-UStreamer-Send-Time",			get_now_monotonic());
 
 #	undef ADD_TIME_HEADER
 
@@ -240,6 +254,7 @@ static void _http_callback_stream(struct evhttp_request *request, void *v_server
 	struct stream_client_t *client;
 	char *client_addr;
 	unsigned short client_port;
+	uuid_t uuid;
 
 	PROCESS_HEAD_REQUEST;
 
@@ -251,6 +266,9 @@ static void _http_callback_stream(struct evhttp_request *request, void *v_server
 		client->need_initial = true;
 		client->need_first_frame = true;
 
+		uuid_generate(uuid);
+		uuid_unparse_lower(uuid, client->id);
+
 		if (server->run->stream_clients == NULL) {
 			server->run->stream_clients = client;
 		} else {
@@ -264,8 +282,8 @@ static void _http_callback_stream(struct evhttp_request *request, void *v_server
 
 		evhttp_connection_get_peer(conn, &client_addr, &client_port);
 		LOG_INFO(
-			"HTTP: Registered the new stream client: [%s]:%u; clients now: %u",
-			client_addr, client_port, server->run->stream_clients_count
+			"HTTP: Registered the new stream client: [%s]:%u; id=%s; clients now: %u",
+			client_addr, client_port, client->id, server->run->stream_clients_count
 		);
 
 		buf_event = evhttp_connection_get_bufferevent(conn);
@@ -284,6 +302,15 @@ static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_c
 
 	struct stream_client_t *client = (struct stream_client_t *)v_client;
 	struct evbuffer *buf;
+	long double now = get_now_monotonic();
+	long long now_second = floor_ms(now);
+
+	if (now_second != client->fps_accum_second) {
+		client->fps = client->fps_accum;
+		client->fps_accum = 0;
+		client->fps_accum_second = now_second;
+	}
+	client->fps_accum += 1;
 
 	assert((buf = evbuffer_new()));
 
@@ -294,9 +321,11 @@ static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_c
 			"Cache-Control: no-store, no-cache, must-revalidate, pre-check=0, post-check=0, max-age=0" RN
 			"Pragma: no-cache" RN
 			"Expires: Mon, 3 Jan 2000 12:34:56 GMT" RN
+			"Set-Cookie: stream_client_id=%s; path=/; max-age=30" RN
 			"Content-Type: multipart/x-mixed-replace;boundary=" BOUNDARY RN
 			RN
-			"--" BOUNDARY RN
+			"--" BOUNDARY RN,
+			client->id
 		));
 		assert(!bufferevent_write_buffer(buf_event, buf));
 		client->need_initial = false;
@@ -310,23 +339,29 @@ static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_c
 		"X-Timestamp: %.06Lf" RN
 		"%s",
 		EXPOSED(picture.size) * sizeof(*EXPOSED(picture.data)),
-		now_real_ms(), (client->server->add_x_timings ? "" : RN)
+		get_now_real(), (client->server->extra_stream_headers ? "" : RN)
 	));
-	if (client->server->add_x_timings) {
+	if (client->server->extra_stream_headers) {
 		assert(evbuffer_add_printf(buf,
+			"X-UStreamer-Online: %s" RN
+			"X-UStreamer-Client-FPS: %u" RN
 			"X-UStreamer-Grab-Time: %.06Lf" RN
 			"X-UStreamer-Encode-Begin-Time: %.06Lf" RN
 			"X-UStreamer-Encode-End-Time: %.06Lf" RN
 			"X-UStreamer-Expose-Begin-Time: %.06Lf" RN
+			"X-UStreamer-Expose-Cmp-Time: %.06Lf" RN
 			"X-UStreamer-Expose-End-Time: %.06Lf" RN
 			"X-UStreamer-Send-Time: %.06Lf" RN
 			RN,
+			(EXPOSED(online) ? "true" : "false"),
+			client->fps,
 			EXPOSED(picture.grab_time),
 			EXPOSED(picture.encode_begin_time),
 			EXPOSED(picture.encode_end_time),
 			EXPOSED(expose_begin_time),
+			EXPOSED(expose_cmp_time),
 			EXPOSED(expose_end_time),
-			now_monotonic_ms()
+			now
 		));
 	}
 
@@ -379,19 +414,32 @@ static void _http_callback_stream_error(UNUSED struct bufferevent *buf_event, UN
 }
 
 static void _http_queue_send_stream(struct http_server_t *server, const bool updated) {
-	struct stream_client_t *client;
 	struct evhttp_connection *conn;
 	struct bufferevent *buf_event;
+	long long now;
+	bool queued = false;
+	static unsigned queued_fps_accum = 0;
+	static long long queued_fps_second = 0;
 
-	for (client = server->run->stream_clients; client != NULL; client = client->next) {
+	for (struct stream_client_t *client = server->run->stream_clients; client != NULL; client = client->next) {
 		conn = evhttp_request_get_connection(client->request);
 		if (conn != NULL && (updated || client->need_first_frame)) {
 			buf_event = evhttp_connection_get_bufferevent(conn);
 			bufferevent_setcb(buf_event, NULL, _http_callback_stream_write, _http_callback_stream_error, (void *)client);
 			bufferevent_enable(buf_event, EV_READ|EV_WRITE);
 			client->need_first_frame = false;
+			queued = true;
 		}
 	}
+
+	if (queued) {
+		if ((now = floor_ms(get_now_monotonic())) != queued_fps_second) {
+			server->run->exposed->queued_fps = queued_fps_accum;
+			queued_fps_accum = 0;
+			queued_fps_second = now;
+		}
+		queued_fps_accum += 1;
+	}
 }
 
 static void _http_exposed_refresh(UNUSED int fd, UNUSED short what, void *v_server) {
@@ -423,6 +471,20 @@ static void _http_exposed_refresh(UNUSED int fd, UNUSED short what, void *v_serv
 	}
 
 	if (queue_send) {
+		if (server->drop_same_frames) {
+			// Хром всегда показывает не новый пришедший фрейм, а предыдущий.
+			// При updated == false нужно еще один раз послать предыдущий фрейм
+			// https://bugs.chromium.org/p/chromium/issues/detail?id=527446
+
+			static bool updated_prev = false;
+			bool updated_orig = updated;
+
+			if (updated_prev && !updated_orig) {
+				updated = true;
+			}
+			updated_prev = updated_orig;
+		}
+
 		_http_queue_send_stream(server, updated);
 	}
 
@@ -435,8 +497,8 @@ static bool _expose_new_picture(struct http_server_t *server) {
 #	define EXPOSED(_next) server->run->exposed->_next
 
 	assert(STREAM(picture.size) > 0);
-	EXPOSED(fps) = STREAM(fps);
-	EXPOSED(expose_begin_time) = now_monotonic_ms();
+	EXPOSED(captured_fps) = STREAM(captured_fps);
+	EXPOSED(expose_begin_time) = get_now_monotonic();
 
 #	define MEM_STREAM_TO_EXPOSED \
 		EXPOSED(picture.data), STREAM(picture.data), \
@@ -449,10 +511,20 @@ static bool _expose_new_picture(struct http_server_t *server) {
 			&& EXPOSED(picture.size) == STREAM(picture.size)
 			&& !memcmp(MEM_STREAM_TO_EXPOSED)
 		) {
-			LOG_PERF("HTTP: dropped same frame number %u", EXPOSED(dropped));
+			EXPOSED(expose_cmp_time) = get_now_monotonic();
+			EXPOSED(expose_end_time) = EXPOSED(expose_cmp_time);
+			LOG_PERF(
+				"HTTP: dropped same frame number %u; comparsion time = %.06Lf",
+				EXPOSED(dropped), EXPOSED(expose_cmp_time) - EXPOSED(expose_begin_time)
+			);
 			EXPOSED(dropped) += 1;
-			EXPOSED(expose_end_time) = now_monotonic_ms();
 			return false; // Not updated
+		} else {
+			EXPOSED(expose_cmp_time) = get_now_monotonic();
+			LOG_PERF(
+				"HTTP: passed same frame check (frames are differ); comparsion time = %.06Lf",
+				EXPOSED(expose_cmp_time) - EXPOSED(expose_begin_time)
+			);
 		}
 	}
 
@@ -475,7 +547,8 @@ static bool _expose_new_picture(struct http_server_t *server) {
 	EXPOSED(height) = STREAM(height);
 	EXPOSED(online) = true;
 	EXPOSED(dropped) = 0;
-	EXPOSED(expose_end_time) = now_monotonic_ms();
+	EXPOSED(expose_cmp_time) = EXPOSED(expose_begin_time);
+	EXPOSED(expose_end_time) = get_now_monotonic();
 
 #	undef STREAM
 #	undef EXPOSED
@@ -485,7 +558,8 @@ static bool _expose_new_picture(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) = now_monotonic_ms();
+	EXPOSED(expose_begin_time) = get_now_monotonic();
+	EXPOSED(expose_cmp_time) = EXPOSED(expose_begin_time);
 
 	if (EXPOSED(online) || EXPOSED(picture.size) == 0) {
 		if (EXPOSED(picture.allocated) < BLANK_JPG_SIZE) {
@@ -506,7 +580,7 @@ static bool _expose_blank_picture(struct http_server_t *server) {
 
 		EXPOSED(width) = BLANK_JPG_WIDTH;
 		EXPOSED(height) = BLANK_JPG_HEIGHT;
-		EXPOSED(fps) = 0;
+		EXPOSED(captured_fps) = 0;
 		EXPOSED(online) = false;
 		goto updated;
 	}
@@ -514,13 +588,13 @@ 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) = now_monotonic_ms();
+		EXPOSED(expose_end_time) = get_now_monotonic();
 		return false; // Not updated
 	}
 
 	updated:
 		EXPOSED(dropped) = 0;
-		EXPOSED(expose_end_time) = now_monotonic_ms();
+		EXPOSED(expose_end_time) = get_now_monotonic();
 		return true; // Updated
 
 #	undef EXPOSED

src/http.h

@@ -31,8 +31,12 @@
 struct stream_client_t {
 	struct http_server_t	*server;
 	struct evhttp_request	*request;
+	char					id[37]; // ex. "1b4e28ba-2fa1-11d2-883f-0016d3cca427" + "\0"
 	bool					need_initial;
 	bool					need_first_frame;
+	unsigned				fps;
+	unsigned				fps_accum;
+	long long				fps_accum_second;
 
 	struct stream_client_t	*prev;
 	struct stream_client_t	*next;
@@ -42,10 +46,12 @@ struct exposed_t {
 	struct picture_t	picture;
 	unsigned			width;
 	unsigned			height;
-	unsigned			fps;
+	unsigned			captured_fps;
+	unsigned			queued_fps;
 	bool				online;
 	unsigned			dropped;
 	long double			expose_begin_time;
+	long double			expose_cmp_time;
 	long double			expose_end_time;
 };
 
@@ -64,7 +70,7 @@ struct http_server_t {
 	char		*host;
 	unsigned	port;
 	unsigned	drop_same_frames;
-	bool		add_x_timings;
+	bool		extra_stream_headers;
 	unsigned	fake_width;
 	unsigned	fake_height;
 	unsigned	timeout;

src/logging.h

@@ -54,65 +54,72 @@ pthread_mutex_t log_mutex;
 #define LOGGING_UNLOCK	assert(!pthread_mutex_unlock(&log_mutex))
 
 
-#define SEP_INFO(_x_ch) { \
+#define SEP_INFO(_ch) { \
 		LOGGING_LOCK; \
 		for (int _i = 0; _i < 80; ++_i) { \
-			putchar(_x_ch); \
+			putchar(_ch); \
 		} \
 		putchar('\n'); \
+		fflush(stdout); \
 		LOGGING_UNLOCK; \
 	}
 
-#define SEP_DEBUG(_x_ch) { \
+#define SEP_DEBUG(_ch) { \
 		if (log_level >= LOG_LEVEL_DEBUG) { \
-			SEP_INFO(_x_ch); \
+			SEP_INFO(_ch); \
 		} \
 	}
 
-#define LOG_ERROR(_x_msg, ...) { \
+#define LOG_PRINTF_NOLOCK(_label, _msg, ...) { \
+		printf("-- " _label " [%.03Lf tid=%ld] -- " _msg "\n", get_now_monotonic(), syscall(SYS_gettid), ##__VA_ARGS__); \
+		fflush(stdout); \
+	}
+
+#define LOG_ERROR(_msg, ...) { \
 		LOGGING_LOCK; \
-		printf("-- ERROR [%.03Lf tid=%ld] -- " _x_msg "\n", now_monotonic_ms(), syscall(SYS_gettid), ##__VA_ARGS__); \
+		LOG_PRINTF_NOLOCK("ERROR", _msg, ##__VA_ARGS__); \
 		LOGGING_UNLOCK; \
 	}
 
-#define LOG_PERROR(_x_msg, ...) { \
+#define LOG_PERROR(_msg, ...) { \
 		char _buf[1024] = ""; \
 		strerror_r(errno, _buf, 1024); \
 		LOGGING_LOCK; \
-		printf("-- ERROR [%.03Lf tid=%ld] -- " _x_msg ": %s\n", now_monotonic_ms(), syscall(SYS_gettid), ##__VA_ARGS__, _buf); \
+		printf("-- ERROR [%.03Lf tid=%ld] -- " _msg ": %s\n", get_now_monotonic(), syscall(SYS_gettid), ##__VA_ARGS__, _buf); \
+		fflush(stdout); \
 		LOGGING_UNLOCK; \
 	}
 
-#define LOG_INFO(_x_msg, ...) { \
+#define LOG_INFO(_msg, ...) { \
 		LOGGING_LOCK; \
-		printf("-- INFO  [%.03Lf tid=%ld] -- " _x_msg "\n", now_monotonic_ms(), syscall(SYS_gettid), ##__VA_ARGS__); \
+		LOG_PRINTF_NOLOCK("INFO ", _msg, ##__VA_ARGS__); \
 		LOGGING_UNLOCK; \
 	}
 
-#define LOG_INFO_NOLOCK(_x_msg, ...) { \
-		printf("-- INFO  [%.03Lf tid=%ld] -- " _x_msg "\n", now_monotonic_ms(), syscall(SYS_gettid), ##__VA_ARGS__); \
+#define LOG_INFO_NOLOCK(_msg, ...) { \
+		LOG_PRINTF_NOLOCK("INFO ", _msg, ##__VA_ARGS__); \
 	}
 
-#define LOG_PERF(_x_msg, ...) { \
+#define LOG_PERF(_msg, ...) { \
 		if (log_level >= LOG_LEVEL_PERF) { \
 			LOGGING_LOCK; \
-			printf("-- PERF  [%.03Lf tid=%ld] -- " _x_msg "\n", now_monotonic_ms(), syscall(SYS_gettid), ##__VA_ARGS__); \
+			LOG_PRINTF_NOLOCK("PERF ", _msg, ##__VA_ARGS__); \
 			LOGGING_UNLOCK; \
 		} \
 	}
 
-#define LOG_VERBOSE(_x_msg, ...) { \
+#define LOG_VERBOSE(_msg, ...) { \
 		if (log_level >= LOG_LEVEL_VERBOSE) { \
 			LOGGING_LOCK; \
-			printf("-- VERB  [%.03Lf tid=%ld] -- " _x_msg "\n", now_monotonic_ms(), syscall(SYS_gettid), ##__VA_ARGS__); \
+			LOG_PRINTF_NOLOCK("VERB ", _msg, ##__VA_ARGS__); \
 			LOGGING_UNLOCK; \
 		} \
 	}
 
-#define LOG_DEBUG(_x_msg, ...) { \
+#define LOG_DEBUG(_msg, ...) { \
 		if (log_level >= LOG_LEVEL_DEBUG) { \
 			LOGGING_LOCK; \
-			printf("-- DEBUG [%.03Lf tid=%ld] -- " _x_msg "\n", now_monotonic_ms(), syscall(SYS_gettid), ##__VA_ARGS__); \
+			LOG_PRINTF_NOLOCK("DEBUG", _msg, ##__VA_ARGS__); \
 			LOGGING_UNLOCK; \
 		} \
 	}

src/main.c

@@ -40,9 +40,10 @@
 #include "http.h"
 
 
-static const char _short_opts[] = "d:x:y:f:a:e:z:tn:w:q:c:s:p:r:h";
+static const char _short_opts[] = "d:i:x:y:f:a:e:z:tn:w:q:c:s:p:r:h";
 static const struct option _long_opts[] = {
 	{"device",					required_argument,	NULL,	'd'},
+	{"input",					required_argument,	NULL,	'i'},
 	{"width",					required_argument,	NULL,	'x'},
 	{"height",					required_argument,	NULL,	'y'},
 	{"format",					required_argument,	NULL,	'f'},
@@ -63,7 +64,7 @@ static const struct option _long_opts[] = {
 	{"host",					required_argument,	NULL,	's'},
 	{"port",					required_argument,	NULL,	'p'},
 	{"drop-same-frames",		required_argument,	NULL,	'r'},
-	{"add-x-timings",			no_argument,		NULL,	2000},
+	{"extra-stream-headers",	no_argument,		NULL,	2000},
 	{"fake-width",				required_argument,	NULL,	2001},
 	{"fake-height",				required_argument,	NULL,	2002},
 	{"server-timeout",			required_argument,	NULL,	2003},
@@ -83,9 +84,10 @@ static void _help(struct device_t *dev, struct encoder_t *encoder, struct http_s
 	printf("Copyright (C) 2018 Maxim Devaev <mdevaev@gmail.com>\n\n");
 	printf("Capturing options:\n");
 	printf("------------------\n");
-	printf("    -d|--device </dev/path>          -- Path to V4L2 device. Default: %s\n\n", dev->path);
-	printf("    -x|--width <N>                   -- Initial image width. Default: %d\n\n", dev->width);
-	printf("    -y|--height <N>                  -- Initial image height. Default: %d\n\n", dev->height);
+	printf("    -d|--device </dev/path>          -- Path to V4L2 device. Default: %s.\n\n", dev->path);
+	printf("    -i|--input <N>                   -- Input channel. Default: %u.\n\n", dev->input);
+	printf("    -x|--width <N>                   -- Initial image width. Default: %d.\n\n", dev->width);
+	printf("    -y|--height <N>                  -- Initial image height. Default: %d.\n\n", dev->height);
 	printf("    -f|--format <fmt>                -- Image format.\n");
 	printf("                                        Available: %s; default: YUYV.\n\n", FORMATS_STR);
 	printf("    -a|--tv-standard <std>           -- Force TV standard.\n");
@@ -117,7 +119,7 @@ static void _help(struct device_t *dev, struct encoder_t *encoder, struct http_s
 	printf("                                  It can significantly reduce the outgoing traffic, but will increase\n");
 	printf("                                  the CPU loading. Don't use this option with analog signal sources\n");
 	printf("                                  or webcams, it's useless. Default: disabled.\n\n");
-	printf("    --add-x-timings            -- Add X-UStreamer-*-Time headers to the /stream and /snapshot handles.\n");
+	printf("    --extra-stream-headers     -- Add X-UStreamer-* headers to /stream handle (like /snapshot).\n");
 	printf("                                  Default: disabled.\n\n");
 	printf("    --fake-width <N>           -- Override image width for /ping. Default: disabled\n\n");
 	printf("    --fake-height <N>          -- Override image height for /ping. Default: disabled.\n\n");
@@ -156,6 +158,7 @@ static int _parse_options(int argc, char *argv[], struct device_t *dev, struct e
 	while ((ch = getopt_long(argc, argv, _short_opts, _long_opts, &index)) >= 0) {
 		switch (ch) {
 			case 'd':	OPT_SET(dev->path, optarg);
+			case 'i':	OPT_UNSIGNED(dev->input, "--input", 0, 128);
 			case 'x':	OPT_UNSIGNED(dev->width, "--width", 320, 1920);
 			case 'y':	OPT_UNSIGNED(dev->height, "--height", 180, 1200);
 #			pragma GCC diagnostic ignored "-Wsign-compare"
@@ -179,7 +182,7 @@ static int _parse_options(int argc, char *argv[], struct device_t *dev, struct e
 			case 's':	OPT_SET(server->host, optarg);
 			case 'p':	OPT_UNSIGNED(server->port, "--port", 1, 65535);
 			case 'r':	OPT_UNSIGNED(server->drop_same_frames, "--drop-same-frames", 0, 30);
-			case 2000:	OPT_SET(server->add_x_timings, true);
+			case 2000:	OPT_SET(server->extra_stream_headers, true);
 			case 2001:	OPT_UNSIGNED(server->fake_width, "--fake-width", 0, 1920);
 			case 2002:	OPT_UNSIGNED(server->fake_height, "--fake-height", 0, 1200);
 			case 2003:	OPT_UNSIGNED(server->timeout, "--server-timeout", 1, 60);

src/omx/formatters.c

@@ -29,12 +29,12 @@
 #include "formatters.h"
 
 
-#define CASE_TO_STRING(_val) \
-	case _val: { return #_val; }
+#define CASE_TO_STRING(_value) \
+	case _value: { return #_value; }
 
-#define CASE_ASSERT(_msg, _val) default: { \
+#define CASE_ASSERT(_msg, _value) default: { \
 		char *_buf; A_CALLOC(_buf, 128); \
-		sprintf(_buf, _msg ": 0x%08x", _val); \
+		sprintf(_buf, _msg ": 0x%08x", _value); \
 		assert(0 && _buf); \
 	}
 

src/omx/formatters.h

@@ -35,7 +35,7 @@
 
 #define LOG_OMX_ERROR(_error, _msg, ...) { \
 		LOGGING_LOCK; \
-		printf("-- ERROR [%.03Lf tid=%ld] -- " _msg ": %s\n", now_monotonic_ms(), \
+		printf("-- ERROR [%.03Lf tid=%ld] -- " _msg ": %s\n", get_now_monotonic(), \
 			syscall(SYS_gettid), ##__VA_ARGS__, omx_error_to_string(_error)); \
 		LOGGING_UNLOCK; \
 	}

src/stream.c

@@ -85,8 +85,8 @@ void stream_loop(struct stream_t *stream) {
 		unsigned frames_count = 0;
 		long double grab_after = 0;
 		unsigned fluency_passed = 0;
-		unsigned fps = 0;
-		long long fps_second = 0;
+		unsigned captured_fps_accum = 0;
+		long long captured_fps_second = 0;
 
 		LOG_DEBUG("Allocation memory for stream picture ...");
 		A_CALLOC(stream->picture.data, stream->dev->run->max_picture_size);
@@ -111,7 +111,7 @@ void stream_loop(struct stream_t *stream) {
 				free_worker_number = oldest_worker->ctx.number;
 				oldest_worker = oldest_worker->order_next;
 
-				LOG_PERF("##### ACCEPT : %u", free_worker_number);
+				LOG_PERF("##### Raw frame accepted; worker = %u", free_worker_number);
 			} else {
 				for (unsigned number = 0; number < stream->dev->run->n_workers; ++number) {
 					if (!pool.workers[number].has_job && (free_worker_number == -1
@@ -125,7 +125,7 @@ void stream_loop(struct stream_t *stream) {
 				assert(free_worker_number >= 0);
 				assert(!pool.workers[free_worker_number].has_job);
 
-				LOG_PERF("----- DROP   : %u", free_worker_number);
+				LOG_PERF("----- Raw frame dropped;  worker = %u", free_worker_number);
 			}
 
 			if (stream->dev->stop) {
@@ -162,7 +162,8 @@ void stream_loop(struct stream_t *stream) {
 					LOG_DEBUG("Frame is ready");
 
 					struct v4l2_buffer buf_info;
-					long double now = now_monotonic_ms();
+					long double now = get_now_monotonic();
+					long long now_second = floor_ms(now);
 
 					if (_stream_grab_buffer(stream->dev, &buf_info) < 0) {
 						break;
@@ -196,13 +197,13 @@ void stream_loop(struct stream_t *stream) {
 						}
 						fluency_passed = 0;
 
-						if ((long long)now != fps_second) {
-							LOG_PERF("Oldest worker complete, encoding FPS = %u", fps);
-							stream->fps = fps;
-							fps = 0;
-							fps_second = (long long)now;
+						if (now_second != captured_fps_second) {
+							stream->captured_fps = captured_fps_accum;
+							captured_fps_accum = 0;
+							captured_fps_second = now_second;
+							LOG_PERF("Oldest worker complete, Captured-FPS = %u", stream->captured_fps);
 						}
-						fps += 1;
+						captured_fps_accum += 1;
 
 						long double fluency_delay = _stream_get_fluency_delay(stream->dev, &pool);
 

src/stream.h

@@ -86,7 +86,7 @@ struct stream_t {
 	struct picture_t	picture;
 	unsigned			width;
 	unsigned			height;
-	unsigned			fps;
+	unsigned			captured_fps;
 	bool				updated;
 	pthread_mutex_t		mutex;
 	struct device_t		*dev;

src/tools.h

@@ -49,8 +49,8 @@
 
 #define A_CALLOC(_dest, _nmemb)		assert((_dest = calloc(_nmemb, sizeof(*(_dest)))))
 #define A_REALLOC(_dest, _nmemb)	assert((_dest = realloc(_dest, _nmemb * sizeof(*(_dest)))))
-#define MEMSET_ZERO(_x_obj)			memset(&(_x_obj), 0, sizeof(_x_obj))
-#define MEMSET_ZERO_PTR(_x_ptr)		memset(_x_ptr, 0, sizeof(*(_x_ptr)))
+#define MEMSET_ZERO(_obj)			memset(&(_obj), 0, sizeof(_obj))
+#define MEMSET_ZERO_PTR(_ptr)		memset(_ptr, 0, sizeof(*(_ptr)))
 
 
 #define INLINE inline __attribute__((always_inline))
@@ -61,7 +61,11 @@ INLINE unsigned max_u(unsigned a, unsigned b) {
 	return (a > b ? a : b);
 }
 
-INLINE void now_ms(clockid_t clk_id, time_t *sec, long *msec) {
+INLINE long long floor_ms(long double now) {
+	return (long long) now - (now < (long long) now); // floor()
+}
+
+INLINE void get_now(clockid_t clk_id, time_t *sec, long *msec) {
 	struct timespec spec;
 
 	assert(!clock_gettime(clk_id, &spec));
@@ -74,18 +78,18 @@ INLINE void now_ms(clockid_t clk_id, time_t *sec, long *msec) {
 	}
 }
 
-INLINE long double now_monotonic_ms(void) {
+INLINE long double get_now_monotonic(void) {
 	time_t sec;
 	long msec;
 
-	now_ms(CLOCK_MONOTONIC_RAW, &sec, &msec);
+	get_now(CLOCK_MONOTONIC_RAW, &sec, &msec);
 	return (long double)sec + ((long double)msec) / 1000;
 }
 
-INLINE long double now_real_ms(void) {
+INLINE long double get_now_real(void) {
 	time_t sec;
 	long msec;
 
-	now_ms(CLOCK_REALTIME, &sec, &msec);
+	get_now(CLOCK_REALTIME, &sec, &msec);
 	return (long double)sec + ((long double)msec) / 1000;
 }

tools/make-jpg-h.py

@@ -71,7 +71,6 @@ def main():
         *****************************************************************************/
     """).strip() + "\n\n\n" + text
 
-
     with open(dest, "w") as h_file:
         h_file.write(text)