Bump version: 5.18 → 5.19

This reverts commit 021823bcba.

.bumpversion.cfg

@@ -1,18 +1,18 @@
 [bumpversion]
 commit = True
 tag = True
-current_version = 4.7
+current_version = 5.19
 parse = (?P<major>\d+)\.(?P<minor>\d+)
 serialize = 
 	{major}.{minor}
 
-[bumpversion:file:src/libs/config.h]
+[bumpversion:file:src/libs/const.h]
 parse = (?P<major>\d+)
 serialize = {major}
 search = VERSION_MAJOR {current_version}
 replace = VERSION_MAJOR {new_version}
 
-[bumpversion:file:./src/libs/config.h]
+[bumpversion:file:./src/libs/const.h]
 parse = <major>\d+\.(?P<minor>\d+)
 serialize = {minor}
 search = VERSION_MINOR {current_version}

.github/FUNDING.yml

@@ -1,4 +1,4 @@
 # These are supported funding model platforms
 
 patreon: pikvm
-custom: https://www.paypal.me/mdevaev
+#custom: https://www.paypal.me/mdevaev

README.md

@@ -4,7 +4,7 @@
 
 [[Русская версия]](README.ru.md)
 
-µStreamer is a lightweight and very quick server to stream [MJPG](https://en.wikipedia.org/wiki/Motion_JPEG) video from any V4L2 device to the net. All new browsers have native support of this video format, as well as most video players such as mplayer, VLC etc.
+µStreamer is a lightweight and very quick server to stream [MJPEG](https://en.wikipedia.org/wiki/Motion_JPEG) video from any V4L2 device to the net. All new browsers have native support of this video format, as well as most video players such as mplayer, VLC etc.
 µStreamer is a part of the [Pi-KVM](https://github.com/pikvm/pikvm) project designed to stream [VGA](https://www.amazon.com/dp/B0126O0RDC) and [HDMI](https://auvidea.com/b101-hdmi-to-csi-2-bridge-15-pin-fpc/) screencast hardware data with the highest resolution and FPS possible.
 
 µStreamer is very similar to [mjpg-streamer](https://github.com/jacksonliam/mjpg-streamer) with ```input_uvc.so``` and ```output_http.so``` plugins, however, there are some major differences. The key ones are:
@@ -12,11 +12,12 @@
 | **Feature** | **µStreamer** | **mjpg-streamer** |
 |----------|---------------|-------------------|
 | Multithreaded JPEG encoding | ✔ | ✘ |
-| [OpenMAX IL](https://www.khronos.org/openmaxil) hardware acceleration<br>on Raspberry Pi | ✔ | ✘ |
+| Hardware image encoding<br>on Raspberry Pi | ✔ | ✘ |
 | Behavior when the device<br>is disconnected while streaming | ✔ Shows a black screen<br>with ```NO SIGNAL``` on it<br>until reconnected | ✘ Stops the streaming <sup>1</sup> |
 | [DV-timings](https://linuxtv.org/downloads/v4l-dvb-apis-new/userspace-api/v4l/dv-timings.html) support -<br>the ability to change resolution<br>on the fly by source signal | ✔ | ☹ Partially yes <sup>1</sup> |
 | Option to skip frames when streaming<br>static images by HTTP to save the traffic | ✔ <sup>2</sup> | ✘ |
 | Streaming via UNIX domain socket | ✔ | ✘ |
+| Systemd socket activation | ✔ | ✘ |
 | Debug logs without recompiling,<br>performance statistics log,<br>access to HTTP streaming parameters | ✔ | ✘ |
 | Option to serve files<br>with a built-in HTTP server | ✔ | ☹ Regular files only |
 | Signaling about the stream state<br>on GPIO using [libgpiod](https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git/about) | ✔ | ✘ |
@@ -34,13 +35,14 @@ If you're going to live-stream from your backyard webcam and need to control it,
 
 -----
 # Building
-You'll need  ```make```, ```gcc```, ```libevent``` with ```pthreads``` support, ```libjpeg8```/```libjpeg-turbo``` and ```libbsd``` (only for Linux).
+You'll need  ```make```, ```gcc```, ```libevent``` with ```pthreads``` support, ```libjpeg9```/```libjpeg-turbo``` and ```libbsd``` (only for Linux).
 
 * Arch: `sudo pacman -S libevent libjpeg-turbo libutil-linux libbsd`.
-* Raspbian: `sudo apt install libevent-dev libjpeg8-dev libbsd-dev`. Add `libraspberrypi-dev` for `WITH_OMX=1` and `libgpiod` for `WITH_GPIO=1`.
+* Raspbian: `sudo apt install libevent-dev libjpeg8-dev libbsd-dev`. Add `libgpiod-dev` for `WITH_GPIO=1` and `libsystemd-dev` for `WITH_SYSTEMD=1`.
 * Debian/Ubuntu: `sudo apt install build-essential libevent-dev libjpeg-dev libbsd-dev`.
+* Alpine: `sudo apk add libevent-dev libbsd-dev libjpeg-turbo-dev musl-dev`. Build with `WITH_PTHREAD_NP=0`.
 
-On Raspberry Pi you can build the program with OpenMAX IL. To do this pass option ```WITH_OMX=1``` to ```make```. To enable GPIO support install [libgpiod](https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git/about) and pass option ```WITH_GPIO=1```. If the compiler reports about a missing function ```pthread_get_name_np()``` (or similar), add option ```WITH_PTHREAD_NP=0``` (it's enabled by default). For the similar error with ```setproctitle()``` add option ```WITH_SETPROCTITLE=0```.
+To enable GPIO support install [libgpiod](https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git/about) and pass option ```WITH_GPIO=1```. If the compiler reports about a missing function ```pthread_get_name_np()``` (or similar), add option ```WITH_PTHREAD_NP=0``` (it's enabled by default). For the similar error with ```setproctitle()``` add option ```WITH_SETPROCTITLE=0```.
 
 ```
 $ git clone --depth=1 https://github.com/pikvm/ustreamer
@@ -49,11 +51,14 @@ $ make
 $ ./ustreamer --help
 ```
 
-AUR has a package for Arch Linux: https://aur.archlinux.org/packages/ustreamer. It should compile automatically with OpenMAX IL on Raspberry Pi, if the corresponding headers are present in ```/opt/vc/include```.
+AUR has a package for Arch Linux: https://aur.archlinux.org/packages/ustreamer.
+
 FreeBSD port: https://www.freshports.org/multimedia/ustreamer.
 
 -----
 # Usage
+**For M2M hardware encoding on Raspberry Pi, you need at least 5.15.32 kernel. OpenMAX and MMAL support on older kernels is deprecated and removed.**
+
 Without arguments, ```ustreamer``` will try to open ```/dev/video0``` with 640x480 resolution and start streaming on  ```http://127.0.0.1:8080```. You can override this behavior using parameters ```--device```, ```--host``` and ```--port```. For example, to stream to the world, run:
 ```
 # ./ustreamer --device=/dev/video1 --host=0.0.0.0 --port=80
@@ -65,8 +70,8 @@ The recommended way of running µStreamer with [Auvidea B101](https://www.raspbe
 ```bash
 $ ./ustreamer \
     --format=uyvy \ # Device input format
-    --encoder=omx \ # Hardware encoding with OpenMAX
-    --workers=3 \ # Maximum workers for OpenMAX
+    --encoder=m2m-image \ # Hardware encoding on V4L2 M2M driver
+    --workers=3 \ # Workers number
     --persistent \ # Don't re-initialize device on timeout (for example when HDMI cable was disconnected)
     --dv-timings \ # Use DV-timings
     --drop-same-frames=30 # Save the traffic
@@ -95,6 +100,9 @@ $ modprobe bcm2835-v4l2 max_video_width=2592 max_video_height=1944
 -----
 # Integrations
 
+## Janus
+µStreamer supports bandwidth-efficient streaming using [H.264 compression](https://en.wikipedia.org/wiki/Advanced_Video_Coding) and the Janus WebRTC server. See the [Janus integration guide](docs/h264.md) for full details.
+
 ## Nginx
 When uStreamer is behind an Nginx proxy, it's buffering behavior introduces latency into the video stream. It's possible to disable Nginx's buffering to eliminate the additional latency:
 
@@ -122,11 +130,10 @@ v4l2 utilities provide the tools to manage USB webcam setting and information. S
 -----
 # See also
 * [Running uStreamer via systemd service](https://github.com/pikvm/ustreamer/issues/16).
-* [uStreamer Ansible Role](https://github.com/mtlynch/ansible-role-ustreamer): Use [Ansible](https://docs.ansible.com/ansible/latest/index.html) to compile uStreamer and install it as a systemd service automatically.
 
 -----
 # License
-Copyright (C) 2018-2021 by Maxim Devaev mdevaev@gmail.com
+Copyright (C) 2018-2022 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

README.ru.md

@@ -5,18 +5,19 @@
 [[English version]](README.md)
 
 
-µStreamer - это маленький и очень быстрый сервер, который позволяет организовать трансляцию видео в формате [MJPG](https://en.wikipedia.org/wiki/Motion_JPEG) с любого устройства V4L2 в сеть. Этот формат нативно поддерживается всеми современными браузерами и большинством приложений для просмотра видео (mplayer, VLC и так далее). µStreamer был разработан в рамках проекта [Pi-KVM](https://github.com/pikvm/pikvm) специально для стриминга с устройств видеозахвата [VGA](https://www.amazon.com/dp/B0126O0RDC) и [HDMI](https://auvidea.com/b101-hdmi-to-csi-2-bridge-15-pin-fpc/) с максимально возможным разрешением и FPS, которые только позволяет железо.
+µStreamer - это маленький и очень быстрый сервер, который позволяет организовать трансляцию видео в формате [MJPEG](https://en.wikipedia.org/wiki/Motion_JPEG) с любого устройства V4L2 в сеть. Этот формат нативно поддерживается всеми современными браузерами и большинством приложений для просмотра видео (mplayer, VLC и так далее). µStreamer был разработан в рамках проекта [Pi-KVM](https://github.com/pikvm/pikvm) специально для стриминга с устройств видеозахвата [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 | ✔ | ✘ |
-| Аппаратное кодирование с помощью [OpenMAX IL](https://www.khronos.org/openmaxil) на Raspberry Pi | ✔ | ✘ |
+| Аппаратное кодирование на Raspberry Pi | ✔ | ✘ |
 | Поведение при физическом отключении<br>устройства от сервера во время работы | ✔ Транслирует черный экран<br>с надписью ```NO SIGNAL```,<br>пока устройство не будет подключено снова | ✘ Прерывает трансляцию <sup>1</sup> |
 | Поддержка [DV-таймингов](https://linuxtv.org/downloads/v4l-dvb-apis-new/userspace-api/v4l/dv-timings.html) - возможности<br>изменения  параметров разрешения<br>трансляции на лету по сигналу<br>источника (устройства видеозахвата) | ✔ | ☹ Условно есть <sup>1</sup> |
 | Возможность пропуска фреймов при передаче<br>статического изображения по HTTP<br>для экономии трафика | ✔ <sup>2</sup> | ✘ |
 | Стрим через UNIX domain socket | ✔ | ✘ |
+| Systemd socket activation | ✔ | ✘ |
 | Дебаг-логи без перекомпиляции,<br>логгирование статистики производительности,<br>возможность получения параметров<br>трансляции по HTTP | ✔ | ✘ |
 | Возможность сервить файлы встроенным<br>HTTP-сервером  | ✔ | ☹ Нет каталогов |
 | Вывод сигналов о состоянии стрима на GPIO<br>с помощью [libgpiod](https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git/about) | ✔ | ✘ |
@@ -37,10 +38,10 @@
 Для сборки вам понадобятся ```make```, ```gcc```, ```libevent``` с поддержкой ```pthreads```, ```libjpeg8```/```libjpeg-turbo``` и ```libbsd``` (только для Linux).
 
 * Arch: `sudo pacman -S libevent libjpeg-turbo libutil-linux libbsd`.
-* Raspbian: `sudo apt install libevent-dev libjpeg8-dev libbsd-dev`.  Добавьте `libraspberrypi-dev` для сборки с `WITH_OMX=1` и `libgpiod` для `WITH_GPIO=1`.
+* Raspbian: `sudo apt install libevent-dev libjpeg8-dev libbsd-dev`.  Добавьте `libgpiod` для `WITH_GPIO=1` и `libsystemd-dev` для `WITH_SYSTEMD=1`.
 * Debian/Ubuntu: `sudo apt install build-essential libevent-dev libjpeg-dev libbsd-dev`.
 
-На Raspberry Pi программу можно собрать с поддержкой OpenMAX IL. Для этого передайте ```make``` параметр ```WITH_OMX=1```. Для включения сборки с поддержкой GPIO установите [libgpiod](https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git/about) и добавьте параметр ```WITH_GPIO=1```. Если при сборке компилятор ругается на отсутствие функции ```pthread_get_name_np()``` или другой подобной, добавьте параметр ```WITH_PTHREAD_NP=0``` (по умолчанию он включен). При аналогичной ошибке с функцией ```setproctitle()``` добавьте параметр ```WITH_SETPROCTITLE=0```.
+Для включения сборки с поддержкой GPIO установите [libgpiod](https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git/about) и добавьте параметр ```WITH_GPIO=1```. Если при сборке компилятор ругается на отсутствие функции ```pthread_get_name_np()``` или другой подобной, добавьте параметр ```WITH_PTHREAD_NP=0``` (по умолчанию он включен). При аналогичной ошибке с функцией ```setproctitle()``` добавьте параметр ```WITH_SETPROCTITLE=0```.
 
 ```
 $ git clone --depth=1 https://github.com/pikvm/ustreamer
@@ -49,11 +50,14 @@ $ make
 $ ./ustreamer --help
 ```
 
-Для Arch Linux в AUR есть готовый пакет: https://aur.archlinux.org/packages/ustreamer. На Raspberry Pi програма автоматически собирается с поддержкой OpenMAX IL, если обнаружит нужные хедеры в ```/opt/vc/include```.  
+Для Arch Linux в AUR есть готовый пакет: https://aur.archlinux.org/packages/ustreamer.
+
 Порт для FreeBSD: https://www.freshports.org/multimedia/ustreamer.
 
 -----
 # Использование
+**Для аппаратного кодирования M2M на Raspberry Pi, вам нужно ядро минимальной версии 5.15.32. Поддержка OpenMAX и MMAL для более старых ядер объявлена устаревшей и была удалена.**
+
 Будучи запущенным без аргументов, ```ustreamer``` попробует открыть устройство ```/dev/video0``` с разрешением 640x480 и начать трансляцию на ```http://127.0.0.1:8080```. Это поведение может быть изменено с помощью опций ```--device```, ```--host``` и ```--port```. Пример вещания на всю сеть по 80-м порту:
 ```
 # ./ustreamer --device=/dev/video1 --host=0.0.0.0 --port=80
@@ -65,8 +69,8 @@ $ ./ustreamer --help
 ```bash
 $ ./ustreamer \
     --format=uyvy \ # Настройка входного формата устройства
-    --encoder=omx \ # Использование аппаратного кодирования с помощью OpenMAX
-    --workers=3 \ # Максимум воркеров для OpenMAX
+    --encoder=m2m-image \ # Аппаратное кодирование с помощью драйвера V4L2 M2M
+    --workers=3 \ # Максимум воркеров
     --persistent \ # Не переинициализировать устройство при таймауте (например, когда был отключен HDMI-кабель)
     --dv-timings \ # Включение DV-таймингов
     --drop-same-frames=30 # Экономим трафик
@@ -122,11 +126,10 @@ V4L2 предоставляет ряд официальных утилит дл
 -----
 # Смотрите также
 * [Запуск с помощью systemd-сервиса](https://github.com/pikvm/ustreamer/issues/16).
-* [uStreamer Ansible Role](https://github.com/mtlynch/ansible-role-ustreamer): Использование [Ansible](https://docs.ansible.com/ansible/latest/index.html) для сборки и установки стримера как systemd-сервиса.
 
 -----
 # Лицензия
-Copyright (C) 2018-2021 by Maxim Devaev mdevaev@gmail.com
+Copyright (C) 2018-2022 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

docs/h264.md

@@ -0,0 +1,231 @@
+# Streaming H.264 Video over WebRTC with Janus
+
+µStreamer supports bandwidth-efficient streaming using [H.264 compression](https://en.wikipedia.org/wiki/Advanced_Video_Coding) and the Janus WebRTC server.
+
+This guide explains how to configure µStreamer to provide an H.264 video stream and consume it within a web application using WebRTC.
+
+## Components
+
+In addition to µStreamer, H.264 streaming involves the following components:
+
+- [**Janus**](https://janus.conf.meetecho.com/): A general-purpose WebRTC server.
+- [**µStreamer Janus Plugin**](https://github.com/pikvm/ustreamer/tree/master/janus): A Janus plugin that allows Janus to consume a video stream from µStreamer via shared memory.
+- [**Janus JavaScript Client**](https://janus.conf.meetecho.com/docs/JS.html): A frontend library that communicates with the Janus server and the µStreamer Janus plugin.
+
+## Control Flow
+
+To connect to a µStreamer video stream over WebRTC, an application must establish the following control flow:
+
+1. The backend server starts the µStreamer service.
+1. The backend server starts the Janus WebRTC server with the µStreamer Janus plugin.
+1. The client-side JavaScript application establishes a connection to the Janus server.
+1. The client-side JavaScript application instructs the Janus server to attach the µStreamer Janus plugin and start the video stream.
+1. The client-side JavaScript application renders the video stream in the web browser.
+
+## Server Setup
+
+### Prerequisites
+
+To integrate with Janus, µStreamer has the following prerequisites:
+
+- The system packages that µStreamer depends on (see the [main build instructions](../README.md#building)).
+- The Janus WebRTC server with WebSockets transport enabled (see the [Janus documentation](https://github.com/meetecho/janus-gateway)).
+
+### Fixing Janus C Headers
+
+To compile µStreamer with the Janus option, (see [“Installation”](#installation)), you need to make the Janus header files available within µStreamer's build context.
+
+First, create a symbolic link from `/usr/include` to the Janus install directory. By default, Janus installs to `/opt/janus`.
+
+```sh
+ln -s /opt/janus/include/janus /usr/include/janus
+```
+
+Janus uses `#include` paths that make it difficult for third-party libraries to build against its headers. To fix this, modify the `#include` directive in `janus/plugins/plugin.h` to prepend a `../` to the included file name (`#include "refcount.h"` → `#include "../refcount.h"`).
+
+```sh
+sed \
+  --in-place \
+  --expression 's|^#include "refcount.h"$|#include "../refcount.h"|g' \
+  /usr/include/janus/plugins/plugin.h
+```
+
+### Installation
+
+First, compile µStreamer with the Janus plugin option (`WITH_JANUS`).
+
+```sh
+git clone --depth=1 https://github.com/pikvm/ustreamer
+cd ustreamer
+make WITH_JANUS=1
+```
+
+The `WITH_JANUS` option compiles the µStreamer Janus plugin and outputs it to `janus/libjanus_ustreamer.so`. Move this file to the plugin directory of your Janus installation.
+
+```sh
+mv \
+  janus/libjanus_ustreamer.so \
+  /opt/janus/lib/janus/plugins/libjanus_ustreamer.so
+```
+
+Finally, specify a qualifier for the shared memory object so that the µStreamer Janus plugin can read  µStreamer's video data.
+
+```sh
+cat > /opt/janus/lib/janus/configs/janus.plugin.ustreamer.jcfg <<EOF
+memsink: {
+  object = "demo::ustreamer::h264"
+}
+EOF
+```
+
+### Start µStreamer and the Janus WebRTC Server
+
+For µStreamer to share the video stream with the µStreamer Janus plugin, µStreamer must run with the following command-line flags:
+
+- `--h264-sink` with the qualifier of the shared memory object you specified above (`demo::ustreamer::h264`)
+- `--h264-sink-mode` with the permissions bitmask for the shared memory object (e.g., `660`)
+- `--h264-sink-rm` to clean up the shared memory object when the µStreamer process exits
+
+To load the µStreamer Janus plugin and configuration, the Janus WebRTC server must run with the following command-line flags:
+
+- `--configs-folder` with the path to the Janus configuration directory (e.g., `/opt/janus/lib/janus/configs/`)
+- `--plugins-folder` with the path to the Janus plugin directory (e.g., `/opt/janus/lib/janus/plugins/`)
+
+## Client Setup
+
+Once an application's backend server is running µStreamer and Janus, a browser-based JavaScript application can consume the server's video stream.
+
+### Prerequisites
+
+The client needs to load the following JavaScript libraries:
+
+- [WebRTC Adapter library](https://webrtc.github.io/adapter/adapter-8.1.0.js) (`webrtc-adapter.js`, version `8.1.0`)
+- [Janus Gateway JavaScript library](https://raw.githubusercontent.com/meetecho/janus-gateway/v1.0.0/html/janus.js) (`janus.js`, version `1.0.0`)
+
+### Control Flow
+
+The client-side JavaScript application uses the following control flow:
+
+1. The client loads and initializes the Janus client library.
+1. The client establishes a WebSockets connection to the Janus server.
+1. The client instructs the Janus server to attach the µStreamer Janus plugin.
+1. On success, the client obtains a plugin handle through which it can send requests directly to the µStreamer Janus plugin. The client processes responses via the `attach` callbacks:
+   - `onmessage` for general messages
+   - `onremotetrack` for the H.264 video stream
+1. The client issues a `watch` request to the µStreamer Janus plugin, which initiates the H.264 stream in the plugin itself.
+   - It takes a few seconds for uStreamer's video stream to become available to Janus. The first `watch` request may fail, so the client must retry the `watch` request.
+1. The client and server negotiate the underlying parameters of the WebRTC session. This procedure is called JavaScript Session Establishment Protocol (JSEP). The server makes a `jsepOffer` to the client, and the client responds with a `jsepAnswer`.
+1. The client issues a `start` request to the µStreamer Janus plugin to indicate that the client wants to begin consuming the video stream.
+1. The µStreamer Janus plugin delivers the H.264 video stream to the client via WebRTC.
+1. The Janus client library invokes the `onremotetrack` callback. The client attaches the video stream to the `<video>` element, rendering the video stream in the browser window.
+
+### Sample Code
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>µStreamer H.264 demo</title>
+  <script src="https://webrtc.github.io/adapter/adapter-8.1.0.js"></script>
+  <!-- janus.js is the JavaScript client library of Janus, as specified above in
+       the prerequisites section of the client setup. You might need to change
+       the `src` path, depending on where you serve this file from. -->
+  <script src="janus.js"></script>
+  <style>
+    video {
+      height: 100%;
+      width: 100%;
+      object-fit: contain;
+    }
+  </style>
+</head>
+<body>
+  <video id="webrtc-output" autoplay playsinline muted></video>
+  <script type="text/javascript">
+    // Initialize Janus library.
+    Janus.init({
+      // Turn on debug logs in the browser console.
+      debug: true,
+
+      // Configure Janus to use standard browser APIs internally.
+      dependencies: Janus.useDefaultDependencies(),
+    });
+
+    // Establish a WebSockets connection to the server.
+    const janus = new Janus({
+      // Specify the URL of the Janus server’s WebSockets endpoint.
+      server: `ws://${window.location.hostname}:8188/`,
+
+      // Callback function if the client connects successfully.
+      success: attachUStreamerPlugin,
+
+      // Callback function if the client fails to connect.
+      error: console.error,
+    });
+
+    let uStreamerPluginHandle = null;
+
+    function attachUStreamerPlugin() {
+      // Instruct the server to attach the µStreamer Janus plugin.
+      janus.attach({
+        // Qualifier of the plugin.
+        plugin: "janus.plugin.ustreamer",
+
+        // Callback function, for when the server attached the plugin
+        // successfully.
+        success: function (pluginHandle) {
+          uStreamerPluginHandle = pluginHandle;
+          // Instruct the µStreamer Janus plugin to initiate the video stream.
+          uStreamerPluginHandle.send({ message: { request: "watch" } });
+        },
+
+        // Callback function if the server fails to attach the plugin.
+        error: console.error,
+
+        // Callback function for processing messages from the Janus server.
+        onmessage: function (msg, jsepOffer) {
+          // 503 indicates that the plugin is not ready to stream yet. Retry the
+          // watch request until the video stream is available.
+          if (msg.error_code === 503) {
+            uStreamerPluginHandle.send({ message: { request: "watch" } });
+            return;
+          }
+
+          // If there is a JSEP offer, respond to it. This starts the WebRTC
+          // connection.
+          if (jsepOffer) {
+            uStreamerPluginHandle.createAnswer({
+              jsep: jsepOffer,
+              // Prevent the client from sending audio and video, as this would
+              // trigger a permission dialog in the browser.
+              media: { audioSend: false, videoSend: false },
+              success: function (jsepAnswer) {
+                uStreamerPluginHandle.send({
+                  message: { request: "start" },
+                  jsep: jsepAnswer,
+                });
+              },
+              error: console.error,
+            });
+          }
+        },
+
+        // Callback function, for when the video stream arrives.
+        onremotetrack: function (mediaStreamTrack, mediaId, isAdded) {
+          if (isAdded) {
+            // Attach the received media track to the video element. Cloning the
+            // mediaStreamTrack creates a new object with a distinct, globally
+            // unique stream identifier.
+            const videoElement = document.getElementById("webrtc-output");
+            const stream = new MediaStream();
+            stream.addTrack(mediaStreamTrack.clone());
+            videoElement.srcObject = stream;
+          }
+        },
+      });
+    }
+  </script>
+</body>
+</html>
+```

janus/Makefile

@@ -9,10 +9,10 @@ LDFLAGS ?=
 # =====
 _PLUGIN = libjanus_ustreamer.so
 
-_CFLAGS = -fPIC -MD -c -std=c11 -Wall -Wextra -D_GNU_SOURCE $(shell pkg-config --cflags glib-2.0) $(CFLAGS)
-_LDFLAGS = -shared -lm -pthread -lrt -ljansson $(shell pkg-config --libs glib-2.0) $(LDFLAGS)
+_CFLAGS = -fPIC -MD -c -std=c17 -Wall -Wextra -D_GNU_SOURCE $(shell pkg-config --cflags glib-2.0) $(CFLAGS)
+_LDFLAGS = -shared -lm -pthread -lrt -ljansson -lopus -lasound -lspeexdsp $(shell pkg-config --libs glib-2.0) $(LDFLAGS)
 
-_SRCS = $(shell ls src/*.c)
+_SRCS = $(shell ls src/uslibs/*.c src/*.c)
 
 _BUILD = build
 

janus/src/audio.c

@@ -0,0 +1,242 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2022  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/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "audio.h"
+
+
+#define _JLOG_PERROR_ALSA(_err, _prefix, _msg, ...)	US_JLOG_ERROR(_prefix, _msg ": %s", ##__VA_ARGS__, snd_strerror(_err))
+#define _JLOG_PERROR_RES(_err, _prefix, _msg, ...)	US_JLOG_ERROR(_prefix, _msg ": %s", ##__VA_ARGS__, speex_resampler_strerror(_err))
+#define _JLOG_PERROR_OPUS(_err, _prefix, _msg, ...)	US_JLOG_ERROR(_prefix, _msg ": %s", ##__VA_ARGS__, opus_strerror(_err))
+
+// A number of frames per 1 channel:
+//   - https://github.com/xiph/opus/blob/7b05f44/src/opus_demo.c#L368
+#define _HZ_TO_FRAMES(_hz)	(6 * (_hz) / 50) // 120ms
+#define _HZ_TO_BUF16(_hz)	(_HZ_TO_FRAMES(_hz) * 2) // One stereo frame = (16bit L) + (16bit R)
+#define _HZ_TO_BUF8(_hz)	(_HZ_TO_BUF16(_hz) * sizeof(int16_t))
+
+#define _MIN_PCM_HZ			8000
+#define _MAX_PCM_HZ			192000
+#define _MAX_BUF16			_HZ_TO_BUF16(_MAX_PCM_HZ)
+#define _MAX_BUF8			_HZ_TO_BUF8(_MAX_PCM_HZ)
+#define _ENCODER_INPUT_HZ	48000
+
+
+typedef struct {
+	int16_t		data[_MAX_BUF16];
+} _pcm_buffer_s;
+
+typedef struct {
+	uint8_t		data[_MAX_BUF8]; // Worst case
+	size_t		used;
+	uint64_t	pts;
+} _enc_buffer_s;
+
+
+static void *_pcm_thread(void *v_audio);
+static void *_encoder_thread(void *v_audio);
+
+
+us_audio_s *us_audio_init(const char *name, unsigned pcm_hz) {
+	us_audio_s *audio;
+	US_CALLOC(audio, 1);
+	audio->pcm_hz = pcm_hz;
+	audio->pcm_queue = us_queue_init(8);
+	audio->enc_queue = us_queue_init(8);
+	atomic_init(&audio->stop, false);
+
+	int err;
+
+	{
+		if ((err = snd_pcm_open(&audio->pcm, name, SND_PCM_STREAM_CAPTURE, 0)) < 0) {
+			audio->pcm = NULL;
+			_JLOG_PERROR_ALSA(err, "audio", "Can't open PCM capture");
+			goto error;
+		}
+		assert(!snd_pcm_hw_params_malloc(&audio->pcm_params));
+
+#		define SET_PARAM(_msg, _func, ...) { \
+				if ((err = _func(audio->pcm, audio->pcm_params, ##__VA_ARGS__)) < 0) { \
+					_JLOG_PERROR_ALSA(err, "audio", _msg); \
+					goto error; \
+				} \
+			}
+
+		SET_PARAM("Can't initialize PCM params",	snd_pcm_hw_params_any);
+		SET_PARAM("Can't set PCM access type",		snd_pcm_hw_params_set_access, SND_PCM_ACCESS_RW_INTERLEAVED);
+		SET_PARAM("Can't set PCM channels numbre",	snd_pcm_hw_params_set_channels, 2);
+		SET_PARAM("Can't set PCM sampling format",	snd_pcm_hw_params_set_format, SND_PCM_FORMAT_S16_LE);
+		SET_PARAM("Can't set PCM sampling rate",	snd_pcm_hw_params_set_rate_near, &audio->pcm_hz, 0);
+		if (audio->pcm_hz < _MIN_PCM_HZ || audio->pcm_hz > _MAX_PCM_HZ) {
+			US_JLOG_ERROR("audio", "Unsupported PCM freq: %u; should be: %u <= F <= %u",
+				audio->pcm_hz, _MIN_PCM_HZ, _MAX_PCM_HZ);
+			goto error;
+		}
+		audio->pcm_frames = _HZ_TO_FRAMES(audio->pcm_hz);
+		audio->pcm_size = _HZ_TO_BUF8(audio->pcm_hz);
+		SET_PARAM("Can't apply PCM params", snd_pcm_hw_params);
+
+#		undef SET_PARAM
+	}
+
+	if (audio->pcm_hz != _ENCODER_INPUT_HZ) {
+		audio->res = speex_resampler_init(2, audio->pcm_hz, _ENCODER_INPUT_HZ, SPEEX_RESAMPLER_QUALITY_DESKTOP, &err);
+		if (err < 0) {
+			audio->res = NULL;
+			_JLOG_PERROR_RES(err, "audio", "Can't create resampler");
+			goto error;
+		}
+	}
+
+	{
+		// OPUS_APPLICATION_VOIP, OPUS_APPLICATION_RESTRICTED_LOWDELAY
+		audio->enc = opus_encoder_create(_ENCODER_INPUT_HZ, 2, OPUS_APPLICATION_AUDIO, &err);
+		assert(err == 0);
+		assert(!opus_encoder_ctl(audio->enc, OPUS_SET_BITRATE(48000)));
+		assert(!opus_encoder_ctl(audio->enc, OPUS_SET_MAX_BANDWIDTH(OPUS_BANDWIDTH_FULLBAND)));
+		assert(!opus_encoder_ctl(audio->enc, OPUS_SET_SIGNAL(OPUS_SIGNAL_MUSIC)));
+		// OPUS_SET_INBAND_FEC(1), OPUS_SET_PACKET_LOSS_PERC(10): see rtpa.c
+	}
+
+	US_JLOG_INFO("audio", "Pipeline configured on %uHz; capturing ...", audio->pcm_hz);
+	audio->tids_created = true;
+	US_THREAD_CREATE(audio->enc_tid, _encoder_thread, audio);
+	US_THREAD_CREATE(audio->pcm_tid, _pcm_thread, audio);
+
+	return audio;
+
+	error:
+		us_audio_destroy(audio);
+		return NULL;
+}
+
+void us_audio_destroy(us_audio_s *audio) {
+	if (audio->tids_created) {
+		atomic_store(&audio->stop, true);
+		US_THREAD_JOIN(audio->pcm_tid);
+		US_THREAD_JOIN(audio->enc_tid);
+	}
+	US_DELETE(audio->enc, opus_encoder_destroy);
+	US_DELETE(audio->res, speex_resampler_destroy);
+	US_DELETE(audio->pcm, snd_pcm_close);
+	US_DELETE(audio->pcm_params, snd_pcm_hw_params_free);
+	US_QUEUE_DELETE_WITH_ITEMS(audio->enc_queue, free);
+	US_QUEUE_DELETE_WITH_ITEMS(audio->pcm_queue, free);
+	if (audio->tids_created) {
+		US_JLOG_INFO("audio", "Pipeline closed");
+	}
+	free(audio);
+}
+
+int us_audio_get_encoded(us_audio_s *audio, uint8_t *data, size_t *size, uint64_t *pts) {
+	if (atomic_load(&audio->stop)) {
+		return -1;
+	}
+	_enc_buffer_s *buf;
+	if (!us_queue_get(audio->enc_queue, (void **)&buf, 0.1)) {
+		if (*size < buf->used) {
+			free(buf);
+			return -3;
+		}
+		memcpy(data, buf->data, buf->used);
+		*size = buf->used;
+		*pts = buf->pts;
+		free(buf);
+		return 0;
+	}
+	return -2;
+}
+
+static void *_pcm_thread(void *v_audio) {
+	US_THREAD_RENAME("us_a_pcm");
+
+	us_audio_s *const audio = (us_audio_s *)v_audio;
+	uint8_t in[_MAX_BUF8];
+
+	while (!atomic_load(&audio->stop)) {
+		const int frames = snd_pcm_readi(audio->pcm, in, audio->pcm_frames);
+		if (frames < 0) {
+			_JLOG_PERROR_ALSA(frames, "audio", "Fatal: Can't capture PCM frames");
+			break;
+		} else if (frames < (int)audio->pcm_frames) {
+			US_JLOG_ERROR("audio", "Fatal: Too few PCM frames captured");
+			break;
+		}
+
+		if (us_queue_get_free(audio->pcm_queue)) {
+			_pcm_buffer_s *out;
+			US_CALLOC(out, 1);
+			memcpy(out->data, in, audio->pcm_size);
+			assert(!us_queue_put(audio->pcm_queue, out, 0));
+		} else {
+			US_JLOG_ERROR("audio", "PCM queue is full");
+		}
+	}
+
+	atomic_store(&audio->stop, true);
+	return NULL;
+}
+
+static void *_encoder_thread(void *v_audio) {
+	US_THREAD_RENAME("us_a_enc");
+
+	us_audio_s *const audio = (us_audio_s *)v_audio;
+	int16_t in_res[_MAX_BUF16];
+
+	while (!atomic_load(&audio->stop)) {
+		_pcm_buffer_s *in;
+		if (!us_queue_get(audio->pcm_queue, (void **)&in, 0.1)) {
+			int16_t *in_ptr;
+			if (audio->res != NULL) {
+				assert(audio->pcm_hz != _ENCODER_INPUT_HZ);
+				uint32_t in_count = audio->pcm_frames;
+				uint32_t out_count = _HZ_TO_FRAMES(_ENCODER_INPUT_HZ);
+				speex_resampler_process_interleaved_int(audio->res, in->data, &in_count, in_res, &out_count);
+				in_ptr = in_res;
+			} else {
+				assert(audio->pcm_hz == _ENCODER_INPUT_HZ);
+				in_ptr = in->data;
+			}
+
+			_enc_buffer_s *out;
+			US_CALLOC(out, 1);
+			const int size = opus_encode(audio->enc, in_ptr, _HZ_TO_FRAMES(_ENCODER_INPUT_HZ), out->data, US_ARRAY_LEN(out->data));
+			free(in);
+			if (size < 0) {
+				_JLOG_PERROR_OPUS(size, "audio", "Fatal: Can't encode PCM frame to OPUS");
+				free(out);
+				break;
+			}
+			out->used = size;
+			out->pts = audio->pts;
+			// https://datatracker.ietf.org/doc/html/rfc7587#section-4.2
+			audio->pts += _HZ_TO_FRAMES(_ENCODER_INPUT_HZ);
+
+			if (us_queue_put(audio->enc_queue, out, 0) != 0) {
+				US_JLOG_ERROR("audio", "OPUS encoder queue is full");
+				free(out);
+			}
+		}
+	}
+
+	atomic_store(&audio->stop, true);
+	return NULL;
+}

janus/src/audio.h

@@ -0,0 +1,69 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2022  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdatomic.h>
+#include <assert.h>
+
+#include <sys/types.h>
+
+#include <pthread.h>
+#include <alsa/asoundlib.h>
+#include <speex/speex_resampler.h>
+#include <opus/opus.h>
+
+#include "uslibs/tools.h"
+#include "uslibs/array.h"
+#include "uslibs/threading.h"
+
+#include "logging.h"
+#include "queue.h"
+
+
+typedef struct {
+	snd_pcm_t			*pcm;
+	unsigned			pcm_hz;
+	unsigned			pcm_frames;
+	size_t				pcm_size;
+	snd_pcm_hw_params_t	*pcm_params;
+	SpeexResamplerState	*res;
+	OpusEncoder			*enc;
+
+	us_queue_s				*pcm_queue;
+	us_queue_s				*enc_queue;
+	uint32_t			pts;
+
+	pthread_t			pcm_tid;
+	pthread_t			enc_tid;
+	bool				tids_created;
+	atomic_bool			stop;
+} us_audio_s;
+
+
+us_audio_s *us_audio_init(const char *name, unsigned pcm_hz);
+void us_audio_destroy(us_audio_s *audio);
+
+int us_audio_get_encoded(us_audio_s *audio, uint8_t *data, size_t *size, uint64_t *pts);

janus/src/base64.c

@@ -1 +0,0 @@
-../../src/libs/base64.c

janus/src/base64.h

@@ -1 +0,0 @@
-../../src/libs/base64.h

janus/src/client.c

@@ -0,0 +1,119 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2022  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/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "client.h"
+
+
+static void *_video_thread(void *v_client);
+static void *_audio_thread(void *v_client);
+static void *_common_thread(void *v_client, bool video);
+
+
+us_janus_client_s *us_janus_client_init(janus_callbacks *gw, janus_plugin_session *session, bool has_audio) {
+	us_janus_client_s *client;
+	US_CALLOC(client, 1);
+	client->gw = gw;
+	client->session = session;
+	atomic_init(&client->transmit, true);
+
+	atomic_init(&client->stop, false);
+
+	client->video_queue = us_queue_init(1024);
+	US_THREAD_CREATE(client->video_tid, _video_thread, client);
+
+	if (has_audio) {
+		client->audio_queue = us_queue_init(64);
+		US_THREAD_CREATE(client->audio_tid, _audio_thread, client);
+	}
+	return client;
+}
+
+void us_janus_client_destroy(us_janus_client_s *client) {
+	atomic_store(&client->stop, true);
+	us_queue_put(client->video_queue, NULL, 0);
+	if (client->audio_queue != NULL) {
+		us_queue_put(client->audio_queue, NULL, 0);
+	}
+
+	US_THREAD_JOIN(client->video_tid);
+	US_QUEUE_DELETE_WITH_ITEMS(client->video_queue, us_rtp_destroy);
+	if (client->audio_queue != NULL) {
+		US_THREAD_JOIN(client->audio_tid);
+		US_QUEUE_DELETE_WITH_ITEMS(client->audio_queue, us_rtp_destroy);
+	}
+	free(client);
+}
+
+void us_janus_client_send(us_janus_client_s *client, const us_rtp_s *rtp) {
+	if (
+		!atomic_load(&client->transmit)
+		|| (!rtp->video && client->audio_queue == NULL)
+	) {
+		return;
+	}
+	us_rtp_s *const new = us_rtp_dup(rtp);
+	if (us_queue_put((new->video ? client->video_queue : client->audio_queue), new, 0) != 0) {
+		US_JLOG_ERROR("client", "Session %p %s queue is full",
+			client->session, (new->video ? "video" : "audio"));
+		us_rtp_destroy(new);
+	}
+}
+
+static void *_video_thread(void *v_client) {
+	return _common_thread(v_client, true);
+}
+
+static void *_audio_thread(void *v_client) {
+	return _common_thread(v_client, false);
+}
+
+static void *_common_thread(void *v_client, bool video) {
+	us_janus_client_s *const client = (us_janus_client_s *)v_client;
+	us_queue_s *const queue = (video ? client->video_queue : client->audio_queue);
+	assert(queue != NULL); // Audio may be NULL
+
+	while (!atomic_load(&client->stop)) {
+		us_rtp_s *rtp;
+		if (!us_queue_get(queue, (void **)&rtp, 0.1)) {
+			if (rtp == NULL) {
+				break;
+			}
+			if (atomic_load(&client->transmit)) {
+				janus_plugin_rtp packet = {0};
+				packet.video = rtp->video;
+				packet.buffer = (char *)rtp->datagram;
+				packet.length = rtp->used;
+				janus_plugin_rtp_extensions_reset(&packet.extensions);
+				// FIXME: Это очень эффективный способ уменьшить задержку, но WebRTC стек в хроме и фоксе
+				// слишком корявый, чтобы обработать это, из-за чего на кейфреймах начинаются заикания.
+				//   - https://github.com/Glimesh/janus-ftl-plugin/issues/101
+				if (rtp->zero_playout_delay) {
+					packet.extensions.min_delay = 0;
+					packet.extensions.max_delay = 0;
+				}
+				client->gw->relay_rtp(client->session, &packet);
+			}
+			us_rtp_destroy(rtp);
+		}
+	}
+	return NULL;
+}

janus/src/client.h

@@ -0,0 +1,61 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2022  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdatomic.h>
+#include <string.h>
+
+#include <pthread.h>
+#include <janus/plugins/plugin.h>
+
+#include "uslibs/tools.h"
+#include "uslibs/threading.h"
+#include "uslibs/list.h"
+
+#include "logging.h"
+#include "queue.h"
+#include "rtp.h"
+
+
+typedef struct us_janus_client_sx {
+	janus_callbacks			*gw;
+    janus_plugin_session	*session;
+    atomic_bool				transmit;
+
+	pthread_t	video_tid;
+	pthread_t	audio_tid;
+	atomic_bool	stop;
+
+	us_queue_s		*video_queue;
+	us_queue_s		*audio_queue;
+
+    US_LIST_STRUCT(struct us_janus_client_sx);
+} us_janus_client_s;
+
+
+us_janus_client_s *us_janus_client_init(janus_callbacks *gw, janus_plugin_session *session, bool has_audio);
+void us_janus_client_destroy(us_janus_client_s *client);
+
+void us_janus_client_send(us_janus_client_s *client, const us_rtp_s *rtp);

janus/src/config.c

@@ -0,0 +1,99 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2022  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/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "config.h"
+
+
+static char *_get_value(janus_config *jcfg, const char *section, const char *option);
+static bool _get_bool(janus_config *jcfg, const char *section, const char *option, bool def);
+
+
+us_config_s *us_config_init(const char *config_dir_path) {
+	us_config_s *config;
+	US_CALLOC(config, 1);
+
+	char *config_file_path;
+	janus_config *jcfg = NULL;
+
+	US_ASPRINTF(config_file_path, "%s/%s.jcfg", config_dir_path, US_PLUGIN_PACKAGE);
+	US_JLOG_INFO("config", "Reading config file '%s' ...", config_file_path);
+
+	jcfg = janus_config_parse(config_file_path);
+	if (jcfg == NULL) {
+		US_JLOG_ERROR("config", "Can't read config");
+		goto error;
+	}
+	janus_config_print(jcfg);
+
+	if (
+		(config->video_sink_name = _get_value(jcfg, "memsink", "object")) == NULL
+		&& (config->video_sink_name = _get_value(jcfg, "video", "sink")) == NULL
+	) {
+		US_JLOG_ERROR("config", "Missing config value: video.sink (ex. memsink.object)");
+		goto error;
+	}
+	if ((config->video_zero_playout_delay = _get_bool(jcfg, "video", "zero_playout_delay", false)) == true) {
+		US_JLOG_INFO("config", "Enabled the experimental Playout-Delay=0 RTP extension for VIDEO");
+	}
+	if ((config->audio_dev_name = _get_value(jcfg, "audio", "device")) != NULL) {
+		US_JLOG_INFO("config", "Enabled the experimental AUDIO feature");
+		if ((config->tc358743_dev_path = _get_value(jcfg, "audio", "tc358743")) == NULL) {
+			US_JLOG_INFO("config", "Missing config value: audio.tc358743");
+			goto error;
+		}
+	}
+
+	goto ok;
+	error:
+		us_config_destroy(config);
+		config = NULL;
+	ok:
+		US_DELETE(jcfg, janus_config_destroy);
+		free(config_file_path);
+		return config;
+}
+
+void us_config_destroy(us_config_s *config) {
+	US_DELETE(config->video_sink_name, free);
+	US_DELETE(config->audio_dev_name, free);
+	US_DELETE(config->tc358743_dev_path, free);
+	free(config);
+}
+
+static char *_get_value(janus_config *jcfg, const char *section, const char *option) {
+	janus_config_category *section_obj = janus_config_get_create(jcfg, NULL, janus_config_type_category, section);
+	janus_config_item *option_obj = janus_config_get(jcfg, section_obj, janus_config_type_item, option);
+	if (option_obj == NULL || option_obj->value == NULL || option_obj->value[0] == '\0') {
+		return NULL;
+	}
+	return us_strdup(option_obj->value);
+}
+
+static bool _get_bool(janus_config *jcfg, const char *section, const char *option, bool def) {
+	char *const tmp = _get_value(jcfg, section, option);
+	bool value = def;
+	if (tmp != NULL) {
+		value = (!strcasecmp(tmp, "1") || !strcasecmp(tmp, "true") || !strcasecmp(tmp, "yes"));
+		free(tmp);
+	}
+	return value;
+}

janus/src/config.h

@@ -1 +0,0 @@
-../../src/libs/config.h

janus/src/config.h

@@ -0,0 +1,47 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2022  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <janus/config.h>
+#include <janus/plugins/plugin.h>
+
+#include "uslibs/tools.h"
+
+#include "const.h"
+#include "logging.h"
+
+
+typedef struct {
+	char	*video_sink_name;
+	bool	video_zero_playout_delay;
+
+	char	*audio_dev_name;
+	char	*tc358743_dev_path;
+} us_config_s;
+
+
+us_config_s *us_config_init(const char *config_dir_path);
+void us_config_destroy(us_config_s *config);

janus/src/const.h

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -22,11 +22,5 @@
 
 #pragma once
 
-#define VERSION_MAJOR 4
-#define VERSION_MINOR 7
-
-#define MAKE_VERSION2(_major, _minor) #_major "." #_minor
-#define MAKE_VERSION1(_major, _minor) MAKE_VERSION2(_major, _minor)
-#define VERSION MAKE_VERSION1(VERSION_MAJOR, VERSION_MINOR)
-
-#define VERSION_U ((unsigned)(VERSION_MAJOR * 1000 + VERSION_MINOR))
+#define US_PLUGIN_NAME		"ustreamer"
+#define US_PLUGIN_PACKAGE	"janus.plugin.ustreamer"

janus/src/frame.c

@@ -1 +0,0 @@
-../../src/libs/frame.c

janus/src/frame.h

@@ -1 +0,0 @@
-../../src/libs/frame.h

janus/src/list.h

@@ -1 +0,0 @@
-../../src/libs/list.h

janus/src/logging.h

@@ -0,0 +1,38 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2022  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/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include <janus/plugins/plugin.h>
+
+#include "uslibs/tools.h"
+
+#include "const.h"
+
+
+#define US_JLOG_INFO(x_prefix, x_msg, ...)	JANUS_LOG(LOG_INFO, "== %s/%-9s -- " x_msg "\n", US_PLUGIN_NAME, x_prefix, ##__VA_ARGS__)
+#define US_JLOG_WARN(x_prefix, x_msg, ...)	JANUS_LOG(LOG_WARN, "== %s/%-9s -- " x_msg "\n", US_PLUGIN_NAME, x_prefix, ##__VA_ARGS__)
+#define US_JLOG_ERROR(x_prefix, x_msg, ...)	JANUS_LOG(LOG_ERR, "== %s/%-9s -- " x_msg "\n", US_PLUGIN_NAME, x_prefix, ##__VA_ARGS__)
+
+#define US_JLOG_PERROR(x_prefix, x_msg, ...) { \
+		char *const m_perror_str = us_errno_to_string(errno); \
+		JANUS_LOG(LOG_ERR, "[%s/%-9s] " x_msg ": %s\n", US_PLUGIN_NAME, x_prefix, ##__VA_ARGS__, m_perror_str); \
+		free(m_perror_str); \
+	}

janus/src/memsinkfd.c

@@ -0,0 +1,70 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2022  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/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "memsinkfd.h"
+
+
+int us_memsink_fd_wait_frame(int fd, us_memsink_shared_s* mem, uint64_t last_id) {
+	const long double deadline_ts = us_get_now_monotonic() + 1; // wait_timeout
+	long double now;
+	do {
+		const int result = us_flock_timedwait_monotonic(fd, 1); // lock_timeout
+		now = us_get_now_monotonic();
+		if (result < 0 && errno != EWOULDBLOCK) {
+			US_JLOG_PERROR("video", "Can't lock memsink");
+			return -1;
+		} else if (result == 0) {
+			if (mem->magic == US_MEMSINK_MAGIC && mem->version == US_MEMSINK_VERSION && mem->id != last_id) {
+				return 0;
+			}
+			if (flock(fd, LOCK_UN) < 0) {
+				US_JLOG_PERROR("video", "Can't unlock memsink");
+				return -1;
+			}
+		}
+		usleep(1000); // lock_polling
+	} while (now < deadline_ts);
+	return -2;
+}
+
+us_frame_s *us_memsink_fd_get_frame(int fd, us_memsink_shared_s *mem, uint64_t *frame_id) {
+	us_frame_s *frame = us_frame_init();
+	us_frame_set_data(frame, mem->data, mem->used);
+	US_FRAME_COPY_META(mem, frame);
+	*frame_id = mem->id;
+	mem->last_client_ts = us_get_now_monotonic();
+
+	bool ok = true;
+	if (frame->format != V4L2_PIX_FMT_H264) {
+		US_JLOG_ERROR("video", "Got non-H264 frame from memsink");
+		ok = false;
+	}
+	if (flock(fd, LOCK_UN) < 0) {
+		US_JLOG_PERROR("video", "Can't unlock memsink");
+		ok = false;
+	}
+	if (!ok) {
+		us_frame_destroy(frame);
+		frame = NULL;
+	}
+	return frame;
+}

janus/src/memsinkfd.h

@@ -0,0 +1,38 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2022  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#include <stdint.h>
+#include <unistd.h>
+
+#include <linux/videodev2.h>
+
+#include "uslibs/tools.h"
+#include "uslibs/frame.h"
+#include "uslibs/memsinksh.h"
+
+#include "logging.h"
+
+
+int us_memsink_fd_wait_frame(int fd, us_memsink_shared_s* mem, uint64_t last_id);
+us_frame_s *us_memsink_fd_get_frame(int fd, us_memsink_shared_s *mem, uint64_t *frame_id);

janus/src/memsinksh.h

@@ -1 +0,0 @@
-../../src/libs/memsinksh.h

janus/src/plugin.c

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -24,227 +24,139 @@
 #include <stdbool.h>
 #include <stdatomic.h>
 #include <stdlib.h>
+#include <inttypes.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <assert.h>
 
 #include <sys/mman.h>
 #include <sys/stat.h>
-#include <linux/videodev2.h>
 
 #include <pthread.h>
 #include <jansson.h>
-#include <janus/config.h>
 #include <janus/plugins/plugin.h>
 
-#include "config.h"
-#include "tools.h"
-#include "threading.h"
-#include "list.h"
-#include "memsinksh.h"
+#include "uslibs/const.h"
+#include "uslibs/tools.h"
+#include "uslibs/threading.h"
+#include "uslibs/list.h"
+#include "uslibs/memsinksh.h"
 
+#include "const.h"
+#include "logging.h"
+#include "queue.h"
+#include "client.h"
+#include "audio.h"
+#include "tc358743.h"
 #include "rtp.h"
+#include "rtpv.h"
+#include "rtpa.h"
+#include "memsinkfd.h"
+#include "config.h"
 
 
-static int _plugin_init(janus_callbacks *gw, const char *config_file_path);
-static void _plugin_destroy(void);
+static us_config_s	*_g_config = NULL;
+const useconds_t	_g_watchers_polling = 100000;
 
-static void _plugin_create_session(janus_plugin_session *session, int *error);
-static void _plugin_destroy_session(janus_plugin_session *session, int *error);
-static json_t *_plugin_query_session(janus_plugin_session *session);
+static us_janus_client_s	*_g_clients = NULL;
+static janus_callbacks		*_g_gw = NULL;
+static us_queue_s			*_g_video_queue = NULL;
+static us_rtpv_s			*_g_rtpv = NULL;
+static us_rtpa_s			*_g_rtpa = NULL;
 
-static void _plugin_setup_media(janus_plugin_session *session);
-static void _plugin_hangup_media(janus_plugin_session *session);
+static pthread_t		_g_video_rtp_tid;
+static atomic_bool		_g_video_rtp_tid_created = false;
+static pthread_t		_g_video_sink_tid;
+static atomic_bool		_g_video_sink_tid_created = false;
+static pthread_t		_g_audio_tid;
+static atomic_bool		_g_audio_tid_created = false;
 
-static struct janus_plugin_result *_plugin_handle_message(
-	janus_plugin_session *session, char *transaction, json_t *msg, json_t *jsep);
-
-static int _plugin_get_api_compatibility(void);
-static int _plugin_get_version(void);
-static const char *_plugin_get_version_string(void);
-static const char *_plugin_get_description(void);
-static const char *_plugin_get_name(void);
-static const char *_plugin_get_author(void);
-static const char *_plugin_get_package(void);
+static pthread_mutex_t	_g_video_lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t	_g_audio_lock = PTHREAD_MUTEX_INITIALIZER;
+static atomic_bool		_g_ready = false;
+static atomic_bool		_g_stop = false;
+static atomic_bool		_g_has_watchers = false;
 
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Woverride-init"
-static janus_plugin _plugin = JANUS_PLUGIN_INIT(
-	.init = _plugin_init,
-	.destroy = _plugin_destroy,
+#define _LOCK_VIDEO		US_MUTEX_LOCK(_g_video_lock)
+#define _UNLOCK_VIDEO	US_MUTEX_UNLOCK(_g_video_lock)
 
-	.create_session = _plugin_create_session,
-	.destroy_session = _plugin_destroy_session,
-	.query_session = _plugin_query_session,
+#define _LOCK_AUDIO		US_MUTEX_LOCK(_g_audio_lock)
+#define _UNLOCK_AUDIO	US_MUTEX_UNLOCK(_g_audio_lock)
 
-	.setup_media = _plugin_setup_media,
-	.hangup_media = _plugin_hangup_media,
+#define _LOCK_ALL		{ _LOCK_VIDEO; _LOCK_AUDIO; }
+#define _UNLOCK_ALL		{ _UNLOCK_AUDIO; _UNLOCK_VIDEO; }
 
-	.handle_message = _plugin_handle_message,
-
-	.get_api_compatibility = _plugin_get_api_compatibility,
-	.get_version = _plugin_get_version,
-	.get_version_string = _plugin_get_version_string,
-	.get_description = _plugin_get_description,
-	.get_name = _plugin_get_name,
-	.get_author = _plugin_get_author,
-	.get_package = _plugin_get_package,
-);
-#pragma GCC diagnostic pop
-
-janus_plugin *create(void) { // cppcheck-suppress unusedFunction
-	return &_plugin;
-}
+#define _READY			atomic_load(&_g_ready)
+#define _STOP			atomic_load(&_g_stop)
+#define _HAS_WATCHERS	atomic_load(&_g_has_watchers)
 
 
-typedef struct _client_sx {
-	janus_plugin_session *session;
-	bool transmit;
-
-	LIST_STRUCT(struct _client_sx);
-} _client_s;
+janus_plugin *create(void);
 
 
-static char				*_g_memsink_obj = NULL;
-const long double		_g_wait_timeout = 1;
-const long double		_g_lock_timeout = 1;
-const useconds_t		_g_lock_polling = 1000;
-const useconds_t		_g_watchers_polling = 100000;
-
-static _client_s		*_g_clients = NULL;
-static janus_callbacks	*_g_gw = NULL;
-static rtp_s			*_g_rtp = NULL;
-
-static pthread_t		_g_tid;
-static pthread_mutex_t	_g_lock = PTHREAD_MUTEX_INITIALIZER;
-static atomic_bool		_g_ready = ATOMIC_VAR_INIT(false);
-static atomic_bool		_g_stop = ATOMIC_VAR_INIT(false);
-static atomic_bool		_g_has_watchers = ATOMIC_VAR_INIT(false);
-
-
-#define JLOG_INFO(_msg, ...)	JANUS_LOG(LOG_INFO, "== %s -- " _msg "\n", _plugin_get_name(), ##__VA_ARGS__)
-#define JLOG_WARN(_msg, ...)	JANUS_LOG(LOG_WARN, "== %s -- " _msg "\n", _plugin_get_name(), ##__VA_ARGS__)
-#define JLOG_ERROR(_msg, ...)	JANUS_LOG(LOG_ERR, "== %s -- " _msg "\n", _plugin_get_name(), ##__VA_ARGS__)
-
-#define JLOG_PERROR(_msg, ...) { \
-		char _perror_buf[1024] = {0}; \
-		char *_perror_ptr = errno_to_string(errno, _perror_buf, 1023); \
-		JANUS_LOG(LOG_ERR, "[%s] " _msg ": %s\n", _plugin_get_name(), ##__VA_ARGS__, _perror_ptr); \
+#define _IF_NOT_REPORTED(...) { \
+		const unsigned _error_code = __LINE__; \
+		if (error_reported != _error_code) { __VA_ARGS__; error_reported = _error_code; } \
 	}
 
-#define LOCK			A_MUTEX_LOCK(&_g_lock)
-#define UNLOCK			A_MUTEX_UNLOCK(&_g_lock)
-#define READY			atomic_load(&_g_ready)
-#define STOP			atomic_load(&_g_stop)
-#define HAS_WATCHERS	atomic_load(&_g_has_watchers)
+static void *_video_rtp_thread(UNUSED void *arg) {
+	US_THREAD_RENAME("us_video_rtp");
+	atomic_store(&_g_video_rtp_tid_created, true);
 
-
-static void _relay_rtp_clients(const uint8_t *datagram, size_t size) {
-	janus_plugin_rtp packet = {
-		.video = true,
-		.buffer = (char *)datagram,
-		.length = size,
-	};
-	janus_plugin_rtp_extensions_reset(&packet.extensions);
-	LIST_ITERATE(_g_clients, client, {
-		if (client->transmit) {
-			_g_gw->relay_rtp(client->session, &packet);
+	while (!_STOP) {
+		us_frame_s *frame;
+		if (us_queue_get(_g_video_queue, (void **)&frame, 0.1) == 0) {
+			_LOCK_VIDEO;
+			us_rtpv_wrap(_g_rtpv, frame);
+			_UNLOCK_VIDEO;
+			us_frame_destroy(frame);
 		}
-	});
-}
-
-static int _wait_frame(int fd, memsink_shared_s* mem, uint64_t last_id) {
-	long double deadline_ts = get_now_monotonic() + _g_wait_timeout;
-	long double now;
-	do {
-		int retval = flock_timedwait_monotonic(fd, _g_lock_timeout);
-		now = get_now_monotonic();
-		if (retval < 0 && errno != EWOULDBLOCK) {
-			JLOG_PERROR("Can't lock memsink");
-			return -1;
-		} else if (retval == 0) {
-			if (mem->magic == MEMSINK_MAGIC && mem->version == MEMSINK_VERSION && mem->id != last_id) {
-				return 0;
-			}
-			if (flock(fd, LOCK_UN) < 0) {
-				JLOG_PERROR("Can't unlock memsink");
-				return -1;
-			}
-		}
-		usleep(_g_lock_polling);
-	} while (now < deadline_ts);
-	return -2;
-}
-
-static int _get_frame(int fd, memsink_shared_s *mem, frame_s *frame, uint64_t *frame_id) {
-	frame_set_data(frame, mem->data, mem->used);
-	FRAME_COPY_META(mem, frame);
-	*frame_id = mem->id;
-	mem->last_client_ts = get_now_monotonic();
-	int retval = 0;
-	if (frame->format != V4L2_PIX_FMT_H264) {
-		JLOG_ERROR("Got non-H264 frame from memsink");
-		retval = -1;
 	}
-	if (flock(fd, LOCK_UN) < 0) {
-		JLOG_PERROR("Can't unlock memsink");
-		retval = -1;
-	}
-	return retval;
+	return NULL;
 }
 
-static void *_clients_thread(UNUSED void *arg) {
-	A_THREAD_RENAME("us_clients");
-	atomic_store(&_g_ready, true);
+static void *_video_sink_thread(UNUSED void *arg) {
+	US_THREAD_RENAME("us_video_sink");
+	atomic_store(&_g_video_sink_tid_created, true);
 
-	frame_s *frame = frame_init();
 	uint64_t frame_id = 0;
-
 	unsigned error_reported = 0;
 
-#	define IF_NOT_REPORTED(_error, ...) { \
-			if (error_reported != _error) { __VA_ARGS__; error_reported = _error; } \
-		}
-
-	while (!STOP) {
-		if (!HAS_WATCHERS) {
-			IF_NOT_REPORTED(1, {
-				JLOG_INFO("No active watchers, memsink disconnected");
-			});
+	while (!_STOP) {
+		if (!_HAS_WATCHERS) {
+			_IF_NOT_REPORTED({ US_JLOG_INFO("video", "No active watchers, memsink disconnected"); });
 			usleep(_g_watchers_polling);
 			continue;
 		}
 
 		int fd = -1;
-		memsink_shared_s *mem = NULL;
+		us_memsink_shared_s *mem = NULL;
 
-		if ((fd = shm_open(_g_memsink_obj, O_RDWR, 0)) <= 0) {
-			IF_NOT_REPORTED(2, {
-				JLOG_PERROR("Can't open memsink");
-			});
+		if ((fd = shm_open(_g_config->video_sink_name, O_RDWR, 0)) <= 0) {
+			_IF_NOT_REPORTED({ US_JLOG_PERROR("video", "Can't open memsink"); });
 			goto close_memsink;
 		}
 
-		if ((mem = memsink_shared_map(fd)) == NULL) {
-			IF_NOT_REPORTED(3, {
-				JLOG_PERROR("Can't map memsink");
-			});
+		if ((mem = us_memsink_shared_map(fd)) == NULL) {
+			_IF_NOT_REPORTED({ US_JLOG_PERROR("video", "Can't map memsink"); });
 			goto close_memsink;
 		}
 
 		error_reported = 0;
 
-		JLOG_INFO("Memsink opened; reading frames ...");
-		while (!STOP && HAS_WATCHERS) {
-			int result = _wait_frame(fd, mem, frame_id);
+		US_JLOG_INFO("video", "Memsink opened; reading frames ...");
+		while (!_STOP && _HAS_WATCHERS) {
+			const int result = us_memsink_fd_wait_frame(fd, mem, frame_id);
 			if (result == 0) {
-				if (_get_frame(fd, mem, frame, &frame_id) != 0) {
+				us_frame_s *const frame = us_memsink_fd_get_frame(fd, mem, &frame_id);
+				if (frame == NULL) {
 					goto close_memsink;
 				}
-				LOCK;
-				rtp_wrap_h264(_g_rtp, frame, _relay_rtp_clients);
-				UNLOCK;
+				if (us_queue_put(_g_video_queue, frame, 0) != 0) {
+					_IF_NOT_REPORTED({ US_JLOG_PERROR("video", "Video queue is full"); });
+					us_frame_destroy(frame);
+				}
 			} else if (result == -1) {
 				goto close_memsink;
 			}
@@ -252,55 +164,83 @@ static void *_clients_thread(UNUSED void *arg) {
 
 		close_memsink:
 			if (mem != NULL) {
-				JLOG_INFO("Memsink closed");
-				memsink_shared_unmap(mem);
-				mem = NULL;
+				US_JLOG_INFO("video", "Memsink closed");
+				us_memsink_shared_unmap(mem);
 			}
-			if (fd > 0) {
+			if (fd >= 0) {
 				close(fd);
-				fd = -1;
 			}
 			sleep(1); // error_delay
 	}
-
-#	undef IF_NOT_REPORTED
-
-	frame_destroy(frame);
 	return NULL;
 }
 
-static int _read_config(const char *config_dir_path) {
-	char *config_file_path;
-	janus_config *config = NULL;
+static void *_audio_thread(UNUSED void *arg) {
+	US_THREAD_RENAME("us_audio");
+	atomic_store(&_g_audio_tid_created, true);
+	assert(_g_config->audio_dev_name != NULL);
+	assert(_g_config->tc358743_dev_path != NULL);
 
-	A_ASPRINTF(config_file_path, "%s/%s.jcfg", config_dir_path, _plugin_get_package());
-	JLOG_INFO("Reading config file '%s' ...", config_file_path);
+	unsigned error_reported = 0;
 
-	config = janus_config_parse(config_file_path);
-	if (config == NULL) {
-		JLOG_ERROR("Can't read config");
-		goto error;
-	}
-	janus_config_print(config);
-
-	janus_config_category *config_memsink = janus_config_get_create(config, NULL, janus_config_type_category, "memsink");
-	janus_config_item *config_memsink_obj = janus_config_get(config, config_memsink, janus_config_type_item, "object");
-	if (config_memsink_obj == NULL || config_memsink_obj->value == NULL || config_memsink_obj->value[0] == '\0') {
-		JLOG_ERROR("Missing config value: memsink.object");
-		goto error;
-	}
-	_g_memsink_obj = strdup(config_memsink_obj->value);
-
-	int retval = 0;
-	goto ok;
-	error:
-		retval = -1;
-	ok:
-		if (config) {
-			janus_config_destroy(config);
+	while (!_STOP) {
+		if (!_HAS_WATCHERS) {
+			usleep(_g_watchers_polling);
+			continue;
 		}
-		free(config_file_path);
-		return retval;
+
+		us_tc358743_info_s info = {0};
+		us_audio_s *audio = NULL;
+
+		if (us_tc358743_read_info(_g_config->tc358743_dev_path, &info) < 0) {
+			goto close_audio;
+		}
+		if (!info.has_audio) {
+			_IF_NOT_REPORTED({ US_JLOG_INFO("audio", "No audio presented from the host"); });
+			goto close_audio;
+		}
+		_IF_NOT_REPORTED({ US_JLOG_INFO("audio", "Detected host audio"); });
+		if ((audio = us_audio_init(_g_config->audio_dev_name, info.audio_hz)) == NULL) {
+			goto close_audio;
+		}
+
+		error_reported = 0;
+
+		while (!_STOP && _HAS_WATCHERS) {
+			if (
+				us_tc358743_read_info(_g_config->tc358743_dev_path, &info) < 0
+				|| !info.has_audio
+				|| audio->pcm_hz != info.audio_hz
+			) {
+				goto close_audio;
+			}
+
+			size_t size = US_RTP_DATAGRAM_SIZE - US_RTP_HEADER_SIZE;
+			uint8_t data[size];
+			uint64_t pts;
+			const int result = us_audio_get_encoded(audio, data, &size, &pts);
+			if (result == 0) {
+				_LOCK_AUDIO;
+				us_rtpa_wrap(_g_rtpa, data, size, pts);
+				_UNLOCK_AUDIO;
+			} else if (result == -1) {
+				goto close_audio;
+			}
+		}
+
+		close_audio:
+			US_DELETE(audio, us_audio_destroy);
+			sleep(1); // error_delay
+	}
+	return NULL;
+}
+
+#undef _IF_NOT_REPORTED
+
+static void _relay_rtp_clients(const us_rtp_s *rtp) {
+	US_LIST_ITERATE(_g_clients, client, {
+		us_janus_client_send(client, rtp);
+	});
 }
 
 static int _plugin_init(janus_callbacks *gw, const char *config_dir_path) {
@@ -310,115 +250,117 @@ static int _plugin_init(janus_callbacks *gw, const char *config_dir_path) {
 	// sysctl -w net.core.rmem_max=1000000 
 	// sysctl -w net.core.wmem_max=1000000
 
-	JLOG_INFO("Initializing plugin ...");
-	assert(!READY);
-	assert(!STOP);
-	if (gw == NULL || config_dir_path == NULL || _read_config(config_dir_path) < 0) {
+	US_JLOG_INFO("main", "Initializing plugin ...");
+	if (gw == NULL || config_dir_path == NULL || ((_g_config = us_config_init(config_dir_path)) == NULL)) {
 		return -1;
 	}
 	_g_gw = gw;
-	_g_rtp = rtp_init();
-	A_THREAD_CREATE(&_g_tid, _clients_thread, NULL);
+
+	_g_video_queue = us_queue_init(1024);
+	_g_rtpv = us_rtpv_init(_relay_rtp_clients, _g_config->video_zero_playout_delay);
+	if (_g_config->audio_dev_name != NULL) {
+		_g_rtpa = us_rtpa_init(_relay_rtp_clients);
+		US_THREAD_CREATE(_g_audio_tid, _audio_thread, NULL);
+	}
+	US_THREAD_CREATE(_g_video_rtp_tid, _video_rtp_thread, NULL);
+	US_THREAD_CREATE(_g_video_sink_tid, _video_sink_thread, NULL);
+
+	atomic_store(&_g_ready, true);
 	return 0;
 }
 
 static void _plugin_destroy(void) {
-	JLOG_INFO("Destroying plugin ...");
+	US_JLOG_INFO("main", "Destroying plugin ...");
+
 	atomic_store(&_g_stop, true);
-	if (READY) {
-		A_THREAD_JOIN(_g_tid);
-	}
+#	define JOIN(_tid) { if (atomic_load(&_tid##_created)) { US_THREAD_JOIN(_tid); } }
+	JOIN(_g_video_sink_tid);
+	JOIN(_g_video_rtp_tid);
+	JOIN(_g_audio_tid);
+#	undef JOIN
 
-	LIST_ITERATE(_g_clients, client, {
-		LIST_REMOVE(_g_clients, client);
-		free(client);
+	US_LIST_ITERATE(_g_clients, client, {
+		US_LIST_REMOVE(_g_clients, client);
+		us_janus_client_destroy(client);
 	});
-	_g_clients = NULL;
 
-	rtp_destroy(_g_rtp);
-	_g_rtp = NULL;
+	US_QUEUE_DELETE_WITH_ITEMS(_g_video_queue, us_frame_destroy);
 
-	_g_gw = NULL;
-
-	if (_g_memsink_obj) {
-		free(_g_memsink_obj);
-		_g_memsink_obj = NULL;
-	}
+	US_DELETE(_g_rtpa, us_rtpa_destroy);
+	US_DELETE(_g_rtpv, us_rtpv_destroy);
+	US_DELETE(_g_config, us_config_destroy);
 }
 
-#define IF_DISABLED(...) { if (!READY || STOP) { __VA_ARGS__ } }
+#define _IF_DISABLED(...) { if (!_READY || _STOP) { __VA_ARGS__ } }
 
-static void _plugin_create_session(janus_plugin_session *session, int *error) {
-	IF_DISABLED({ *error = -1; return; });
-	LOCK;
-	JLOG_INFO("Creating session %p ...", session);
-	_client_s *client;
-	A_CALLOC(client, 1);
-	client->session = session;
-	client->transmit = true;
-	LIST_APPEND(_g_clients, client);
+static void _plugin_create_session(janus_plugin_session *session, int *err) {
+	_IF_DISABLED({ *err = -1; return; });
+	_LOCK_ALL;
+	US_JLOG_INFO("main", "Creating session %p ...", session);
+	us_janus_client_s *const client = us_janus_client_init(_g_gw, session, (_g_config->audio_dev_name != NULL));
+	US_LIST_APPEND(_g_clients, client);
 	atomic_store(&_g_has_watchers, true);
-	UNLOCK;
+	_UNLOCK_ALL;
 }
 
-static void _plugin_destroy_session(janus_plugin_session* session, int *error) {
-	IF_DISABLED({ *error = -1; return; });
-	LOCK;
+static void _plugin_destroy_session(janus_plugin_session* session, int *err) {
+	_IF_DISABLED({ *err = -1; return; });
+	_LOCK_ALL;
 	bool found = false;
 	bool has_watchers = false;
-	LIST_ITERATE(_g_clients, client, {
+	US_LIST_ITERATE(_g_clients, client, {
 		if (client->session == session) {
-			JLOG_INFO("Removing session %p ...", session);
-			LIST_REMOVE(_g_clients, client);
-			free(client);
+			US_JLOG_INFO("main", "Removing session %p ...", session);
+			US_LIST_REMOVE(_g_clients, client);
+			us_janus_client_destroy(client);
 			found = true;
 		} else {
-			has_watchers = (has_watchers || client->transmit);
+			has_watchers = (has_watchers || atomic_load(&client->transmit));
 		}
 	});
 	if (!found) {
-		JLOG_WARN("No session %p", session);
-		*error = -2;
+		US_JLOG_WARN("main", "No session %p", session);
+		*err = -2;
 	}
 	atomic_store(&_g_has_watchers, has_watchers);
-	UNLOCK;
+	_UNLOCK_ALL;
 }
 
 static json_t *_plugin_query_session(janus_plugin_session *session) {
-	IF_DISABLED({ return NULL; });
+	_IF_DISABLED({ return NULL; });
 	json_t *info = NULL;
-	LOCK;
-	LIST_ITERATE(_g_clients, client, {
+	_LOCK_ALL;
+	US_LIST_ITERATE(_g_clients, client, {
 		if (client->session == session) {
 			info = json_string("session_found");
 			break;
 		}
 	});
-	UNLOCK;
+	_UNLOCK_ALL;
 	return info;
 }
 
 static void _set_transmit(janus_plugin_session *session, UNUSED const char *msg, bool transmit) {
-	IF_DISABLED({ return; });
-	LOCK;
+	_IF_DISABLED({ return; });
+	_LOCK_ALL;
 	bool found = false;
 	bool has_watchers = false;
-	LIST_ITERATE(_g_clients, client, {
+	US_LIST_ITERATE(_g_clients, client, {
 		if (client->session == session) {
-			client->transmit = transmit;
-			//JLOG_INFO("%s session %p", msg, session);
+			atomic_store(&client->transmit, transmit);
+			// US_JLOG_INFO("main", "%s session %p", msg, session);
 			found = true;
 		}
-		has_watchers = (has_watchers || client->transmit);
+		has_watchers = (has_watchers || atomic_load(&client->transmit));
 	});
 	if (!found) {
-		JLOG_WARN("No session %p", session);
+		US_JLOG_WARN("main", "No session %p", session);
 	}
 	atomic_store(&_g_has_watchers, has_watchers);
-	UNLOCK;
+	_UNLOCK_ALL;
 }
 
-#undef IF_DISABLED
+#undef _IF_DISABLED
 
 static void _plugin_setup_media(janus_plugin_session *session) { _set_transmit(session, "Unmuted", true); }
 static void _plugin_hangup_media(janus_plugin_session *session) { _set_transmit(session, "Muted", false); }
@@ -429,8 +371,8 @@ static struct janus_plugin_result *_plugin_handle_message(
 	assert(transaction != NULL);
 
 #	define FREE_MSG_JSEP { \
-			if (msg) json_decref(msg); \
-			if (jsep) json_decref(jsep); \
+			US_DELETE(msg, json_decref); \
+			US_DELETE(jsep, json_decref); \
 		}
 
 	if (session == NULL || msg == NULL) {
@@ -439,37 +381,37 @@ static struct janus_plugin_result *_plugin_handle_message(
 		return janus_plugin_result_new(JANUS_PLUGIN_ERROR, (msg ? "No session" : "No message"), NULL);
 	}
 
-#	define PUSH_ERROR(_error, _reason) { \
-			/*JLOG_ERROR("Message error in session %p: %s", session, _reason);*/ \
-			json_t *_event = json_object(); \
-			json_object_set_new(_event, "ustreamer", json_string("event")); \
-			json_object_set_new(_event, "error_code", json_integer(_error)); \
-			json_object_set_new(_event, "error", json_string(_reason)); \
-			_g_gw->push_event(session, &_plugin, transaction, _event, NULL); \
-			json_decref(_event); \
+#	define PUSH_ERROR(x_error, x_reason) { \
+			/*US_JLOG_ERROR("main", "Message error in session %p: %s", session, x_reason);*/ \
+			json_t *m_event = json_object(); \
+			json_object_set_new(m_event, "ustreamer", json_string("event")); \
+			json_object_set_new(m_event, "error_code", json_integer(x_error)); \
+			json_object_set_new(m_event, "error", json_string(x_reason)); \
+			_g_gw->push_event(session, create(), transaction, m_event, NULL); \
+			json_decref(m_event); \
 		}
 
-	json_t *request_obj = json_object_get(msg, "request");
+	json_t *const request_obj = json_object_get(msg, "request");
 	if (request_obj == NULL) {
 		PUSH_ERROR(400, "Request missing");
 		goto ok_wait;
 	}
 
-	const char *request_str = json_string_value(request_obj);
-	if (!request_str) {
+	const char *const request_str = json_string_value(request_obj);
+	if (request_str == NULL) {
 		PUSH_ERROR(400, "Request not a string");
 		goto ok_wait;
 	}
-	//JLOG_INFO("Message: %s", request_str);
+	// US_JLOG_INFO("main", "Message: %s", request_str);
 
-#	define PUSH_STATUS(_status, _jsep) { \
-			json_t *_event = json_object(); \
-			json_object_set_new(_event, "ustreamer", json_string("event")); \
-			json_t *_result = json_object(); \
-			json_object_set_new(_result, "status", json_string(_status)); \
-			json_object_set_new(_event, "result", _result); \
-			_g_gw->push_event(session, &_plugin, transaction, _event, _jsep); \
-			json_decref(_event); \
+#	define PUSH_STATUS(x_status, x_jsep) { \
+			json_t *const m_event = json_object(); \
+			json_object_set_new(m_event, "ustreamer", json_string("event")); \
+			json_t *const m_result = json_object(); \
+			json_object_set_new(m_result, "status", json_string(x_status)); \
+			json_object_set_new(m_event, "result", m_result); \
+			_g_gw->push_event(session, create(), transaction, m_event, x_jsep); \
+			json_decref(m_event); \
 		}
 
 	if (!strcmp(request_str, "start")) {
@@ -479,13 +421,26 @@ static struct janus_plugin_result *_plugin_handle_message(
 		PUSH_STATUS("stopped", NULL);
 
 	} else if (!strcmp(request_str, "watch")) {
-		char *sdp = rtp_make_sdp(_g_rtp);
-		if (sdp == NULL) {
-			PUSH_ERROR(503, "Haven't received SPS/PPS from memsink yet");
-			goto ok_wait;
+		char *sdp;
+		{
+			char *const video_sdp = us_rtpv_make_sdp(_g_rtpv);
+			if (video_sdp == NULL) {
+				PUSH_ERROR(503, "Haven't received SPS/PPS from memsink yet");
+				goto ok_wait;
+			}
+			char *const audio_sdp = (_g_rtpa ? us_rtpa_make_sdp(_g_rtpa) : us_strdup(""));
+			US_ASPRINTF(sdp,
+				"v=0" RN
+				"o=- %" PRIu64 " 1 IN IP4 0.0.0.0" RN
+				"s=PiKVM uStreamer" RN
+				"t=0 0" RN
+				"%s%s",
+				us_get_now_id() >> 1, audio_sdp, video_sdp
+			);
+			free(audio_sdp);
+			free(video_sdp);
 		}
-		//JLOG_INFO("SDP generated:\n%s", sdp);
-		json_t *offer_jsep = json_pack("{ssss}", "type", "offer", "sdp", sdp);
+		json_t *const offer_jsep = json_pack("{ssss}", "type", "offer", "sdp", sdp);
 		free(sdp);
 		PUSH_STATUS("started", offer_jsep);
 		json_decref(offer_jsep);
@@ -498,25 +453,52 @@ static struct janus_plugin_result *_plugin_handle_message(
 		FREE_MSG_JSEP;
 		return janus_plugin_result_new(JANUS_PLUGIN_OK_WAIT, NULL, NULL);
 
+#	undef PUSH_STATUS
 #	undef PUSH_ERROR
 #	undef FREE_MSG_JSEP
 }
 
+
+// ***** Plugin *****
+
 static int _plugin_get_api_compatibility(void)		{ return JANUS_PLUGIN_API_VERSION; }
-static int _plugin_get_version(void)				{ return VERSION_U; }
-static const char *_plugin_get_version_string(void)	{ return VERSION; }
-static const char *_plugin_get_description(void)	{ return "Pi-KVM uStreamer Janus plugin for H.264 video"; }
-static const char *_plugin_get_name(void)			{ return "ustreamer"; }
+static int _plugin_get_version(void)				{ return US_VERSION_U; }
+static const char *_plugin_get_version_string(void)	{ return US_VERSION; }
+static const char *_plugin_get_description(void)	{ return "PiKVM uStreamer Janus plugin for H.264 video"; }
+static const char *_plugin_get_name(void)			{ return US_PLUGIN_NAME; }
 static const char *_plugin_get_author(void)			{ return "Maxim Devaev <mdevaev@gmail.com>"; }
-static const char *_plugin_get_package(void)		{ return "janus.plugin.ustreamer"; }
+static const char *_plugin_get_package(void)		{ return US_PLUGIN_PACKAGE; }
 
+static void _plugin_incoming_rtp(UNUSED janus_plugin_session *handle, UNUSED janus_plugin_rtp *packet) {
+	// Just a stub to avoid logging spam about the plugin's purpose
+}
 
-#undef STOP
-#undef READY
-#undef UNLOCK
-#undef LOCK
+janus_plugin *create(void) {
+#	pragma GCC diagnostic push
+#	pragma GCC diagnostic ignored "-Woverride-init"
+	static janus_plugin plugin = JANUS_PLUGIN_INIT(
+		.init = _plugin_init,
+		.destroy = _plugin_destroy,
 
-#undef JLOG_PERROR
-#undef JLOG_ERROR
-#undef JLOG_WARN
-#undef JLOG_INFO
+		.create_session = _plugin_create_session,
+		.destroy_session = _plugin_destroy_session,
+		.query_session = _plugin_query_session,
+
+		.setup_media = _plugin_setup_media,
+		.hangup_media = _plugin_hangup_media,
+
+		.handle_message = _plugin_handle_message,
+
+		.get_api_compatibility = _plugin_get_api_compatibility,
+		.get_version = _plugin_get_version,
+		.get_version_string = _plugin_get_version_string,
+		.get_description = _plugin_get_description,
+		.get_name = _plugin_get_name,
+		.get_author = _plugin_get_author,
+		.get_package = _plugin_get_package,
+
+		.incoming_rtp = _plugin_incoming_rtp,
+	);
+#	pragma GCC diagnostic pop
+	return &plugin;
+}

janus/src/queue.c

@@ -0,0 +1,102 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2022  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/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "queue.h"
+
+
+us_queue_s *us_queue_init(unsigned capacity) {
+	us_queue_s *queue;
+	US_CALLOC(queue, 1);
+	US_CALLOC(queue->items, capacity);
+	queue->capacity = capacity;
+	US_MUTEX_INIT(queue->mutex);
+
+	pthread_condattr_t attrs;
+	assert(!pthread_condattr_init(&attrs));
+	assert(!pthread_condattr_setclock(&attrs, CLOCK_MONOTONIC));
+	assert(!pthread_cond_init(&queue->full_cond, &attrs));
+	assert(!pthread_cond_init(&queue->empty_cond, &attrs));
+	assert(!pthread_condattr_destroy(&attrs));
+	return queue;
+}
+
+void us_queue_destroy(us_queue_s *queue) {
+	US_COND_DESTROY(queue->empty_cond);
+	US_COND_DESTROY(queue->full_cond);
+	US_MUTEX_DESTROY(queue->mutex);
+	free(queue->items);
+	free(queue);
+}
+
+#define _WAIT_OR_UNLOCK(x_var, x_cond) { \
+		struct timespec m_ts; \
+		assert(!clock_gettime(CLOCK_MONOTONIC, &m_ts)); \
+		us_ld_to_timespec(us_timespec_to_ld(&m_ts) + timeout, &m_ts); \
+		while (x_var) { \
+			const int err = pthread_cond_timedwait(&(x_cond), &queue->mutex, &m_ts); \
+			if (err == ETIMEDOUT) { \
+				US_MUTEX_UNLOCK(queue->mutex); \
+				return -1; \
+			} \
+			assert(!err); \
+		} \
+	}
+
+int us_queue_put(us_queue_s *queue, void *item, long double timeout) {
+	US_MUTEX_LOCK(queue->mutex);
+	if (timeout == 0) {
+		if (queue->size == queue->capacity) {
+			US_MUTEX_UNLOCK(queue->mutex);
+			return -1;
+		}
+	} else {
+		_WAIT_OR_UNLOCK(queue->size == queue->capacity, queue->full_cond);
+	}
+	queue->items[queue->in] = item;
+	++queue->size;
+	++queue->in;
+	queue->in %= queue->capacity;
+	US_MUTEX_UNLOCK(queue->mutex);
+	US_COND_BROADCAST(queue->empty_cond);
+	return 0;
+}
+
+int us_queue_get(us_queue_s *queue, void **item, long double timeout) {
+	US_MUTEX_LOCK(queue->mutex);
+	_WAIT_OR_UNLOCK(queue->size == 0, queue->empty_cond);
+	*item = queue->items[queue->out];
+	--queue->size;
+	++queue->out;
+	queue->out %= queue->capacity;
+	US_MUTEX_UNLOCK(queue->mutex);
+	US_COND_BROADCAST(queue->full_cond);
+	return 0;
+}
+
+#undef _WAIT_OR_UNLOCK
+
+int us_queue_get_free(us_queue_s *queue) {
+	US_MUTEX_LOCK(queue->mutex);
+	const unsigned size = queue->size;
+	US_MUTEX_UNLOCK(queue->mutex);
+	return queue->capacity - size;
+}

janus/src/queue.h

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -22,32 +22,47 @@
 
 #pragma once
 
-#include <string.h>
-#include <unistd.h>
+#include <errno.h>
+#include <time.h>
+#include <assert.h>
 
-#include <IL/OMX_Core.h>
-#include <IL/OMX_Component.h>
+#include <pthread.h>
 
-#include "../../../libs/logging.h"
-
-#include "formatters.h"
+#include "uslibs/tools.h"
+#include "uslibs/threading.h"
 
 
-#define OMX_INIT_STRUCTURE(_var) { \
-		memset(&(_var), 0, sizeof(_var)); \
-		(_var).nSize = sizeof(_var); \
-		(_var).nVersion.nVersion = OMX_VERSION; \
-		(_var).nVersion.s.nVersionMajor = OMX_VERSION_MAJOR; \
-		(_var).nVersion.s.nVersionMinor = OMX_VERSION_MINOR; \
-		(_var).nVersion.s.nRevision = OMX_VERSION_REVISION; \
-		(_var).nVersion.s.nStep = OMX_VERSION_STEP; \
+// Based on https://github.com/seifzadeh/c-pthread-queue/blob/master/queue.h
+
+typedef struct {
+	void			**items;
+	unsigned		size;
+	unsigned		capacity;
+	unsigned		in;
+	unsigned		out;
+
+	pthread_mutex_t	mutex;
+	pthread_cond_t	full_cond;
+	pthread_cond_t	empty_cond;
+} us_queue_s;
+
+
+#define US_QUEUE_DELETE_WITH_ITEMS(x_queue, x_free_item) { \
+		if (x_queue) { \
+			while (!us_queue_get_free(x_queue)) { \
+				void *m_ptr; \
+				if (!us_queue_get(x_queue, &m_ptr, 0)) { \
+					US_DELETE(m_ptr, x_free_item); \
+				} \
+			} \
+			us_queue_destroy(x_queue); \
+		} \
 	}
 
 
-int omx_component_enable_port(OMX_HANDLETYPE *comp, OMX_U32 port);
-int omx_component_disable_port(OMX_HANDLETYPE *comp, OMX_U32 port);
+us_queue_s *us_queue_init(unsigned capacity);
+void us_queue_destroy(us_queue_s *queue);
 
-int omx_component_get_portdef(OMX_HANDLETYPE *comp, OMX_PARAM_PORTDEFINITIONTYPE *portdef, OMX_U32 port);
-int omx_component_set_portdef(OMX_HANDLETYPE *comp, OMX_PARAM_PORTDEFINITIONTYPE *portdef);
-
-int omx_component_set_state(OMX_HANDLETYPE *comp, OMX_STATETYPE state);
+int us_queue_put(us_queue_s *queue, void *item, long double timeout);
+int us_queue_get(us_queue_s *queue, void **item, long double timeout);
+int us_queue_get_free(us_queue_s *queue);

janus/src/rtp.c

@@ -1,11 +1,11 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
 #    This source file is partially based on this code:                       #
 #      - https://github.com/catid/kvm/blob/master/kvm_pipeline/src           #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -26,182 +26,33 @@
 #include "rtp.h"
 
 
-#define PAYLOAD 96 // Payload type
-#define PRE 3 // Annex B prefix length
-
-
-void _rtp_process_nalu(rtp_s *rtp, const uint8_t *data, size_t size, uint32_t pts, bool marked, rtp_callback_f callback);
-static void _rtp_write_header(rtp_s *rtp, uint32_t pts, bool marked);
-
-static ssize_t _find_annexb(const uint8_t *data, size_t size);
-
-
-rtp_s *rtp_init(void) {
-	rtp_s *rtp;
-	A_CALLOC(rtp, 1);
-	rtp->ssrc = triple_u32(get_now_monotonic_u64());
-	rtp->sps = frame_init();
-	rtp->pps = frame_init();
-	A_MUTEX_INIT(&rtp->mutex);
+us_rtp_s *us_rtp_init(unsigned payload, bool video, bool zero_playout_delay) {
+	us_rtp_s *rtp;
+	US_CALLOC(rtp, 1);
+	rtp->payload = payload;
+	rtp->video = video;
+	rtp->zero_playout_delay = zero_playout_delay; // See client.c
+	rtp->ssrc = us_triple_u32(us_get_now_monotonic_u64());
 	return rtp;
 }
 
-void rtp_destroy(rtp_s *rtp) {
-	A_MUTEX_DESTROY(&rtp->mutex);
-	frame_destroy(rtp->pps);
-	frame_destroy(rtp->sps);
+us_rtp_s *us_rtp_dup(const us_rtp_s *rtp) {
+	us_rtp_s *new;
+	US_CALLOC(new, 1);
+	memcpy(new, rtp, sizeof(us_rtp_s));
+	return new;
+}
+
+void us_rtp_destroy(us_rtp_s *rtp) {
 	free(rtp);
 }
 
-char *rtp_make_sdp(rtp_s *rtp) {
-	A_MUTEX_LOCK(&rtp->mutex);
-
-	if (rtp->sps->used == 0 || rtp->pps->used == 0) {
-		A_MUTEX_UNLOCK(&rtp->mutex);
-		return NULL;
-	}
-
-	char *sps = NULL;
-	char *pps = NULL;
-	base64_encode(rtp->sps->data, rtp->sps->used, &sps, NULL);
-	base64_encode(rtp->pps->data, rtp->pps->used, &pps, NULL);
-
-	A_MUTEX_UNLOCK(&rtp->mutex);
-
-	// https://tools.ietf.org/html/rfc6184
-	// https://github.com/meetecho/janus-gateway/issues/2443
-	char *sdp;
-	A_ASPRINTF(sdp,
-		"v=0" RN
-		"o=- %" PRIu64 " 1 IN IP4 127.0.0.1" RN
-		"s=Pi-KVM uStreamer" RN
-		"t=0 0" RN
-		"m=video 1 RTP/SAVPF %d" RN
-		"c=IN IP4 0.0.0.0" RN
-		"a=rtpmap:%d H264/90000" RN
-		"a=fmtp:%d profile-level-id=42E01F" RN
-		"a=fmtp:%d packetization-mode=1" RN
-		"a=fmtp:%d sprop-sps=%s" RN
-		"a=fmtp:%d sprop-pps=%s" RN
-		"a=rtcp-fb:%d nack" RN
-		"a=rtcp-fb:%d nack pli" RN
-		"a=rtcp-fb:%d goog-remb" RN
-		"a=sendonly" RN,
-		get_now_id() >> 1, PAYLOAD, PAYLOAD, PAYLOAD, PAYLOAD,
-		PAYLOAD, sps,
-		PAYLOAD, pps,
-		PAYLOAD, PAYLOAD, PAYLOAD
-	);
-
-	free(sps);
-	free(pps);
-	return sdp;
-}
-
-void rtp_wrap_h264(rtp_s *rtp, const frame_s *frame, rtp_callback_f callback) {
-	// There is a complicated logic here but everything works as it should:
-	//   - https://github.com/pikvm/ustreamer/issues/115#issuecomment-893071775
-
-	assert(frame->format == V4L2_PIX_FMT_H264);
-
-	const uint32_t pts = get_now_monotonic_u64() * 9 / 100; // PTS units are in 90 kHz
-	ssize_t last_offset = -PRE;
-
-	while (true) { // Find and iterate by nalus
-		const size_t next_start = last_offset + PRE;
-		ssize_t offset = _find_annexb(frame->data + next_start, frame->used - next_start);
-		if (offset < 0) {
-			break;
-		}
-		offset += next_start;
-
-		if (last_offset >= 0) {
-			const uint8_t *data = frame->data + last_offset + PRE;
-			size_t size = offset - last_offset - PRE;
-			if (data[size - 1] == 0) { // Check for extra 00
-				--size;
-			}
-			_rtp_process_nalu(rtp, data, size, pts, false, callback);
-		}
-
-		last_offset = offset;
-	}
-
-	if (last_offset >= 0) {
-		const uint8_t *data = frame->data + last_offset + PRE;
-		size_t size = frame->used - last_offset - PRE;
-		_rtp_process_nalu(rtp, data, size, pts, true, callback);
-	}
-}
-
-void _rtp_process_nalu(rtp_s *rtp, const uint8_t *data, size_t size, uint32_t pts, bool marked, rtp_callback_f callback) {
-	const unsigned ref_idc = (data[0] >> 5) & 3;
-	const unsigned type = data[0] & 0x1F;
-
-	frame_s *ps = NULL;
-	switch (type) {
-		case 7: ps = rtp->sps; break;
-		case 8: ps = rtp->pps; break;
-	}
-	if (ps) {
-		A_MUTEX_LOCK(&rtp->mutex);
-		frame_set_data(ps, data, size);
-		A_MUTEX_UNLOCK(&rtp->mutex);
-	}
-
-#	define HEADER_SIZE 12
-
-	if (size + HEADER_SIZE <= RTP_DATAGRAM_SIZE) {
-		_rtp_write_header(rtp, pts, marked);
-		memcpy(rtp->datagram + HEADER_SIZE, data, size);
-		callback(rtp->datagram, size + HEADER_SIZE);
-		return;
-	}
-
-	const size_t fu_overhead = HEADER_SIZE + 2; // FU-A overhead
-
-	const uint8_t *src = data + 1;
-	ssize_t remaining = size - 1;
-
-	bool first = true;
-	while (remaining > 0) {
-		ssize_t frag_size = RTP_DATAGRAM_SIZE - fu_overhead;
-		const bool last = (remaining <= frag_size);
-		if (last) {
-			frag_size = remaining;
-		}
-
-		_rtp_write_header(rtp, pts, (marked && last));
-
-		rtp->datagram[HEADER_SIZE] = 28 | (ref_idc << 5);
-
-		uint8_t fu = type;
-		if (first) {
-			fu |= 0x80;
-		}
-		if (last) {
-			fu |= 0x40;
-		}
-		rtp->datagram[HEADER_SIZE + 1] = fu;
-
-		memcpy(rtp->datagram + fu_overhead,	src, frag_size);
-
-		callback(rtp->datagram, fu_overhead + frag_size);
-
-		src += frag_size;
-		remaining -= frag_size;
-		first = false;
-	}
-
-#	undef HEADER_SIZE
-}
-
-static void _rtp_write_header(rtp_s *rtp, uint32_t pts, bool marked) {
+void us_rtp_write_header(us_rtp_s *rtp, uint32_t pts, bool marked) {
 	uint32_t word0 = 0x80000000;
 	if (marked) {
 		word0 |= 1 << 23;
 	}
-	word0 |= (PAYLOAD & 0x7F) << 16;
+	word0 |= (rtp->payload & 0x7F) << 16;
 	word0 |= rtp->seq;
 	++rtp->seq;
 
@@ -211,18 +62,3 @@ static void _rtp_write_header(rtp_s *rtp, uint32_t pts, bool marked) {
 	WRITE_BE_U32(8, rtp->ssrc);
 #	undef WRITE_BE_U32
 }
-
-static ssize_t _find_annexb(const uint8_t *data, size_t size) {
-	// Parses buffer for 00 00 01 start codes
-	if (size >= PRE) {
-		for (size_t index = 0; index <= size - PRE; ++index) {
-			if (data[index] == 0 && data[index + 1] == 0 && data[index + 2] == 1) {
-				return index;
-			}
-		}
-	}
-	return -1;
-}
-
-#undef PRE
-#undef PAYLOAD

janus/src/rtp.h

@@ -1,11 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    This source file is partially based on this code:                       #
-#      - https://github.com/catid/kvm/blob/master/kvm_pipeline/src           #
-#                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -26,44 +23,35 @@
 #pragma once
 
 #include <stdlib.h>
-#include <stdbool.h>
 #include <stdint.h>
-#include <inttypes.h>
-#include <string.h>
-#include <assert.h>
+#include <stdbool.h>
 
 #include <sys/types.h>
-#include <linux/videodev2.h>
 
-#include <pthread.h>
-
-#include "tools.h"
-#include "threading.h"
-#include "frame.h"
-#include "base64.h"
+#include "uslibs/tools.h"
 
 
 // https://stackoverflow.com/questions/47635545/why-webrtc-chose-rtp-max-packet-size-to-1200-bytes
-#define RTP_DATAGRAM_SIZE 1200
+#define US_RTP_DATAGRAM_SIZE	1200
+#define US_RTP_HEADER_SIZE		12
 
 
 typedef struct {
-	uint32_t ssrc;
-	uint16_t seq;
+	unsigned	payload;
+	bool		video;
+	bool		zero_playout_delay;
+	uint32_t	ssrc;
 
-	uint8_t datagram[RTP_DATAGRAM_SIZE];
+	uint16_t	seq;
+	uint8_t		datagram[US_RTP_DATAGRAM_SIZE];
+	size_t		used;
+} us_rtp_s;
 
-	frame_s *sps; // Actually not a frame, just a bytes storage
-	frame_s *pps;
-
-	pthread_mutex_t mutex;
-} rtp_s;
-
-typedef void (*rtp_callback_f)(const uint8_t *datagram, size_t size);
+typedef void (*us_rtp_callback_f)(const us_rtp_s *rtp);
 
 
-rtp_s *rtp_init(void);
-void rtp_destroy(rtp_s *rtp);
+us_rtp_s *us_rtp_init(unsigned payload, bool video, bool zero_playout_delay);
+us_rtp_s *us_rtp_dup(const us_rtp_s *rtp);
+void us_rtp_destroy(us_rtp_s *rtp);
 
-char *rtp_make_sdp(rtp_s *rtp);
-void rtp_wrap_h264(rtp_s *rtp, const frame_s *frame, rtp_callback_f callback);
+void us_rtp_write_header(us_rtp_s *rtp, uint32_t pts, bool marked);

janus/src/rtpa.c

@@ -0,0 +1,66 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2022  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/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "rtpa.h"
+
+
+us_rtpa_s *us_rtpa_init(us_rtp_callback_f callback) {
+	us_rtpa_s *rtpa;
+	US_CALLOC(rtpa, 1);
+	rtpa->rtp = us_rtp_init(111, false, false);
+	rtpa->callback = callback;
+	return rtpa;
+}
+
+void us_rtpa_destroy(us_rtpa_s *rtpa) {
+	us_rtp_destroy(rtpa->rtp);
+	free(rtpa);
+}
+
+char *us_rtpa_make_sdp(us_rtpa_s *rtpa) {
+#	define PAYLOAD rtpa->rtp->payload
+	char *sdp;
+	US_ASPRINTF(sdp,
+		"m=audio 1 RTP/SAVPF %u" RN
+		"c=IN IP4 0.0.0.0" RN
+		"a=rtpmap:%u OPUS/48000/2" RN
+		// "a=fmtp:%u useinbandfec=1" RN
+		"a=rtcp-fb:%u nack" RN
+		"a=rtcp-fb:%u nack pli" RN
+		"a=rtcp-fb:%u goog-remb" RN
+		"a=ssrc:%" PRIu32 " cname:ustreamer" RN
+		"a=sendonly" RN,
+		PAYLOAD, PAYLOAD, PAYLOAD, PAYLOAD, PAYLOAD, // PAYLOAD,
+		rtpa->rtp->ssrc
+	);
+#	undef PAYLOAD
+	return sdp;
+}
+
+void us_rtpa_wrap(us_rtpa_s *rtpa, const uint8_t *data, size_t size, uint32_t pts) {
+    if (size + US_RTP_HEADER_SIZE <= US_RTP_DATAGRAM_SIZE) {
+        us_rtp_write_header(rtpa->rtp, pts, false);
+        memcpy(rtpa->rtp->datagram + US_RTP_HEADER_SIZE, data, size);
+		rtpa->rtp->used = size + US_RTP_HEADER_SIZE;
+        rtpa->callback(rtpa->rtp);
+	}
+}

janus/src/rtpa.h

@@ -0,0 +1,48 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2022  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <inttypes.h>
+
+#include <sys/types.h>
+
+#include "uslibs/tools.h"
+#include "uslibs/threading.h"
+
+#include "rtp.h"
+
+
+typedef struct {
+	us_rtp_s			*rtp;
+	us_rtp_callback_f	callback;
+} us_rtpa_s;
+
+
+us_rtpa_s *us_rtpa_init(us_rtp_callback_f callback);
+void us_rtpa_destroy(us_rtpa_s *rtpa);
+
+char *us_rtpa_make_sdp(us_rtpa_s *rtpa);
+void us_rtpa_wrap(us_rtpa_s *rtpa, const uint8_t *data, size_t size, uint32_t pts);

janus/src/rtpv.c

@@ -0,0 +1,213 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    This source file is partially based on this code:                       #
+#      - https://github.com/catid/kvm/blob/master/kvm_pipeline/src           #
+#                                                                            #
+#    Copyright (C) 2018-2022  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/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "rtpv.h"
+
+
+void _rtpv_process_nalu(us_rtpv_s *rtpv, const uint8_t *data, size_t size, uint32_t pts, bool marked);
+
+static ssize_t _find_annexb(const uint8_t *data, size_t size);
+
+
+us_rtpv_s *us_rtpv_init(us_rtp_callback_f callback, bool zero_playout_delay) {
+	us_rtpv_s *rtpv;
+	US_CALLOC(rtpv, 1);
+	rtpv->rtp = us_rtp_init(96, true, zero_playout_delay);
+	rtpv->callback = callback;
+	rtpv->sps = us_frame_init();
+	rtpv->pps = us_frame_init();
+	US_MUTEX_INIT(rtpv->mutex);
+	return rtpv;
+}
+
+void us_rtpv_destroy(us_rtpv_s *rtpv) {
+	US_MUTEX_DESTROY(rtpv->mutex);
+	us_frame_destroy(rtpv->pps);
+	us_frame_destroy(rtpv->sps);
+	us_rtp_destroy(rtpv->rtp);
+	free(rtpv);
+}
+
+char *us_rtpv_make_sdp(us_rtpv_s *rtpv) {
+	US_MUTEX_LOCK(rtpv->mutex);
+
+	if (rtpv->sps->used == 0 || rtpv->pps->used == 0) {
+		US_MUTEX_UNLOCK(rtpv->mutex);
+		return NULL;
+	}
+
+	char *sps = NULL;
+	char *pps = NULL;
+	us_base64_encode(rtpv->sps->data, rtpv->sps->used, &sps, NULL);
+	us_base64_encode(rtpv->pps->data, rtpv->pps->used, &pps, NULL);
+
+	US_MUTEX_UNLOCK(rtpv->mutex);
+
+#	define PAYLOAD rtpv->rtp->payload
+	// https://tools.ietf.org/html/rfc6184
+	// https://github.com/meetecho/janus-gateway/issues/2443
+	char *sdp;
+	US_ASPRINTF(sdp,
+		"m=video 1 RTP/SAVPF %u" RN
+		"c=IN IP4 0.0.0.0" RN
+		"a=rtpmap:%u H264/90000" RN
+		"a=fmtp:%u profile-level-id=42E01F" RN
+		"a=fmtp:%u packetization-mode=1" RN
+		"a=fmtp:%u sprop-sps=%s" RN
+		"a=fmtp:%u sprop-pps=%s" RN
+		"a=rtcp-fb:%u nack" RN
+		"a=rtcp-fb:%u nack pli" RN
+		"a=rtcp-fb:%u goog-remb" RN
+		"a=ssrc:%" PRIu32 " cname:ustreamer" RN
+		"%s" // playout-delay
+		"a=sendonly" RN,
+		PAYLOAD, PAYLOAD, PAYLOAD, PAYLOAD,
+		PAYLOAD, sps,
+		PAYLOAD, pps,
+		PAYLOAD, PAYLOAD, PAYLOAD,
+		rtpv->rtp->ssrc,
+		(rtpv->rtp->zero_playout_delay ? "a=extmap:1 http://www.webrtc.org/experiments/rtp-hdrext/playout-delay" RN : "")
+	);
+#	undef PAYLOAD
+
+	free(sps);
+	free(pps);
+	return sdp;
+}
+
+#define _PRE 3 // Annex B prefix length
+
+void us_rtpv_wrap(us_rtpv_s *rtpv, const us_frame_s *frame) {
+	// There is a complicated logic here but everything works as it should:
+	//   - https://github.com/pikvm/ustreamer/issues/115#issuecomment-893071775
+
+	assert(frame->format == V4L2_PIX_FMT_H264);
+
+	const uint32_t pts = us_get_now_monotonic_u64() * 9 / 100; // PTS units are in 90 kHz
+	ssize_t last_offset = -_PRE;
+
+	while (true) { // Find and iterate by nalus
+		const size_t next_start = last_offset + _PRE;
+		ssize_t offset = _find_annexb(frame->data + next_start, frame->used - next_start);
+		if (offset < 0) {
+			break;
+		}
+		offset += next_start;
+
+		if (last_offset >= 0) {
+			const uint8_t *const data = frame->data + last_offset + _PRE;
+			size_t size = offset - last_offset - _PRE;
+			if (data[size - 1] == 0) { // Check for extra 00
+				--size;
+			}
+			_rtpv_process_nalu(rtpv, data, size, pts, false);
+		}
+
+		last_offset = offset;
+	}
+
+	if (last_offset >= 0) {
+		const uint8_t *const data = frame->data + last_offset + _PRE;
+		size_t size = frame->used - last_offset - _PRE;
+		_rtpv_process_nalu(rtpv, data, size, pts, true);
+	}
+}
+
+void _rtpv_process_nalu(us_rtpv_s *rtpv, const uint8_t *data, size_t size, uint32_t pts, bool marked) {
+	const unsigned ref_idc = (data[0] >> 5) & 3;
+	const unsigned type = data[0] & 0x1F;
+
+	us_frame_s *ps = NULL;
+	switch (type) {
+		case 7: ps = rtpv->sps; break;
+		case 8: ps = rtpv->pps; break;
+	}
+	if (ps != NULL) {
+		US_MUTEX_LOCK(rtpv->mutex);
+		us_frame_set_data(ps, data, size);
+		US_MUTEX_UNLOCK(rtpv->mutex);
+	}
+
+#	define DG rtpv->rtp->datagram
+
+	if (size + US_RTP_HEADER_SIZE <= US_RTP_DATAGRAM_SIZE) {
+		us_rtp_write_header(rtpv->rtp, pts, marked);
+		memcpy(DG + US_RTP_HEADER_SIZE, data, size);
+		rtpv->rtp->used = size + US_RTP_HEADER_SIZE;
+		rtpv->callback(rtpv->rtp);
+		return;
+	}
+
+	const size_t fu_overhead = US_RTP_HEADER_SIZE + 2; // FU-A overhead
+
+	const uint8_t *src = data + 1;
+	ssize_t remaining = size - 1;
+
+	bool first = true;
+	while (remaining > 0) {
+		ssize_t frag_size = US_RTP_DATAGRAM_SIZE - fu_overhead;
+		const bool last = (remaining <= frag_size);
+		if (last) {
+			frag_size = remaining;
+		}
+
+		us_rtp_write_header(rtpv->rtp, pts, (marked && last));
+
+		DG[US_RTP_HEADER_SIZE] = 28 | (ref_idc << 5);
+
+		uint8_t fu = type;
+		if (first) {
+			fu |= 0x80;
+		}
+		if (last) {
+			fu |= 0x40;
+		}
+		DG[US_RTP_HEADER_SIZE + 1] = fu;
+
+		memcpy(DG + fu_overhead, src, frag_size);
+		rtpv->rtp->used = fu_overhead + frag_size;
+		rtpv->callback(rtpv->rtp);
+
+		src += frag_size;
+		remaining -= frag_size;
+		first = false;
+	}
+
+#	undef DG
+}
+
+static ssize_t _find_annexb(const uint8_t *data, size_t size) {
+	// Parses buffer for 00 00 01 start codes
+	if (size >= _PRE) {
+		for (size_t index = 0; index <= size - _PRE; ++index) {
+			if (data[index] == 0 && data[index + 1] == 0 && data[index + 2] == 1) {
+				return index;
+			}
+		}
+	}
+	return -1;
+}
+
+#undef _PRE

janus/src/rtpv.h

@@ -0,0 +1,57 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2022  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <inttypes.h>
+#include <assert.h>
+
+#include <sys/types.h>
+#include <linux/videodev2.h>
+
+#include <pthread.h>
+
+#include "uslibs/tools.h"
+#include "uslibs/threading.h"
+#include "uslibs/frame.h"
+#include "uslibs/base64.h"
+
+#include "rtp.h"
+
+
+typedef struct {
+	us_rtp_s			*rtp;
+	us_rtp_callback_f	callback;
+	us_frame_s			*sps; // Actually not a frame, just a bytes storage
+	us_frame_s			*pps;
+	pthread_mutex_t		mutex;
+} us_rtpv_s;
+
+
+us_rtpv_s *us_rtpv_init(us_rtp_callback_f callback, bool zero_playout_delay);
+void us_rtpv_destroy(us_rtpv_s *rtpv);
+
+char *us_rtpv_make_sdp(us_rtpv_s *rtpv);
+void us_rtpv_wrap(us_rtpv_s *rtpv, const us_frame_s *frame);

janus/src/tc358743.c

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -20,36 +20,45 @@
 *****************************************************************************/
 
 
-#include "vcos.h"
+#include "tc358743.h"
 
 
-int vcos_my_semwait(const char *prefix, VCOS_SEMAPHORE_T *sem, long double timeout) {
-	// vcos_semaphore_wait() can wait infinite
-	// vcos_semaphore_wait_timeout() is broken by design:
-	//   - https://github.com/pikvm/ustreamer/issues/56
-	//   - https://github.com/raspberrypi/userland/issues/658
-	//   - The current approach is an ugly busyloop
-	// Три стула.
+#ifndef V4L2_CID_USER_TC358743_BASE
+#	define V4L2_CID_USER_TC358743_BASE (V4L2_CID_USER_BASE + 0x1080)
+#endif
+#ifndef TC358743_CID_AUDIO_PRESENT
+#	define TC358743_CID_AUDIO_PRESENT (V4L2_CID_USER_TC358743_BASE + 1)
+#endif
+#ifndef TC358743_CID_AUDIO_SAMPLING_RATE
+#	define TC358743_CID_AUDIO_SAMPLING_RATE (V4L2_CID_USER_TC358743_BASE + 0)
+#endif
 
-	long double deadline_ts = get_now_monotonic() + timeout;
-	VCOS_STATUS_T sem_status;
 
-	while (true) {
-		sem_status = vcos_semaphore_trywait(sem);
-		if (sem_status == VCOS_SUCCESS) {
-			return 0;
-		} else if (sem_status != VCOS_EAGAIN || get_now_monotonic() > deadline_ts) {
-			break;
-		}
-		if (usleep(1000) < 0) {
-			break;
-		}
+int us_tc358743_read_info(const char *path, us_tc358743_info_s *info) {
+	US_MEMSET_ZERO(*info);
+
+	int fd = -1;
+	if ((fd = open(path, O_RDWR)) < 0) {
+		US_JLOG_PERROR("audio", "Can't open TC358743 V4L2 device");
+		return -1;
 	}
 
-	switch (sem_status) {
-		case VCOS_EAGAIN: LOG_ERROR("%sCan't wait VCOS semaphore: EAGAIN (timeout)", prefix); break;
-		case VCOS_EINVAL: LOG_ERROR("%sCan't wait VCOS semaphore: EINVAL", prefix); break;
-		default: LOG_ERROR("%sCan't wait VCOS semaphore: %d", prefix, sem_status); break;
-	}
-	return -1;
+#	define READ_CID(x_cid, x_field) { \
+			struct v4l2_control m_ctl = {0}; \
+			m_ctl.id = x_cid; \
+			if (us_xioctl(fd, VIDIOC_G_CTRL, &m_ctl) < 0) { \
+				US_JLOG_PERROR("audio", "Can't get value of " #x_cid); \
+				close(fd); \
+				return -1; \
+			} \
+			info->x_field = m_ctl.value; \
+		}
+
+	READ_CID(TC358743_CID_AUDIO_PRESENT,		has_audio);
+	READ_CID(TC358743_CID_AUDIO_SAMPLING_RATE,	audio_hz);
+
+#	undef READ_CID
+
+	close(fd);
+	return 0;
 }

janus/src/tc358743.h

@@ -0,0 +1,46 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2022  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdbool.h>
+
+#include <sys/types.h>
+
+#include <linux/videodev2.h>
+#include <linux/v4l2-controls.h>
+
+#include "uslibs/tools.h"
+#include "uslibs/xioctl.h"
+
+#include "logging.h"
+
+
+typedef struct {
+	bool		has_audio;
+	unsigned	audio_hz;
+} us_tc358743_info_s;
+
+
+int us_tc358743_read_info(const char *path, us_tc358743_info_s *info);

janus/src/threading.h

@@ -1 +0,0 @@
-../../src/libs/threading.h

janus/src/tools.h

@@ -1 +0,0 @@
-../../src/libs/tools.h

janus/src/uslibs/array.h

@@ -0,0 +1 @@
+../../../src/libs/array.h

janus/src/uslibs/base64.c

@@ -0,0 +1 @@
+../../../src/libs/base64.c

janus/src/uslibs/base64.h

@@ -0,0 +1 @@
+../../../src/libs/base64.h

janus/src/uslibs/const.h

@@ -0,0 +1 @@
+../../../src/libs/const.h

janus/src/uslibs/frame.c

@@ -0,0 +1 @@
+../../../src/libs/frame.c

janus/src/uslibs/frame.h

@@ -0,0 +1 @@
+../../../src/libs/frame.h

janus/src/uslibs/list.h

@@ -0,0 +1 @@
+../../../src/libs/list.h

janus/src/uslibs/memsinksh.h

@@ -0,0 +1 @@
+../../../src/libs/memsinksh.h

janus/src/uslibs/threading.h

@@ -0,0 +1 @@
+../../../src/libs/threading.h

janus/src/uslibs/tools.h

@@ -0,0 +1 @@
+../../../src/libs/tools.h

janus/src/uslibs/xioctl.h

@@ -0,0 +1 @@
+../../../src/libs/xioctl.h

linters/cppcheck.h

@@ -1,4 +1,6 @@
 #define CHAR_BIT 8
-#define WITH_OMX
 #define WITH_GPIO
 #define JANUS_PLUGIN_INIT(...) { __VA_ARGS__ }
+#define EVTHREAD_USE_PTHREADS_IMPLEMENTED 1
+#define CLOCK_MONOTONIC_RAW 1
+#define CLOCK_MONOTONIC_FAST 1

linters/pylint.ini

@@ -15,15 +15,8 @@ disable =
 	locally-disabled,
 	fixme,
 	missing-docstring,
-	no-init,
-	no-self-use,
 	superfluous-parens,
-	abstract-class-not-used,
-	abstract-class-little-used,
 	duplicate-code,
-	bad-continuation,
-	bad-whitespace,
-	star-args,
 	broad-except,
 	redundant-keyword-arg,
 	wrong-import-order,
@@ -39,9 +32,6 @@ msg-template = {symbol} -- {path}:{line}({obj}): {msg}
 max-line-length = 160
 
 [BASIC]
-# List of builtins function names that should not be used, separated by a comma
-bad-functions =
-
 # Good variable names which should always be accepted, separated by a comma
 good-names = _, __, x, y, ws, make-html-h, make-jpeg-h
 

linters/tox.ini

@@ -3,14 +3,15 @@ envlist = cppcheck, flake8, pylint, mypy, vulture, htmlhint
 skipsdist = true
 
 [testenv]
-basepython = python3.9
+basepython = python3.10
 changedir = /src
 
 [testenv:cppcheck]
 whitelist_externals = cppcheck
 commands = cppcheck \
+			-j4 \
 			--force \
-			--std=c11 \
+			--std=c17 \
 			--error-exitcode=1 \
 			--quiet \
 			--enable=warning,unusedFunction,portability,performance,style \
@@ -19,7 +20,7 @@ commands = cppcheck \
 			--inline-suppr \
 			--library=python \
 			--include=linters/cppcheck.h \
-		src python/ustreamer.c janus/rtp.h janus/rtp.c janus/plugin.c
+		src python/*.? janus/*.?
 
 [testenv:flake8]
 whitelist_externals = bash

man/ustreamer-dump.1

@@ -1,6 +1,6 @@
 .\" Manpage for ustreamer-dump.
 .\" Open an issue or pull request to https://github.com/pikvm/ustreamer to correct errors or typos
-.TH USTREAMER-DUMP 1 "version 4.7" "January 2021"
+.TH USTREAMER-DUMP 1 "version 5.19" "January 2021"
 
 .SH NAME
 ustreamer-dump \- Dump uStreamer's memory sink to file

man/ustreamer.1

@@ -1,16 +1,16 @@
 .\" Manpage for ustreamer.
 .\" Open an issue or pull request to https://github.com/pikvm/ustreamer to correct errors or typos
-.TH USTREAMER 1 "version 4.7" "November 2020"
+.TH USTREAMER 1 "version 5.19" "November 2020"
 
 .SH NAME
-ustreamer \- stream MJPG video from any V4L2 device to the network
+ustreamer \- stream MJPEG video from any V4L2 device to the network
 
 .SH SYNOPSIS
 .B ustreamer
 .RI [OPTIONS]
 
 .SH DESCRIPTION
-µStreamer (\fBustreamer\fP) is a lightweight and very quick server to stream MJPG video from any V4L2 device to the network. All new browsers have native support of this video format, as well as most video players such as mplayer, VLC etc. µStreamer is a part of the Pi-KVM project designed to stream VGA and HDMI screencast hardware data with the highest resolution and FPS possible.
+µStreamer (\fBustreamer\fP) is a lightweight and very quick server to stream MJPEG video from any V4L2 device to the network. All new browsers have native support of this video format, as well as most video players such as mplayer, VLC etc. µStreamer is a part of the Pi-KVM project designed to stream VGA and HDMI screencast hardware data with the highest resolution and FPS possible.
 
 .SH USAGE
 Without arguments, \fBustreamer\fR will try to open \fB/dev/video0\fR with 640x480 resolution and start streaming on \fBhttp://127\.0\.0\.1:8080\fR\. You can override this behavior using parameters \fB\-\-device\fR, \fB\-\-host\fR and \fB\-\-port\fR\. For example, to stream to the world, run: \fBustreamer --device=/dev/video1 --host=0.0.0.0 --port=80\fR
@@ -23,9 +23,9 @@ For example, the recommended way of running µStreamer with Auvidea B101 on a Ra
 .RS
 \fB\-\-format=uyvy \e\fR # Device input format
 .nf
-\fB\-\-encoder=omx \e\fR # Hardware encoding with OpenMAX
+\fB\-\-encoder=m2m-image \e\fR # Hardware encoding with V4L2 M2M intraface
 .nf
-\fB\-\-workers=3 \e\fR # Maximum workers for OpenMAX
+\fB\-\-workers=3 \e\fR # Maximum workers for V4L2 encoder
 .nf
 \fB\-\-persistent \e\fR # Don\'t re\-initialize device on timeout (for example when HDMI cable was disconnected)
 .nf
@@ -72,7 +72,7 @@ Drop frames smaller then this limit. Useful if the device produces small\-sized
 Don't re\-initialize device on timeout. Default: disabled.
 .TP
 .BR \-t ", " \-\-dv\-timings
-Enable DV timings querying and events processing to automatic resolution change. Default: disabled.
+Enable DV-timings querying and events processing to automatic resolution change. Default: disabled.
 .TP
 .BR \-b\ \fIN ", " \-\-buffers\ \fIN
 The number of buffers to receive data from the device. Each buffer may processed using an independent thread.
@@ -84,21 +84,23 @@ Default: 1 (the number of CPU cores (but not more than 4)).
 .TP
 .BR \-q\ \fIN ", " \-\-quality\ \fIN
 Set quality of JPEG encoding from 1 to 100 (best). Default: 80.
-Note: If HW encoding is used (JPEG source format selected), this parameter attempts to configure the camera or capture device hardware's internal encoder. It does not re\-encode MJPG to MJPG to change the quality level for sources that already output MJPG.
+Note: If HW encoding is used (JPEG source format selected), this parameter attempts to configure the camera or capture device hardware's internal encoder. It does not re\-encode MJPEG to MJPEG to change the quality level for sources that already output MJPEG.
 .TP
 .BR \-c\ \fItype ", " \-\-encoder\ \fItype
 Use specified encoder. It may affect the number of workers.
 
-CPU ─ Software MJPG encoding (default).
+CPU ─ Software MJPEG encoding (default).
 
-OMX ─ GPU hardware accelerated MJPG encoding with OpenMax (required \fBWITH_OMX\fR feature).
+HW ─ Use pre-encoded MJPEG frames directly from camera hardware.
 
-HW ─ Use pre-encoded MJPG frames directly from camera hardware.
+M2M-VIDEO ─ GPU-accelerated MJPEG encoding.
 
-NOOP ─ Don't compress MJPG stream (do nothing).
+M2M-IMAGE ─ GPU-accelerated JPEG encoding.
+
+NOOP ─ Don't compress MJPEG stream (do nothing).
 .TP
 .BR \-g\ \fIWxH,... ", " \-\-glitched\-resolutions\ \fIWxH,...
-It doesn't do anything. Still here for compatibility. Required \fBWITH_OMX\fR feature.
+It doesn't do anything. Still here for compatibility.
 .TP
 .BR \-k\ \fIpath ", " \-\-blank\ \fIpath
 Path to JPEG file that will be shown when the device is disconnected during the streaming. Default: black screen 640x480 with 'NO SIGNAL'.
@@ -114,6 +116,9 @@ Timeout for device querying. Default: 1.
 .TP
 .BR \-\-device\-error\-delay\ \fIsec
 Delay before trying to connect to the device again after an error (timeout for example). Default: 1.
+.TP
+.BR \-\-m2m\-device\ \fI/dev/path
+Path to V4L2 mem-to-mem encoder device. Default: auto-select.
 
 .SS "Image control options"
 .TP
@@ -167,12 +172,15 @@ Bind to this TCP port. Default: 8080.
 .BR \-U\ \fIpath ", " \-\-unix\ \fIpath
 Bind to UNIX domain socket. Default: disabled.
 .TP
-.BR \-d ", " \-\-unix\-rm
+.BR \-D ", " \-\-unix\-rm
 Try to remove old unix socket file before binding. default: disabled.
 .TP
 .BR \-M\ \fImode ", " \-\-unix\-mode\ \fImode
 Set UNIX socket file permissions (like 777). Default: disabled.
 .TP
+.BR \-S ", " \-\-systemd
+Bind to systemd socket for socket activation. Required \fBWITH_SYSTEMD\fR feature. Default: disabled.
+.TP
 .BR \-\-user\ \fIname
 HTTP basic auth user. Default: disabled.
 .TP
@@ -189,7 +197,7 @@ Don't send identical frames to clients, but no more than specified number. It ca
 Override image resolution for the /state. Default: disabled.
 .TP
 .BR \-\-tcp\-nodelay
-Set TCP_NODELAY flag to the client /stream socket. Ignored for \-\-unix.
+Set TCP_NODELAY flag to the client /stream socket. Only for TCP socket.
 Default: disabled.
 .TP
 .BR \-\-allow\-origin\ \fIstr
@@ -218,10 +226,8 @@ Timeout for lock. Default: 1.
 
 .SS "H264 sink options"
 .TP
-Available only if \fBWITH_OMX\fR feature enabled.
-.TP
 .BR \-\-h264\-sink\ \fIname
-Use the specified shared memory object to sink H264 frames encoded by MMAL. Default: disabled.
+Use the specified shared memory object to sink H264 frames. Default: disabled.
 .TP
 .BR \-\-h264\-sink\-mode\ \fImode
 Set H264 sink permissions (like 777). Default: 660.
@@ -240,12 +246,19 @@ H264 bitrate in Kbps. Default: 5000.
 .TP
 .BR \-\-h264\-gop\ \fIN
 Intarval between keyframes. Default: 30.
+.TP
+.BR \-\-h264\-m2m\-device\ \fI/dev/path
+Path to V4L2 mem-to-mem encoder device. Default: auto-select.
+
 
 .SS "Process options"
 .TP
 .BR \-\-exit\-on\-parent\-death
 Exit the program if the parent process is dead. Required \fBHAS_PDEATHSIG\fR feature. Default: disabled.
 .TP
+.BR \-\-exit\-on\-no\-clients \fIsec
+Exit the program if there have been no stream or sink clients or any HTTP requests in the last N seconds. Default: 0 (disabled).
+.TP
 .BR \-\-process\-name\-prefix\ \fIstr
 Set process name prefix which will be displayed in the process list like '\fIstr: ustreamer \-\-blah\-blah\-blah'\fR. Required \fBWITH_SETPROCTITLE\fR feature. Default: disabled.
 .TP

pkg/arch/PKGBUILD

@@ -3,32 +3,27 @@
 
 
 pkgname=ustreamer
-pkgver=4.7
+pkgver=5.19
 pkgrel=1
-pkgdesc="Lightweight and fast MJPG-HTTP streamer"
+pkgdesc="Lightweight and fast MJPEG-HTTP streamer"
 url="https://github.com/pikvm/ustreamer"
 license=(GPL)
 arch=(i686 x86_64 armv6h armv7h aarch64)
-depends=(libjpeg libevent libbsd libgpiod)
-makedepends=(gcc make)
+depends=(libjpeg libevent libbsd libgpiod systemd)
+makedepends=(gcc make systemd)
 source=(${pkgname}::"git+https://github.com/pikvm/ustreamer#commit=v${pkgver}")
 md5sums=(SKIP)
 
 
-_options="WITH_GPIO=1"
+_options="WITH_GPIO=1 WITH_SYSTEMD=1"
 if [ -e /usr/bin/python3 ]; then
 	_options="$_options WITH_PYTHON=1"
 	depends+=(python)
 	makedepends+=(python-setuptools)
 fi
-if [ -e /opt/vc/include/IL/OMX_Core.h ]; then
-	depends+=(raspberrypi-firmware)
-	makedepends+=(raspberrypi-firmware)
-	_options="$_options WITH_OMX=1"
-fi
 if [ -e /usr/include/janus/plugins/plugin.h ];then
-	depends+=(janus-gateway-pikvm)
-	makedepends+=(janus-gateway-pikvm)
+	depends+=(janus-gateway-pikvm alsa-lib opus)
+	makedepends+=(janus-gateway-pikvm alsa-lib opus)
 	_options="$_options WITH_JANUS=1"
 fi
 

pkg/docker/Dockerfile.arm.cross

@@ -7,13 +7,12 @@ RUN apt-get update \
 		gcc \
 		libjpeg8-dev \
 		libbsd-dev \
-		libraspberrypi-dev \
 		libgpiod-dev \
 	&& rm -rf /var/lib/apt/lists/*
 
 WORKDIR /build/ustreamer/
 COPY . .
-RUN make -j5 WITH_OMX=1 WITH_GPIO=1
+RUN make -j5 WITH_GPIO=1
 RUN ["cross-build-end"]
 
 FROM balenalib/raspberrypi3-debian:run as RUN

pkg/docker/Dockerfile.arm.native

@@ -5,13 +5,12 @@ RUN apt-get update \
 		gcc \
 		libjpeg8-dev \
 		libbsd-dev \
-		libraspberrypi-dev \
 		libgpiod-dev \
 	&& rm -rf /var/lib/apt/lists/*
 
 WORKDIR /build/ustreamer/
 COPY . .
-RUN make -j5 WITH_OMX=1 WITH_GPIO=1
+RUN make -j5 WITH_GPIO=1
 
 FROM balenalib/raspberrypi3-debian:run as RUN
 

pkg/gentoo/ustreamer-9999.ebuild

@@ -5,7 +5,7 @@ EAPI=7
 
 inherit git-r3
 
-DESCRIPTION="uStreamer - Lightweight and fast MJPG-HTTP streamer"
+DESCRIPTION="uStreamer - Lightweight and fast MJPEG-HTTP streamer"
 HOMEPAGE="https://github.com/pikvm/ustreamer"
 EGIT_REPO_URI="https://github.com/pikvm/ustreamer.git"
 

pkg/openwrt/Makefile

@@ -6,7 +6,7 @@
 include $(TOPDIR)/rules.mk
 
 PKG_NAME:=ustreamer
-PKG_VERSION:=4.7
+PKG_VERSION:=5.19
 PKG_RELEASE:=1
 PKG_MAINTAINER:=Maxim Devaev <mdevaev@gmail.com>
 
@@ -30,7 +30,7 @@ define Package/ustreamer
 endef
 
 define Package/ustreamer/description
- µStreamer - Lightweight and fast MJPG-HTTP streamer
+ µStreamer - Lightweight and fast MJPEG-HTTP streamer
 endef
 
 define Package/ustreamer/install

python/setup.py

@@ -1,14 +1,25 @@
 import os
 
-from distutils.core import Extension
-from distutils.core import setup
+from typing import List
+
+from setuptools import Extension
+from setuptools import setup
 
 
 # =====
+def _find_sources(suffix: str) -> List[str]:
+    sources: List[str] = []
+    for (root_path, _, names) in os.walk("src"):
+        for name in names:
+            if name.endswith(suffix):
+                sources.append(os.path.join(root_path, name))
+    return sources
+
+
 if __name__ == "__main__":
     setup(
         name="ustreamer",
-        version="4.7",
+        version="5.19",
         description="uStreamer tools",
         author="Maxim Devaev",
         author_email="mdevaev@gmail.com",
@@ -17,9 +28,10 @@ if __name__ == "__main__":
             Extension(
                 "ustreamer",
                 libraries=["rt", "m", "pthread"],
+                extra_compile_args=["-std=c17", "-D_GNU_SOURCE"],
                 undef_macros=["NDEBUG"],
-                sources=["src/" + name for name in os.listdir("src") if name.endswith(".c")],
-                depends=["src/" + name for name in os.listdir("src") if name.endswith(".h")],
+                sources=_find_sources(".c"),
+                depends=_find_sources(".h"),
             ),
         ],
     )

python/src/frame.c

@@ -1 +0,0 @@
-../../src/libs/frame.c

python/src/frame.h

@@ -1 +0,0 @@
-../../src/libs/frame.h

python/src/memsinksh.h

@@ -1 +0,0 @@
-../../src/libs/memsinksh.h

python/src/tools.h

@@ -1 +0,0 @@
-../../src/libs/tools.h

python/src/uslibs/frame.c

@@ -0,0 +1 @@
+../../../src/libs/frame.c

python/src/uslibs/frame.h

@@ -0,0 +1 @@
+../../../src/libs/frame.h

python/src/uslibs/memsinksh.h

@@ -0,0 +1 @@
+../../../src/libs/memsinksh.h

python/src/uslibs/tools.h

@@ -0,0 +1 @@
+../../../src/libs/tools.h

python/src/ustreamer.c

@@ -13,9 +13,9 @@
 
 #include <Python.h>
 
-#include "tools.h"
-#include "frame.h"
-#include "memsinksh.h"
+#include "uslibs/tools.h"
+#include "uslibs/frame.h"
+#include "uslibs/memsinksh.h"
 
 
 typedef struct {
@@ -27,34 +27,34 @@ typedef struct {
 	double	drop_same_frames;
 
 	int					fd;
-	memsink_shared_s	*mem;
+	us_memsink_shared_s	*mem;
 
-	uint64_t	frame_id;
-	long double	frame_ts;
-	frame_s		*frame;
-} MemsinkObject;
+	uint64_t		frame_id;
+	long double		frame_ts;
+	us_frame_s		*frame;
+} _MemsinkObject;
 
 
-#define MEM(_next)		self->mem->_next
-#define FRAME(_next)	self->frame->_next
+#define _MEM(x_next)	self->mem->x_next
+#define _FRAME(x_next)	self->frame->x_next
 
 
-static void MemsinkObject_destroy_internals(MemsinkObject *self) {
+static void _MemsinkObject_destroy_internals(_MemsinkObject *self) {
 	if (self->mem != NULL) {
-		memsink_shared_unmap(self->mem);
+		us_memsink_shared_unmap(self->mem);
 		self->mem = NULL;
 	}
-	if (self->fd > 0) {
+	if (self->fd >= 0) {
 		close(self->fd);
 		self->fd = -1;
 	}
-	if (self->frame) {
-		frame_destroy(self->frame);
+	if (self->frame != NULL) {
+		us_frame_destroy(self->frame);
 		self->frame = NULL;
 	}
 }
 
-static int MemsinkObject_init(MemsinkObject *self, PyObject *args, PyObject *kwargs) {
+static int _MemsinkObject_init(_MemsinkObject *self, PyObject *args, PyObject *kwargs) {
 	self->lock_timeout = 1;
 	self->wait_timeout = 1;
 
@@ -78,14 +78,14 @@ static int MemsinkObject_init(MemsinkObject *self, PyObject *args, PyObject *kwa
 
 #	undef SET_DOUBLE
 
-	self->frame = frame_init();
+	self->frame = us_frame_init();
 
 	if ((self->fd = shm_open(self->obj, O_RDWR, 0)) == -1) {
 		PyErr_SetFromErrno(PyExc_OSError);
 		goto error;
 	}
 
-	if ((self->mem = memsink_shared_map(self->fd)) == NULL) {
+	if ((self->mem = us_memsink_shared_map(self->fd)) == NULL) {
 		PyErr_SetFromErrno(PyExc_OSError);
 		goto error;
 	}
@@ -93,37 +93,37 @@ static int MemsinkObject_init(MemsinkObject *self, PyObject *args, PyObject *kwa
 	return 0;
 
 	error:
-		MemsinkObject_destroy_internals(self);
+		_MemsinkObject_destroy_internals(self);
 		return -1;
 }
 
-static PyObject *MemsinkObject_repr(MemsinkObject *self) {
+static PyObject *_MemsinkObject_repr(_MemsinkObject *self) {
 	char repr[1024];
 	snprintf(repr, 1023, "<Memsink(%s)>", self->obj);
 	return Py_BuildValue("s", repr);
 }
 
-static void MemsinkObject_dealloc(MemsinkObject *self) {
-	MemsinkObject_destroy_internals(self);
+static void _MemsinkObject_dealloc(_MemsinkObject *self) {
+	_MemsinkObject_destroy_internals(self);
 	PyObject_Del(self);
 }
 
-static PyObject *MemsinkObject_close(MemsinkObject *self, PyObject *Py_UNUSED(ignored)) {
-	MemsinkObject_destroy_internals(self);
+static PyObject *_MemsinkObject_close(_MemsinkObject *self, PyObject *Py_UNUSED(ignored)) {
+	_MemsinkObject_destroy_internals(self);
 	Py_RETURN_NONE;
 }
 
-static PyObject *MemsinkObject_enter(MemsinkObject *self, PyObject *Py_UNUSED(ignored)) {
+static PyObject *_MemsinkObject_enter(_MemsinkObject *self, PyObject *Py_UNUSED(ignored)) {
 	Py_INCREF(self);
 	return (PyObject *)self;
 }
 
-static PyObject *MemsinkObject_exit(MemsinkObject *self, PyObject *Py_UNUSED(ignored)) {
+static PyObject *_MemsinkObject_exit(_MemsinkObject *self, PyObject *Py_UNUSED(ignored)) {
 	return PyObject_CallMethod((PyObject *)self, "close", "");
 }
 
-static int wait_frame(MemsinkObject *self) {
-	long double deadline_ts = get_now_monotonic() + self->wait_timeout;
+static int _wait_frame(_MemsinkObject *self) {
+	const long double deadline_ts = us_get_now_monotonic() + self->wait_timeout;
 
 #	define RETURN_OS_ERROR { \
 			Py_BLOCK_THREADS \
@@ -135,21 +135,21 @@ static int wait_frame(MemsinkObject *self) {
 	do {
 		Py_BEGIN_ALLOW_THREADS
 
-		int retval = flock_timedwait_monotonic(self->fd, self->lock_timeout);
-		now = get_now_monotonic();
+		const int retval = us_flock_timedwait_monotonic(self->fd, self->lock_timeout);
+		now = us_get_now_monotonic();
 
 		if (retval < 0 && errno != EWOULDBLOCK) {
 			RETURN_OS_ERROR;
 
 		} else if (retval == 0) {
-			if (MEM(magic) == MEMSINK_MAGIC && MEM(version) == MEMSINK_VERSION && MEM(id) != self->frame_id) {
+			if (_MEM(magic) == US_MEMSINK_MAGIC && _MEM(version) == US_MEMSINK_VERSION && _MEM(id) != self->frame_id) {
 				if (self->drop_same_frames > 0) {
 					if (
-						FRAME_COMPARE_META_USED_NOTS(self->mem, self->frame)
+						US_FRAME_COMPARE_META_USED_NOTS(self->mem, self->frame)
 						&& (self->frame_ts + self->drop_same_frames > now)
-						&& !memcmp(FRAME(data), MEM(data), MEM(used))
+						&& !memcmp(_FRAME(data), _MEM(data), _MEM(used))
 					) {
-						self->frame_id = MEM(id);
+						self->frame_id = _MEM(id);
 						goto drop;
 					}
 				}
@@ -181,23 +181,23 @@ static int wait_frame(MemsinkObject *self) {
 	return -2;
 }
 
-static PyObject *MemsinkObject_wait_frame(MemsinkObject *self, PyObject *Py_UNUSED(ignored)) {
+static PyObject *_MemsinkObject_wait_frame(_MemsinkObject *self, PyObject *Py_UNUSED(ignored)) {
 	if (self->mem == NULL || self->fd <= 0) {
 		PyErr_SetString(PyExc_RuntimeError, "Closed");
 		return NULL;
 	}
 
-	switch (wait_frame(self)) {
+	switch (_wait_frame(self)) {
 		case 0: break;
 		case -2: Py_RETURN_NONE;
 		default: return NULL;
 	}
 
-	frame_set_data(self->frame, MEM(data), MEM(used));
-	FRAME_COPY_META(self->mem, self->frame);
-	self->frame_id = MEM(id);
-	self->frame_ts = get_now_monotonic();
-	MEM(last_client_ts) = self->frame_ts;
+	us_frame_set_data(self->frame, _MEM(data), _MEM(used));
+	US_FRAME_COPY_META(self->mem, self->frame);
+	self->frame_id = _MEM(id);
+	self->frame_ts = us_get_now_monotonic();
+	_MEM(last_client_ts) = self->frame_ts;
 
 	if (flock(self->fd, LOCK_UN) < 0) {
 		return PyErr_SetFromErrno(PyExc_OSError);
@@ -219,7 +219,7 @@ static PyObject *MemsinkObject_wait_frame(MemsinkObject *self, PyObject *Py_UNUS
 			} \
 			Py_DECREF(_tmp); \
 		}
-#	define SET_NUMBER(_key, _from, _to) SET_VALUE(#_key, Py##_to##_From##_from(FRAME(_key)))
+#	define SET_NUMBER(_key, _from, _to) SET_VALUE(#_key, Py##_to##_From##_from(_FRAME(_key)))
 
 	SET_NUMBER(width, Long, Long);
 	SET_NUMBER(height, Long, Long);
@@ -230,7 +230,7 @@ static PyObject *MemsinkObject_wait_frame(MemsinkObject *self, PyObject *Py_UNUS
 	SET_NUMBER(grab_ts, Double, Float);
 	SET_NUMBER(encode_begin_ts, Double, Float);
 	SET_NUMBER(encode_end_ts, Double, Float);
-	SET_VALUE("data", PyBytes_FromStringAndSize((const char *)FRAME(data), FRAME(used)));
+	SET_VALUE("data", PyBytes_FromStringAndSize((const char *)_FRAME(data), _FRAME(used)));
 
 #	undef SET_NUMBER
 #	undef SET_VALUE
@@ -238,12 +238,12 @@ static PyObject *MemsinkObject_wait_frame(MemsinkObject *self, PyObject *Py_UNUS
 	return dict_frame;
 }
 
-static PyObject *MemsinkObject_is_opened(MemsinkObject *self, PyObject *Py_UNUSED(ignored)) {
+static PyObject *_MemsinkObject_is_opened(_MemsinkObject *self, PyObject *Py_UNUSED(ignored)) {
 	return PyBool_FromLong(self->mem != NULL && self->fd > 0);
 }
 
 #define FIELD_GETTER(_field, _from, _to) \
-	static PyObject *MemsinkObject_getter_##_field(MemsinkObject *self, void *Py_UNUSED(closure)) { \
+	static PyObject *_MemsinkObject_getter_##_field(_MemsinkObject *self, void *Py_UNUSED(closure)) { \
 		return Py##_to##_From##_from(self->_field); \
 	}
 
@@ -254,9 +254,9 @@ FIELD_GETTER(drop_same_frames, Double, Float)
 
 #undef FIELD_GETTER
 
-static PyMethodDef MemsinkObject_methods[] = {
+static PyMethodDef _MemsinkObject_methods[] = {
 #	define ADD_METHOD(_name, _method, _flags) \
-		{.ml_name = _name, .ml_meth = (PyCFunction)MemsinkObject_##_method, .ml_flags = (_flags)}
+		{.ml_name = _name, .ml_meth = (PyCFunction)_MemsinkObject_##_method, .ml_flags = (_flags)}
 	ADD_METHOD("close", close, METH_NOARGS),
 	ADD_METHOD("__enter__", enter, METH_NOARGS),
 	ADD_METHOD("__exit__", exit, METH_VARARGS),
@@ -266,8 +266,8 @@ static PyMethodDef MemsinkObject_methods[] = {
 #	undef ADD_METHOD
 };
 
-static PyGetSetDef MemsinkObject_getsets[] = {
-#	define ADD_GETTER(_field) {.name = #_field, .get = (getter)MemsinkObject_getter_##_field}
+static PyGetSetDef _MemsinkObject_getsets[] = {
+#	define ADD_GETTER(_field) {.name = #_field, .get = (getter)_MemsinkObject_getter_##_field}
 	ADD_GETTER(obj),
 	ADD_GETTER(lock_timeout),
 	ADD_GETTER(wait_timeout),
@@ -276,43 +276,40 @@ static PyGetSetDef MemsinkObject_getsets[] = {
 #	undef ADD_GETTER
 };
 
-static PyTypeObject MemsinkType = {
+static PyTypeObject _MemsinkType = {
 	PyVarObject_HEAD_INIT(NULL, 0)
 	.tp_name		= "ustreamer.Memsink",
-	.tp_basicsize	= sizeof(MemsinkObject),
+	.tp_basicsize	= sizeof(_MemsinkObject),
 	.tp_flags		= Py_TPFLAGS_DEFAULT,
 	.tp_new			= PyType_GenericNew,
-	.tp_init		= (initproc)MemsinkObject_init,
-	.tp_dealloc		= (destructor)MemsinkObject_dealloc,
-	.tp_repr		= (reprfunc)MemsinkObject_repr,
-	.tp_methods		= MemsinkObject_methods,
-	.tp_getset		= MemsinkObject_getsets,
+	.tp_init		= (initproc)_MemsinkObject_init,
+	.tp_dealloc		= (destructor)_MemsinkObject_dealloc,
+	.tp_repr		= (reprfunc)_MemsinkObject_repr,
+	.tp_methods		= _MemsinkObject_methods,
+	.tp_getset		= _MemsinkObject_getsets,
 };
 
-static PyModuleDef ustreamer_Module = {
+static PyModuleDef _Module = {
 	PyModuleDef_HEAD_INIT,
 	.m_name = "ustreamer",
 	.m_size = -1,
 };
 
 PyMODINIT_FUNC PyInit_ustreamer(void) { // cppcheck-suppress unusedFunction
-	PyObject *module = PyModule_Create(&ustreamer_Module);
+	PyObject *module = PyModule_Create(&_Module);
 	if (module == NULL) {
 		return NULL;
 	}
 
-	if (PyType_Ready(&MemsinkType) < 0) {
+	if (PyType_Ready(&_MemsinkType) < 0) {
 		return NULL;
 	}
 
-	Py_INCREF(&MemsinkType);
+	Py_INCREF(&_MemsinkType);
 
-	if (PyModule_AddObject(module, "Memsink", (PyObject *)&MemsinkType) < 0) {
+	if (PyModule_AddObject(module, "Memsink", (PyObject *)&_MemsinkType) < 0) {
 		return NULL;
 	}
 
 	return module;
 }
-
-#undef FRAME
-#undef MEM

src/Makefile

@@ -5,15 +5,12 @@ CC ?= gcc
 CFLAGS ?= -O3
 LDFLAGS ?=
 
-RPI_VC_HEADERS ?= /opt/vc/include
-RPI_VC_LIBS ?= /opt/vc/lib
-
 
 # =====
 _USTR = ustreamer.bin
 _DUMP = ustreamer-dump.bin
 
-_CFLAGS = -MD -c -std=c11 -Wall -Wextra -D_GNU_SOURCE $(CFLAGS)
+_CFLAGS = -MD -c -std=c17 -Wall -Wextra -D_GNU_SOURCE $(CFLAGS)
 _LDFLAGS = $(LDFLAGS)
 
 _COMMON_LIBS = -lm -ljpeg -pthread -lrt
@@ -26,6 +23,7 @@ _USTR_SRCS = $(shell ls \
 	ustreamer/data/*.c \
 	ustreamer/encoders/cpu/*.c \
 	ustreamer/encoders/hw/*.c \
+	ustreamer/h264/*.c \
 )
 
 _DUMP_LIBS = $(_COMMON_LIBS)
@@ -42,16 +40,6 @@ $(filter $(shell echo $(1) | tr A-Z a-z), yes on 1)
 endef
 
 
-ifneq ($(call optbool,$(WITH_OMX)),)
-_USTR_LIBS += -lbcm_host -lvcos -lvcsm -lopenmaxil -lmmal -lmmal_core -lmmal_util -lmmal_vc_client -lmmal_components -L$(RPI_VC_LIBS)
-override _CFLAGS += -DWITH_OMX -DOMX_SKIP64BIT -I$(RPI_VC_HEADERS)
-_USTR_SRCS += $(shell ls \
-	ustreamer/encoders/omx/*.c \
-	ustreamer/h264/*.c \
-)
-endif
-
-
 ifneq ($(call optbool,$(WITH_GPIO)),)
 _USTR_LIBS += -lgpiod
 override _CFLAGS += -DWITH_GPIO
@@ -59,6 +47,13 @@ _USTR_SRCS += $(shell ls ustreamer/gpio/*.c)
 endif
 
 
+ifneq ($(call optbool,$(WITH_SYSTEMD)),)
+_USTR_LIBS += -lsystemd
+override _CFLAGS += -DWITH_SYSTEMD
+_USTR_SRCS += $(shell ls ustreamer/http/systemd/*.c)
+endif
+
+
 WITH_PTHREAD_NP ?= 1
 ifneq ($(call optbool,$(WITH_PTHREAD_NP)),)
 override _CFLAGS += -DWITH_PTHREAD_NP

src/dump/file.c

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -23,17 +23,17 @@
 #include "file.h"
 
 
-output_file_s *output_file_init(const char *path, bool json) {
-	output_file_s *output;
-	A_CALLOC(output, 1);
+us_output_file_s *us_output_file_init(const char *path, bool json) {
+	us_output_file_s *output;
+	US_CALLOC(output, 1);
 
 	if (!strcmp(path, "-")) {
-		LOG_INFO("Using output: <stdout>");
+		US_LOG_INFO("Using output: <stdout>");
 		output->fp = stdout;
 	} else {
-		LOG_INFO("Using output: %s", path);
+		US_LOG_INFO("Using output: %s", path);
 		if ((output->fp = fopen(path, "wb")) == NULL) {
-			LOG_PERROR("Can't open output file");
+			US_LOG_PERROR("Can't open output file");
 			goto error;
 		}
 	}
@@ -42,14 +42,14 @@ output_file_s *output_file_init(const char *path, bool json) {
 	return output;
 
 	error:
-		output_file_destroy(output);
+		us_output_file_destroy(output);
 		return NULL;
 }
 
-void output_file_write(void *v_output, const frame_s *frame) {
-	output_file_s *output = (output_file_s *)v_output;
+void us_output_file_write(void *v_output, const us_frame_s *frame) {
+	us_output_file_s *output = (us_output_file_s *)v_output;
 	if (output->json) {
-		base64_encode(frame->data, frame->used, &output->base64_data, &output->base64_allocated);
+		us_base64_encode(frame->data, frame->used, &output->base64_data, &output->base64_allocated);
 		fprintf(output->fp,
 			"{\"size\": %zu, \"width\": %u, \"height\": %u,"
 			" \"format\": %u, \"stride\": %u, \"online\": %u,"
@@ -65,14 +65,12 @@ void output_file_write(void *v_output, const frame_s *frame) {
 	fflush(output->fp);
 }
 
-void output_file_destroy(void *v_output) {
-	output_file_s *output = (output_file_s *)v_output;
-	if (output->base64_data) {
-		free(output->base64_data);
-	}
+void us_output_file_destroy(void *v_output) {
+	us_output_file_s *output = (us_output_file_s *)v_output;
+	US_DELETE(output->base64_data, free);
 	if (output->fp && output->fp != stdout) {
 		if (fclose(output->fp) < 0) {
-			LOG_PERROR("Can't close output file");
+			US_LOG_PERROR("Can't close output file");
 		}
 	}
 	free(output);

src/dump/file.h

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -41,9 +41,9 @@ typedef struct {
 	FILE		*fp;
 	char		*base64_data;
 	size_t		base64_allocated;
-} output_file_s;
+} us_output_file_s;
 
 
-output_file_s *output_file_init(const char *path, bool json);
-void output_file_write(void *v_output, const frame_s *frame);
-void output_file_destroy(void *v_output);
+us_output_file_s *us_output_file_init(const char *path, bool json);
+void us_output_file_write(void *v_output, const us_frame_s *frame);
+void us_output_file_destroy(void *v_output);

src/dump/main.c

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -31,7 +31,7 @@
 #include <errno.h>
 #include <assert.h>
 
-#include "../libs/config.h"
+#include "../libs/const.h"
 #include "../libs/tools.h"
 #include "../libs/logging.h"
 #include "../libs/frame.h"
@@ -82,12 +82,12 @@ static const struct option _LONG_OPTS[] = {
 };
 
 
-volatile bool global_stop = false;
+volatile bool _g_stop = false;
 
 
 typedef struct {
 	void *v_output;
-	void (*write)(void *v_output, const frame_s *frame);
+	void (*write)(void *v_output, const us_frame_s *frame);
 	void (*destroy)(void *v_output);
 } _output_context_s;
 
@@ -104,8 +104,8 @@ static void _help(FILE *fp);
 
 
 int main(int argc, char *argv[]) {
-	LOGGING_INIT;
-	A_THREAD_RENAME("main");
+	US_LOGGING_INIT;
+	US_THREAD_RENAME("main");
 
 	char *sink_name = NULL;
 	unsigned sink_timeout = 1;
@@ -140,7 +140,7 @@ int main(int argc, char *argv[]) {
 		}
 
 	char short_opts[128];
-	build_short_options(_LONG_OPTS, short_opts, 128);
+	us_build_short_options(_LONG_OPTS, short_opts, 128);
 
 	for (int ch; (ch = getopt_long(argc, argv, short_opts, _LONG_OPTS, NULL)) >= 0;) {
 		switch (ch) {
@@ -151,15 +151,15 @@ int main(int argc, char *argv[]) {
 			case _O_COUNT:			OPT_NUMBER("--count", count, 0, LLONG_MAX, 0);
 			case _O_INTERVAL:		OPT_LDOUBLE("--interval", interval, 0, 60);
 
-			case _O_LOG_LEVEL:			OPT_NUMBER("--log-level", us_log_level, LOG_LEVEL_INFO, LOG_LEVEL_DEBUG, 0);
-			case _O_PERF:				OPT_SET(us_log_level, LOG_LEVEL_PERF);
-			case _O_VERBOSE:			OPT_SET(us_log_level, LOG_LEVEL_VERBOSE);
-			case _O_DEBUG:				OPT_SET(us_log_level, LOG_LEVEL_DEBUG);
-			case _O_FORCE_LOG_COLORS:	OPT_SET(us_log_colored, true);
-			case _O_NO_LOG_COLORS:		OPT_SET(us_log_colored, false);
+			case _O_LOG_LEVEL:			OPT_NUMBER("--log-level", us_g_log_level, US_LOG_LEVEL_INFO, US_LOG_LEVEL_DEBUG, 0);
+			case _O_PERF:				OPT_SET(us_g_log_level, US_LOG_LEVEL_PERF);
+			case _O_VERBOSE:			OPT_SET(us_g_log_level, US_LOG_LEVEL_VERBOSE);
+			case _O_DEBUG:				OPT_SET(us_g_log_level, US_LOG_LEVEL_DEBUG);
+			case _O_FORCE_LOG_COLORS:	OPT_SET(us_g_log_colored, true);
+			case _O_NO_LOG_COLORS:		OPT_SET(us_g_log_colored, false);
 
 			case _O_HELP:		_help(stdout); return 0;
-			case _O_VERSION:	puts(VERSION); return 0;
+			case _O_VERSION:	puts(US_VERSION); return 0;
 
 			case 0:		break;
 			default:	return 1;
@@ -175,19 +175,18 @@ int main(int argc, char *argv[]) {
 		return 1;
 	}
 
-	_output_context_s ctx;
-	MEMSET_ZERO(ctx);
+	_output_context_s ctx = {0};
 
 	if (output_path && output_path[0] != '\0') {
-		if ((ctx.v_output = (void *)output_file_init(output_path, output_json)) == NULL) {
+		if ((ctx.v_output = (void *)us_output_file_init(output_path, output_json)) == NULL) {
 			return 1;
 		}
-		ctx.write = output_file_write;
-		ctx.destroy = output_file_destroy;
+		ctx.write = us_output_file_write;
+		ctx.destroy = us_output_file_destroy;
 	}
 
 	_install_signal_handlers();
-	int retval = abs(_dump_sink(sink_name, sink_timeout, count, interval, &ctx));
+	const int retval = abs(_dump_sink(sink_name, sink_timeout, count, interval, &ctx));
 	if (ctx.v_output && ctx.destroy) {
 		ctx.destroy(ctx.v_output);
 	}
@@ -196,18 +195,14 @@ int main(int argc, char *argv[]) {
 
 
 static void _signal_handler(int signum) {
-	switch (signum) {
-		case SIGTERM:	LOG_INFO_NOLOCK("===== Stopping by SIGTERM ====="); break;
-		case SIGINT:	LOG_INFO_NOLOCK("===== Stopping by SIGINT ====="); break;
-		case SIGPIPE:	LOG_INFO_NOLOCK("===== Stopping by SIGPIPE ====="); break;
-		default:		LOG_INFO_NOLOCK("===== Stopping by %d =====", signum); break;
-	}
-	global_stop = true;
+	char *const name = us_signum_to_string(signum);
+	US_LOG_INFO_NOLOCK("===== Stopping by %s =====", name);
+	free(name);
+	_g_stop = true;
 }
 
 static void _install_signal_handlers(void) {
-	struct sigaction sig_act;
-	MEMSET_ZERO(sig_act);
+	struct sigaction sig_act = {0};
 
 	assert(!sigemptyset(&sig_act.sa_mask));
 	sig_act.sa_handler = _signal_handler;
@@ -215,13 +210,13 @@ static void _install_signal_handlers(void) {
 	assert(!sigaddset(&sig_act.sa_mask, SIGTERM));
 	assert(!sigaddset(&sig_act.sa_mask, SIGPIPE));
 
-	LOG_DEBUG("Installing SIGINT handler ...");
+	US_LOG_DEBUG("Installing SIGINT handler ...");
 	assert(!sigaction(SIGINT, &sig_act, NULL));
 
-	LOG_DEBUG("Installing SIGTERM handler ...");
+	US_LOG_DEBUG("Installing SIGTERM handler ...");
 	assert(!sigaction(SIGTERM, &sig_act, NULL));
 
-	LOG_DEBUG("Installing SIGTERM handler ...");
+	US_LOG_DEBUG("Installing SIGTERM handler ...");
 	assert(!sigaction(SIGPIPE, &sig_act, NULL));
 }
 
@@ -234,12 +229,12 @@ static int _dump_sink(
 		count = -1;
 	}
 
-	useconds_t interval_us = interval * 1000000;
+	const useconds_t interval_us = interval * 1000000;
 
-	frame_s *frame = frame_init();
-	memsink_s *sink = NULL;
+	us_frame_s *frame = us_frame_init();
+	us_memsink_s *sink = NULL;
 
-	if ((sink = memsink_init("input", sink_name, false, 0, false, 0, sink_timeout)) == NULL) {
+	if ((sink = us_memsink_init("input", sink_name, false, 0, false, 0, sink_timeout)) == NULL) {
 		goto error;
 	}
 
@@ -249,32 +244,32 @@ static int _dump_sink(
 
 	long double last_ts = 0;
 
-	while (!global_stop) {
-		int error = memsink_client_get(sink, frame);
+	while (!_g_stop) {
+		int error = us_memsink_client_get(sink, frame);
 		if (error == 0) {
-			const long double now = get_now_monotonic();
-			const long long now_second = floor_ms(now);
+			const long double now = us_get_now_monotonic();
+			const long long now_second = us_floor_ms(now);
 
 			char fourcc_str[8];
-			LOG_VERBOSE("Frame: size=%zu, res=%ux%u, fourcc=%s, stride=%u, online=%d, key=%d, latency=%.3Lf, diff=%.3Lf",
+			US_LOG_VERBOSE("Frame: size=%zu, res=%ux%u, fourcc=%s, stride=%u, online=%d, key=%d, latency=%.3Lf, diff=%.3Lf",
 				frame->used, frame->width, frame->height,
-				fourcc_to_string(frame->format, fourcc_str, 8),
+				us_fourcc_to_string(frame->format, fourcc_str, 8),
 				frame->stride, frame->online, frame->key,
 				now - frame->grab_ts, (last_ts ? now - last_ts : 0));
 			last_ts = now;
 
-			LOG_DEBUG("       grab_ts=%.3Lf, encode_begin_ts=%.3Lf, encode_end_ts=%.3Lf",
+			US_LOG_DEBUG("       grab_ts=%.3Lf, encode_begin_ts=%.3Lf, encode_end_ts=%.3Lf",
 				frame->grab_ts, frame->encode_begin_ts, frame->encode_end_ts);
 
 			if (now_second != fps_second) {
 				fps = fps_accum;
 				fps_accum = 0;
 				fps_second = now_second;
-				LOG_PERF_FPS("A new second has come; captured_fps=%u", fps);
+				US_LOG_PERF_FPS("A new second has come; captured_fps=%u", fps);
 			}
 			fps_accum += 1;
 
-			if (ctx->v_output) {
+			if (ctx->v_output != NULL) {
 				ctx->write(ctx->v_output, frame);
 			}
 
@@ -302,12 +297,10 @@ static int _dump_sink(
 		retval = -1;
 
 	ok:
-		if (sink) {
-			memsink_destroy(sink);
-		}
-		frame_destroy(frame);
+		US_DELETE(sink, us_memsink_destroy);
+		us_frame_destroy(frame);
 
-		LOG_INFO("Bye-bye");
+		US_LOG_INFO("Bye-bye");
 		return retval;
 }
 
@@ -315,8 +308,8 @@ static void _help(FILE *fp) {
 #	define SAY(_msg, ...) fprintf(fp, _msg "\n", ##__VA_ARGS__)
 	SAY("\nuStreamer-dump - Dump uStreamer's memory sink to file");
 	SAY("═════════════════════════════════════════════════════");
-	SAY("Version: %s; license: GPLv3", VERSION);
-	SAY("Copyright (C) 2018-2021 Maxim Devaev <mdevaev@gmail.com>\n");
+	SAY("Version: %s; license: GPLv3", US_VERSION);
+	SAY("Copyright (C) 2018-2022 Maxim Devaev <mdevaev@gmail.com>\n");
 	SAY("Example:");
 	SAY("════════");
 	SAY("    ustreamer-dump --sink test --output - \\");
@@ -334,7 +327,7 @@ static void _help(FILE *fp) {
 	SAY("    --log-level <N>  ──── Verbosity level of messages from 0 (info) to 3 (debug).");
 	SAY("                          Enabling debugging messages can slow down the program.");
 	SAY("                          Available levels: 0 (info), 1 (performance), 2 (verbose), 3 (debug).");
-	SAY("                          Default: %d.\n", us_log_level);
+	SAY("                          Default: %d.\n", us_g_log_level);
 	SAY("    --perf  ───────────── Enable performance messages (same as --log-level=1). Default: disabled.\n");
 	SAY("    --verbose  ────────── Enable verbose messages and lower (same as --log-level=2). Default: disabled.\n");
 	SAY("    --debug  ──────────── Enable debug messages and lower (same as --log-level=3). Default: disabled.\n");

src/libs/array.h

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -22,21 +22,16 @@
 
 #pragma once
 
-#include <stdio.h>
 #include <assert.h>
 
-#include <IL/OMX_IVCommon.h>
-#include <IL/OMX_Core.h>
-#include <IL/OMX_Image.h>
 
-#include "../../../libs/tools.h"
-#include "../../../libs/logging.h"
+#define US_ARRAY_LEN(x_array) (sizeof(x_array) / sizeof((x_array)[0]))
 
-
-#define LOG_ERROR_OMX(_error, _msg, ...) { \
-		LOG_ERROR(_msg ": %s", ##__VA_ARGS__, omx_error_to_string(_error)); \
+#define US_ARRAY_ITERATE(x_array, x_start, x_item_ptr, ...) { \
+		const int m_len = US_ARRAY_LEN(x_array); \
+		assert(x_start <= m_len); \
+		for (int m_index = x_start; m_index < m_len; ++m_index) { \
+			__typeof__((x_array)[0]) *const x_item_ptr = &x_array[m_index]; \
+			__VA_ARGS__ \
+		} \
 	}
-
-
-const char *omx_error_to_string(OMX_ERRORTYPE error);
-const char *omx_state_to_string(OMX_STATETYPE state);

src/libs/base64.c

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -37,11 +37,11 @@ static const char _ENCODING_TABLE[] = {
 static const unsigned _MOD_TABLE[] = {0, 2, 1};
 
 
-void base64_encode(const uint8_t *data, size_t size, char **encoded, size_t *allocated) {
+void us_base64_encode(const uint8_t *data, size_t size, char **encoded, size_t *allocated) {
 	const size_t encoded_size = 4 * ((size + 2) / 3) + 1; // +1 for '\0'
 
 	if (*encoded == NULL || (allocated && *allocated < encoded_size)) {
-		A_REALLOC(*encoded, encoded_size);
+		US_REALLOC(*encoded, encoded_size);
 		if (allocated) {
 			*allocated = encoded_size;
 		}
@@ -54,7 +54,7 @@ void base64_encode(const uint8_t *data, size_t size, char **encoded, size_t *all
 		OCTET(octet_c);
 #		undef OCTET
 
-		unsigned triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;
+		const unsigned triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;
 
 #		define ENCODE(_offset) (*encoded)[encoded_index++] = _ENCODING_TABLE[(triple >> _offset * 6) & 0x3F]
 		ENCODE(3);

src/libs/base64.h

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -31,4 +31,4 @@
 #include "tools.h"
 
 
-void base64_encode(const uint8_t *data, size_t size, char **encoded, size_t *allocated);
+void us_base64_encode(const uint8_t *data, size_t size, char **encoded, size_t *allocated);

src/libs/const.h

@@ -0,0 +1,32 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2022  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#define US_VERSION_MAJOR 5
+#define US_VERSION_MINOR 19
+
+#define US_MAKE_VERSION2(_major, _minor) #_major "." #_minor
+#define US_MAKE_VERSION1(_major, _minor) US_MAKE_VERSION2(_major, _minor)
+#define US_VERSION US_MAKE_VERSION1(US_VERSION_MAJOR, US_VERSION_MINOR)
+
+#define US_VERSION_U ((unsigned)(US_VERSION_MAJOR * 1000 + US_VERSION_MINOR))

src/libs/frame.c

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -23,54 +23,53 @@
 #include "frame.h"
 
 
-frame_s *frame_init(void) {
-	frame_s *frame;
-	A_CALLOC(frame, 1);
-	frame_realloc_data(frame, 512 * 1024);
+us_frame_s *us_frame_init(void) {
+	us_frame_s *frame;
+	US_CALLOC(frame, 1);
+	us_frame_realloc_data(frame, 512 * 1024);
+	frame->dma_fd = -1;
 	return frame;
 }
 
-void frame_destroy(frame_s *frame) {
-	if (frame->data) {
-		free(frame->data);
-	}
+void us_frame_destroy(us_frame_s *frame) {
+	US_DELETE(frame->data, free);
 	free(frame);
 }
 
-void frame_realloc_data(frame_s *frame, size_t size) {
+void us_frame_realloc_data(us_frame_s *frame, size_t size) {
 	if (frame->allocated < size) {
-		A_REALLOC(frame->data, size);
+		US_REALLOC(frame->data, size);
 		frame->allocated = size;
 	}
 }
 
-void frame_set_data(frame_s *frame, const uint8_t *data, size_t size) {
-	frame_realloc_data(frame, size);
+void us_frame_set_data(us_frame_s *frame, const uint8_t *data, size_t size) {
+	us_frame_realloc_data(frame, size);
 	memcpy(frame->data, data, size);
 	frame->used = size;
 }
 
-void frame_append_data(frame_s *frame, const uint8_t *data, size_t size) {
-	size_t new_used = frame->used + size;
-	frame_realloc_data(frame, new_used);
+void us_frame_append_data(us_frame_s *frame, const uint8_t *data, size_t size) {
+	const size_t new_used = frame->used + size;
+	us_frame_realloc_data(frame, new_used);
 	memcpy(frame->data + frame->used, data, size);
 	frame->used = new_used;
 }
 
-void frame_copy(const frame_s *src, frame_s *dest) {
-	frame_set_data(dest, src->data, src->used);
-	FRAME_COPY_META(src, dest);
+void us_frame_copy(const us_frame_s *src, us_frame_s *dest) {
+	us_frame_set_data(dest, src->data, src->used);
+	US_FRAME_COPY_META(src, dest);
 }
 
-bool frame_compare(const frame_s *a, const frame_s *b) {
+bool us_frame_compare(const us_frame_s *a, const us_frame_s *b) {
 	return (
 		a->allocated && b->allocated
-		&& FRAME_COMPARE_META_USED_NOTS(a, b)
+		&& US_FRAME_COMPARE_META_USED_NOTS(a, b)
 		&& !memcmp(a->data, b->data, b->used)
 	);
 }
 
-unsigned frame_get_padding(const frame_s *frame) {
+unsigned us_frame_get_padding(const us_frame_s *frame) {
 	unsigned bytes_per_pixel = 0;
 	switch (frame->format) {
 		case V4L2_PIX_FMT_YUYV:
@@ -80,7 +79,7 @@ unsigned frame_get_padding(const frame_s *frame) {
 		// case V4L2_PIX_FMT_H264:
 		case V4L2_PIX_FMT_MJPEG:
 		case V4L2_PIX_FMT_JPEG: bytes_per_pixel = 0; break;
-		default: assert(0 && "Unknown pixelformat");
+		default: assert(0 && "Unknown format");
 	}
 	if (bytes_per_pixel > 0 && frame->stride > frame->width) {
 		return (frame->stride - frame->width * bytes_per_pixel);
@@ -88,7 +87,7 @@ unsigned frame_get_padding(const frame_s *frame) {
 	return 0;
 }
 
-const char *fourcc_to_string(unsigned format, char *buf, size_t size) {
+const char *us_fourcc_to_string(unsigned format, char *buf, size_t size) {
 	assert(size >= 8);
 	buf[0] = format & 0x7F;
 	buf[1] = (format >> 8) & 0x7F;

src/libs/frame.h

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -35,68 +35,84 @@
 
 
 typedef struct {
-	uint8_t	*data;
-	size_t	used;
-	size_t	allocated;
+	uint8_t		*data;
+	size_t		used;
+	size_t		allocated;
+	int			dma_fd;
 
-	unsigned width;
-	unsigned height;
-	unsigned format;
-	unsigned stride;
+	unsigned	width;
+	unsigned	height;
+	unsigned	format;
+	unsigned	stride;
 	// Stride is a bytesperline in V4L2
 	// https://www.kernel.org/doc/html/v4.14/media/uapi/v4l/pixfmt-v4l2.html
 	// https://medium.com/@oleg.shipitko/what-does-stride-mean-in-image-processing-bba158a72bcd
 
-	bool online;
-	bool key;
+	bool		online;
+	bool		key;
 
 	long double	grab_ts;
 	long double	encode_begin_ts;
 	long double	encode_end_ts;
-} frame_s;
+} us_frame_s;
 
 
-#define FRAME_COPY_META(_src, _dest) { \
-		_dest->width = _src->width; \
-		_dest->height = _src->height; \
-		_dest->format = _src->format; \
-		_dest->stride = _src->stride; \
-		_dest->online = _src->online; \
-		_dest->key = _src->key; \
-		_dest->grab_ts = _src->grab_ts; \
-		_dest->encode_begin_ts = _src->encode_begin_ts; \
-		_dest->encode_end_ts = _src->encode_end_ts; \
+#define US_FRAME_COPY_META(x_src, x_dest) { \
+		x_dest->width = x_src->width; \
+		x_dest->height = x_src->height; \
+		x_dest->format = x_src->format; \
+		x_dest->stride = x_src->stride; \
+		x_dest->online = x_src->online; \
+		x_dest->key = x_src->key; \
+		x_dest->grab_ts = x_src->grab_ts; \
+		x_dest->encode_begin_ts = x_src->encode_begin_ts; \
+		x_dest->encode_end_ts = x_src->encode_end_ts; \
 	}
 
-inline void frame_copy_meta(const frame_s *src, frame_s *dest) {
-	FRAME_COPY_META(src, dest);
+static inline void us_frame_copy_meta(const us_frame_s *src, us_frame_s *dest) {
+	US_FRAME_COPY_META(src, dest);
 }
 
-#define FRAME_COMPARE_META_USED_NOTS(_a, _b) ( \
-		_a->used == _b->used \
-		&& _a->width == _b->width \
-		&& _a->height == _b->height \
-		&& _a->format == _b->format \
-		&& _a->stride == _b->stride \
-		&& _a->online == _b->online \
-		&& _a->key == _b->key \
+#define US_FRAME_COMPARE_META_USED_NOTS(x_a, x_b) ( \
+		x_a->used == x_b->used \
+		&& x_a->width == x_b->width \
+		&& x_a->height == x_b->height \
+		&& x_a->format == x_b->format \
+		&& x_a->stride == x_b->stride \
+		&& x_a->online == x_b->online \
+		&& x_a->key == x_b->key \
 	)
 
 
-frame_s *frame_init(void);
-void frame_destroy(frame_s *frame);
+static inline void us_frame_encoding_begin(const us_frame_s *src, us_frame_s *dest, unsigned format) {
+	assert(src->used > 0);
+	us_frame_copy_meta(src, dest);
+	dest->encode_begin_ts = us_get_now_monotonic();
+	dest->format = format;
+	dest->stride = 0;
+	dest->used = 0;
+}
 
-void frame_realloc_data(frame_s *frame, size_t size);
-void frame_set_data(frame_s *frame, const uint8_t *data, size_t size);
-void frame_append_data(frame_s *frame, const uint8_t *data, size_t size);
+static inline void us_frame_encoding_end(us_frame_s *dest) {
+	assert(dest->used > 0);
+	dest->encode_end_ts = us_get_now_monotonic();
+}
 
-void frame_copy(const frame_s *src, frame_s *dest);
-bool frame_compare(const frame_s *a, const frame_s *b);
 
-unsigned frame_get_padding(const frame_s *frame);
+us_frame_s *us_frame_init(void);
+void us_frame_destroy(us_frame_s *frame);
 
-const char *fourcc_to_string(unsigned format, char *buf, size_t size);
+void us_frame_realloc_data(us_frame_s *frame, size_t size);
+void us_frame_set_data(us_frame_s *frame, const uint8_t *data, size_t size);
+void us_frame_append_data(us_frame_s *frame, const uint8_t *data, size_t size);
 
-inline bool is_jpeg(unsigned format) {
+void us_frame_copy(const us_frame_s *src, us_frame_s *dest);
+bool us_frame_compare(const us_frame_s *a, const us_frame_s *b);
+
+unsigned us_frame_get_padding(const us_frame_s *frame);
+
+const char *us_fourcc_to_string(unsigned format, char *buf, size_t size);
+
+static inline bool us_is_jpeg(unsigned format) {
 	return (format == V4L2_PIX_FMT_JPEG || format == V4L2_PIX_FMT_MJPEG);
 }

src/libs/list.h

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -25,47 +25,47 @@
 #include <assert.h>
 
 
-#define LIST_STRUCT(...) \
+#define US_LIST_STRUCT(...) \
 	__VA_ARGS__ *prev; \
 	__VA_ARGS__ *next;
 
-#define LIST_ITERATE(_first, _item, ...) { \
-		for (__typeof__(_first) _item = _first; _item;) { \
-			__typeof__(_first) _next = _item->next; \
+#define US_LIST_ITERATE(x_first, x_item, ...) { \
+		for (__typeof__(x_first) x_item = x_first; x_item;) { \
+			__typeof__(x_first) m_next = x_item->next; \
 			__VA_ARGS__ \
-			_item = _next; \
+			x_item = m_next; \
 		} \
 	}
 
-#define LIST_APPEND(_first, _item) { \
-		if (_first == NULL) { \
-			_first = _item; \
+#define US_LIST_APPEND(x_first, x_item) { \
+		if (x_first == NULL) { \
+			x_first = x_item; \
 		} else { \
-			__typeof__(_first) _last = _first; \
-			for (; _last->next; _last = _last->next); \
-			_item->prev = _last; \
-			_last->next = _item; \
+			__typeof__(x_first) m_last = x_first; \
+			for (; m_last->next; m_last = m_last->next); \
+			x_item->prev = m_last; \
+			m_last->next = x_item; \
 		} \
 	}
 
-#define LIST_APPEND_C(_first, _item, _count) { \
-		LIST_APPEND(_first, _item); \
-		++(_count); \
+#define US_LIST_APPEND_C(x_first, x_item, x_count) { \
+		US_LIST_APPEND(x_first, x_item); \
+		++(x_count); \
 	}
 
-#define LIST_REMOVE(_first, _item) { \
-		if (_item->prev == NULL) { \
-			_first = _item->next; \
+#define US_LIST_REMOVE(x_first, x_item) { \
+		if (x_item->prev == NULL) { \
+			x_first = x_item->next; \
 		} else { \
-			_item->prev->next = _item->next; \
+			x_item->prev->next = x_item->next; \
 		} \
-		if (_item->next != NULL) { \
-			_item->next->prev = _item->prev; \
+		if (x_item->next != NULL) { \
+			x_item->next->prev = x_item->prev; \
 		} \
 	}
 
-#define LIST_REMOVE_C(_first, _item, _count) { \
-		LIST_REMOVE(_first, _item); \
-		assert((_count) >= 1); \
-		--(_count); \
+#define US_LIST_REMOVE_C(x_first, x_item, x_count) { \
+		US_LIST_REMOVE(x_first, x_item); \
+		assert((x_count) >= 1); \
+		--(x_count); \
 	}

src/libs/logging.c

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -23,8 +23,8 @@
 #include "logging.h"
 
 
-enum log_level_t us_log_level;
+enum us_log_level_t us_g_log_level;
 
-bool us_log_colored;
+bool us_g_log_colored;
 
-pthread_mutex_t us_log_mutex;
+pthread_mutex_t us_g_log_mutex;

src/libs/logging.h

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -37,126 +37,126 @@
 #include "threading.h"
 
 
-enum log_level_t {
-    LOG_LEVEL_INFO,
-    LOG_LEVEL_PERF,
-    LOG_LEVEL_VERBOSE,
-    LOG_LEVEL_DEBUG,
+enum us_log_level_t {
+    US_LOG_LEVEL_INFO,
+    US_LOG_LEVEL_PERF,
+    US_LOG_LEVEL_VERBOSE,
+    US_LOG_LEVEL_DEBUG,
 };
 
 
-extern enum log_level_t us_log_level;
+extern enum us_log_level_t us_g_log_level;
 
-extern bool us_log_colored;
+extern bool us_g_log_colored;
 
-extern pthread_mutex_t us_log_mutex;
+extern pthread_mutex_t us_g_log_mutex;
 
 
-#define LOGGING_INIT { \
-		us_log_level = LOG_LEVEL_INFO; \
-		us_log_colored = isatty(2); \
-		A_MUTEX_INIT(&us_log_mutex); \
+#define US_LOGGING_INIT { \
+		us_g_log_level = US_LOG_LEVEL_INFO; \
+		us_g_log_colored = isatty(2); \
+		US_MUTEX_INIT(us_g_log_mutex); \
 	}
 
-#define LOGGING_DESTROY A_MUTEX_DESTROY(&us_log_mutex)
+#define US_LOGGING_DESTROY	US_MUTEX_DESTROY(us_g_log_mutex)
 
-#define LOGGING_LOCK	A_MUTEX_LOCK(&us_log_mutex)
-#define LOGGING_UNLOCK	A_MUTEX_UNLOCK(&us_log_mutex)
+#define US_LOGGING_LOCK		US_MUTEX_LOCK(us_g_log_mutex)
+#define US_LOGGING_UNLOCK	US_MUTEX_UNLOCK(us_g_log_mutex)
 
 
-#define COLOR_GRAY		"\x1b[30;1m"
-#define COLOR_RED		"\x1b[31;1m"
-#define COLOR_GREEN		"\x1b[32;1m"
-#define COLOR_YELLOW	"\x1b[33;1m"
-#define COLOR_BLUE		"\x1b[34;1m"
-#define COLOR_CYAN		"\x1b[36;1m"
-#define COLOR_RESET		"\x1b[0m"
+#define US_COLOR_GRAY		"\x1b[30;1m"
+#define US_COLOR_RED		"\x1b[31;1m"
+#define US_COLOR_GREEN		"\x1b[32;1m"
+#define US_COLOR_YELLOW		"\x1b[33;1m"
+#define US_COLOR_BLUE		"\x1b[34;1m"
+#define US_COLOR_CYAN		"\x1b[36;1m"
+#define US_COLOR_RESET		"\x1b[0m"
 
 
-#define SEP_INFO(_ch) { \
-		LOGGING_LOCK; \
-		for (int _i = 0; _i < 80; ++_i) { \
-			fputc(_ch, stderr); \
+#define US_SEP_INFO(x_ch) { \
+		US_LOGGING_LOCK; \
+		for (int m_count = 0; m_count < 80; ++m_count) { \
+			fputc((x_ch), stderr); \
 		} \
 		fputc('\n', stderr); \
 		fflush(stderr); \
-		LOGGING_UNLOCK; \
+		US_LOGGING_UNLOCK; \
 	}
 
-#define SEP_DEBUG(_ch) { \
-		if (us_log_level >= LOG_LEVEL_DEBUG) { \
-			SEP_INFO(_ch); \
+#define US_SEP_DEBUG(x_ch) { \
+		if (us_g_log_level >= US_LOG_LEVEL_DEBUG) { \
+			US_SEP_INFO(x_ch); \
 		} \
 	}
 
 
-#define LOG_PRINTF_NOLOCK(_label_color, _label, _msg_color, _msg, ...) { \
-		char _tname_buf[MAX_THREAD_NAME] = {0}; \
-		thread_get_name(_tname_buf); \
-		if (us_log_colored) { \
-			fprintf(stderr, COLOR_GRAY "-- " _label_color _label COLOR_GRAY \
-				" [%.03Lf %9s]" " -- " COLOR_RESET _msg_color _msg COLOR_RESET, \
-				get_now_monotonic(), _tname_buf, ##__VA_ARGS__); \
+#define US_LOG_PRINTF_NOLOCK(x_label_color, x_label, x_msg_color, x_msg, ...) { \
+		char m_tname_buf[US_MAX_THREAD_NAME] = {0}; \
+		us_thread_get_name(m_tname_buf); \
+		if (us_g_log_colored) { \
+			fprintf(stderr, US_COLOR_GRAY "-- " x_label_color x_label US_COLOR_GRAY \
+				" [%.03Lf %9s]" " -- " US_COLOR_RESET x_msg_color x_msg US_COLOR_RESET, \
+				us_get_now_monotonic(), m_tname_buf, ##__VA_ARGS__); \
 		} else { \
-			fprintf(stderr, "-- " _label " [%.03Lf %9s] -- " _msg, \
-				get_now_monotonic(), _tname_buf, ##__VA_ARGS__); \
+			fprintf(stderr, "-- " x_label " [%.03Lf %9s] -- " x_msg, \
+				us_get_now_monotonic(), m_tname_buf, ##__VA_ARGS__); \
 		} \
 		fputc('\n', stderr); \
 		fflush(stderr); \
 	}
 
-#define LOG_PRINTF(_label_color, _label, _msg_color, _msg, ...) { \
-		LOGGING_LOCK; \
-		LOG_PRINTF_NOLOCK(_label_color, _label, _msg_color, _msg, ##__VA_ARGS__); \
-		LOGGING_UNLOCK; \
+#define US_LOG_PRINTF(x_label_color, x_label, x_msg_color, x_msg, ...) { \
+		US_LOGGING_LOCK; \
+		US_LOG_PRINTF_NOLOCK(x_label_color, x_label, x_msg_color, x_msg, ##__VA_ARGS__); \
+		US_LOGGING_UNLOCK; \
 	}
 
-#define LOG_ERROR(_msg, ...) { \
-		LOG_PRINTF(COLOR_RED, "ERROR", COLOR_RED, _msg, ##__VA_ARGS__); \
+#define US_LOG_ERROR(x_msg, ...) { \
+		US_LOG_PRINTF(US_COLOR_RED, "ERROR", US_COLOR_RED, x_msg, ##__VA_ARGS__); \
 	}
 
-#define LOG_PERROR(_msg, ...) { \
-		char _perror_buf[1024] = {0}; \
-		char *_perror_ptr = errno_to_string(errno, _perror_buf, 1024); \
-		LOG_ERROR(_msg ": %s", ##__VA_ARGS__, _perror_ptr); \
+#define US_LOG_PERROR(x_msg, ...) { \
+		char *const m_perror_str = us_errno_to_string(errno); \
+		US_LOG_ERROR(x_msg ": %s", ##__VA_ARGS__, m_perror_str); \
+		free(m_perror_str); \
 	}
 
-#define LOG_INFO(_msg, ...) { \
-		LOG_PRINTF(COLOR_GREEN, "INFO ", "", _msg, ##__VA_ARGS__); \
+#define US_LOG_INFO(x_msg, ...) { \
+		US_LOG_PRINTF(US_COLOR_GREEN, "INFO ", "", x_msg, ##__VA_ARGS__); \
 	}
 
-#define LOG_INFO_NOLOCK(_msg, ...) { \
-		LOG_PRINTF_NOLOCK(COLOR_GREEN, "INFO ", "", _msg, ##__VA_ARGS__); \
+#define US_LOG_INFO_NOLOCK(x_msg, ...) { \
+		US_LOG_PRINTF_NOLOCK(US_COLOR_GREEN, "INFO ", "", x_msg, ##__VA_ARGS__); \
 	}
 
-#define LOG_PERF(_msg, ...) { \
-		if (us_log_level >= LOG_LEVEL_PERF) { \
-			LOG_PRINTF(COLOR_CYAN, "PERF ", COLOR_CYAN, _msg, ##__VA_ARGS__); \
+#define US_LOG_PERF(x_msg, ...) { \
+		if (us_g_log_level >= US_LOG_LEVEL_PERF) { \
+			US_LOG_PRINTF(US_COLOR_CYAN, "PERF ", US_COLOR_CYAN, x_msg, ##__VA_ARGS__); \
 		} \
 	}
 
-#define LOG_PERF_FPS(_msg, ...) { \
-		if (us_log_level >= LOG_LEVEL_PERF) { \
-			LOG_PRINTF(COLOR_YELLOW, "PERF ", COLOR_YELLOW, _msg, ##__VA_ARGS__); \
+#define US_LOG_PERF_FPS(x_msg, ...) { \
+		if (us_g_log_level >= US_LOG_LEVEL_PERF) { \
+			US_LOG_PRINTF(US_COLOR_YELLOW, "PERF ", US_COLOR_YELLOW, x_msg, ##__VA_ARGS__); \
 		} \
 	}
 
-#define LOG_VERBOSE(_msg, ...) { \
-		if (us_log_level >= LOG_LEVEL_VERBOSE) { \
-			LOG_PRINTF(COLOR_BLUE, "VERB ", COLOR_BLUE, _msg, ##__VA_ARGS__); \
+#define US_LOG_VERBOSE(x_msg, ...) { \
+		if (us_g_log_level >= US_LOG_LEVEL_VERBOSE) { \
+			US_LOG_PRINTF(US_COLOR_BLUE, "VERB ", US_COLOR_BLUE, x_msg, ##__VA_ARGS__); \
 		} \
 	}
 
-#define LOG_VERBOSE_PERROR(_msg, ...) { \
-		if (us_log_level >= LOG_LEVEL_VERBOSE) { \
-			char _perror_buf[1024] = {0}; \
-			char *_perror_ptr = errno_to_string(errno, _perror_buf, 1023); \
-			LOG_PRINTF(COLOR_BLUE, "VERB ", COLOR_BLUE, _msg ": %s", ##__VA_ARGS__, _perror_ptr); \
+#define US_LOG_VERBOSE_PERROR(x_msg, ...) { \
+		if (us_g_log_level >= US_LOG_LEVEL_VERBOSE) { \
+			char *m_perror_str = us_errno_to_string(errno); \
+			US_LOG_PRINTF(US_COLOR_BLUE, "VERB ", US_COLOR_BLUE, x_msg ": %s", ##__VA_ARGS__, m_perror_str); \
+			free(m_perror_str); \
 		} \
 	}
 
-#define LOG_DEBUG(_msg, ...) { \
-		if (us_log_level >= LOG_LEVEL_DEBUG) { \
-			LOG_PRINTF(COLOR_GRAY, "DEBUG", COLOR_GRAY, _msg, ##__VA_ARGS__); \
+#define US_LOG_DEBUG(x_msg, ...) { \
+		if (us_g_log_level >= US_LOG_LEVEL_DEBUG) { \
+			US_LOG_PRINTF(US_COLOR_GRAY, "DEBUG", US_COLOR_GRAY, x_msg, ##__VA_ARGS__); \
 		} \
 	}

src/libs/memsink.c

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -23,12 +23,12 @@
 #include "memsink.h"
 
 
-memsink_s *memsink_init(
+us_memsink_s *us_memsink_init(
 	const char *name, const char *obj, bool server,
 	mode_t mode, bool rm, unsigned client_ttl, unsigned timeout) {
 
-	memsink_s *sink;
-	A_CALLOC(sink, 1);
+	us_memsink_s *sink;
+	US_CALLOC(sink, 1);
 	sink->name = name;
 	sink->obj = obj;
 	sink->server = server;
@@ -36,57 +36,56 @@ memsink_s *memsink_init(
 	sink->client_ttl = client_ttl;
 	sink->timeout = timeout;
 	sink->fd = -1;
-	sink->mem = MAP_FAILED;
 	atomic_init(&sink->has_clients, false);
 
-	LOG_INFO("Using %s-sink: %s", name, obj);
+	US_LOG_INFO("Using %s-sink: %s", name, obj);
 
-	mode_t mask = umask(0);
+	const mode_t mask = umask(0);
 	sink->fd = shm_open(sink->obj, (server ? O_RDWR | O_CREAT : O_RDWR), mode);
 	umask(mask);
 	if (sink->fd == -1) {
 		umask(mask);
-		LOG_PERROR("%s-sink: Can't open shared memory", name);
+		US_LOG_PERROR("%s-sink: Can't open shared memory", name);
 		goto error;
 	}
 
-	if (sink->server && ftruncate(sink->fd, sizeof(memsink_shared_s)) < 0) {
-		LOG_PERROR("%s-sink: Can't truncate shared memory", name);
+	if (sink->server && ftruncate(sink->fd, sizeof(us_memsink_shared_s)) < 0) {
+		US_LOG_PERROR("%s-sink: Can't truncate shared memory", name);
 		goto error;
 	}
 
-	if ((sink->mem = memsink_shared_map(sink->fd)) == NULL) {
-		LOG_PERROR("%s-sink: Can't mmap shared memory", name);
+	if ((sink->mem = us_memsink_shared_map(sink->fd)) == NULL) {
+		US_LOG_PERROR("%s-sink: Can't mmap shared memory", name);
 		goto error;
 	}
 
 	return sink;
 
 	error:
-		memsink_destroy(sink);
+		us_memsink_destroy(sink);
 		return NULL;
 }
 
-void memsink_destroy(memsink_s *sink) {
-	if (sink->mem != MAP_FAILED) {
-		if (memsink_shared_unmap(sink->mem) < 0) {
-			LOG_PERROR("%s-sink: Can't unmap shared memory", sink->name);
+void us_memsink_destroy(us_memsink_s *sink) {
+	if (sink->mem != NULL) {
+		if (us_memsink_shared_unmap(sink->mem) < 0) {
+			US_LOG_PERROR("%s-sink: Can't unmap shared memory", sink->name);
 		}
 	}
 	if (sink->fd >= 0) {
 		if (close(sink->fd) < 0) {
-			LOG_PERROR("%s-sink: Can't close shared memory fd", sink->name);
+			US_LOG_PERROR("%s-sink: Can't close shared memory fd", sink->name);
 		}
 		if (sink->rm && shm_unlink(sink->obj) < 0) {
 			if (errno != ENOENT) {
-				LOG_PERROR("%s-sink: Can't remove shared memory", sink->name);
+				US_LOG_PERROR("%s-sink: Can't remove shared memory", sink->name);
 			}
 		}
 	}
 	free(sink);
 }
 
-bool memsink_server_check(memsink_s *sink, const frame_s *frame) {
+bool us_memsink_server_check(us_memsink_s *sink, const us_frame_s *frame) {
 	// Return true (the need to write to memsink) on any of these conditions:
 	//   - EWOULDBLOCK - we have an active client;
 	//   - Incorrect magic or version - need to first write;
@@ -100,97 +99,97 @@ bool memsink_server_check(memsink_s *sink, const frame_s *frame) {
 			atomic_store(&sink->has_clients, true);
 			return true;
 		}
-		LOG_PERROR("%s-sink: Can't lock memory", sink->name);
+		US_LOG_PERROR("%s-sink: Can't lock memory", sink->name);
 		return false;
 	}
 
-	if (sink->mem->magic != MEMSINK_MAGIC || sink->mem->version != MEMSINK_VERSION) {
+	if (sink->mem->magic != US_MEMSINK_MAGIC || sink->mem->version != US_MEMSINK_VERSION) {
 		return true;
 	}
 
-	bool has_clients = (sink->mem->last_client_ts + sink->client_ttl > get_now_monotonic());
+	const bool has_clients = (sink->mem->last_client_ts + sink->client_ttl > us_get_now_monotonic());
 	atomic_store(&sink->has_clients, has_clients);
 
 	if (flock(sink->fd, LOCK_UN) < 0) {
-		LOG_PERROR("%s-sink: Can't unlock memory", sink->name);
+		US_LOG_PERROR("%s-sink: Can't unlock memory", sink->name);
 		return false;
 	}
-	return (has_clients || !FRAME_COMPARE_META_USED_NOTS(sink->mem, frame));;
+	return (has_clients || !US_FRAME_COMPARE_META_USED_NOTS(sink->mem, frame));;
 }
 
-int memsink_server_put(memsink_s *sink, const frame_s *frame) {
+int us_memsink_server_put(us_memsink_s *sink, const us_frame_s *frame) {
 	assert(sink->server);
 
-	const long double now = get_now_monotonic();
+	const long double now = us_get_now_monotonic();
 
-	if (frame->used > MEMSINK_MAX_DATA) {
-		LOG_ERROR("%s-sink: Can't put frame: is too big (%zu > %zu)",
-			sink->name, frame->used, MEMSINK_MAX_DATA);
+	if (frame->used > US_MEMSINK_MAX_DATA) {
+		US_LOG_ERROR("%s-sink: Can't put frame: is too big (%zu > %zu)",
+			sink->name, frame->used, US_MEMSINK_MAX_DATA);
 		return 0; // -2
 	}
 
-	if (flock_timedwait_monotonic(sink->fd, 1) == 0) {
-		LOG_VERBOSE("%s-sink: >>>>> Exposing new frame ...", sink->name);
+	if (us_flock_timedwait_monotonic(sink->fd, 1) == 0) {
+		US_LOG_VERBOSE("%s-sink: >>>>> Exposing new frame ...", sink->name);
 
-		sink->last_id = get_now_id();
+		sink->last_id = us_get_now_id();
 		sink->mem->id = sink->last_id;
 
 		memcpy(sink->mem->data, frame->data, frame->used);
 		sink->mem->used = frame->used;
-		FRAME_COPY_META(frame, sink->mem);
+		US_FRAME_COPY_META(frame, sink->mem);
 
-		sink->mem->magic = MEMSINK_MAGIC;
-		sink->mem->version = MEMSINK_VERSION;
-		atomic_store(&sink->has_clients, (sink->mem->last_client_ts + sink->client_ttl > get_now_monotonic()));
+		sink->mem->magic = US_MEMSINK_MAGIC;
+		sink->mem->version = US_MEMSINK_VERSION;
+		atomic_store(&sink->has_clients, (sink->mem->last_client_ts + sink->client_ttl > us_get_now_monotonic()));
 
 		if (flock(sink->fd, LOCK_UN) < 0) {
-			LOG_PERROR("%s-sink: Can't unlock memory", sink->name);
+			US_LOG_PERROR("%s-sink: Can't unlock memory", sink->name);
 			return -1;
 		}
-		LOG_VERBOSE("%s-sink: Exposed new frame; full exposition time = %.3Lf",
-			sink->name, get_now_monotonic() - now);
+		US_LOG_VERBOSE("%s-sink: Exposed new frame; full exposition time = %.3Lf",
+			sink->name, us_get_now_monotonic() - now);
 
 	} else if (errno == EWOULDBLOCK) {
-		LOG_VERBOSE("%s-sink: ===== Shared memory is busy now; frame skipped", sink->name);
+		US_LOG_VERBOSE("%s-sink: ===== Shared memory is busy now; frame skipped", sink->name);
 
 	} else {
-		LOG_PERROR("%s-sink: Can't lock memory", sink->name);
+		US_LOG_PERROR("%s-sink: Can't lock memory", sink->name);
 		return -1;
 	}
 	return 0;
 }
 
-int memsink_client_get(memsink_s *sink, frame_s *frame) { // cppcheck-suppress unusedFunction
+int us_memsink_client_get(us_memsink_s *sink, us_frame_s *frame) { // cppcheck-suppress unusedFunction
 	assert(!sink->server); // Client only
 
-	if (flock_timedwait_monotonic(sink->fd, sink->timeout) < 0) {
+	if (us_flock_timedwait_monotonic(sink->fd, sink->timeout) < 0) {
 		if (errno == EWOULDBLOCK) {
 			return -2;
 		}
-		LOG_PERROR("%s-sink: Can't lock memory", sink->name);
+		US_LOG_PERROR("%s-sink: Can't lock memory", sink->name);
 		return -1;
 	}
 
 	int retval = -2; // Not updated
-	if (sink->mem->magic == MEMSINK_MAGIC) {
-		if (sink->mem->version != MEMSINK_VERSION) {
-			LOG_ERROR("%s-sink: Protocol version mismatch: sink=%u, required=%u",
-				sink->name, sink->mem->version, MEMSINK_VERSION);
+	if (sink->mem->magic == US_MEMSINK_MAGIC) {
+		if (sink->mem->version != US_MEMSINK_VERSION) {
+			US_LOG_ERROR("%s-sink: Protocol version mismatch: sink=%u, required=%u",
+				sink->name, sink->mem->version, US_MEMSINK_VERSION);
 			retval = -1;
 			goto done;
 		}
 		if (sink->mem->id != sink->last_id) { // When updated
 			sink->last_id = sink->mem->id;
-			frame_set_data(frame, sink->mem->data, sink->mem->used);
-			FRAME_COPY_META(sink->mem, frame);
+			us_frame_set_data(frame, sink->mem->data, sink->mem->used);
+			US_FRAME_COPY_META(sink->mem, frame);
 			retval = 0;
 		}
-		sink->mem->last_client_ts = get_now_monotonic();
+		sink->mem->last_client_ts = us_get_now_monotonic();
 	}
 
 	done:
 		if (flock(sink->fd, LOCK_UN) < 0) {
-			LOG_PERROR("%s-sink: Can't unlock memory", sink->name);
+			US_LOG_PERROR("%s-sink: Can't unlock memory", sink->name);
 			return -1;
 		}
 		return retval;

src/libs/memsink.h

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -42,27 +42,27 @@
 
 
 typedef struct {
-	const char	*name;
-	const char	*obj;
-	bool		server;
-	bool		rm;
-	unsigned	client_ttl; // Only for server
-	unsigned	timeout;
+	const char			*name;
+	const char			*obj;
+	bool				server;
+	bool				rm;
+	unsigned			client_ttl; // Only for server
+	unsigned			timeout;
 
 	int					fd;
-	memsink_shared_s	*mem;
+	us_memsink_shared_s	*mem;
 	uint64_t			last_id;
 	atomic_bool			has_clients; // Only for server
-} memsink_s;
+} us_memsink_s;
 
 
-memsink_s *memsink_init(
+us_memsink_s *us_memsink_init(
 	const char *name, const char *obj, bool server,
 	mode_t mode, bool rm, unsigned client_ttl, unsigned timeout);
 
-void memsink_destroy(memsink_s *sink);
+void us_memsink_destroy(us_memsink_s *sink);
 
-bool memsink_server_check(memsink_s *sink, const frame_s *frame);
-int memsink_server_put(memsink_s *sink, const frame_s *frame);
+bool us_memsink_server_check(us_memsink_s *sink, const us_frame_s *frame);
+int us_memsink_server_put(us_memsink_s *sink, const us_frame_s *frame);
 
-int memsink_client_get(memsink_s *sink, frame_s *frame);
+int us_memsink_client_get(us_memsink_s *sink, us_frame_s *frame);

src/libs/memsinksh.h

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -29,13 +29,13 @@
 #include <sys/mman.h>
 
 
-#define MEMSINK_MAGIC	((uint64_t)0xCAFEBABECAFEBABE)
-#define MEMSINK_VERSION	((uint32_t)2)
+#define US_MEMSINK_MAGIC	((uint64_t)0xCAFEBABECAFEBABE)
+#define US_MEMSINK_VERSION	((uint32_t)2)
 
-#ifndef CFG_MEMSINK_MAX_DATA
-#	define CFG_MEMSINK_MAX_DATA 33554432
+#ifndef US_CFG_MEMSINK_MAX_DATA
+#	define US_CFG_MEMSINK_MAX_DATA 33554432
 #endif
-#define MEMSINK_MAX_DATA ((size_t)(CFG_MEMSINK_MAX_DATA))
+#define US_MEMSINK_MAX_DATA ((size_t)(US_CFG_MEMSINK_MAX_DATA))
 
 
 typedef struct {
@@ -58,14 +58,14 @@ typedef struct {
 
 	long double	last_client_ts;
 
-	uint8_t		data[MEMSINK_MAX_DATA];
-} memsink_shared_s;
+	uint8_t		data[US_MEMSINK_MAX_DATA];
+} us_memsink_shared_s;
 
 
-INLINE memsink_shared_s *memsink_shared_map(int fd) {
-	memsink_shared_s *mem = mmap(
+INLINE us_memsink_shared_s *us_memsink_shared_map(int fd) {
+	us_memsink_shared_s *mem = mmap(
 		NULL,
-		sizeof(memsink_shared_s),
+		sizeof(us_memsink_shared_s),
 		PROT_READ | PROT_WRITE,
 		MAP_SHARED,
 		fd,
@@ -78,7 +78,7 @@ INLINE memsink_shared_s *memsink_shared_map(int fd) {
 	return mem;
 }
 
-INLINE int memsink_shared_unmap(memsink_shared_s *mem) {
+INLINE int us_memsink_shared_unmap(us_memsink_shared_s *mem) {
 	assert(mem != NULL);
-	return munmap(mem, sizeof(memsink_shared_s));
+	return munmap(mem, sizeof(us_memsink_shared_s));
 }

src/libs/options.c

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -23,7 +23,7 @@
 #include "options.h"
 
 
-void build_short_options(const struct option opts[], char *short_opts, size_t size) {
+void us_build_short_options(const struct option opts[], char *short_opts, size_t size) {
 	memset(short_opts, 0, size);
     for (unsigned short_index = 0, opt_index = 0; opts[opt_index].name != NULL; ++opt_index) {
 		assert(short_index < size - 3);

src/libs/options.h

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -30,4 +30,4 @@
 #include <sys/types.h>
 
 
-void build_short_options(const struct option opts[], char *short_opts, size_t size);
+void us_build_short_options(const struct option opts[], char *short_opts, size_t size);

src/libs/process.h

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -72,26 +72,25 @@ extern char **environ;
 
 
 #ifdef HAS_PDEATHSIG
-INLINE int process_track_parent_death(void) {
-	pid_t parent = getppid();
+INLINE int us_process_track_parent_death(void) {
+	const pid_t parent = getppid();
 	int signum = SIGTERM;
 #	if defined(__linux__)
-	int retval = prctl(PR_SET_PDEATHSIG, signum);
+	const int retval = prctl(PR_SET_PDEATHSIG, signum);
 #	elif defined(__FreeBSD__)
-	int retval = procctl(P_PID, 0, PROC_PDEATHSIG_CTL, &signum);
+	const int retval = procctl(P_PID, 0, PROC_PDEATHSIG_CTL, &signum);
 #	else
 #		error WTF?
 #	endif
 	if (retval < 0) {
-		LOG_PERROR("Can't set to receive SIGTERM on parent process death");
+		US_LOG_PERROR("Can't set to receive SIGTERM on parent process death");
 		return -1;
 	}
 
 	if (kill(parent, 0) < 0) {
-		LOG_PERROR("The parent process %d is already dead", parent);
+		US_LOG_PERROR("The parent process %d is already dead", parent);
 		return -1;
 	}
-
 	return 0;
 }
 #endif
@@ -99,21 +98,21 @@ INLINE int process_track_parent_death(void) {
 #ifdef WITH_SETPROCTITLE
 #	pragma GCC diagnostic ignored "-Wunused-parameter"
 #	pragma GCC diagnostic push
-INLINE void process_set_name_prefix(int argc, char *argv[], const char *prefix) {
+INLINE void us_process_set_name_prefix(int argc, char *argv[], const char *prefix) {
 #	pragma GCC diagnostic pop
 
 	char *cmdline = NULL;
 	size_t allocated = 2048;
 	size_t used = 0;
 
-	A_REALLOC(cmdline, allocated);
+	US_REALLOC(cmdline, allocated);
 	cmdline[0] = '\0';
 
 	for (int index = 0; index < argc; ++index) {
 		size_t arg_len = strlen(argv[index]);
 		if (used + arg_len + 16 >= allocated) {
 			allocated += arg_len + 2048;
-			A_REALLOC(cmdline, allocated); // cppcheck-suppress memleakOnRealloc // False-positive (ok with assert)
+			US_REALLOC(cmdline, allocated); // cppcheck-suppress memleakOnRealloc // False-positive (ok with assert)
 		}
 
 		strcat(cmdline, " ");
@@ -130,10 +129,16 @@ INLINE void process_set_name_prefix(int argc, char *argv[], const char *prefix)
 }
 #endif
 
-INLINE void process_notify_parent(void) {
-	pid_t parent = getppid();
-
+INLINE void us_process_notify_parent(void) {
+	const pid_t parent = getppid();
 	if (kill(parent, SIGUSR2) < 0) {
-		LOG_PERROR("Can't send SIGUSR2 to the parent process %d", parent);
+		US_LOG_PERROR("Can't send SIGUSR2 to the parent process %d", parent);
+	}
+}
+
+INLINE void us_process_suicide(void) {
+	const pid_t pid = getpid();
+	if (kill(pid, SIGTERM) < 0) {
+		US_LOG_PERROR("Can't send SIGTERM to own pid %d", pid);
 	}
 }

src/libs/threading.h

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -41,37 +41,38 @@
 
 
 #ifdef PTHREAD_MAX_NAMELEN_NP
-#	define MAX_THREAD_NAME ((size_t)(PTHREAD_MAX_NAMELEN_NP))
+#	define US_MAX_THREAD_NAME ((size_t)(PTHREAD_MAX_NAMELEN_NP))
 #else
-#	define MAX_THREAD_NAME ((size_t)16)
+#	define US_MAX_THREAD_NAME ((size_t)16)
 #endif
 
-#define A_THREAD_CREATE(_tid, _func, _arg)	assert(!pthread_create(_tid, NULL, _func, _arg))
-#define A_THREAD_JOIN(_tid)					assert(!pthread_join(_tid, NULL))
+#define US_THREAD_CREATE(x_tid, x_func, x_arg)	assert(!pthread_create(&(x_tid), NULL, (x_func), (x_arg)))
+#define US_THREAD_JOIN(x_tid)					assert(!pthread_join((x_tid), NULL))
 
 #ifdef WITH_PTHREAD_NP
-#	define A_THREAD_RENAME(_fmt, ...) { \
-			char _new_tname_buf[MAX_THREAD_NAME] = {0}; \
-			assert(snprintf(_new_tname_buf, MAX_THREAD_NAME, _fmt, ##__VA_ARGS__) > 0); \
-			thread_set_name(_new_tname_buf); \
+#	define US_THREAD_RENAME(x_fmt, ...) { \
+			char m_new_tname_buf[US_MAX_THREAD_NAME] = {0}; \
+			assert(snprintf(m_new_tname_buf, US_MAX_THREAD_NAME, (x_fmt), ##__VA_ARGS__) > 0); \
+			us_thread_set_name(m_new_tname_buf); \
 		}
 #else
-#	define A_THREAD_RENAME(_fmt, ...)
+#	define US_THREAD_RENAME(_fmt, ...)
 #endif
 
-#define A_MUTEX_INIT(_mutex)	assert(!pthread_mutex_init(_mutex, NULL))
-#define A_MUTEX_DESTROY(_mutex)	assert(!pthread_mutex_destroy(_mutex))
-#define A_MUTEX_LOCK(_mutex)	assert(!pthread_mutex_lock(_mutex))
-#define A_MUTEX_UNLOCK(_mutex)	assert(!pthread_mutex_unlock(_mutex))
+#define US_MUTEX_INIT(x_mutex)		assert(!pthread_mutex_init(&(x_mutex), NULL))
+#define US_MUTEX_DESTROY(x_mutex)	assert(!pthread_mutex_destroy(&(x_mutex)))
+#define US_MUTEX_LOCK(x_mutex)		assert(!pthread_mutex_lock(&(x_mutex)))
+#define US_MUTEX_UNLOCK(x_mutex)	assert(!pthread_mutex_unlock(&(x_mutex)))
 
-#define A_COND_INIT(_cond)		assert(!pthread_cond_init(_cond, NULL))
-#define A_COND_DESTROY(_cond)	assert(!pthread_cond_destroy(_cond))
-#define A_COND_SIGNAL(...)		assert(!pthread_cond_signal(__VA_ARGS__))
-#define A_COND_WAIT_TRUE(_var, _cond, _mutex) { while(!_var) assert(!pthread_cond_wait(_cond, _mutex)); }
+#define US_COND_INIT(x_cond)		assert(!pthread_cond_init(&(x_cond), NULL))
+#define US_COND_DESTROY(x_cond)		assert(!pthread_cond_destroy(&(x_cond)))
+#define US_COND_SIGNAL(x_cond)		assert(!pthread_cond_signal(&(x_cond)))
+#define US_COND_BROADCAST(x_cond)	assert(!pthread_cond_broadcast(&(x_cond)))
+#define US_COND_WAIT_FOR(x_var, x_cond, x_mutex) { while(!(x_var)) assert(!pthread_cond_wait(&(x_cond), &(x_mutex))); }
 
 
 #ifdef WITH_PTHREAD_NP
-INLINE void thread_set_name(const char *name) {
+INLINE void us_thread_set_name(const char *name) {
 #	if defined(__linux__)
 	pthread_setname_np(pthread_self(), name);
 #	elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
@@ -79,45 +80,45 @@ INLINE void thread_set_name(const char *name) {
 #	elif defined(__NetBSD__)
 	pthread_setname_np(pthread_self(), "%s", (void *)name);
 #	else
-#		error thread_set_name() not implemented, you can disable it using WITH_PTHREAD_NP=0
+#		error us_thread_set_name() not implemented, you can disable it using WITH_PTHREAD_NP=0
 #	endif
 }
 #endif
 
-INLINE void thread_get_name(char *name) { // Always required for logging
+INLINE void us_thread_get_name(char *name) { // Always required for logging
 #ifdef WITH_PTHREAD_NP
 	int retval = -1;
 #	if defined(__linux__) || defined (__NetBSD__)
-	retval = pthread_getname_np(pthread_self(), name, MAX_THREAD_NAME);
+	retval = pthread_getname_np(pthread_self(), name, US_MAX_THREAD_NAME);
 #	elif \
 		(defined(__FreeBSD__) && defined(__FreeBSD_version) && __FreeBSD_version >= 1103500) \
 		|| (defined(__OpenBSD__) && defined(OpenBSD) && OpenBSD >= 201905) \
 		|| defined(__DragonFly__)
-	pthread_get_name_np(pthread_self(), name, MAX_THREAD_NAME);
+	pthread_get_name_np(pthread_self(), name, US_MAX_THREAD_NAME);
 	if (name[0] != '\0') {
 		retval = 0;
 	}
 #	else
-#		error thread_get_name() not implemented, you can disable it using WITH_PTHREAD_NP=0
+#		error us_thread_get_name() not implemented, you can disable it using WITH_PTHREAD_NP=0
 #	endif
 	if (retval < 0) {
 #endif
 
 #if defined(__linux__)
-		pid_t tid = syscall(SYS_gettid);
+		const pid_t tid = syscall(SYS_gettid);
 #elif defined(__FreeBSD__)
-		pid_t tid = syscall(SYS_thr_self);
+		const pid_t tid = syscall(SYS_thr_self);
 #elif defined(__OpenBSD__)
-		pid_t tid = syscall(SYS_getthrid);
+		const pid_t tid = syscall(SYS_getthrid);
 #elif defined(__NetBSD__)
-		pid_t tid = syscall(SYS__lwp_self);
+		const pid_t tid = syscall(SYS__lwp_self);
 #elif defined(__DragonFly__)
-		pid_t tid = syscall(SYS_lwp_gettid);
+		const pid_t tid = syscall(SYS_lwp_gettid);
 #else
-		pid_t tid = 0; // Makes cppcheck happy
+		const pid_t tid = 0; // Makes cppcheck happy
 #	warning gettid() not implemented
 #endif
-		assert(snprintf(name, MAX_THREAD_NAME, "tid=%d", tid) > 0);
+		assert(snprintf(name, US_MAX_THREAD_NAME, "tid=%d", tid) > 0);
 
 #ifdef WITH_PTHREAD_NP
 	}

src/libs/tools.h

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -28,50 +28,72 @@
 #include <stdbool.h>
 #include <string.h>
 #include <unistd.h>
+#include <limits.h>
 #include <locale.h>
 #include <errno.h>
 #include <math.h>
 #include <time.h>
 #include <assert.h>
 
+#include <sys/types.h>
 #include <sys/file.h>
 
+#if defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 32
+#	define HAS_SIGABBREV_NP
+#else
+#	include <signal.h>
+#endif
+
+
+#ifdef NDEBUG
+#	error WTF dude? Asserts are good things!
+#endif
+
+#if CHAR_BIT != 8
+#	error There are not 8 bits in a char!
+#endif
+
 
 #define RN "\r\n"
 
 #define INLINE inline __attribute__((always_inline))
 #define UNUSED __attribute__((unused))
 
-#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(_obj)			memset(&(_obj), 0, sizeof(_obj))
+#define US_CALLOC(x_dest, x_nmemb)		assert(((x_dest) = calloc((x_nmemb), sizeof(*(x_dest)))) != NULL)
+#define US_REALLOC(x_dest, x_nmemb)		assert(((x_dest) = realloc((x_dest), (x_nmemb) * sizeof(*(x_dest)))) != NULL)
+#define US_DELETE(x_dest, x_free)		{ if (x_dest) { x_free(x_dest); } }
+#define US_MEMSET_ZERO(x_obj)			memset(&(x_obj), 0, sizeof(x_obj))
 
-#define A_ASPRINTF(_dest, _fmt, ...) assert(asprintf(&(_dest), _fmt, ##__VA_ARGS__) >= 0)
-
-#define ARRAY_LEN(_array) (sizeof(_array) / sizeof(_array[0]))
+#define US_ASPRINTF(x_dest, x_fmt, ...) assert(asprintf(&(x_dest), (x_fmt), ##__VA_ARGS__) >= 0)
 
 
-INLINE const char *bool_to_string(bool flag) {
+INLINE char *us_strdup(const char *str) {
+	char *const new = strdup(str);
+	assert(new != NULL);
+	return new;
+}
+
+INLINE const char *us_bool_to_string(bool flag) {
 	return (flag ? "true" : "false");
 }
 
-INLINE size_t align_size(size_t size, size_t to) {
+INLINE size_t us_align_size(size_t size, size_t to) {
 	return ((size + (to - 1)) & ~(to - 1));
 }
 
-INLINE unsigned min_u(unsigned a, unsigned b) {
+INLINE unsigned us_min_u(unsigned a, unsigned b) {
 	return (a < b ? a : b);
 }
 
-INLINE unsigned max_u(unsigned a, unsigned b) {
+INLINE unsigned us_max_u(unsigned a, unsigned b) {
 	return (a > b ? a : b);
 }
 
-INLINE long long floor_ms(long double now) {
+INLINE long long us_floor_ms(long double now) {
 	return (long long)now - (now < (long long)now); // floor()
 }
 
-INLINE uint32_t triple_u32(uint32_t x) {
+INLINE uint32_t us_triple_u32(uint32_t x) {
 	// https://nullprogram.com/blog/2018/07/31/
 	x ^= x >> 17;
 	x *= UINT32_C(0xED5AD4BB);
@@ -83,7 +105,7 @@ INLINE uint32_t triple_u32(uint32_t x) {
 	return x;
 }
 
-INLINE void get_now(clockid_t clk_id, time_t *sec, long *msec) {
+INLINE void us_get_now(clockid_t clk_id, time_t *sec, long *msec) {
 	struct timespec ts;
 	assert(!clock_gettime(clk_id, &ts));
 	*sec = ts.tv_sec;
@@ -96,53 +118,66 @@ INLINE void get_now(clockid_t clk_id, time_t *sec, long *msec) {
 }
 
 #if defined(CLOCK_MONOTONIC_RAW)
-#	define X_CLOCK_MONOTONIC CLOCK_MONOTONIC_RAW
+#	define _X_CLOCK_MONOTONIC CLOCK_MONOTONIC_RAW
 #elif defined(CLOCK_MONOTONIC_FAST)
-#	define X_CLOCK_MONOTONIC CLOCK_MONOTONIC_FAST
+#	define _X_CLOCK_MONOTONIC CLOCK_MONOTONIC_FAST
 #else
-#	define X_CLOCK_MONOTONIC CLOCK_MONOTONIC
+#	define _X_CLOCK_MONOTONIC CLOCK_MONOTONIC
 #endif
 
-INLINE long double get_now_monotonic(void) {
+INLINE long double us_get_now_monotonic(void) {
 	time_t sec;
 	long msec;
-	get_now(X_CLOCK_MONOTONIC, &sec, &msec);
+	us_get_now(_X_CLOCK_MONOTONIC, &sec, &msec);
 	return (long double)sec + ((long double)msec) / 1000;
 }
 
-INLINE uint64_t get_now_monotonic_u64(void) {
+INLINE uint64_t us_get_now_monotonic_u64(void) {
 	struct timespec ts;
-	assert(!clock_gettime(X_CLOCK_MONOTONIC, &ts));
+	assert(!clock_gettime(_X_CLOCK_MONOTONIC, &ts));
 	return (uint64_t)(ts.tv_nsec / 1000) + (uint64_t)ts.tv_sec * 1000000;
 }
 
-INLINE uint64_t get_now_id(void) {
-	uint64_t now = get_now_monotonic_u64();
-	return (uint64_t)triple_u32(now) | ((uint64_t)triple_u32(now + 12345) << 32);
+#undef _X_CLOCK_MONOTONIC
+
+INLINE uint64_t us_get_now_id(void) {
+	const uint64_t now = us_get_now_monotonic_u64();
+	return (uint64_t)us_triple_u32(now) | ((uint64_t)us_triple_u32(now + 12345) << 32);
 }
 
-#undef X_CLOCK_MONOTONIC
-
-INLINE long double get_now_real(void) {
+INLINE long double us_get_now_real(void) {
 	time_t sec;
 	long msec;
-	get_now(CLOCK_REALTIME, &sec, &msec);
+	us_get_now(CLOCK_REALTIME, &sec, &msec);
 	return (long double)sec + ((long double)msec) / 1000;
 }
 
-INLINE unsigned get_cores_available(void) {
+INLINE unsigned us_get_cores_available(void) {
 	long cores_sysconf = sysconf(_SC_NPROCESSORS_ONLN);
 	cores_sysconf = (cores_sysconf < 0 ? 0 : cores_sysconf);
-	return max_u(min_u(cores_sysconf, 4), 1);
+	return us_max_u(us_min_u(cores_sysconf, 4), 1);
 }
 
-INLINE int flock_timedwait_monotonic(int fd, long double timeout) {
-	long double deadline_ts = get_now_monotonic() + timeout;
+INLINE void us_ld_to_timespec(long double ld, struct timespec *ts) {
+	ts->tv_sec = (long)ld;
+	ts->tv_nsec = (ld - ts->tv_sec) * 1000000000L;
+	if (ts->tv_nsec > 999999999L) {
+		ts->tv_sec += 1;
+		ts->tv_nsec = 0;
+	}
+}
+
+INLINE long double us_timespec_to_ld(const struct timespec *ts) {
+	return ts->tv_sec + ((long double)ts->tv_nsec) / 1000000000;
+}
+
+INLINE int us_flock_timedwait_monotonic(int fd, long double timeout) {
+	const long double deadline_ts = us_get_now_monotonic() + timeout;
 	int retval = -1;
 
 	while (true) {
 		retval = flock(fd, LOCK_EX | LOCK_NB);
-		if (retval == 0 || errno != EWOULDBLOCK || get_now_monotonic() > deadline_ts) {
+		if (retval == 0 || errno != EWOULDBLOCK || us_get_now_monotonic() > deadline_ts) {
 			break;
 		}
 		if (usleep(1000) < 0) {
@@ -152,15 +187,34 @@ INLINE int flock_timedwait_monotonic(int fd, long double timeout) {
 	return retval;
 }
 
-INLINE char *errno_to_string(int error, char *buf, size_t size) {
-	assert(buf);
-	assert(size > 0);
+INLINE char *us_errno_to_string(int error) {
 	locale_t locale = newlocale(LC_MESSAGES_MASK, "C", NULL);
-	char *str = "!!! newlocale() error !!!";
-	strncpy(buf, (locale ? strerror_l(error, locale) : str), size - 1);
-	buf[size - 1] = '\0';
+	char *buf;
 	if (locale) {
+		buf = us_strdup(strerror_l(error, locale));
 		freelocale(locale);
+	} else {
+		buf = us_strdup("!!! newlocale() error !!!");
+	}
+	return buf;
+}
+
+INLINE char *us_signum_to_string(int signum) {
+#	ifdef HAS_SIGABBREV_NP
+	const char *const name = sigabbrev_np(signum);
+#	else
+	const char *const name = (
+		signum == SIGTERM ? "TERM" :
+		signum == SIGINT ? "INT" :
+		signum == SIGPIPE ? "PIPE" :
+		NULL
+	);
+#	endif
+	char *buf;
+	if (name != NULL) {
+		US_ASPRINTF(buf, "SIG%s", name);
+	} else {
+		US_ASPRINTF(buf, "SIG[%d]", signum);
 	}
 	return buf;
 }

src/libs/unjpeg.c

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -26,15 +26,15 @@
 typedef struct {
 	struct jpeg_error_mgr	mgr; // Default manager
 	jmp_buf					jmp;
-	const frame_s			*frame;
+	const us_frame_s		*frame;
 } _jpeg_error_manager_s;
 
 
 static void _jpeg_error_handler(j_common_ptr jpeg);
 
 
-int unjpeg(const frame_s *src, frame_s *dest, bool decode) {
-	assert(is_jpeg(src->format));
+int us_unjpeg(const us_frame_s *src, us_frame_s *dest, bool decode) {
+	assert(us_is_jpeg(src->format));
 
 	volatile int retval = 0;
 
@@ -57,7 +57,7 @@ int unjpeg(const frame_s *src, frame_s *dest, bool decode) {
 
 	jpeg_start_decompress(&jpeg);
 
-	frame_copy_meta(src, dest);
+	us_frame_copy_meta(src, dest);
 	dest->format = V4L2_PIX_FMT_RGB24;
 	dest->width = jpeg.output_width;
 	dest->height = jpeg.output_height;
@@ -68,10 +68,10 @@ int unjpeg(const frame_s *src, frame_s *dest, bool decode) {
 		JSAMPARRAY scanlines;
 		scanlines = (*jpeg.mem->alloc_sarray)((j_common_ptr) &jpeg, JPOOL_IMAGE, dest->stride, 1);
 
-		frame_realloc_data(dest, ((dest->width * dest->height) << 1) * 2);
+		us_frame_realloc_data(dest, ((dest->width * dest->height) << 1) * 2);
 		while (jpeg.output_scanline < jpeg.output_height) {
 			jpeg_read_scanlines(&jpeg, scanlines, 1);
-			frame_append_data(dest, scanlines[0], dest->stride);
+			us_frame_append_data(dest, scanlines[0], dest->stride);
 		}
 
 		jpeg_finish_decompress(&jpeg);
@@ -87,6 +87,6 @@ static void _jpeg_error_handler(j_common_ptr jpeg) {
 	char msg[JMSG_LENGTH_MAX];
 
 	(*jpeg_error->mgr.format_message)(jpeg, msg);
-	LOG_ERROR("Can't decompress JPEG: %s", msg);
+	US_LOG_ERROR("Can't decompress JPEG: %s", msg);
 	longjmp(jpeg_error->jmp, -1);
 }

src/libs/unjpeg.h

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -37,4 +37,4 @@
 #include "frame.h"
 
 
-int unjpeg(const frame_s *src, frame_s *dest, bool decode);
+int us_unjpeg(const us_frame_s *src, us_frame_s *dest, bool decode);

src/libs/xioctl.h

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -26,18 +26,15 @@
 
 #include <sys/ioctl.h>
 
-#include "../libs/tools.h"
-#include "../libs/logging.h"
 
-
-#ifndef CFG_XIOCTL_RETRIES
-#	define CFG_XIOCTL_RETRIES 4
+#ifndef US_CFG_XIOCTL_RETRIES
+#	define US_CFG_XIOCTL_RETRIES 4
 #endif
-#define XIOCTL_RETRIES ((unsigned)(CFG_XIOCTL_RETRIES))
+#define _XIOCTL_RETRIES ((unsigned)(US_CFG_XIOCTL_RETRIES))
 
 
-INLINE int xioctl(int fd, int request, void *arg) {
-	int retries = XIOCTL_RETRIES;
+INLINE int us_xioctl(int fd, int request, void *arg) {
+	int retries = _XIOCTL_RETRIES;
 	int retval = -1;
 
 	do {
@@ -51,10 +48,5 @@ INLINE int xioctl(int fd, int request, void *arg) {
 			|| errno == ETIMEDOUT
 		)
 	);
-
-	// cppcheck-suppress knownConditionTrueFalse
-	if (retval && retries <= 0) {
-		LOG_PERROR("ioctl(%d) retried %u times; giving up", request, XIOCTL_RETRIES);
-	}
 	return retval;
 }

src/ustreamer/blank.c

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -23,85 +23,83 @@
 #include "blank.h"
 
 
-static frame_s *_init_internal(void);
-static frame_s *_init_external(const char *path);
+static us_frame_s *_init_internal(void);
+static us_frame_s *_init_external(const char *path);
 
 
-frame_s *blank_frame_init(const char *path) {
-	frame_s *blank = NULL;
+us_frame_s *us_blank_frame_init(const char *path) {
+	us_frame_s *blank = NULL;
 
 	if (path && path[0] != '\0') {
 		blank = _init_external(path);
 	}
 
-	if (blank) {
-		LOG_INFO("Using external blank placeholder: %s", path);
+	if (blank != NULL) {
+		US_LOG_INFO("Using external blank placeholder: %s", path);
 	} else {
 		blank = _init_internal();
-		LOG_INFO("Using internal blank placeholder");
+		US_LOG_INFO("Using internal blank placeholder");
 	}
 	return blank;
 }
 
-static frame_s *_init_internal(void) {
-	frame_s *blank = frame_init();
-	frame_set_data(blank, BLANK_JPEG_DATA, BLANK_JPEG_DATA_SIZE);
-	blank->width = BLANK_JPEG_WIDTH;
-	blank->height = BLANK_JPEG_HEIGHT;
+static us_frame_s *_init_internal(void) {
+	us_frame_s *const blank = us_frame_init();
+	us_frame_set_data(blank, US_BLANK_JPEG_DATA, US_BLANK_JPEG_DATA_SIZE);
+	blank->width = US_BLANK_JPEG_WIDTH;
+	blank->height = US_BLANK_JPEG_HEIGHT;
 	blank->format = V4L2_PIX_FMT_JPEG;
 	return blank;
 }
 
-static frame_s *_init_external(const char *path) {
+static us_frame_s *_init_external(const char *path) {
 	FILE *fp = NULL;
 
-	frame_s *blank = frame_init();
+	us_frame_s *blank = us_frame_init();
 	blank->format = V4L2_PIX_FMT_JPEG;
 
 	if ((fp = fopen(path, "rb")) == NULL) {
-		LOG_PERROR("Can't open blank placeholder '%s'", path);
+		US_LOG_PERROR("Can't open blank placeholder '%s'", path);
 		goto error;
 	}
 
 #	define CHUNK_SIZE ((size_t)(100 * 1024))
 	while (true) {
 		if (blank->used + CHUNK_SIZE >= blank->allocated) {
-			frame_realloc_data(blank, blank->used + CHUNK_SIZE * 2);
+			us_frame_realloc_data(blank, blank->used + CHUNK_SIZE * 2);
 		}
 
-		size_t readed = fread(blank->data + blank->used, 1, CHUNK_SIZE, fp);
+		const size_t readed = fread(blank->data + blank->used, 1, CHUNK_SIZE, fp);
 		blank->used += readed;
 
 		if (readed < CHUNK_SIZE) {
 			if (feof(fp)) {
 				break;
 			} else {
-				LOG_PERROR("Can't read blank placeholder");
+				US_LOG_PERROR("Can't read blank placeholder");
 				goto error;
 			}
 		}
 	}
 #	undef CHUNK_SIZE
 
-	frame_s *decoded = frame_init();
-	if (unjpeg(blank, decoded, false) < 0) {
-		frame_destroy(decoded);
+	us_frame_s *const decoded = us_frame_init();
+	if (us_unjpeg(blank, decoded, false) < 0) {
+		us_frame_destroy(decoded);
 		goto error;
 	}
 	blank->width = decoded->width;
 	blank->height = decoded->height;
-	frame_destroy(decoded);
+	us_frame_destroy(decoded);
 
 	goto ok;
 
 	error:
-		frame_destroy(blank);
+		us_frame_destroy(blank);
 		blank = NULL;
 
 	ok:
-		if (fp) {
-			fclose(fp);
-		}
+		US_DELETE(fp, fclose);
 
 	return blank;
 }

src/ustreamer/blank.h

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -35,4 +35,4 @@
 #include "data/blank_jpeg.h"
 
 
-frame_s *blank_frame_init(const char *path);
+us_frame_s *us_blank_frame_init(const char *path);

src/ustreamer/data/blank_jpeg.c

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -22,11 +22,11 @@
 #include "blank_jpeg.h"
 
 
-const unsigned BLANK_JPEG_WIDTH = 640;
-const unsigned BLANK_JPEG_HEIGHT = 480;
+const unsigned US_BLANK_JPEG_WIDTH = 640;
+const unsigned US_BLANK_JPEG_HEIGHT = 480;
 
-const size_t BLANK_JPEG_DATA_SIZE = 13845;
-const uint8_t BLANK_JPEG_DATA[] = {
+const size_t US_BLANK_JPEG_DATA_SIZE = 13845;
+const uint8_t US_BLANK_JPEG_DATA[] = {
 	0xFF, 0xD8, 0xFF, 0xE1, 0x09, 0x50, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x6E, 0x73, 0x2E, 0x61, 0x64, 0x6F, 0x62,
 	0x65, 0x2E, 0x63, 0x6F, 0x6D, 0x2F, 0x78, 0x61, 0x70, 0x2F, 0x31, 0x2E, 0x30, 0x2F, 0x00, 0x3C, 0x3F, 0x78, 0x70, 0x61,
 	0x63, 0x6B, 0x65, 0x74, 0x20, 0x62, 0x65, 0x67, 0x69, 0x6E, 0x3D, 0x22, 0xEF, 0xBB, 0xBF, 0x22, 0x20, 0x69, 0x64, 0x3D,

src/ustreamer/data/blank_jpeg.h

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -27,8 +27,8 @@
 #include <sys/types.h>
 
 
-extern const unsigned BLANK_JPEG_WIDTH;
-extern const unsigned BLANK_JPEG_HEIGHT;
+extern const unsigned US_BLANK_JPEG_WIDTH;
+extern const unsigned US_BLANK_JPEG_HEIGHT;
 
-extern const size_t BLANK_JPEG_DATA_SIZE;
-extern const uint8_t BLANK_JPEG_DATA[];
+extern const size_t US_BLANK_JPEG_DATA_SIZE;
+extern const uint8_t US_BLANK_JPEG_DATA[];

src/ustreamer/data/index.html

@@ -12,30 +12,30 @@
 	<hr>
 	<ul>
 		<li>
-			<a href="/state"><b>/state</b></a><br>
+			<a href="state"><b>/state</b></a><br>
 			Get JSON structure with the state of the server.
 		</li>
 		<br>
 		<li>
-			<a href="/snapshot"><b>/snapshot</b></a><br>
+			<a href="snapshot"><b>/snapshot</b></a><br>
 			Get a current actual image from the server.
 		</li>
 		<br>
 		<li>
-			<a href="/stream"><b>/stream</b></a><br>
+			<a href="stream"><b>/stream</b></a><br>
 			Get a live stream. Query params:<br>
 			<br>
 			<ul>
 				<li>
 					<b>key=abc123</b><br>
 					The user-defined key, which is part of cookie <i>stream_client</i>, which allows<br>
-					the stream client to determine its identifier and view statistics using <a href="/state">/state</a>.
+					the stream client to determine its identifier and view statistics using <a href="state">/state</a>.
 				</li>
 				<br>
 				<li>
 					<b>extra_headers=1</b><br>
-					Add <i>X-UStreamer-*</i> headers to the <a href="/stream">/stream</a> handle
-					(like with the <a href="/snapshot">/snapshot</a>).
+					Add <i>X-UStreamer-*</i> headers to the <a href="stream">/stream</a> handle
+					(like with the <a href="snapshot">/snapshot</a>).
 				</li>
 				<br>
 				<li>
@@ -62,9 +62,9 @@
 			The mjpg-streamer compatibility layer:<br>
 			<br>
 			<ul>
-				<li><a href="/?action=snapshot">/?action=snapshot</a> as alias to the <a href="/snapshot">/snapshot</a>.</li>
+				<li><a href="?action=snapshot">/?action=snapshot</a> as alias to the <a href="snapshot">/snapshot</a>.</li>
 				<br>
-				<li><a href="/?action=stream">/?action=stream</a> as alias to the <a href="/stream">/stream</a>.</li>
+				<li><a href="?action=stream">/?action=stream</a> as alias to the <a href="stream">/stream</a>.</li>
 			</ul>
 		</li>
 	</ul>

src/ustreamer/data/index_html.c

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -22,7 +22,7 @@
 #include "index_html.h"
 
 
-const char *const HTML_INDEX_PAGE = " \
+const char *const US_HTML_INDEX_PAGE = " \
 	<!DOCTYPE html> \
 	\
 	<html> \
@@ -33,34 +33,34 @@ const char *const HTML_INDEX_PAGE = " \
 	</head> \
 	\
 	<body> \
-		<h3>&micro;Streamer v" VERSION "</h3> \
+		<h3>&micro;Streamer v" US_VERSION "</h3> \
 		<hr> \
 		<ul> \
 			<li> \
-				<a href=\"/state\"><b>/state</b></a><br> \
+				<a href=\"state\"><b>/state</b></a><br> \
 				Get JSON structure with the state of the server. \
 			</li> \
 			<br> \
 			<li> \
-				<a href=\"/snapshot\"><b>/snapshot</b></a><br> \
+				<a href=\"snapshot\"><b>/snapshot</b></a><br> \
 				Get a current actual image from the server. \
 			</li> \
 			<br> \
 			<li> \
-				<a href=\"/stream\"><b>/stream</b></a><br> \
+				<a href=\"stream\"><b>/stream</b></a><br> \
 				Get a live stream. Query params:<br> \
 				<br> \
 				<ul> \
 					<li> \
 						<b>key=abc123</b><br> \
 						The user-defined key, which is part of cookie <i>stream_client</i>, which allows<br> \
-						the stream client to determine its identifier and view statistics using <a href=\"/state\">/state</a>. \
+						the stream client to determine its identifier and view statistics using <a href=\"state\">/state</a>. \
 					</li> \
 					<br> \
 					<li> \
 						<b>extra_headers=1</b><br> \
-						Add <i>X-UStreamer-*</i> headers to the <a href=\"/stream\">/stream</a> handle \
-						(like with the <a href=\"/snapshot\">/snapshot</a>). \
+						Add <i>X-UStreamer-*</i> headers to the <a href=\"stream\">/stream</a> handle \
+						(like with the <a href=\"snapshot\">/snapshot</a>). \
 					</li> \
 					<br> \
 					<li> \
@@ -87,9 +87,9 @@ const char *const HTML_INDEX_PAGE = " \
 				The mjpg-streamer compatibility layer:<br> \
 				<br> \
 				<ul> \
-					<li><a href=\"/?action=snapshot\">/?action=snapshot</a> as alias to the <a href=\"/snapshot\">/snapshot</a>.</li> \
+					<li><a href=\"?action=snapshot\">/?action=snapshot</a> as alias to the <a href=\"snapshot\">/snapshot</a>.</li> \
 					<br> \
-					<li><a href=\"/?action=stream\">/?action=stream</a> as alias to the <a href=\"/stream\">/stream</a>.</li> \
+					<li><a href=\"?action=stream\">/?action=stream</a> as alias to the <a href=\"stream\">/stream</a>.</li> \
 				</ul> \
 			</li> \
 		</ul> \

src/ustreamer/data/index_html.h

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -24,7 +24,7 @@
 
 #include <sys/types.h>
 
-#include "../../libs/config.h"
+#include "../../libs/const.h"
 
 
-extern const char *const HTML_INDEX_PAGE;
+extern const char *const US_HTML_INDEX_PAGE;

src/ustreamer/device.h

@@ -1,8 +1,8 @@
 /*****************************************************************************
 #                                                                            #
-#    uStreamer - Lightweight and fast MJPG-HTTP streamer.                    #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2021  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2022  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    #
@@ -40,92 +40,82 @@
 #include <pthread.h>
 #include <linux/videodev2.h>
 #include <linux/v4l2-controls.h>
-#ifdef WITH_OMX
-#	include <interface/vcsm/user-vcsm.h>
-#endif
 
 #include "../libs/tools.h"
+#include "../libs/array.h"
 #include "../libs/logging.h"
 #include "../libs/threading.h"
 #include "../libs/frame.h"
-
-#include "xioctl.h"
+#include "../libs/xioctl.h"
 
 
-#define VIDEO_MIN_WIDTH		((unsigned)160)
-#define VIDEO_MAX_WIDTH		((unsigned)10240)
+#define US_VIDEO_MIN_WIDTH		((unsigned)160)
+#define US_VIDEO_MAX_WIDTH		((unsigned)10240)
 
-#define VIDEO_MIN_HEIGHT	((unsigned)120)
-#define VIDEO_MAX_HEIGHT	((unsigned)4320)
+#define US_VIDEO_MIN_HEIGHT		((unsigned)120)
+#define US_VIDEO_MAX_HEIGHT		((unsigned)4320)
 
-#define VIDEO_MAX_FPS		((unsigned)120)
+#define US_VIDEO_MAX_FPS		((unsigned)120)
 
-#define STANDARD_UNKNOWN	V4L2_STD_UNKNOWN
-#define STANDARDS_STR		"PAL, NTSC, SECAM"
+#define US_STANDARD_UNKNOWN		V4L2_STD_UNKNOWN
+#define US_STANDARDS_STR		"PAL, NTSC, SECAM"
 
-#define FORMAT_UNKNOWN	-1
-#define FORMATS_STR		"YUYV, UYVY, RGB565, RGB24, MJPEG, JPEG"
+#define US_FORMAT_UNKNOWN		-1
+#define US_FORMATS_STR			"YUYV, UYVY, RGB565, RGB24, MJPEG, JPEG"
 
-#define IO_METHOD_UNKNOWN	-1
-#define IO_METHODS_STR		"MMAP, USERPTR"
+#define US_IO_METHOD_UNKNOWN	-1
+#define US_IO_METHODS_STR		"MMAP, USERPTR"
 
 
 typedef struct {
-	frame_s raw;
-
-	struct v4l2_buffer buf_info;
-
-#	ifdef WITH_OMX
-	int dma_fd;
-	int vcsm_handle;
-#	endif
-
-	pthread_mutex_t grabbed_mutex;
-	bool			grabbed;
-} hw_buffer_s;
+	us_frame_s			raw;
+	struct v4l2_buffer	buf;
+	int					dma_fd;
+	bool				grabbed;
+} us_hw_buffer_s;
 
 typedef struct {
-	int			fd;
-	unsigned	width;
-	unsigned	height;
-	unsigned	format;
-	unsigned	stride;
-	unsigned	hw_fps;
-	unsigned	jpeg_quality;
-	size_t		raw_size;
-	unsigned	n_bufs;
-	hw_buffer_s	*hw_bufs;
-	bool		capturing;
-	bool		persistent_timeout_reported;
-} device_runtime_s;
+	int				fd;
+	unsigned		width;
+	unsigned		height;
+	unsigned		format;
+	unsigned		stride;
+	unsigned		hw_fps;
+	unsigned		jpeg_quality;
+	size_t			raw_size;
+	unsigned		n_bufs;
+	us_hw_buffer_s	*hw_bufs;
+	bool			capturing;
+	bool			persistent_timeout_reported;
+} us_device_runtime_s;
 
 typedef enum {
 	CTL_MODE_NONE = 0,
 	CTL_MODE_VALUE,
 	CTL_MODE_AUTO,
 	CTL_MODE_DEFAULT,
-} control_mode_e;
+} us_control_mode_e;
 
 typedef struct {
-	control_mode_e	mode;
-	int				value;
-} control_s;
+	us_control_mode_e	mode;
+	int					value;
+} us_control_s;
 
 typedef struct {
-	control_s brightness;
-	control_s contrast;
-	control_s saturation;
-	control_s hue;
-	control_s gamma;
-	control_s sharpness;
-	control_s backlight_compensation;
-	control_s white_balance;
-	control_s gain;
-	control_s color_effect;
-	control_s rotate;
-	control_s flip_vertical;
-	control_s flip_horizontal;
-} controls_s;
+	us_control_s	brightness;
+	us_control_s	contrast;
+	us_control_s	saturation;
+	us_control_s	hue;
+	us_control_s	gamma;
+	us_control_s	sharpness;
+	us_control_s	backlight_compensation;
+	us_control_s	white_balance;
+	us_control_s	gain;
+	us_control_s	color_effect;
+	us_control_s	rotate;
+	us_control_s	flip_vertical;
+	us_control_s	flip_horizontal;
+} us_controls_s;
 
 typedef struct {
 	char				*path;
@@ -143,27 +133,25 @@ typedef struct {
 	bool				persistent;
 	unsigned			timeout;
 
-	controls_s ctl;
+	us_controls_s 		ctl;
 
-	device_runtime_s *run;
-} device_s;
+	us_device_runtime_s *run;
+} us_device_s;
 
 
-device_s *device_init(void);
-void device_destroy(device_s *dev);
+us_device_s *us_device_init(void);
+void us_device_destroy(us_device_s *dev);
 
-int device_parse_format(const char *str);
-v4l2_std_id device_parse_standard(const char *str);
-int device_parse_io_method(const char *str);
+int us_device_parse_format(const char *str);
+v4l2_std_id us_device_parse_standard(const char *str);
+int us_device_parse_io_method(const char *str);
 
-int device_open(device_s *dev);
-void device_close(device_s *dev);
+int us_device_open(us_device_s *dev);
+void us_device_close(us_device_s *dev);
 
-#ifdef WITH_OMX
-int device_export_to_vcsm(device_s *dev);
-#endif
-int device_switch_capturing(device_s *dev, bool enable);
-int device_select(device_s *dev, bool *has_read, bool *has_write, bool *has_error);
-int device_grab_buffer(device_s *dev, hw_buffer_s **hw);
-int device_release_buffer(device_s *dev, hw_buffer_s *hw);
-int device_consume_event(device_s *dev);
+int us_device_export_to_dma(us_device_s *dev);
+int us_device_switch_capturing(us_device_s *dev, bool enable);
+int us_device_select(us_device_s *dev, bool *has_read, bool *has_write, bool *has_error);
+int us_device_grab_buffer(us_device_s *dev, us_hw_buffer_s **hw);
+int us_device_release_buffer(us_device_s *dev, us_hw_buffer_s *hw);
+int us_device_consume_event(us_device_s *dev);