Bump version: 0.37 → 0.38

.bumpversion.cfg

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

PKGBUILD

@@ -3,7 +3,7 @@
 
 
 pkgname=ustreamer
-pkgver=0.31
+pkgver=0.38
 pkgrel=1
 pkgdesc="Lightweight and fast MJPG-HTTP streamer"
 url="https://github.com/pi-kvm/ustreamer"

src/config.h

@@ -21,4 +21,4 @@
 
 #pragma once
 
-#define VERSION "0.31"
+#define VERSION "0.38"

src/data/index.html

@@ -11,7 +11,7 @@
 	<hr>
 	<ul>
 		<li>
-			<a href="/ping"><b><samp>/ping</samp></b></a><br>
+			<a href="/state"><b><samp>/state</samp></b></a><br>
 			Get JSON structure with state of the server.
 		</li>
 		<br>
@@ -25,6 +25,12 @@
 			Get a live stream. Query params:<br>
 			<br>
 			<ul>
+				<li>
+					<b><samp>key=abc123</samp></b><br>
+					User-defined key, which is part of cookie <samp>stream_client</samp>, which allows<br>
+					the stream client to determine its identifier and view statistics using <a href="/state"><samp>/state</samp></a>.
+				</li>
+				<br>
 				<li>
 					<b><samp>extra_headers=1</samp></b><br>
 					Add <samp>X-UStreamer-*</samp> headers to /stream handle (like on <a href="/snapshot"><samp>/snapshot</samp></a>).
@@ -40,7 +46,7 @@
 					<b><samp>dual_final_frames=1</samp></b><br>
 					Enable workaround for Safari/WebKit bug when using option <samp>--drop-same-frames</samp>.<br>
 					Without this option, when the frame series is completed, WebKit-based browsers<br>
-					renders the last one with a delay.
+					renders the last frame with a delay.
 				</li>
 			</ul>
 		</li>

src/data/index_html.h

@@ -38,7 +38,7 @@ const char *HTML_INDEX_PAGE = " \
 		<hr> \
 		<ul> \
 			<li> \
-				<a href=\"/ping\"><b><samp>/ping</samp></b></a><br> \
+				<a href=\"/state\"><b><samp>/state</samp></b></a><br> \
 				Get JSON structure with state of the server. \
 			</li> \
 			<br> \
@@ -52,6 +52,12 @@ const char *HTML_INDEX_PAGE = " \
 				Get a live stream. Query params:<br> \
 				<br> \
 				<ul> \
+					<li> \
+						<b><samp>key=abc123</samp></b><br> \
+						User-defined key, which is part of cookie <samp>stream_client</samp>, which allows<br> \
+						the stream client to determine its identifier and view statistics using <a href=\"/state\"><samp>/state</samp></a>. \
+					</li> \
+					<br> \
 					<li> \
 						<b><samp>extra_headers=1</samp></b><br> \
 						Add <samp>X-UStreamer-*</samp> headers to /stream handle (like on <a href=\"/snapshot\"><samp>/snapshot</samp></a>). \
@@ -67,7 +73,7 @@ const char *HTML_INDEX_PAGE = " \
 						<b><samp>dual_final_frames=1</samp></b><br> \
 						Enable workaround for Safari/WebKit bug when using option <samp>--drop-same-frames</samp>.<br> \
 						Without this option, when the frame series is completed, WebKit-based browsers<br> \
-						renders the last one with a delay. \
+						renders the last frame with a delay. \
 					</li> \
 				</ul> \
 			</li> \

src/device.c

@@ -84,7 +84,6 @@ struct device_t *device_init() {
 	dev->standard = V4L2_STD_UNKNOWN;
 	dev->n_buffers = max_u(sysconf(_SC_NPROCESSORS_ONLN), 1) + 1;
 	dev->n_workers = dev->n_buffers;
-	dev->soft_fps = 30;
 	dev->timeout = 1;
 	dev->error_delay = 1;
 	dev->run = run;
@@ -138,8 +137,6 @@ int device_open(struct device_t *dev) {
 	}
 	_device_open_alloc_picbufs(dev);
 
-	dev->run->n_workers = dev->n_workers;
-
 	LOG_DEBUG("Device fd=%d initialized", dev->run->fd);
 	return 0;
 

src/device.h

@@ -72,7 +72,7 @@ struct device_t {
 	bool			dv_timings;
 	unsigned		n_buffers;
 	unsigned		n_workers;
-	unsigned		soft_fps;
+	unsigned		desired_fps;
 	unsigned		every_frame;
 	unsigned		min_frame_size;
 	bool			persistent;

src/encoder.c

@@ -54,7 +54,11 @@ struct encoder_t *encoder_init() {
 	return encoder;
 }
 
-void encoder_prepare(struct encoder_t *encoder) {
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic push
+void encoder_prepare(struct encoder_t *encoder, struct device_t *dev) {
+#pragma GCC diagnostic pop
+
 	assert(encoder->type != ENCODER_TYPE_UNKNOWN);
 
 	if (encoder->type != ENCODER_TYPE_CPU) {
@@ -65,8 +69,20 @@ void encoder_prepare(struct encoder_t *encoder) {
 
 #	ifdef OMX_ENCODER
 	if (encoder->type == ENCODER_TYPE_OMX) {
-		if ((encoder->omx = omx_encoder_init()) == NULL) {
-			goto use_fallback;
+		if (dev->n_workers > OMX_MAX_ENCODERS) {
+			LOG_INFO(
+				"OMX-based encoder can only work with %u worker threads; forced --workers=%u",
+				OMX_MAX_ENCODERS, OMX_MAX_ENCODERS
+			);
+			dev->n_workers = OMX_MAX_ENCODERS;
+		}
+		encoder->n_omxs = dev->n_workers;
+
+		A_CALLOC(encoder->omxs, encoder->n_omxs);
+		for (unsigned index = 0; index < encoder->n_omxs; ++index) {
+			if ((encoder->omxs[index] = omx_encoder_init()) == NULL) {
+				goto use_fallback;
+			}
 		}
 	}
 #	endif
@@ -83,8 +99,13 @@ void encoder_prepare(struct encoder_t *encoder) {
 
 void encoder_destroy(struct encoder_t *encoder) {
 #	ifdef OMX_ENCODER
-	if (encoder->omx) {
-		omx_encoder_destroy(encoder->omx);
+	if (encoder->omxs) {
+		for (unsigned index = 0; index < encoder->n_omxs; ++index) {
+			if (encoder->omxs[index]) {
+				omx_encoder_destroy(encoder->omxs[index]);
+			}
+		}
+		free(encoder->omxs);
 	}
 #	endif
 	free(encoder);
@@ -101,18 +122,16 @@ enum encoder_type_t encoder_parse_type(const char *const str) {
 
 #pragma GCC diagnostic ignored "-Wunused-parameter"
 #pragma GCC diagnostic push
-void encoder_prepare_for_device(struct encoder_t *encoder, struct device_t *dev) {
+void encoder_prepare_live(struct encoder_t *encoder, struct device_t *dev) {
 	assert(encoder->type != ENCODER_TYPE_UNKNOWN);
 
 #pragma GCC diagnostic pop
 #	ifdef OMX_ENCODER
 	if (encoder->type == ENCODER_TYPE_OMX) {
-		if (omx_encoder_prepare_for_device(encoder->omx, dev, encoder->quality, encoder->omx_use_ijg) < 0) {
-			goto use_fallback;
-		}
-		if (dev->run->n_workers > 1) {
-			LOG_INFO("OMX encoder can only work with one worker thread; forcing n_workers to 1");
-			dev->run->n_workers = 1;
+		for (unsigned index = 0; index < encoder->n_omxs; ++index) {
+			if (omx_encoder_prepare_live(encoder->omxs[index], dev, encoder->quality, encoder->omx_use_ijg) < 0) {
+				goto use_fallback;
+			}
 		}
 	}
 #	endif
@@ -124,28 +143,28 @@ void encoder_prepare_for_device(struct encoder_t *encoder, struct device_t *dev)
 	use_fallback:
 		LOG_ERROR("Can't prepare selected encoder, falling back to CPU");
 		encoder->type = ENCODER_TYPE_CPU;
-		dev->run->n_workers = dev->n_workers;
 #	pragma GCC diagnostic pop
 }
 
-int encoder_compress_buffer(struct encoder_t *encoder, struct device_t *dev, const unsigned index) {
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic push
+int encoder_compress_buffer(struct encoder_t *encoder, struct device_t *dev,
+	const unsigned worker_number, const unsigned buf_index) {
+#pragma GCC diagnostic pop
+
 	assert(encoder->type != ENCODER_TYPE_UNKNOWN);
 
-	dev->run->pictures[index].encode_begin_time = get_now_monotonic();
-
 	if (encoder->type == ENCODER_TYPE_CPU) {
-		jpeg_encoder_compress_buffer(dev, index, encoder->quality);
+		jpeg_encoder_compress_buffer(dev, buf_index, encoder->quality);
 	}
 #	ifdef OMX_ENCODER
 	else if (encoder->type == ENCODER_TYPE_OMX) {
-		if (omx_encoder_compress_buffer(encoder->omx, dev, index) < 0) {
+		if (omx_encoder_compress_buffer(encoder->omxs[worker_number], dev, buf_index) < 0) {
 			goto error;
 		}
 	}
 #	endif
 
-	dev->run->pictures[index].encode_end_time = get_now_monotonic();
-
 	return 0;
 
 #	pragma GCC diagnostic ignored "-Wunused-label"
@@ -153,7 +172,6 @@ int encoder_compress_buffer(struct encoder_t *encoder, struct device_t *dev, con
 	error:
 		LOG_INFO("HW compressing error, falling back to CPU");
 		encoder->type = ENCODER_TYPE_CPU;
-		dev->run->n_workers = dev->n_workers;
 		return -1;
 #	pragma GCC diagnostic pop
 }

src/encoder.h

@@ -49,7 +49,8 @@ struct encoder_t {
 	unsigned				quality;
 #ifdef OMX_ENCODER
 	bool					omx_use_ijg;
-	struct omx_encoder_t	*omx;
+	unsigned				n_omxs;
+	struct omx_encoder_t	**omxs;
 #endif
 };
 
@@ -59,6 +60,8 @@ void encoder_destroy(struct encoder_t *encoder);
 
 enum encoder_type_t encoder_parse_type(const char *const str);
 
-void encoder_prepare(struct encoder_t *encoder);
-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);
+void encoder_prepare(struct encoder_t *encoder, struct device_t *dev);
+void encoder_prepare_live(struct encoder_t *encoder, struct device_t *dev);
+
+int encoder_compress_buffer(struct encoder_t *encoder, struct device_t *dev,
+	const unsigned worker_number, const unsigned buf_index);

src/http.c

@@ -48,9 +48,10 @@
 
 
 static bool _http_get_param_true(struct evkeyvalq *params, const char *key);
+static char *_http_get_param_uri(struct evkeyvalq *params, const char *key);
 
 static void _http_callback_root(struct evhttp_request *request, void *arg);
-static void _http_callback_ping(struct evhttp_request *request, void *v_server);
+static void _http_callback_state(struct evhttp_request *request, void *v_server);
 static void _http_callback_snapshot(struct evhttp_request *request, void *v_server);
 
 static void _http_callback_stream(struct evhttp_request *request, void *v_server);
@@ -90,7 +91,7 @@ struct http_server_t *http_server_init(struct stream_t *stream) {
 	evhttp_set_allowed_methods(run->http, EVHTTP_REQ_GET|EVHTTP_REQ_HEAD);
 
 	assert(!evhttp_set_cb(run->http, "/", _http_callback_root, NULL));
-	assert(!evhttp_set_cb(run->http, "/ping", _http_callback_ping, (void *)server));
+	assert(!evhttp_set_cb(run->http, "/state", _http_callback_state, (void *)server));
 	assert(!evhttp_set_cb(run->http, "/snapshot", _http_callback_snapshot, (void *)server));
 	assert(!evhttp_set_cb(run->http, "/stream", _http_callback_stream, (void *)server));
 
@@ -117,7 +118,11 @@ int http_server_listen(struct http_server_t *server) {
 	struct timeval refresh_interval;
 
 	refresh_interval.tv_sec = 0;
-	refresh_interval.tv_usec = 1000000 / (server->run->stream->dev->soft_fps * 2);
+	if (server->run->stream->dev->desired_fps > 0) {
+		refresh_interval.tv_usec = 1000000 / (server->run->stream->dev->desired_fps * 2);
+	} else {
+		refresh_interval.tv_usec = 16000; // ~60fps
+	}
 	assert((server->run->refresh = event_new(server->run->base, -1, EV_PERSIST, _http_exposed_refresh, server)));
 	assert(!event_add(server->run->refresh, &refresh_interval));
 
@@ -157,6 +162,15 @@ static bool _http_get_param_true(struct evkeyvalq *params, const char *key) {
 	return false;
 }
 
+static char *_http_get_param_uri(struct evkeyvalq *params, const char *key) {
+	const char *value_str;
+
+	if ((value_str = evhttp_find_header(params, key)) != NULL) {
+		return evhttp_encode_uri(value_str);
+	}
+	return NULL;
+}
+
 #define ADD_HEADER(_key, _value) \
 	assert(!evhttp_add_header(evhttp_request_get_output_headers(request), _key, _value))
 
@@ -179,7 +193,7 @@ static void _http_callback_root(struct evhttp_request *request, UNUSED void *arg
 	evbuffer_free(buf);
 }
 
-static void _http_callback_ping(struct evhttp_request *request, void *v_server) {
+static void _http_callback_state(struct evhttp_request *request, void *v_server) {
 	struct http_server_t *server = (struct http_server_t *)v_server;
 	struct evbuffer *buf;
 
@@ -187,29 +201,31 @@ static void _http_callback_ping(struct evhttp_request *request, void *v_server)
 
 	assert((buf = evbuffer_new()));
 	assert(evbuffer_add_printf(buf,
-		"{\"source\": {\"resolution\": {\"width\": %u, \"height\": %u},"
-		" \"online\": %s, \"quality\": %u, \"soft_fps\": %u, \"captured_fps\": %u},"
-		" \"stream\": {\"queued_fps\": %u,  \"clients\": %u, \"clients_stat\": {",
+		"{\"ok\": true, \"result\":"
+		" {\"source\": {\"resolution\": {\"width\": %u, \"height\": %u},"
+		" \"online\": %s, \"quality\": %u, \"desired_fps\": %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),
 		bool_to_string(server->run->exposed->online),
 		server->run->stream->encoder->quality,
-		server->run->stream->dev->soft_fps,
+		server->run->stream->dev->desired_fps,
 		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, \"advance_headers\": %s, \"dual_final_frames\": %s}%s",
+			"\"%s\": {\"fps\": %u, \"extra_headers\": %s, \"advance_headers\": %s, \"dual_final_frames\": %s}%s",
 			client->id,
 			client->fps,
+			bool_to_string(client->extra_headers),
 			bool_to_string(client->advance_headers),
 			bool_to_string(client->dual_final_frames),
 			(client->next ? ", " : "")
 		));
 	}
-	assert(evbuffer_add_printf(buf, "}}}"));
+	assert(evbuffer_add_printf(buf, "}}}}"));
 
 	ADD_HEADER("Content-Type", "application/json");
 	evhttp_send_reply(request, HTTP_OK, "OK", buf);
@@ -219,7 +235,7 @@ static void _http_callback_ping(struct evhttp_request *request, void *v_server)
 static void _http_callback_snapshot(struct evhttp_request *request, void *v_server) {
 	struct http_server_t *server = (struct http_server_t *)v_server;
 	struct evbuffer *buf;
-	char time_buf[64];
+	char header_buf[64];
 
 	PROCESS_HEAD_REQUEST;
 
@@ -234,11 +250,16 @@ static void _http_callback_snapshot(struct evhttp_request *request, void *v_serv
 	ADD_HEADER("Expires", "Mon, 3 Jan 2000 12:34:56 GMT");
 
 #	define ADD_TIME_HEADER(_key, _value) \
-		{ sprintf(time_buf, "%.06Lf", _value); ADD_HEADER(_key, time_buf); }
+		{ sprintf(header_buf, "%.06Lf", _value); ADD_HEADER(_key, header_buf); }
+
+#	define ADD_UNSIGNED_HEADER(_key, _value) \
+		{ sprintf(header_buf, "%u", _value); ADD_HEADER(_key, header_buf); }
 
 	ADD_TIME_HEADER("X-Timestamp", get_now_real());
 
 	ADD_HEADER("X-UStreamer-Online",					bool_to_string(EXPOSED(online)));
+	ADD_UNSIGNED_HEADER("X-UStreamer-Width",			EXPOSED(width));
+	ADD_UNSIGNED_HEADER("X-UStreamer-Height",			EXPOSED(height));
 	ADD_TIME_HEADER("X-UStreamer-Grab-Time",			EXPOSED(picture.grab_time));
 	ADD_TIME_HEADER("X-UStreamer-Encode-Begin-Time",	EXPOSED(picture.encode_begin_time));
 	ADD_TIME_HEADER("X-UStreamer-Encode-End-Time",		EXPOSED(picture.encode_end_time));
@@ -247,6 +268,7 @@ static void _http_callback_snapshot(struct evhttp_request *request, void *v_serv
 	ADD_TIME_HEADER("X-UStreamer-Expose-End-Time",		EXPOSED(expose_end_time));
 	ADD_TIME_HEADER("X-UStreamer-Send-Time",			get_now_monotonic());
 
+#	undef ADD_UNSUGNED_HEADER
 #	undef ADD_TIME_HEADER
 
 	ADD_HEADER("Content-Type", "image/jpeg");
@@ -286,6 +308,7 @@ static void _http_callback_stream(struct evhttp_request *request, void *v_server
 		client->need_first_frame = true;
 
 		evhttp_parse_query(evhttp_request_get_uri(request), &params);
+		client->key = _http_get_param_uri(&params, "key");
 		client->extra_headers = _http_get_param_true(&params, "extra_headers");
 		client->advance_headers = _http_get_param_true(&params, "advance_headers");
 		client->dual_final_frames = _http_get_param_true(&params, "dual_final_frames");
@@ -375,10 +398,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
+			"Set-Cookie: stream_client=%s/%s; path=/; max-age=30" RN
 			"Content-Type: multipart/x-mixed-replace;boundary=" BOUNDARY RN
 			RN
 			"--" BOUNDARY RN,
+			(client->key != NULL ? client->key : "0"),
 			client->id
 		));
 
@@ -404,6 +428,8 @@ static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_c
 		if (client->extra_headers) {
 			assert(evbuffer_add_printf(buf,
 				"X-UStreamer-Online: %s" RN
+				"X-UStreamer-Width: %u" RN
+				"X-UStreamer-Height: %u" RN
 				"X-UStreamer-Client-FPS: %u" RN
 				"X-UStreamer-Grab-Time: %.06Lf" RN
 				"X-UStreamer-Encode-Begin-Time: %.06Lf" RN
@@ -414,6 +440,8 @@ static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_c
 				"X-UStreamer-Send-Time: %.06Lf" RN
 				RN,
 				bool_to_string(EXPOSED(online)),
+				EXPOSED(width),
+				EXPOSED(height),
 				client->fps,
 				EXPOSED(picture.grab_time),
 				EXPOSED(picture.encode_begin_time),
@@ -442,10 +470,10 @@ static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_c
 	bufferevent_setcb(buf_event, NULL, NULL, _http_callback_stream_error, (void *)client);
 	bufferevent_enable(buf_event, EV_READ);
 
-#	undef BOUNDARY
-#	undef RN
-#	undef ADD_ADVANCE_HEADERS
 #	undef EXPOSED
+#	undef ADD_ADVANCE_HEADERS
+#	undef RN
+#	undef BOUNDARY
 }
 
 static void _http_callback_stream_error(UNUSED struct bufferevent *buf_event, UNUSED short what, void *v_client) {
@@ -476,6 +504,7 @@ static void _http_callback_stream_error(UNUSED struct bufferevent *buf_event, UN
 	if (client->next != NULL) {
 		client->next->prev = client->prev;
 	}
+	free(client->key);
 	free(client);
 }
 
@@ -621,8 +650,8 @@ static bool _expose_new_picture(struct http_server_t *server) {
 		 EXPOSED(expose_end_time) - EXPOSED(expose_begin_time)
 	);
 
-#	undef STREAM
 #	undef EXPOSED
+#	undef STREAM
 	return true; // Updated
 }
 

src/http.h

@@ -32,6 +32,7 @@ struct stream_client_t {
 	struct http_server_t	*server;
 	struct evhttp_request	*request;
 
+	char					*key;
 	bool					extra_headers;
 	bool					advance_headers;
 	bool					dual_final_frames;

src/main.c

@@ -46,9 +46,9 @@ static const struct option _long_opts[] = {
 	{"input",					required_argument,	NULL,	'i'},
 	{"width",					required_argument,	NULL,	'x'},
 	{"height",					required_argument,	NULL,	'y'},
-	{"format",					required_argument,	NULL,	'f'},
+	{"format",					required_argument,	NULL,	'm'},
 	{"tv-standard",				required_argument,	NULL,	'a'},
-	{"soft-fps",				required_argument,	NULL,	'm'},
+	{"fps",						required_argument,	NULL,	'f'},
 	{"every-frame",				required_argument,	NULL,	'e'},
 	{"min-frame-size",			required_argument,	NULL,	'z'},
 	{"dv-timings",				no_argument,		NULL,	't'},
@@ -102,11 +102,11 @@ static void _help(struct device_t *dev, struct encoder_t *encoder, struct http_s
 	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("    -m|--format <fmt>                -- Image format.\n");
 	printf("                                        Available: %s; default: YUYV.\n\n", FORMATS_STR);
 	printf("    -a|--tv-standard <std>           -- Force TV standard.\n");
 	printf("                                        Available: %s; default: disabled.\n\n", STANDARDS_STR);
-	printf("    -m|--soft-fps <N>                -- Soft FPS limit; default: %u.\n\n", dev->soft_fps);
+	printf("    -f|--desired-fps <N>             -- Desired FPS; default: maximum as possible.\n\n");
 	printf("    -e|--every-frame <N>             -- Drop all input frames except specified. Default: disabled.\n\n");
 	printf("    -z|--min-frame-size <N>          -- Drop frames smaller then this limit.\n");
 	printf("                                        Useful if the device produces small-sized garbage frames.\n\n");
@@ -135,8 +135,8 @@ 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("    --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");
+	printf("    --fake-width <N>           -- Override image width for /state. Default: disabled\n\n");
+	printf("    --fake-height <N>          -- Override image height for /state. Default: disabled.\n\n");
 	printf("    --server-timeout <seconds> -- Timeout for client connections. Default: %d\n\n", server->timeout);
 	printf("Misc options:\n");
 	printf("-------------\n");
@@ -177,10 +177,10 @@ static int _parse_options(int argc, char *argv[], struct device_t *dev, struct e
 			case 'y':	OPT_UNSIGNED(dev->height, "--height", 180, 1200);
 #			pragma GCC diagnostic ignored "-Wsign-compare"
 #			pragma GCC diagnostic push
-			case 'f':	OPT_PARSE(dev->format, device_parse_format, FORMAT_UNKNOWN, "pixel format");
+			case 'm':	OPT_PARSE(dev->format, device_parse_format, FORMAT_UNKNOWN, "pixel format");
 #			pragma GCC diagnostic pop
 			case 'a':	OPT_PARSE(dev->standard, device_parse_standard, STANDARD_UNKNOWN, "TV standard");
-			case 'm':	OPT_UNSIGNED(dev->soft_fps, "--soft-fps", 1, 30);
+			case 'f':	OPT_UNSIGNED(dev->desired_fps, "--desired-fps", 0, 30);
 			case 'e':	OPT_UNSIGNED(dev->every_frame, "--every-frame", 1, 30);
 			case 'z':	OPT_UNSIGNED(dev->min_frame_size, "--min-frame-size", 0, 8192);
 			case 't':	OPT_SET(dev->dv_timings, true);
@@ -213,9 +213,9 @@ static int _parse_options(int argc, char *argv[], struct device_t *dev, struct e
 		}
 	}
 
-#	undef OPT_SET
-#	undef OPT_UNSIGNED
 #	undef OPT_PARSE
+#	undef OPT_UNSIGNED
+#	undef OPT_SET
 	return 0;
 }
 
@@ -287,7 +287,7 @@ int main(int argc, char *argv[]) {
 
 	if ((exit_code = _parse_options(argc, argv, dev, encoder, server)) == 0) {
 		_install_signal_handlers();
-		encoder_prepare(encoder);
+		encoder_prepare(encoder, dev);
 
 		pthread_t stream_loop_tid;
 		pthread_t server_loop_tid;

src/omx/encoder.c

@@ -45,6 +45,9 @@
 #define OUTPUT_PORT 341
 
 
+static int _i_omx = 0;
+
+
 static int _omx_init_component(struct omx_encoder_t *omx);
 static int _omx_init_disable_ports(struct omx_encoder_t *omx);
 static int _omx_setup_input(struct omx_encoder_t *omx, struct device_t *dev);
@@ -77,17 +80,20 @@ struct omx_encoder_t *omx_encoder_init() {
 
 	A_CALLOC(omx, 1);
 
-	LOG_INFO("Initializing OMX JPEG encoder ...");
+	assert(_i_omx >= 0);
+	if (_i_omx == 0) {
+		LOG_INFO("Initializing BCM ...");
+		bcm_host_init();
 
-	LOG_DEBUG("Initializing BCM ...");
-	bcm_host_init();
-
-	LOG_DEBUG("Initializing OMX ...");
-	if ((error = OMX_Init()) != OMX_ErrorNone) {
-		LOG_OMX_ERROR(error, "Can't initialize OMX");
-		goto error;
+		LOG_INFO("Initializing OMX ...");
+		if ((error = OMX_Init()) != OMX_ErrorNone) {
+			LOG_OMX_ERROR(error, "Can't initialize OMX");
+			goto error;
+		}
 	}
-	omx->i_omx = true;
+	_i_omx += 1;
+
+	LOG_INFO("Initializing OMX JPEG encoder ...");
 
 	if (vcos_semaphore_create(&omx->handler_lock, "handler_lock", 0) != VCOS_SUCCESS) {
 		LOG_ERROR("Can't create VCOS semaphore");
@@ -129,14 +135,20 @@ void omx_encoder_destroy(struct omx_encoder_t *omx) {
 		}
 	}
 
-	if (omx->i_omx) {
+	assert(_i_omx >= 0);
+	_i_omx -= 1;
+	if (_i_omx == 0) {
+		LOG_INFO("Destroying OMX ...");
 		OMX_Deinit();
+
+		LOG_INFO("Destroying BCM ...");
+		bcm_host_deinit();
 	}
-	bcm_host_deinit();
+
 	free(omx);
 }
 
-int omx_encoder_prepare_for_device(struct omx_encoder_t *omx, struct device_t *dev, const unsigned quality, const bool use_ijg) {
+int omx_encoder_prepare_live(struct omx_encoder_t *omx, struct device_t *dev, const unsigned quality, const bool use_ijg) {
 	if (component_set_state(&omx->encoder, OMX_StateIdle) < 0) {
 		return -1;
 	}

src/omx/encoder.h

@@ -29,6 +29,9 @@
 #include "../device.h"
 
 
+#define OMX_MAX_ENCODERS 3
+
+
 struct omx_encoder_t {
 	OMX_HANDLETYPE			encoder;
 	OMX_BUFFERHEADERTYPE	*input_buffer;
@@ -38,7 +41,6 @@ struct omx_encoder_t {
 	bool					failed;
 	VCOS_SEMAPHORE_T		handler_lock;
 
-	bool	i_omx;
 	bool	i_handler_lock;
 	bool	i_encoder;
 	bool	i_input_port_enabled;
@@ -49,5 +51,5 @@ struct omx_encoder_t {
 struct omx_encoder_t *omx_encoder_init();
 void omx_encoder_destroy(struct omx_encoder_t *omx);
 
-int omx_encoder_prepare_for_device(struct omx_encoder_t *omx, struct device_t *dev, const unsigned quality, const bool use_ijg);
+int omx_encoder_prepare_live(struct omx_encoder_t *omx, struct device_t *dev, const unsigned quality, const bool use_ijg);
 int omx_encoder_compress_buffer(struct omx_encoder_t *omx, struct device_t *dev, const unsigned index);

src/omx/formatters.c

@@ -78,5 +78,5 @@ const char *omx_state_to_string(const OMX_STATETYPE state) {
 	}
 }
 
-#undef CASE_TO_STRING
 #undef CASE_ASSERT
+#undef CASE_TO_STRING

src/stream.c

@@ -116,7 +116,7 @@ void stream_loop(struct stream_t *stream) {
 
 				LOG_PERF("##### Raw frame accepted; worker = %u", free_worker_number);
 			} else {
-				for (unsigned number = 0; number < stream->dev->run->n_workers; ++number) {
+				for (unsigned number = 0; number < stream->dev->n_workers; ++number) {
 					if (!pool.workers[number].has_job && (free_worker_number == -1
 						|| pool.workers[free_worker_number].job_start_time < pool.workers[number].job_start_time
 					)) {
@@ -321,25 +321,28 @@ static void _stream_expose_picture(struct stream_t *stream, unsigned buf_index)
 }
 
 static long double _stream_get_fluency_delay(struct device_t *dev, struct workers_pool_t *pool) {
-	long double comp_time = 0;
+	long double sum_comp_time = 0;
+	long double avg_comp_time;
 	long double min_delay;
 	long double soft_delay;
 
-	for (unsigned number = 0; number < dev->run->n_workers; ++number) {
+	for (unsigned number = 0; number < dev->n_workers; ++number) {
 		A_PTHREAD_M_LOCK(&pool->workers[number].last_comp_time_mutex);
 		if (pool->workers[number].last_comp_time > 0) {
-			comp_time += pool->workers[number].last_comp_time;
+			sum_comp_time += pool->workers[number].last_comp_time;
 		}
 		A_PTHREAD_M_UNLOCK(&pool->workers[number].last_comp_time_mutex);
 	}
-	comp_time = comp_time / dev->run->n_workers; // Среднее время работы воркеров
+	avg_comp_time = sum_comp_time / dev->n_workers; // Среднее время работы воркеров
 
-	min_delay = comp_time / dev->run->n_workers; // Минимальное время работы размазывается на N воркеров
-	soft_delay = ((long double)1) / dev->soft_fps; // Искусственное время задержки на основе желаемого FPS
+	min_delay = avg_comp_time / dev->n_workers; // Среднее время работы размазывается на N воркеров
 
-	if (min_delay > 0) {
+	if (dev->desired_fps > 0 && min_delay > 0) {
+		// Искусственное время задержки на основе желаемого FPS, если включен --desired-fps
+		soft_delay = ((long double) 1) / dev->desired_fps - sum_comp_time;
 		return (min_delay > soft_delay ? min_delay : soft_delay);
 	}
+
 	return min_delay;
 }
 
@@ -372,7 +375,7 @@ static int _stream_init(struct device_t *dev, struct workers_pool_t *pool) {
 		goto error;
 	}
 
-	encoder_prepare_for_device(pool->encoder, dev);
+	encoder_prepare_live(pool->encoder, dev);
 
 	_stream_init_workers(dev, pool);
 
@@ -384,15 +387,15 @@ static int _stream_init(struct device_t *dev, struct workers_pool_t *pool) {
 }
 
 static void _stream_init_workers(struct device_t *dev, struct workers_pool_t *pool) {
-	LOG_INFO("Spawning %d workers ...", dev->run->n_workers);
+	LOG_INFO("Spawning %d workers ...", dev->n_workers);
 
 	*pool->workers_stop = false;
-	A_CALLOC(pool->workers, dev->run->n_workers);
+	A_CALLOC(pool->workers, dev->n_workers);
 
 	A_PTHREAD_M_INIT(&pool->free_workers_mutex);
 	A_PTHREAD_C_INIT(&pool->free_workers_cond);
 
-	for (unsigned number = 0; number < dev->run->n_workers; ++number) {
+	for (unsigned number = 0; number < dev->n_workers; ++number) {
 		pool->free_workers += 1;
 
 		A_PTHREAD_M_INIT(&pool->workers[number].has_job_mutex);
@@ -437,18 +440,22 @@ static void *_stream_worker_thread(void *v_ctx) {
 		A_PTHREAD_C_WAIT_TRUE(*ctx->has_job, ctx->has_job_cond, ctx->has_job_mutex);
 		A_PTHREAD_M_UNLOCK(ctx->has_job_mutex);
 
+#	define PICTURE(_next) ctx->dev->run->pictures[ctx->buf_index]._next
+
 		if (!*ctx->workers_stop) {
 			LOG_DEBUG("Worker %u compressing JPEG from buffer %d ...", ctx->number, ctx->buf_index);
 
-			if (encoder_compress_buffer(ctx->encoder, ctx->dev, ctx->buf_index) < 0) {
+			PICTURE(encode_begin_time) = get_now_monotonic();
+			if (encoder_compress_buffer(ctx->encoder, ctx->dev, ctx->number, ctx->buf_index) < 0) {
 				*ctx->job_failed = true;
 			}
+			PICTURE(encode_end_time) = get_now_monotonic();
 
 			if (_stream_release_buffer(ctx->dev, &ctx->buf_info) == 0) {
-				*ctx->job_start_time = ctx->dev->run->pictures[ctx->buf_index].encode_begin_time;
+				*ctx->job_start_time = PICTURE(encode_begin_time);
 				*ctx->has_job = false;
 
-				long double last_comp_time = ctx->dev->run->pictures[ctx->buf_index].encode_end_time - *ctx->job_start_time;
+				long double last_comp_time = PICTURE(encode_end_time) - *ctx->job_start_time;
 
 				A_PTHREAD_M_LOCK(ctx->last_comp_time_mutex);
 				*ctx->last_comp_time = last_comp_time;
@@ -456,7 +463,7 @@ static void *_stream_worker_thread(void *v_ctx) {
 
 				LOG_VERBOSE(
 					"Compressed JPEG size=%ld; time=%0.3Lf; worker=%u; buffer=%d",
-					ctx->dev->run->pictures[ctx->buf_index].size, last_comp_time, ctx->number, ctx->buf_index
+					PICTURE(size), last_comp_time, ctx->number, ctx->buf_index
 				);
 			} else {
 				*ctx->job_failed = true;
@@ -464,6 +471,8 @@ static void *_stream_worker_thread(void *v_ctx) {
 			}
 		}
 
+#	undef PICTURE
+
 		A_PTHREAD_M_LOCK(ctx->free_workers_mutex);
 		*ctx->free_workers += 1;
 		A_PTHREAD_M_UNLOCK(ctx->free_workers_mutex);
@@ -479,7 +488,7 @@ static void _stream_destroy_workers(struct device_t *dev, struct workers_pool_t
 		LOG_INFO("Destroying workers ...");
 
 		*pool->workers_stop = true;
-		for (unsigned number = 0; number < dev->run->n_workers; ++number) {
+		for (unsigned number = 0; number < dev->n_workers; ++number) {
 			A_PTHREAD_M_LOCK(&pool->workers[number].has_job_mutex);
 			pool->workers[number].has_job = true; // Final job: die
 			A_PTHREAD_M_UNLOCK(&pool->workers[number].has_job_mutex);

src/stream.h

@@ -72,7 +72,7 @@ struct worker_t {
 };
 
 struct workers_pool_t {
-	struct worker_t*workers;
+	struct worker_t		*workers;
 	bool				*workers_stop;
 
 	pthread_mutex_t		free_workers_mutex;