Bump version: 0.10 → 0.11

.bumpversion.cfg

@@ -1,7 +1,7 @@
 [bumpversion]
 commit = True
 tag = True
-current_version = 0.10
+current_version = 0.11
 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.10
+pkgver=0.11
 pkgrel=1
 pkgdesc="Lightweight and fast MJPG-HTTP streamer"
 url="https://github.com/pi-kvm/ustreamer"

README.md

@@ -0,0 +1,76 @@
+# µStreamer
+
+µStreamer - это маленький и очень быстрый сервер, который позволяет организовать трансляцию видео в формате [MJPG](https://en.wikipedia.org/wiki/Motion_JPEG) с любого устройства V4L2 в сеть. Этот формат нативно поддерживается всеми современными браузерами и большинством приложений для просмотра видео (mplayer, VLC и так далее). µStreamer был разработан в рамках проекта [Pi-KVM](https://github.com/pi-kvm) специально для стриминга с устройств видеозахвата [VGA](https://www.amazon.com/dp/B0126O0RDC) и [HDMI](https://auvidea.com/b101-hdmi-to-csi-2-bridge-15-pin-fpc/) с максимально возможным разрешением и FPS, которые только позволяет железо.
+
+Функционально µStreamer очень похож на [mjpg-streamer](https://github.com/jacksonliam/mjpg-streamer) при использовании им плагинов ```input_uvc.so``` и ```output_http.so```, однако имеет ряд серьезных отличий. Основные приведены в этой таблице:
+
+| **Фича** | **µStreamer** | **mjpg-streamer** |
+|----------|---------------|-------------------|
+| Многопоточное кодирование JPEG | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Нет |
+| Аппаратное кодирование с помощью [OpenMAX IL](https://www.khronos.org/openmaxil) на Raspberry Pi | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Нет |
+| Поведение при физическом отключении устройства<br>от сервера во время работы | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Транслирует черный экран<br>с надписью ```NO SIGNAL```,<br>пока устройство не будет подключено снова | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Необратимо зависает <sup>1</sup> |
+| Поддержка [DV-таймингов](https://linuxtv.org/downloads/v4l-dvb-apis/uapi/v4l/dv-timings.html) - возможности изменения <br>параметров разрешения трансляции на лету<br>по сигналу источника (устройства видеозахвата) | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Нет <sup>1</sup> |
+| Дебаг-логи без перекомпиляции,<br>логгирование статистики производительности,<br>возможность получения параметров<br>трансляции по HTTP | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Нет |
+| Поддерживаемые входные форматы устройств | ![#ffaa00](https://placehold.it/15/ffaa00/000000?text=+) YUYV, UYVY,<br>RGB565, ~~MJPG~~ <sup>2</sup> | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) YUYV, UYVY,<br>RGB565, MJPG |
+| Поддержка контролов веб-камер (фокус,<br> движение сервами) и всяких настроек,<br> типа яркости, через HTTP | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Нет | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть |
+| Возможность сервить файлы встроенным<br>HTTP-сервером, настройки авторизации | ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) Нет <sup>3</sup> | ![#00aa00](https://placehold.it/15/00aa00/000000?text=+) Есть |
+
+Сносочки:
+  * ```1``` Для mjpg-streamer существует [мой патч](https://github.com/jacksonliam/mjpg-streamer/pull/164), предотвращающий зависание при отключении устройства и добавляющий поддержку DV-таймингов, однако трансляция при этом все равно прерывается. В данный момент этот патч не принят в апстрим, и я даже не гарантирую его стопроцентную работоспособность. Код mjpg-streamer очень плохо структурирован и чрезвычайно запутан, и я мог что-то упустить. Собственно, это одна из причин, почему µStreamer написан с нуля.
+
+  * ```2``` Поскольку µ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 источника, но у меня просто пока не дошли до этого руки.
+
+  * ```3``` ... и не будет. µStreamer придерживается концепции UNIX-way, так что если вам нужно нарисовать маленький сайтик со встроенной трансляцией - просто поставьте NGINX.
+
+-----
+# TL;DR
+Если вам нужно вещать стрим с уличной камеры и управлять ее параметрами - возьмите mjpg-streamer. Если же вам нужно очень качественное изображение с высоким FPS - µStreamer ваш бро.
+
+-----
+# Сборка
+Для сборки вам понадобятся ```make```, ```gcc```, ```libevent``` с поддержкой ```pthreads``` и ```libjpeg8```/```libjpeg-turbo```.
+
+На Raspberry Pi програма автоматически собирается с поддержкой OpenMAX, если обнаружит нужные хедеры в ```/opt/vc/include```.
+
+```
+$ git clone --depth=1 https://github.com/pi-kvm/ustreamer
+$ cd ustreamer
+$ make
+$ ./ustreamer --help
+```
+
+Для Arch Linux в AUR есть готовый пакет: https://aur.archlinux.org/packages/ustreamer
+
+-----
+# Использование
+Будучи запущенным без аргументов, ```ustremaer``` попробует открыть устройство ```/dev/video0``` с разрешением 640x480 и начать трансляцию на ```http://localhost:8080```. Это поведение может быть изменено с помощью опций ```--device```, ```--host``` и ```--port```. Пример вещания на всю сеть по 80 порту:
+```
+# ./ustreamer --device=/dev/video1 --host=0.0.0.0 --port=80
+```
+
+Рекомендуемый способ запуска µStreamer для работы с [Auvidea B101](https://www.raspberrypi.org/forums/viewtopic.php?f=38&t=120702&start=400#p1339178) на Raspberry Pi:
+```bash
+$ ./ustreamer \
+    --format=uyvy \ # Настройка входного формата устройства
+    --encoder=omx \ # Использование аппаратного кодирования с помощью OpenMAX
+    --dv-timings # Включение DV-таймингов
+```
+
+За полным списком опций обращайтесь ко встроенной справке: ```ustreamer --help```.
+
+-----
+# Лицензия
+Copyright (C) 2018 by Maxim Devaev mdevaev@gmail.com
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see https://www.gnu.org/licenses/.

src/config.h

@@ -21,4 +21,4 @@
 
 #pragma once
 
-#define VERSION "0.10"
+#define VERSION "0.11"

src/device.c

@@ -39,7 +39,7 @@
 static const struct {
 	const char *name;
 	const v4l2_std_id standard;
-} STANDARDS[] = {
+} _STANDARDS[] = {
 	{"UNKNOWN",	V4L2_STD_UNKNOWN},
 	{"PAL",		V4L2_STD_PAL},
 	{"NTSC",	V4L2_STD_NTSC},
@@ -49,7 +49,7 @@ static const struct {
 static const struct {
 	const char *name;
 	const unsigned format;
-} FORMATS[] = {
+} _FORMATS[] = {
 	{"YUYV",	V4L2_PIX_FMT_YUYV},
 	{"UYVY",	V4L2_PIX_FMT_UYVY},
 	{"RGB565",	V4L2_PIX_FMT_RGB565},
@@ -96,18 +96,18 @@ void device_destroy(struct device_t *dev) {
 }
 
 int device_parse_format(const char *const str) {
-	for (unsigned index = 0; index < sizeof(FORMATS) / sizeof(FORMATS[0]); ++index) {
-		if (!strcasecmp(str, FORMATS[index].name)) {
-			return FORMATS[index].format;
+	for (unsigned index = 0; index < sizeof(_FORMATS) / sizeof(_FORMATS[0]); ++index) {
+		if (!strcasecmp(str, _FORMATS[index].name)) {
+			return _FORMATS[index].format;
 		}
 	}
 	return FORMAT_UNKNOWN;
 }
 
 v4l2_std_id device_parse_standard(const char *const str) {
-	for (unsigned index = 1; index < sizeof(STANDARDS) / sizeof(STANDARDS[0]); ++index) {
-		if (!strcasecmp(str, STANDARDS[index].name)) {
-			return STANDARDS[index].standard;
+	for (unsigned index = 1; index < sizeof(_STANDARDS) / sizeof(_STANDARDS[0]); ++index) {
+		if (!strcasecmp(str, _STANDARDS[index].name)) {
+			return _STANDARDS[index].standard;
 		}
 	}
 	return STANDARD_UNKNOWN;
@@ -434,19 +434,19 @@ static const char *_format_to_string_auto(char *buf, const size_t size, const un
 }
 
 static const char *_format_to_string_null(const unsigned format) {
-    for (unsigned index = 0; index < sizeof(FORMATS) / sizeof(FORMATS[0]); ++index) {
-		if (format == FORMATS[index].format) {
-			return FORMATS[index].name;
+    for (unsigned index = 0; index < sizeof(_FORMATS) / sizeof(_FORMATS[0]); ++index) {
+		if (format == _FORMATS[index].format) {
+			return _FORMATS[index].name;
 		}
     }
     return NULL;
 }
 
 static const char *_standard_to_string(v4l2_std_id standard) {
-	for (unsigned index = 0; index < sizeof(STANDARDS) / sizeof(STANDARDS[0]); ++index) {
-		if (standard == STANDARDS[index].standard) {
-			return STANDARDS[index].name;
+	for (unsigned index = 0; index < sizeof(_STANDARDS) / sizeof(_STANDARDS[0]); ++index) {
+		if (standard == _STANDARDS[index].standard) {
+			return _STANDARDS[index].name;
 		}
 	}
-	return STANDARDS[0].name;
+	return _STANDARDS[0].name;
 }

src/encoder.c

@@ -37,7 +37,7 @@
 static const struct {
 	const char *name;
 	const enum encoder_type_t type;
-} ENCODER_TYPES[] = {
+} _ENCODER_TYPES[] = {
 	{"CPU",	ENCODER_TYPE_CPU},
 #	ifdef OMX_ENCODER
 	{"OMX",	ENCODER_TYPE_OMX},
@@ -91,9 +91,9 @@ void encoder_destroy(struct encoder_t *encoder) {
 }
 
 enum encoder_type_t encoder_parse_type(const char *const str) {
-	for (unsigned index = 0; index < sizeof(ENCODER_TYPES) / sizeof(ENCODER_TYPES[0]); ++index) {
-		if (!strcasecmp(str, ENCODER_TYPES[index].name)) {
-			return ENCODER_TYPES[index].type;
+	for (unsigned index = 0; index < sizeof(_ENCODER_TYPES) / sizeof(_ENCODER_TYPES[0]); ++index) {
+		if (!strcasecmp(str, _ENCODER_TYPES[index].name)) {
+			return _ENCODER_TYPES[index].type;
 		}
 	}
 	return ENCODER_TYPE_UNKNOWN;

src/jpeg/encoder.c

@@ -38,10 +38,7 @@
 #include "encoder.h"
 
 
-#define JPEG_OUTPUT_BUFFER_SIZE  4096
-
-
-struct mjpg_destination_mgr {
+struct _mjpg_destination_mgr {
 	struct			jpeg_destination_mgr mgr; // Default manager
 	JOCTET			*buffer; // Start of buffer
 	unsigned char	*outbuffer_cursor;
@@ -114,15 +111,15 @@ void jpeg_encoder_compress_buffer(struct device_t *dev, const unsigned index, co
 }
 
 static void _jpeg_set_dest_picture(j_compress_ptr jpeg, unsigned char *picture, unsigned long *written) {
-	struct mjpg_destination_mgr *dest;
+	struct _mjpg_destination_mgr *dest;
 
 	if (jpeg->dest == NULL) {
 		assert((jpeg->dest = (struct jpeg_destination_mgr *)(*jpeg->mem->alloc_small)(
-			(j_common_ptr) jpeg, JPOOL_PERMANENT, sizeof(struct mjpg_destination_mgr)
+			(j_common_ptr) jpeg, JPOOL_PERMANENT, sizeof(struct _mjpg_destination_mgr)
 		)));
 	}
 
-	dest = (struct mjpg_destination_mgr *) jpeg->dest;
+	dest = (struct _mjpg_destination_mgr *) jpeg->dest;
 	dest->mgr.init_destination = _jpeg_init_destination;
 	dest->mgr.empty_output_buffer = _jpeg_empty_output_buffer;
 	dest->mgr.term_destination = _jpeg_term_destination;
@@ -222,8 +219,10 @@ static void _jpeg_write_scanlines_rgb565(struct jpeg_compress_struct *jpeg,
 	}
 }
 
+#define JPEG_OUTPUT_BUFFER_SIZE  4096
+
 static void _jpeg_init_destination(j_compress_ptr jpeg) {
-	struct mjpg_destination_mgr *dest = (struct mjpg_destination_mgr *) jpeg->dest;
+	struct _mjpg_destination_mgr *dest = (struct _mjpg_destination_mgr *) jpeg->dest;
 
 	// Allocate the output buffer - it will be released when done with image
 	assert((dest->buffer = (JOCTET *)(*jpeg->mem->alloc_small)(
@@ -237,7 +236,7 @@ static void _jpeg_init_destination(j_compress_ptr jpeg) {
 static boolean _jpeg_empty_output_buffer(j_compress_ptr jpeg) {
 	// Called whenever local jpeg buffer fills up
 
-	struct mjpg_destination_mgr *dest = (struct mjpg_destination_mgr *) jpeg->dest;
+	struct _mjpg_destination_mgr *dest = (struct _mjpg_destination_mgr *) jpeg->dest;
 
 	memcpy(dest->outbuffer_cursor, dest->buffer, JPEG_OUTPUT_BUFFER_SIZE);
 	dest->outbuffer_cursor += JPEG_OUTPUT_BUFFER_SIZE;
@@ -253,7 +252,7 @@ static void _jpeg_term_destination(j_compress_ptr jpeg) {
 	// Called by jpeg_finish_compress after all data has been written.
 	// Usually needs to flush buffer
 
-	struct mjpg_destination_mgr *dest = (struct mjpg_destination_mgr *) jpeg->dest;
+	struct _mjpg_destination_mgr *dest = (struct _mjpg_destination_mgr *) jpeg->dest;
 	size_t data_count = JPEG_OUTPUT_BUFFER_SIZE - dest->mgr.free_in_buffer;
 
 	// Write any data remaining in the buffer
@@ -261,3 +260,5 @@ static void _jpeg_term_destination(j_compress_ptr jpeg) {
 	dest->outbuffer_cursor += data_count;
 	*dest->written += data_count;
 }
+
+#undef JPEG_OUTPUT_BUFFER_SIZE

src/omx/component.h

@@ -40,6 +40,8 @@
 
 int component_enable_port(OMX_HANDLETYPE *component, const OMX_U32 port);
 int component_disable_port(OMX_HANDLETYPE *component, const OMX_U32 port);
+
 int component_get_portdef(OMX_HANDLETYPE *component, OMX_PARAM_PORTDEFINITIONTYPE *portdef, const OMX_U32 port);
 int component_set_portdef(OMX_HANDLETYPE *component, OMX_PARAM_PORTDEFINITIONTYPE *portdef);
+
 int component_set_state(OMX_HANDLETYPE *component, const OMX_STATETYPE state);