Bump version: 6.22 → 6.23

Extension of c96559e4ac.
Some cheap Chinise cameras produces frames which are detected as 'broken'. However they
are later handled well.
Introduce an option which allows disable the check on demand.

.bumpversion.cfg

@@ -1,7 +1,7 @@
 [bumpversion]
 commit = True
 tag = True
-current_version = 5.40
+current_version = 6.23
 parse = (?P<major>\d+)\.(?P<minor>\d+)
 serialize = 
 	{major}.{minor}

.github/workflows/docker-alpine-image.yaml

@@ -66,7 +66,7 @@ jobs:
         uses: docker/build-push-action@v3
         with:
           context: .
-          platforms: linux/arm64,linux/amd64,linux/arm/v7
+          platforms: linux/arm64,linux/amd64,linux/arm/v6,linux/arm/v7
           file: pkg/docker/Dockerfile.alpine
       -
         name: Push

.gitignore

@@ -3,10 +3,12 @@
 /pkg/arch/pkg/
 /pkg/arch/src/
 /src/build/
-/python/build/
+/python/dist/
+/python/ustreamer.egg-info/
+/python/root/
 /janus/build/
 /ustreamer
-/ustreamer-dump
+/ustreamer-*
 /config.mk
 vgcore.*
 *.sock

Makefile

@@ -9,19 +9,27 @@ PY ?= python3
 CFLAGS ?= -O3
 LDFLAGS ?=
 
-RPI_VC_HEADERS ?= /opt/vc/include
-RPI_VC_LIBS ?= /opt/vc/lib
+R_DESTDIR = $(if $(DESTDIR),$(shell realpath "$(DESTDIR)"),)
 
 export
 
 _LINTERS_IMAGE ?= ustreamer-linters
 
 
+# =====
+ifeq (__not_found__,$(shell which pkg-config 2>/dev/null || echo "__not_found__"))
+$(error "No pkg-config found in $(PATH)")
+endif
+
+
 # =====
 define optbool
 $(filter $(shell echo $(1) | tr A-Z a-z), yes on 1)
 endef
 
+ifeq ($(V),)
+	ECHO = @
+endif
 
 # =====
 all:
@@ -36,18 +44,19 @@ endif
 
 apps:
 	$(MAKE) -C src
-	@ ln -sf src/ustreamer.bin ustreamer
-	@ ln -sf src/ustreamer-dump.bin ustreamer-dump
+	for i in src/*.bin; do \
+		test ! -x $$i || ln -sf $$i `basename $$i .bin`; \
+	done
 
 
 python:
 	$(MAKE) -C python
-	@ ln -sf python/build/lib.*/*.so .
+	$(ECHO) ln -sf python/root/usr/lib/python*/site-packages/*.so .
 
 
 janus:
 	$(MAKE) -C janus
-	@ ln -sf janus/*.so .
+	$(ECHO) ln -sf janus/*.so .
 
 
 install: all
@@ -58,10 +67,10 @@ endif
 ifneq ($(call optbool,$(WITH_JANUS)),)
 	$(MAKE) -C janus install
 endif
-	mkdir -p $(DESTDIR)$(MANPREFIX)/man1
+	mkdir -p $(R_DESTDIR)$(MANPREFIX)/man1
 	for man in $(shell ls man); do \
-		install -m644 man/$$man $(DESTDIR)$(MANPREFIX)/man1/$$man; \
-		gzip -f $(DESTDIR)$(MANPREFIX)/man1/$$man; \
+		install -m644 man/$$man $(R_DESTDIR)$(MANPREFIX)/man1/$$man; \
+		gzip -f $(R_DESTDIR)$(MANPREFIX)/man1/$$man; \
 	done
 
 
@@ -70,9 +79,8 @@ install-strip: install
 
 
 regen:
-	tools/$(MAKE)-jpeg-h.py src/ustreamer/data/blank.jpeg src/ustreamer/data/blank_jpeg.c BLANK
-	tools/$(MAKE)-ico-h.py src/ustreamer/data/favicon.ico src/ustreamer/data/favicon_ico.c FAVICON
-	tools/$(MAKE)-html-h.py src/ustreamer/data/index.html src/ustreamer/data/index_html.c INDEX
+	tools/make-ico-h.py src/ustreamer/data/favicon.ico src/ustreamer/data/favicon_ico.c FAVICON
+	tools/make-html-h.py src/ustreamer/data/index.html src/ustreamer/data/index_html.c INDEX
 
 
 release:
@@ -119,7 +127,7 @@ clean-all: linters clean
 
 clean:
 	rm -rf pkg/arch/pkg pkg/arch/src pkg/arch/v*.tar.gz pkg/arch/ustreamer-*.pkg.tar.{xz,zst}
-	rm -f ustreamer ustreamer-dump *.so
+	rm -f ustreamer ustreamer-* *.so
 	$(MAKE) -C src clean
 	$(MAKE) -C python clean
 	$(MAKE) -C janus clean

README.md

@@ -23,7 +23,7 @@
 | Compatibility with mjpg-streamer's API | ✔ | :) |
 
 Footnotes:
-  * ```1``` Long before µStreamer, I made a [patch](https://github.com/jacksonliam/mjpg-streamer/pull/164) to add DV-timings support to mjpg-streamer and to keep it from hanging up no device disconnection. Alas, the patch is far from perfect and I can't guarantee it will work every time - mjpg-streamer's source code is very complicated and its structure is hard to understand. With this in mind, along with needing multithreading and JPEG hardware acceleration in the future, I decided to make my own stream server from scratch instead of supporting legacy code.
+  * ```1``` Long before µStreamer, I made a [patch](https://github.com/jacksonliam/mjpg-streamer/pull/164) to add DV-timings support to mjpg-streamer and to keep it from hanging up on device disconnection. Alas, the patch is far from perfect and I can't guarantee it will work every time - mjpg-streamer's source code is very complicated and its structure is hard to understand. With this in mind, along with needing multithreading and JPEG hardware acceleration in the future, I decided to make my own stream server from scratch instead of supporting legacy code.
 
   * ```2``` This feature allows to cut down outgoing traffic several-fold when streaming HDMI, but it increases CPU usage a little bit. The idea is that HDMI is a fully digital interface and each captured frame can be identical to the previous one byte-wise. There's no need to stream the same image over the net several times a second. With the `--drop-same-frames=20` option enabled, µStreamer will drop all the matching frames (with a limit of 20 in a row). Each new frame is matched with the previous one first by length, then using ```memcmp()```.
 
@@ -47,15 +47,13 @@ You need to download the µStreamer onto your system and build it from the sourc
 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 libjpeg9-dev libbsd-dev`. Add `libgpiod-dev` for `WITH_GPIO=1` and `libsystemd-dev` for `WITH_SYSTEMD=1` and `libasound2-dev libspeex-dev libspeexdsp-dev libopus-dev` for `WITH_JANUS=1`.
+* Raspberry OS Bullseye: `sudo apt install libevent-dev libjpeg62-turbo libbsd-dev`. Add `libgpiod-dev` for `WITH_GPIO=1` and `libsystemd-dev` for `WITH_SYSTEMD=1` and `libasound2-dev libspeex-dev libspeexdsp-dev libopus-dev` for `WITH_JANUS=1`.
+* Raspberry OS Bookworm: same as previous but replace `libjpeg62-turbo` to `libjpeg62-turbo-dev`.
 * 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`.
 
 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```.
 
-> **Note**
-> Raspian: In case your version of Raspian is too old for there to be a libjpeg9 package, use `libjpeg8-dev` instead: `E: Package 'libjpeg9-dev' has no installation candidate`.
-
 ### Make
 The most convenient process is to clone the µStreamer Git repository onto your system. If you don't have Git installed and don't want to install it either, you can download and unzip the sources from GitHub using `wget https://github.com/pikvm/ustreamer/archive/refs/heads/master.zip`.
 
@@ -87,13 +85,13 @@ Without arguments, ```ustreamer``` will try to open ```/dev/video0``` with 640x4
 
 :exclamation: Please note that since µStreamer v2.0 cross-domain requests were disabled by default for [security reasons](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS). To enable the old behavior, use the option `--allow-origin=\*`.
 
-The recommended way of running µStreamer with [Auvidea B101](https://www.raspberrypi.org/forums/viewtopic.php?f=38&t=120702&start=400#p1339178) on Raspberry Pi:
-```bash
+The recommended way of running µStreamer with [TC358743-based capture device](https://www.raspberrypi.org/forums/viewtopic.php?f=38&t=120702&start=400#p1339178) on Raspberry Pi:
+```
 $ ./ustreamer \
     --format=uyvy \ # Device input format
     --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)
+    --persistent \ # Suppress repetitive signal source errors (for example when HDMI cable was disconnected)
     --dv-timings \ # Use DV-timings
     --drop-same-frames=30 # Save the traffic
 ```
@@ -115,7 +113,7 @@ dtoverlay=tc358743
 
 Check size of CMA:
 
-```bash
+```
 $ dmesg | grep cma-reserved
 [    0.000000] Memory: 7700524K/8244224K available (11772K kernel code, 1278K rwdata, 4320K rodata, 4096K init, 1077K bss, 281556K reserved, 262144K cma-reserved)
 ```
@@ -131,14 +129,14 @@ Save changes and reboot.
 ## Launch
 Start container:
 
-```bash
+```
 $ docker run --device /dev/video0:/dev/video0 -e EDID=1 -p 8080:8080 pikvm/ustreamer:latest
 ```
 
 Then access the web interface at port 8080 (e.g. http://raspberrypi.local:8080).
 
 ## Custom config
-```bash
+```
 $ docker run --rm pikvm/ustreamer:latest \
     --format=uyvy \
     --workers=3 \
@@ -153,8 +151,16 @@ Add `-e EDID=1` to set HDMI EDID before starting ustreamer. Use together with `-
 -----
 # Raspberry Pi Camera Example
 
+Example usage for the Raspberry Pi v3 camera (required `libcamerify` which is located in `libcamera-tools` and `libcamera-v4l2` (install both) on Raspbian):
+```
+$ sudo modprobe bcm2835-v4l2
+$ libcamerify ./ustreamer --host :: --encoder=m2m-image
+```
+
+For v2 camera you can use the same trick with `libcamerify` but enable legacy camera mode in `raspi-config`.
+
 Example usage for the Raspberry Pi v1 camera:
-```bash
+```
 $ sudo modprobe bcm2835-v4l2
 $ ./ustreamer --host :: -m jpeg --device-timeout=5 --buffers=3 -r 2592x1944
 ```
@@ -163,7 +169,7 @@ $ ./ustreamer --host :: -m jpeg --device-timeout=5 --buffers=3 -r 2592x1944
 
 :exclamation: If you get a poor framerate, it could be that the camera is switched to photo mode, which produces a low framerate (but a higher quality picture). This is because `bcm2835-v4l2` switches to photo mode at resolutions higher than `1280x720`. To work around this, pass the `max_video_width` and `max_video_height` module parameters like so:
 
-```bash
+```
 $ modprobe bcm2835-v4l2 max_video_width=2592 max_video_height=1944
 ```
 
@@ -174,7 +180,7 @@ $ modprobe bcm2835-v4l2 max_video_width=2592 max_video_height=1944
 µ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:
+When uStreamer is behind an Nginx proxy, its buffering behavior introduces latency into the video stream. It's possible to disable Nginx's buffering to eliminate the additional latency:
 
 ```nginx
 location /stream {
@@ -203,7 +209,7 @@ v4l2 utilities provide the tools to manage USB webcam setting and information. S
 
 -----
 # License
-Copyright (C) 2018-2023 by Maxim Devaev mdevaev@gmail.com
+Copyright (C) 2018-2024 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/ssl/README.md

@@ -0,0 +1,50 @@
+# Adding SSL
+These days, browsers are not happy if you have HTTP content on an HTTPS page.
+The browser will not show an HTTP stream on a page if the parent page is from a site which is using HTTPS.
+
+The files in this folder configure an Nginx proxy in front of the µStreamer stream.
+Using certbot, an SSL cert is created from Let's Encrypt and installed.
+These scripts can be modified to add SSL to just about any HTTP server.
+
+The scripts are not fire and forget.
+They will require some pre-configuration and are interactive (you'll be asked questions while they're running).
+They have been tested using the following setup.
+1. A Raspberry Pi 4
+1. µStreamer set up and running as a service
+    1. Internally on port 8080
+    1. Public port will be 5101
+1. Verizon home Wi-Fi router
+1. Domain registration from GoDaddy
+
+## The Script
+Below is an overview of the steps performed by `ssl-config.sh` (for Raspberry OS):
+1. Install snapd - certbot uses this for installation
+1. Install certbot
+1. Get a free cert from Let's Encrypt using certbot
+1. Install nginx
+1. Configures nginx to proxy for µStreamer
+
+## Steps
+1. Create a public DNS entry.
+    1. Pointing to the Pi itself or the public IP of the router behind which the Pi sits.
+    1. This would be managed in the domain registrar, such as GoDaddy.
+    1. Use a subdomain, such as `webcam.domain.com`
+1. Port Forwarding
+    1. If using a Wi-Fi router, create a port forwarding rule which passes traffic from port 80 to the Pi. This is needed for certbot to ensure your DNS entry reaches the Pi, even if your final port will be something else.
+    1. Create a second rule for your final setup. For example, forward traffic from the router on port 5101 to the Pi's IP port 8080.
+1. Update the ustreamer-proxy file in this folder
+    1. Replace `your.domain.com` with a fully qualified domain, it's three places in the proxy file.
+    1. Modify the line `listen 5101 ssl` port if needed. This is the public port, not the port on which the µStreamer service is running
+    1. Modify `proxy_pass http://127.0.0.1:8080;` with the working address of the internal µStreamer service.
+1. Run the script
+    1. Stand buy, certbot asks some basic questions, such as email, domain, agree to terms, etc.
+    1. `bash ssl-config.sh`
+1. Test your URL!
+
+## Down the Road
+Two important points to keep in mind for the future:
+1. Dynamic IP - Most routers do not have a static IP address on the WAN side. So, if you reboot your router or if your internet provider gives you a new IP, you'll have to update the DNS entry.
+    1. Many routers have some sort of dynamic DNS feature. This would automatically update the DNS entry for you. That functionality is outside the scope of this document.
+1. SSL Renewals - certbot automatically creates a task to renew the SSL cert before it expires. Assuming the Pi is running all the time, this shouldn't be an issue.
+
+## Enjoy!

docs/ssl/ssl-config.sh

@@ -0,0 +1,20 @@
+#!/bin/sh
+
+echo -e "\e[32mInstalling snapd...\e[0m"
+sudo apt install snapd -y
+sudo snap install core
+
+
+echo -e "\e[32mInstalling certbot, don't leave, it's going to ask questions...\e[0m"
+sudo snap install --classic certbot
+sudo ln -s /snap/bin/certbot /usr/bin/certbot
+sudo certbot certonly --standalone
+sudo certbot renew --dry-run
+
+
+echo -e "\e[32mInstalling nginx...\e[0m"
+sudo apt-get install nginx -y
+sudo cp ustreamer-proxy /etc/nginx/sites-available/ustreamer-proxy
+sudo ln -s /etc/nginx/sites-available/ustreamer-proxy /etc/nginx/sites-enabled/
+sudo nginx -t
+sudo systemctl reload nginx

docs/ssl/ustreamer-proxy

@@ -0,0 +1,13 @@
+server {
+    listen 5101 ssl;
+    server_name your.domain.com;
+
+    ssl_certificate /etc/letsencrypt/live/your.domain.com/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/your.domain.com/privkey.pem;
+
+    location / {
+        proxy_pass http://127.0.0.1:8080;  # Change this to the uStreamer server address
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+    }
+}

docs/youtube.md

@@ -0,0 +1,97 @@
+## Streaming to third party services
+
+This method provides the ability of streaming a USB Webcam and include audio to large audiences.
+It uses to two machines. One is a Raspberry Pi and the other a more capable machine to performance
+the encoding of the video and audio that is streamed to the third party service such as YouTube.
+
+Another benefit of using a browser (http stream) is the video can have overlays add in the custom ustreamer webpage.
+For example a cron process that retrieves weather information and updates a file to include on the page, announcements,
+or other creative ideas. The audio stream can also be something other than the webcam mic (music, voice files, etc.)
+and easily changed on the second machine setup. In the following example filtering is applied in ffmpeg to
+improve the sound of the webcam mic making vocals clearer and more intelligible.
+
+* Machine 1:
+    * USB webcam on the machine (Pi for example) running ustreamer (video) and VLC (audio). Remember to make any needed firewall changes if machine 2 is on a separate network so it can reach the ports for the video and audio.
+    * To stream audio from the Pi.
+        ```
+        /usr/bin/vlc -I dummy -vvv alsa://hw:2,0 --sout #transcode{acodec=mp3,ab=128}:standard{access=http,mux=ts,dst=:[PickAPort}
+        ```
+
+* Machine 2:
+    * On a more capable box run the video stream in a browser using ffmpeg to combine the video (browser) and audio and stream to YouTube or other services. In this example a VM with two virtual monitors running the browser full screen one of the monitors is used.
+
+Script to stream the combination to YouTube:
+```bash
+#!/bin/bash
+KEY=$1
+echo
+echo Cleanup -------------------------------------------------
+source live-yt.key
+killall -9 ffmpeg
+killall -9 chromium
+sleep 3
+
+echo Setup General--------------------------------------------
+cd /home/[USER]
+rm -f nohup.out
+export DISPLAY=:0.0
+export $(dbus-launch)
+
+echo Setup Chromium-------------------------------------------
+CHROMIUM_TEMP=/home/{USER]/tmp/chromium
+rm -rf $CHROMIUM_TEMP.bak
+mv $CHROMIUM_TEMP $CHROMIUM_TEMP.bak
+mkdir -p $CHROMIUM_TEMP
+
+echo Start Chromium ------------------------------------------
+nohup /usr/lib/chromium/chromium \
+    --new-window "http://[ustreamerURL]" \
+    --start-fullscreen \
+    --disable \
+    --disable-translate \
+    --disable-infobars \
+    --disable-suggestions-service \
+    --disable-save-password-bubble \
+    --disable-new-tab-first-run \
+    --disable-session-crashed-bubble \
+    --disable-bundled-ppapi-flash  \
+    --disable-gpu \
+    --enable-javascript \
+    --enable-user-scripts \
+    --disk-cache-dir=$CHROMIUM_TEMP/cache/ustreamer/ \
+    --user-data-dir=$CHROMIUM_TEMP/user_data/ustreamer/ \
+    --window-position=1440,12 \
+     >/dev/null 2>&1 &
+sleep 5
+
+echo Start FFMpeg---------------------------------------------
+nohup /usr/bin/ffmpeg \
+    -loglevel level+warning \
+    -thread_queue_size 512 \
+    -framerate 30 \
+    -f x11grab \
+    -s 1920x1080 \
+    -probesize 42M \
+    -i :0.0+1024,0 \
+    -i http://[VLCaudioURL] \
+    -filter:a "volume=10, highpass=f=300, lowpass=f=2800" \
+    -c:v libx264 \
+    -pix_fmt yuv420p \
+    -g 60 \
+    -b:v 2500k \
+    -c:a libmp3lame \
+    -ar 44100 \
+    -b:a 32k \
+    -preset ultrafast \
+    -maxrate 5000k \
+    -bufsize 2500k \
+    -preset ultrafast \
+    -flvflags no_duration_filesize  \
+    -f flv "rtmp://a.rtmp.youtube.com/live2/$KEY" \
+     >/home/{USER]/ff-audio.log 2>&1 &
+
+echo Done ----------------------------------------------------
+echo
+```
+
+*PS: Recipe by David Klippel*

janus/Makefile

@@ -1,4 +1,4 @@
-DESTDIR ?=
+R_DESTDIR ?=
 PREFIX ?= /usr/local
 
 CC ?= gcc
@@ -31,19 +31,19 @@ endif
 # =====
 $(_PLUGIN): $(_SRCS:%.c=$(_BUILD)/%.o)
 	$(info == SO $@)
-	@ $(CC) $^ -o $@ $(_LDFLAGS)
+	$(ECHO) $(CC) $^ -o $@ $(_LDFLAGS)
 
 
 $(_BUILD)/%.o: %.c
 	$(info -- CC $<)
-	@ mkdir -p $(dir $@) || true
-	@ $(CC) $< -o $@ $(_CFLAGS)
+	$(ECHO) mkdir -p $(dir $@) || true
+	$(ECHO) $(CC) $< -o $@ $(_CFLAGS)
 
 
 
 install: $(_PLUGIN)
-	mkdir -p $(DESTDIR)$(PREFIX)/lib/ustreamer/janus
-	install -m755 $(_PLUGIN) $(DESTDIR)$(PREFIX)/lib/ustreamer/janus/$(PLUGIN)
+	mkdir -p $(R_DESTDIR)$(PREFIX)/lib/ustreamer/janus
+	install -m755 $(_PLUGIN) $(R_DESTDIR)$(PREFIX)/lib/ustreamer/janus/$(PLUGIN)
 
 
 clean:

janus/src/acap.c

@@ -0,0 +1,295 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  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 "acap.h"
+
+#include <stdlib.h>
+#include <stdatomic.h>
+#include <assert.h>
+
+#include <pthread.h>
+#include <alsa/asoundlib.h>
+#include <speex/speex_resampler.h>
+#include <opus/opus.h>
+
+#include "uslibs/types.h"
+#include "uslibs/errors.h"
+#include "uslibs/tools.h"
+#include "uslibs/array.h"
+#include "uslibs/ring.h"
+#include "uslibs/threading.h"
+
+#include "logging.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_FRAMES(_hz)	((_hz) / 50) // 20ms
+#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(s16))
+
+#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 {
+	s16		data[_MAX_BUF16];
+} _pcm_buffer_s;
+
+typedef struct {
+	u8		data[_MAX_BUF8]; // Worst case
+	uz		used;
+	u64	pts;
+} _enc_buffer_s;
+
+
+static _pcm_buffer_s *_pcm_buffer_init(void);
+static _enc_buffer_s *_enc_buffer_init(void);
+
+static void *_pcm_thread(void *v_acap);
+static void *_encoder_thread(void *v_acap);
+
+
+bool us_acap_probe(const char *name) {
+	snd_pcm_t *pcm;
+	int err;
+	US_JLOG_INFO("acap", "Probing PCM capture ...");
+	if ((err = snd_pcm_open(&pcm, name, SND_PCM_STREAM_CAPTURE, 0)) < 0) {
+		_JLOG_PERROR_ALSA(err, "acap", "Can't probe PCM capture");
+		return false;
+	}
+	snd_pcm_close(pcm);
+	US_JLOG_INFO("acap", "PCM capture is available");
+	return true;
+}
+
+us_acap_s *us_acap_init(const char *name, uint pcm_hz) {
+	us_acap_s *acap;
+	US_CALLOC(acap, 1);
+	acap->pcm_hz = pcm_hz;
+	US_RING_INIT_WITH_ITEMS(acap->pcm_ring, 8, _pcm_buffer_init);
+	US_RING_INIT_WITH_ITEMS(acap->enc_ring, 8, _enc_buffer_init);
+	atomic_init(&acap->stop, false);
+
+	int err;
+
+	{
+		if ((err = snd_pcm_open(&acap->pcm, name, SND_PCM_STREAM_CAPTURE, 0)) < 0) {
+			acap->pcm = NULL;
+			_JLOG_PERROR_ALSA(err, "acap", "Can't open PCM capture");
+			goto error;
+		}
+		assert(!snd_pcm_hw_params_malloc(&acap->pcm_params));
+
+#		define SET_PARAM(_msg, _func, ...) { \
+				if ((err = _func(acap->pcm, acap->pcm_params, ##__VA_ARGS__)) < 0) { \
+					_JLOG_PERROR_ALSA(err, "acap", _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, &acap->pcm_hz, 0);
+		if (acap->pcm_hz < _MIN_PCM_HZ || acap->pcm_hz > _MAX_PCM_HZ) {
+			US_JLOG_ERROR("acap", "Unsupported PCM freq: %u; should be: %u <= F <= %u",
+				acap->pcm_hz, _MIN_PCM_HZ, _MAX_PCM_HZ);
+			goto error;
+		}
+		acap->pcm_frames = _HZ_TO_FRAMES(acap->pcm_hz);
+		acap->pcm_size = _HZ_TO_BUF8(acap->pcm_hz);
+		SET_PARAM("Can't apply PCM params", snd_pcm_hw_params);
+
+#		undef SET_PARAM
+	}
+
+	if (acap->pcm_hz != _ENCODER_INPUT_HZ) {
+		acap->res = speex_resampler_init(2, acap->pcm_hz, _ENCODER_INPUT_HZ, SPEEX_RESAMPLER_QUALITY_DESKTOP, &err);
+		if (err < 0) {
+			acap->res = NULL;
+			_JLOG_PERROR_RES(err, "acap", "Can't create resampler");
+			goto error;
+		}
+	}
+
+	{
+		// OPUS_APPLICATION_VOIP, OPUS_APPLICATION_RESTRICTED_LOWDELAY
+		acap->enc = opus_encoder_create(_ENCODER_INPUT_HZ, 2, OPUS_APPLICATION_AUDIO, &err);
+		assert(err == 0);
+		assert(!opus_encoder_ctl(acap->enc, OPUS_SET_BITRATE(48000)));
+		assert(!opus_encoder_ctl(acap->enc, OPUS_SET_MAX_BANDWIDTH(OPUS_BANDWIDTH_FULLBAND)));
+		assert(!opus_encoder_ctl(acap->enc, OPUS_SET_SIGNAL(OPUS_SIGNAL_MUSIC)));
+		// OPUS_SET_INBAND_FEC(1), OPUS_SET_PACKET_LOSS_PERC(10): see rtpa.c
+	}
+
+	US_JLOG_INFO("acap", "Pipeline configured on %uHz; capturing ...", acap->pcm_hz);
+	acap->tids_created = true;
+	US_THREAD_CREATE(acap->enc_tid, _encoder_thread, acap);
+	US_THREAD_CREATE(acap->pcm_tid, _pcm_thread, acap);
+
+	return acap;
+
+	error:
+		us_acap_destroy(acap);
+		return NULL;
+}
+
+void us_acap_destroy(us_acap_s *acap) {
+	if (acap->tids_created) {
+		atomic_store(&acap->stop, true);
+		US_THREAD_JOIN(acap->pcm_tid);
+		US_THREAD_JOIN(acap->enc_tid);
+	}
+	US_DELETE(acap->enc, opus_encoder_destroy);
+	US_DELETE(acap->res, speex_resampler_destroy);
+	US_DELETE(acap->pcm, snd_pcm_close);
+	US_DELETE(acap->pcm_params, snd_pcm_hw_params_free);
+	US_RING_DELETE_WITH_ITEMS(acap->enc_ring, free);
+	US_RING_DELETE_WITH_ITEMS(acap->pcm_ring, free);
+	if (acap->tids_created) {
+		US_JLOG_INFO("acap", "Pipeline closed");
+	}
+	free(acap);
+}
+
+int us_acap_get_encoded(us_acap_s *acap, u8 *data, uz *size, u64 *pts) {
+	if (atomic_load(&acap->stop)) {
+		return -1;
+	}
+	const int ri = us_ring_consumer_acquire(acap->enc_ring, 0.1);
+	if (ri < 0) {
+		return US_ERROR_NO_DATA;
+	}
+	const _enc_buffer_s *const buf = acap->enc_ring->items[ri];
+	if (*size < buf->used) {
+		us_ring_consumer_release(acap->enc_ring, ri);
+		return US_ERROR_NO_DATA;
+	}
+	memcpy(data, buf->data, buf->used);
+	*size = buf->used;
+	*pts = buf->pts;
+	us_ring_consumer_release(acap->enc_ring, ri);
+	return 0;
+}
+
+static _pcm_buffer_s *_pcm_buffer_init(void) {
+	_pcm_buffer_s *buf;
+	US_CALLOC(buf, 1);
+	return buf;
+}
+
+static _enc_buffer_s *_enc_buffer_init(void) {
+	_enc_buffer_s *buf;
+	US_CALLOC(buf, 1);
+	return buf;
+}
+
+static void *_pcm_thread(void *v_acap) {
+	US_THREAD_SETTLE("us_ac_pcm");
+
+	us_acap_s *const acap = v_acap;
+	u8 in[_MAX_BUF8];
+
+	while (!atomic_load(&acap->stop)) {
+		const int frames = snd_pcm_readi(acap->pcm, in, acap->pcm_frames);
+		if (frames < 0) {
+			_JLOG_PERROR_ALSA(frames, "acap", "Fatal: Can't capture PCM frames");
+			break;
+		} else if (frames < (int)acap->pcm_frames) {
+			US_JLOG_ERROR("acap", "Fatal: Too few PCM frames captured");
+			break;
+		}
+
+		const int ri = us_ring_producer_acquire(acap->pcm_ring, 0);
+		if (ri >= 0) {
+			_pcm_buffer_s *const out = acap->pcm_ring->items[ri];
+			memcpy(out->data, in, acap->pcm_size);
+			us_ring_producer_release(acap->pcm_ring, ri);
+		} else {
+			US_JLOG_ERROR("acap", "PCM ring is full");
+		}
+	}
+
+	atomic_store(&acap->stop, true);
+	return NULL;
+}
+
+static void *_encoder_thread(void *v_acap) {
+	US_THREAD_SETTLE("us_a_enc");
+
+	us_acap_s *const acap = v_acap;
+	s16 in_res[_MAX_BUF16];
+
+	while (!atomic_load(&acap->stop)) {
+		const int in_ri = us_ring_consumer_acquire(acap->pcm_ring, 0.1);
+		if (in_ri < 0) {
+			continue;
+		}
+		_pcm_buffer_s *const in = acap->pcm_ring->items[in_ri];
+
+		s16 *in_ptr;
+		if (acap->res != NULL) {
+			assert(acap->pcm_hz != _ENCODER_INPUT_HZ);
+			u32 in_count = acap->pcm_frames;
+			u32 out_count = _HZ_TO_FRAMES(_ENCODER_INPUT_HZ);
+			speex_resampler_process_interleaved_int(acap->res, in->data, &in_count, in_res, &out_count);
+			in_ptr = in_res;
+		} else {
+			assert(acap->pcm_hz == _ENCODER_INPUT_HZ);
+			in_ptr = in->data;
+		}
+
+		const int out_ri = us_ring_producer_acquire(acap->enc_ring, 0);
+		if (out_ri < 0) {
+			US_JLOG_ERROR("acap", "OPUS encoder queue is full");
+			us_ring_consumer_release(acap->pcm_ring, in_ri);
+			continue;
+		}
+		_enc_buffer_s *const out = acap->enc_ring->items[out_ri];
+
+		const int size = opus_encode(acap->enc, in_ptr, _HZ_TO_FRAMES(_ENCODER_INPUT_HZ), out->data, US_ARRAY_LEN(out->data));
+		us_ring_consumer_release(acap->pcm_ring, in_ri);
+
+		if (size >= 0) {
+			out->used = size;
+			out->pts = acap->pts;
+			// https://datatracker.ietf.org/doc/html/rfc7587#section-4.2
+			acap->pts += _HZ_TO_FRAMES(_ENCODER_INPUT_HZ);
+		} else {
+			_JLOG_PERROR_OPUS(size, "acap", "Fatal: Can't encode PCM frame to OPUS");
+		}
+		us_ring_producer_release(acap->enc_ring, out_ri);
+	}
+
+	atomic_store(&acap->stop, true);
+	return NULL;
+}

janus/src/acap.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,50 +22,40 @@
 
 #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"
+#include "uslibs/types.h"
+#include "uslibs/ring.h"
 
 
 typedef struct {
 	snd_pcm_t			*pcm;
-	unsigned			pcm_hz;
-	unsigned			pcm_frames;
-	size_t				pcm_size;
+	uint				pcm_hz;
+	uint				pcm_frames;
+	uz					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;
+	us_ring_s		*pcm_ring;
+	us_ring_s		*enc_ring;
+	u32				pts;
 
-	pthread_t			pcm_tid;
-	pthread_t			enc_tid;
-	bool				tids_created;
-	atomic_bool			stop;
-} us_audio_s;
+	pthread_t		pcm_tid;
+	pthread_t		enc_tid;
+	bool			tids_created;
+	atomic_bool		stop;
+} us_acap_s;
 
 
-bool us_audio_probe(const char *name);
+bool us_acap_probe(const char *name);
 
-us_audio_s *us_audio_init(const char *name, unsigned pcm_hz);
-void us_audio_destroy(us_audio_s *audio);
+us_acap_s *us_acap_init(const char *name, uint pcm_hz);
+void us_acap_destroy(us_acap_s *acap);
 
-int us_audio_get_encoded(us_audio_s *audio, uint8_t *data, size_t *size, uint64_t *pts);
+int us_acap_get_encoded(us_acap_s *acap, u8 *data, uz *size, u64 *pts);

janus/src/audio.c

@@ -1,255 +0,0 @@
-/*****************************************************************************
-#                                                                            #
-#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
-#                                                                            #
-#    Copyright (C) 2018-2023  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);
-
-
-bool us_audio_probe(const char *name) {
-	snd_pcm_t *pcm;
-	int err;
-	US_JLOG_INFO("audio", "Probing PCM capture ...");
-	if ((err = snd_pcm_open(&pcm, name, SND_PCM_STREAM_CAPTURE, 0)) < 0) {
-		_JLOG_PERROR_ALSA(err, "audio", "Can't probe PCM capture");
-		return false;
-	}
-	snd_pcm_close(pcm);
-	US_JLOG_INFO("audio", "PCM capture is available");
-	return true;
-}
-
-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/client.c

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,9 +22,25 @@
 
 #include "client.h"
 
+#include <stdlib.h>
+#include <stdatomic.h>
+#include <string.h>
+
+#include <pthread.h>
+#include <janus/plugins/plugin.h>
+
+#include "uslibs/types.h"
+#include "uslibs/tools.h"
+#include "uslibs/threading.h"
+#include "uslibs/list.h"
+#include "uslibs/ring.h"
+
+#include "logging.h"
+#include "rtp.h"
+
 
 static void *_video_thread(void *v_client);
-static void *_audio_thread(void *v_client);
+static void *_acap_thread(void *v_client);
 static void *_common_thread(void *v_client, bool video);
 
 
@@ -34,29 +50,28 @@ us_janus_client_s *us_janus_client_init(janus_callbacks *gw, janus_plugin_sessio
 	client->gw = gw;
 	client->session = session;
 	atomic_init(&client->transmit, false);
-	atomic_init(&client->transmit_audio, false);
+	atomic_init(&client->transmit_acap, false);
+	atomic_init(&client->video_orient, 0);
 
 	atomic_init(&client->stop, false);
 
-	client->video_queue = us_queue_init(1024);
+	US_RING_INIT_WITH_ITEMS(client->video_ring, 2048, us_rtp_init);
 	US_THREAD_CREATE(client->video_tid, _video_thread, client);
 
-	client->audio_queue = us_queue_init(64);
-	US_THREAD_CREATE(client->audio_tid, _audio_thread, client);
+	US_RING_INIT_WITH_ITEMS(client->acap_ring, 64, us_rtp_init);
+	US_THREAD_CREATE(client->acap_tid, _acap_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);
-	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);
+	US_RING_DELETE_WITH_ITEMS(client->video_ring, us_rtp_destroy);
 
-	US_THREAD_JOIN(client->audio_tid);
-	US_QUEUE_DELETE_WITH_ITEMS(client->audio_queue, us_rtp_destroy);
+	US_THREAD_JOIN(client->acap_tid);
+	US_RING_DELETE_WITH_ITEMS(client->acap_ring, us_rtp_destroy);
 
 	free(client);
 }
@@ -64,64 +79,79 @@ 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) {
 	if (
 		atomic_load(&client->transmit)
-		&& (rtp->video || atomic_load(&client->transmit_audio))
+		&& (rtp->video || atomic_load(&client->transmit_acap))
 	) {
-		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);
+		us_ring_s *const ring = (rtp->video ? client->video_ring : client->acap_ring);
+		const int ri = us_ring_producer_acquire(ring, 0);
+		if (ri < 0) {
+			US_JLOG_ERROR("client", "Session %p %s ring is full",
+				client->session, (rtp->video ? "video" : "acap"));
+			return;
 		}
+		memcpy(ring->items[ri], rtp, sizeof(us_rtp_s));
+		us_ring_producer_release(ring, ri);
 	}
 }
 
 static void *_video_thread(void *v_client) {
+	US_THREAD_SETTLE("us_c_video");
 	return _common_thread(v_client, true);
 }
 
-static void *_audio_thread(void *v_client) {
+static void *_acap_thread(void *v_client) {
+	US_THREAD_SETTLE("us_c_acap");
 	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
+	us_janus_client_s *const client = v_client;
+	us_ring_s *const ring = (video ? client->video_ring : client->acap_ring);
+	assert(ring != 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;
-			}
+		const int ri = us_ring_consumer_acquire(ring, 0.1);
+		if (ri < 0) {
+			continue;
+		}
+		us_rtp_s rtp;
+		memcpy(&rtp, ring->items[ri], sizeof(us_rtp_s));
+		us_ring_consumer_release(ring, ri);
 
-			if (
-				atomic_load(&client->transmit)
-				&& (video || atomic_load(&client->transmit_audio))
-			) {
-				janus_plugin_rtp packet = {0};
-				packet.video = rtp->video;
-				packet.buffer = (char *)rtp->datagram;
-				packet.length = rtp->used;
+		if (
+			atomic_load(&client->transmit)
+			&& (video || atomic_load(&client->transmit_acap))
+		) {
+			janus_plugin_rtp packet = {
+				.video = rtp.video,
+				.buffer = (char*)rtp.datagram,
+				.length = rtp.used,
 #				if JANUS_PLUGIN_API_VERSION >= 100
 				// The uStreamer Janus plugin places video in stream index 0 and audio
 				// (if available) in stream index 1.
-				packet.mindex = (rtp->video ? 0 : 1);
+				.mindex = (rtp.video ? 0 : 1),
 #				endif
+			};
+			janus_plugin_rtp_extensions_reset(&packet.extensions);
 
-				janus_plugin_rtp_extensions_reset(&packet.extensions);
-				/*if (rtp->zero_playout_delay) {
-					// https://github.com/pikvm/pikvm/issues/784
-					packet.extensions.min_delay = 0;
-					packet.extensions.max_delay = 0;
-				} else {
-					packet.extensions.min_delay = 0;
-					packet.extensions.max_delay = 1000;
-				}*/
+			/*if (rtp->zero_playout_delay) {
+				// https://github.com/pikvm/pikvm/issues/784
+				packet.extensions.min_delay = 0;
+				packet.extensions.max_delay = 0;
+			} else {
+				packet.extensions.min_delay = 0;
+				// 10s - Chromium/WebRTC default
+				// 3s - Firefox default
+				packet.extensions.max_delay = 300; // == 3s, i.e. 10ms granularity
+			}*/
 
-				client->gw->relay_rtp(client->session, &packet);
+			if (rtp.video) {
+				const uint video_orient = atomic_load(&client->video_orient);
+				if (video_orient != 0) {
+					packet.extensions.video_rotation = video_orient;
+				}
 			}
-			us_rtp_destroy(rtp);
+
+			client->gw->relay_rtp(client->session, &packet);
 		}
 	}
 	return NULL;

janus/src/client.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,37 +22,33 @@
 
 #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/types.h"
 #include "uslibs/list.h"
+#include "uslibs/ring.h"
 
-#include "logging.h"
-#include "queue.h"
 #include "rtp.h"
 
 
-typedef struct us_janus_client_sx {
+typedef struct {
 	janus_callbacks			*gw;
 	janus_plugin_session	*session;
 	atomic_bool				transmit;
-	atomic_bool				transmit_audio;
+	atomic_bool				transmit_acap;
+	atomic_uint				video_orient;
 
 	pthread_t				video_tid;
-	pthread_t				audio_tid;
+	pthread_t				acap_tid;
 	atomic_bool				stop;
 
-	us_queue_s				*video_queue;
-	us_queue_s				*audio_queue;
+	us_ring_s				*video_ring;
+	us_ring_s				*acap_ring;
 
-    US_LIST_STRUCT(struct us_janus_client_sx);
+    US_LIST_DECLARE;
 } us_janus_client_s;
 
 

janus/src/config.c

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,6 +22,17 @@
 
 #include "config.h"
 
+#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"
+
 
 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);
@@ -51,7 +62,7 @@ us_config_s *us_config_init(const char *config_dir_path) {
 		US_JLOG_ERROR("config", "Missing config value: video.sink (ex. memsink.object)");
 		goto error;
 	}
-	if ((config->audio_dev_name = _get_value(jcfg, "audio", "device")) != NULL) {
+	if ((config->acap_dev_name = _get_value(jcfg, "audio", "device")) != NULL) {
 		if ((config->tc358743_dev_path = _get_value(jcfg, "audio", "tc358743")) == NULL) {
 			US_JLOG_INFO("config", "Missing config value: audio.tc358743");
 			goto error;
@@ -59,18 +70,19 @@ us_config_s *us_config_init(const char *config_dir_path) {
 	}
 
 	goto ok;
-	error:
-		us_config_destroy(config);
-		config = NULL;
-	ok:
-		US_DELETE(jcfg, janus_config_destroy);
-		free(config_file_path);
-		return config;
+
+error:
+	US_DELETE(config, us_config_destroy);
+
+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->acap_dev_name, free);
 	US_DELETE(config->tc358743_dev_path, free);
 	free(config);
 }

janus/src/config.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,22 +22,11 @@
 
 #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;
 
-	char	*audio_dev_name;
+	char	*acap_dev_name;
 	char	*tc358743_dev_path;
 } us_config_s;
 

janus/src/const.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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    #

janus/src/logging.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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    #
@@ -36,11 +36,3 @@
 		JANUS_LOG(LOG_ERR, "[%s/%-9s] " x_msg ": %s\n", US_PLUGIN_NAME, x_prefix, ##__VA_ARGS__, m_perror_str); \
 		free(m_perror_str); \
 	}
-
-#define US_ONCE(...) { \
-		const int m_reported = __LINE__; \
-		if (m_reported != once) { \
-			__VA_ARGS__; \
-			once = m_reported; \
-		} \
-	}

janus/src/memsinkfd.c

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,13 +22,25 @@
 
 #include "memsinkfd.h"
 
+#include <unistd.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;
+#include <linux/videodev2.h>
+
+#include "uslibs/types.h"
+#include "uslibs/errors.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, u64 last_id) {
+	const ldf deadline_ts = us_get_now_monotonic() + 1; // wait_timeout
+	ldf now_ts;
 	do {
 		const int result = us_flock_timedwait_monotonic(fd, 1); // lock_timeout
-		now = us_get_now_monotonic();
+		now_ts = us_get_now_monotonic();
 		if (result < 0 && errno != EWOULDBLOCK) {
 			US_JLOG_PERROR("video", "Can't lock memsink");
 			return -1;
@@ -42,13 +54,12 @@ int us_memsink_fd_wait_frame(int fd, us_memsink_shared_s* mem, uint64_t last_id)
 			}
 		}
 		usleep(1000); // lock_polling
-	} while (now < deadline_ts);
-	return -2;
+	} while (now_ts < deadline_ts);
+	return US_ERROR_NO_DATA;
 }
 
-us_frame_s *us_memsink_fd_get_frame(int fd, us_memsink_shared_s *mem, uint64_t *frame_id, bool key_required) {
-	us_frame_s *frame = us_frame_init();
-	us_frame_set_data(frame, mem->data, mem->used);
+int us_memsink_fd_get_frame(int fd, us_memsink_shared_s *mem, us_frame_s *frame, u64 *frame_id, bool key_required) {
+	us_frame_set_data(frame, us_memsink_get_data(mem), mem->used);
 	US_FRAME_COPY_META(mem, frame);
 	*frame_id = mem->id;
 	mem->last_client_ts = us_get_now_monotonic();
@@ -56,18 +67,14 @@ us_frame_s *us_memsink_fd_get_frame(int fd, us_memsink_shared_s *mem, uint64_t *
 		mem->key_requested = true;
 	}
 
-	bool ok = true;
+	bool retval = 0;
 	if (frame->format != V4L2_PIX_FMT_H264) {
 		US_JLOG_ERROR("video", "Got non-H264 frame from memsink");
-		ok = false;
+		retval = -1;
 	}
 	if (flock(fd, LOCK_UN) < 0) {
 		US_JLOG_PERROR("video", "Can't unlock memsink");
-		ok = false;
+		retval = -1;
 	}
-	if (!ok) {
-		us_frame_destroy(frame);
-		frame = NULL;
-	}
-	return frame;
+	return retval;
 }

janus/src/memsinkfd.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,18 +22,10 @@
 
 #pragma once
 
-#include <stdbool.h>
-#include <stdint.h>
-#include <unistd.h>
-
-#include <linux/videodev2.h>
-
-#include "uslibs/tools.h"
+#include "uslibs/types.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, bool key_required);
+int us_memsink_fd_wait_frame(int fd, us_memsink_shared_s *mem, u64 last_id);
+int us_memsink_fd_get_frame(int fd, us_memsink_shared_s *mem, us_frame_s *frame, u64 *frame_id, bool key_required);

janus/src/plugin.c

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,8 +20,6 @@
 *****************************************************************************/
 
 
-#include <stdint.h>
-#include <stdbool.h>
 #include <stdatomic.h>
 #include <stdlib.h>
 #include <inttypes.h>
@@ -37,18 +35,20 @@
 #include <janus/plugins/plugin.h>
 #include <janus/rtcp.h>
 
+#include "uslibs/types.h"
 #include "uslibs/const.h"
+#include "uslibs/errors.h"
 #include "uslibs/tools.h"
 #include "uslibs/threading.h"
 #include "uslibs/list.h"
+#include "uslibs/ring.h"
 #include "uslibs/memsinksh.h"
+#include "uslibs/tc358743.h"
 
 #include "const.h"
 #include "logging.h"
-#include "queue.h"
 #include "client.h"
-#include "audio.h"
-#include "tc358743.h"
+#include "acap.h"
 #include "rtp.h"
 #include "rtpv.h"
 #include "rtpa.h"
@@ -56,12 +56,12 @@
 #include "config.h"
 
 
-static us_config_s	*_g_config = NULL;
-const useconds_t	_g_watchers_polling = 100000;
+static us_config_s		*_g_config = NULL;
+static const useconds_t	_g_watchers_polling = 100000;
 
 static us_janus_client_s	*_g_clients = NULL;
 static janus_callbacks		*_g_gw = NULL;
-static us_queue_s			*_g_video_queue = NULL;
+static us_ring_s			*_g_video_ring = NULL;
 static us_rtpv_s			*_g_rtpv = NULL;
 static us_rtpa_s			*_g_rtpa = NULL;
 
@@ -69,11 +69,11 @@ 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 pthread_t		_g_acap_tid;
+static atomic_bool		_g_acap_tid_created = false;
 
 static pthread_mutex_t	_g_video_lock = PTHREAD_MUTEX_INITIALIZER;
-static pthread_mutex_t	_g_audio_lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t	_g_acap_lock = PTHREAD_MUTEX_INITIALIZER;
 static atomic_bool		_g_ready = false;
 static atomic_bool		_g_stop = false;
 static atomic_bool		_g_has_watchers = false;
@@ -84,11 +84,11 @@ static atomic_bool		_g_key_required = false;
 #define _LOCK_VIDEO		US_MUTEX_LOCK(_g_video_lock)
 #define _UNLOCK_VIDEO	US_MUTEX_UNLOCK(_g_video_lock)
 
-#define _LOCK_AUDIO		US_MUTEX_LOCK(_g_audio_lock)
-#define _UNLOCK_AUDIO	US_MUTEX_UNLOCK(_g_audio_lock)
+#define _LOCK_ACAP		US_MUTEX_LOCK(_g_acap_lock)
+#define _UNLOCK_ACAP	US_MUTEX_UNLOCK(_g_acap_lock)
 
-#define _LOCK_ALL		{ _LOCK_VIDEO; _LOCK_AUDIO; }
-#define _UNLOCK_ALL		{ _UNLOCK_AUDIO; _UNLOCK_VIDEO; }
+#define _LOCK_ALL		{ _LOCK_VIDEO; _LOCK_ACAP; }
+#define _UNLOCK_ALL		{ _UNLOCK_ACAP; _UNLOCK_VIDEO; }
 
 #define _READY			atomic_load(&_g_ready)
 #define _STOP			atomic_load(&_g_stop)
@@ -99,27 +99,32 @@ static atomic_bool		_g_key_required = false;
 janus_plugin *create(void);
 
 
-static void *_video_rtp_thread(UNUSED void *arg) {
-	US_THREAD_RENAME("us_video_rtp");
+static void *_video_rtp_thread(void *arg) {
+	(void)arg;
+	US_THREAD_SETTLE("us_video_rtp");
 	atomic_store(&_g_video_rtp_tid_created, true);
 
 	while (!_STOP) {
-		us_frame_s *frame;
-		if (us_queue_get(_g_video_queue, (void **)&frame, 0.1) == 0) {
+		const int ri = us_ring_consumer_acquire(_g_video_ring, 0.1);
+		if (ri >= 0) {
+			const us_frame_s *const frame = _g_video_ring->items[ri];
 			_LOCK_VIDEO;
-			us_rtpv_wrap(_g_rtpv, frame);
+			const bool zero_playout_delay = (frame->gop == 0);
+			us_rtpv_wrap(_g_rtpv, frame, zero_playout_delay);
 			_UNLOCK_VIDEO;
-			us_frame_destroy(frame);
+			us_ring_consumer_release(_g_video_ring, ri);
 		}
 	}
 	return NULL;
 }
 
-static void *_video_sink_thread(UNUSED void *arg) {
-	US_THREAD_RENAME("us_video_sink");
+static void *_video_sink_thread(void *arg) {
+	(void)arg;
+	US_THREAD_SETTLE("us_video_sink");
 	atomic_store(&_g_video_sink_tid_created, true);
 
-	uint64_t frame_id = 0;
+	us_frame_s *drop = us_frame_init();
+	u64 frame_id = 0;
 	int once = 0;
 
 	while (!_STOP) {
@@ -132,12 +137,18 @@ static void *_video_sink_thread(UNUSED void *arg) {
 		int fd = -1;
 		us_memsink_shared_s *mem = NULL;
 
+		const uz data_size = us_memsink_calculate_size(_g_config->video_sink_name);
+		if (data_size == 0) {
+			US_ONCE({ US_JLOG_ERROR("video", "Invalid memsink object suffix"); });
+			goto close_memsink;
+		}
+
 		if ((fd = shm_open(_g_config->video_sink_name, O_RDWR, 0)) <= 0) {
 			US_ONCE({ US_JLOG_PERROR("video", "Can't open memsink"); });
 			goto close_memsink;
 		}
 
-		if ((mem = us_memsink_shared_map(fd)) == NULL) {
+		if ((mem = us_memsink_shared_map(fd, data_size)) == NULL) {
 			US_ONCE({ US_JLOG_PERROR("video", "Can't map memsink"); });
 			goto close_memsink;
 		}
@@ -146,41 +157,69 @@ static void *_video_sink_thread(UNUSED void *arg) {
 
 		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) {
-				us_frame_s *const frame = us_memsink_fd_get_frame(fd, mem, &frame_id, atomic_load(&_g_key_required));
-				if (frame == NULL) {
+			const int waited = us_memsink_fd_wait_frame(fd, mem, frame_id);
+			if (waited == 0) {
+				const int ri = us_ring_producer_acquire(_g_video_ring, 0);
+				us_frame_s *frame;
+				if (ri >= 0) {
+					frame = _g_video_ring->items[ri];
+				} else {
+					US_ONCE({ US_JLOG_PERROR("video", "Video ring is full"); });
+					frame = drop;
+				}
+
+				const int got = us_memsink_fd_get_frame(fd, mem, frame, &frame_id, atomic_load(&_g_key_required));
+				if (ri >= 0) {
+					us_ring_producer_release(_g_video_ring, ri);
+				}
+				if (got < 0) {
 					goto close_memsink;
 				}
-				if (frame->key) {
+
+				if (ri >= 0 && frame->key) {
 					atomic_store(&_g_key_required, false);
 				}
-				if (us_queue_put(_g_video_queue, frame, 0) != 0) {
-					US_ONCE({ US_JLOG_PERROR("video", "Video queue is full"); });
-					us_frame_destroy(frame);
-				}
-			} else if (result == -1) {
+			} else if (waited != US_ERROR_NO_DATA) {
 				goto close_memsink;
 			}
 		}
 
-		close_memsink:
-			if (mem != NULL) {
-				US_JLOG_INFO("video", "Memsink closed");
-				us_memsink_shared_unmap(mem);
-			}
-			if (fd >= 0) {
-				close(fd);
-			}
-			sleep(1); // error_delay
+	close_memsink:
+		if (mem != NULL) {
+			us_memsink_shared_unmap(mem, data_size);
+			mem = NULL;
+		}
+		US_CLOSE_FD(fd);
+		US_JLOG_INFO("video", "Memsink closed");
+		sleep(1); // error_delay
 	}
+
+	us_frame_destroy(drop);
 	return 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);
+static int _check_tc358743_acap(uint *hz) {
+	int fd;
+	if ((fd = open(_g_config->tc358743_dev_path, O_RDWR)) < 0) {
+		US_JLOG_PERROR("acap", "Can't open TC358743 V4L2 device");
+		return -1;
+	}
+	const int checked = us_tc358743_xioctl_get_audio_hz(fd, hz);
+	if (checked < 0) {
+		US_JLOG_PERROR("acap", "Can't check TC358743 audio state (%d)", checked);
+		close(fd);
+		return -1;
+	}
+	close(fd);
+	return 0;
+}
+
+static void *_acap_thread(void *arg) {
+	(void)arg;
+	US_THREAD_SETTLE("us_acap");
+	atomic_store(&_g_acap_tid_created, true);
+
+	assert(_g_config->acap_dev_name != NULL);
 	assert(_g_config->tc358743_dev_path != NULL);
 
 	int once = 0;
@@ -191,48 +230,43 @@ static void *_audio_thread(UNUSED void *arg) {
 			continue;
 		}
 
-		us_tc358743_info_s info = {0};
-		us_audio_s *audio = NULL;
+		uint hz = 0;
+		us_acap_s *acap = NULL;
 
-		if (us_tc358743_read_info(_g_config->tc358743_dev_path, &info) < 0) {
-			goto close_audio;
+		if (_check_tc358743_acap(&hz) < 0) {
+			goto close_acap;
 		}
-		if (!info.has_audio) {
-			US_ONCE({ US_JLOG_INFO("audio", "No audio presented from the host"); });
-			goto close_audio;
+		if (hz == 0) {
+			US_ONCE({ US_JLOG_INFO("acap", "No audio presented from the host"); });
+			goto close_acap;
 		}
-		US_ONCE({ US_JLOG_INFO("audio", "Detected host audio"); });
-		if ((audio = us_audio_init(_g_config->audio_dev_name, info.audio_hz)) == NULL) {
-			goto close_audio;
+		US_ONCE({ US_JLOG_INFO("acap", "Detected host audio"); });
+		if ((acap = us_acap_init(_g_config->acap_dev_name, hz)) == NULL) {
+			goto close_acap;
 		}
 
 		once = 0;
 
 		while (!_STOP && _HAS_WATCHERS && _HAS_LISTENERS) {
-			if (
-				us_tc358743_read_info(_g_config->tc358743_dev_path, &info) < 0
-				|| !info.has_audio
-				|| audio->pcm_hz != info.audio_hz
-			) {
-				goto close_audio;
+			if (_check_tc358743_acap(&hz) < 0 || acap->pcm_hz != hz) {
+				goto close_acap;
 			}
-
-			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);
+			uz size = US_RTP_DATAGRAM_SIZE - US_RTP_HEADER_SIZE;
+			u8 data[size];
+			u64 pts;
+			const int result = us_acap_get_encoded(acap, data, &size, &pts);
 			if (result == 0) {
-				_LOCK_AUDIO;
+				_LOCK_ACAP;
 				us_rtpa_wrap(_g_rtpa, data, size, pts);
-				_UNLOCK_AUDIO;
+				_UNLOCK_ACAP;
 			} else if (result == -1) {
-				goto close_audio;
+				goto close_acap;
 			}
 		}
 
-		close_audio:
-			US_DELETE(audio, us_audio_destroy);
-			sleep(1); // error_delay
+	close_acap:
+		US_DELETE(acap, us_acap_destroy);
+		sleep(1); // error_delay
 	}
 	return NULL;
 }
@@ -256,11 +290,11 @@ static int _plugin_init(janus_callbacks *gw, const char *config_dir_path) {
 	}
 	_g_gw = gw;
 
-	_g_video_queue = us_queue_init(1024);
+	US_RING_INIT_WITH_ITEMS(_g_video_ring, 64, us_frame_init);
 	_g_rtpv = us_rtpv_init(_relay_rtp_clients);
-	if (_g_config->audio_dev_name != NULL && us_audio_probe(_g_config->audio_dev_name)) {
+	if (_g_config->acap_dev_name != NULL && us_acap_probe(_g_config->acap_dev_name)) {
 		_g_rtpa = us_rtpa_init(_relay_rtp_clients);
-		US_THREAD_CREATE(_g_audio_tid, _audio_thread, NULL);
+		US_THREAD_CREATE(_g_acap_tid, _acap_thread, NULL);
 	}
 	US_THREAD_CREATE(_g_video_rtp_tid, _video_rtp_thread, NULL);
 	US_THREAD_CREATE(_g_video_sink_tid, _video_sink_thread, NULL);
@@ -276,7 +310,7 @@ static void _plugin_destroy(void) {
 #	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);
+	JOIN(_g_acap_tid);
 #	undef JOIN
 
 	US_LIST_ITERATE(_g_clients, client, {
@@ -284,7 +318,7 @@ static void _plugin_destroy(void) {
 		us_janus_client_destroy(client);
 	});
 
-	US_QUEUE_DELETE_WITH_ITEMS(_g_video_queue, us_frame_destroy);
+	US_RING_DELETE_WITH_ITEMS(_g_video_ring, us_frame_destroy);
 
 	US_DELETE(_g_rtpa, us_rtpa_destroy);
 	US_DELETE(_g_rtpv, us_rtpv_destroy);
@@ -317,7 +351,7 @@ static void _plugin_destroy_session(janus_plugin_session* session, int *err) {
 			found = true;
 		} else {
 			has_watchers = (has_watchers || atomic_load(&client->transmit));
-			has_listeners = (has_listeners || atomic_load(&client->transmit_audio));
+			has_listeners = (has_listeners || atomic_load(&client->transmit_acap));
 		}
 	});
 	if (!found) {
@@ -343,7 +377,8 @@ static json_t *_plugin_query_session(janus_plugin_session *session) {
 	return info;
 }
 
-static void _set_transmit(janus_plugin_session *session, UNUSED const char *msg, bool transmit) {
+static void _set_transmit(janus_plugin_session *session, const char *msg, bool transmit) {
+	(void)msg;
 	_IF_DISABLED({ return; });
 	_LOCK_ALL;
 	bool found = false;
@@ -371,17 +406,13 @@ static void _plugin_hangup_media(janus_plugin_session *session) { _set_transmit(
 static struct janus_plugin_result *_plugin_handle_message(
 	janus_plugin_session *session, char *transaction, json_t *msg, json_t *jsep) {
 
-	assert(transaction != NULL);
-
-#	define FREE_MSG_JSEP { \
-			US_DELETE(msg, json_decref); \
-			US_DELETE(jsep, json_decref); \
-		}
+	janus_plugin_result_type result_type = JANUS_PLUGIN_OK;
+	char *result_msg = NULL;
 
 	if (session == NULL || msg == NULL) {
-		free(transaction);
-		FREE_MSG_JSEP;
-		return janus_plugin_result_new(JANUS_PLUGIN_ERROR, (msg ? "No session" : "No message"), NULL);
+		result_type = JANUS_PLUGIN_ERROR;
+		result_msg = (msg ? "No session" : "No message");
+		goto done;
 	}
 
 #	define PUSH_ERROR(x_error, x_reason) { \
@@ -390,20 +421,20 @@ static struct janus_plugin_result *_plugin_handle_message(
 			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); \
+			_g_gw->push_event(session, create(), NULL, m_event, NULL); \
 			json_decref(m_event); \
 		}
 
 	json_t *const request = json_object_get(msg, "request");
 	if (request == NULL) {
 		PUSH_ERROR(400, "Request missing");
-		goto ok_wait;
+		goto done;
 	}
 
 	const char *const request_str = json_string_value(request);
 	if (request_str == NULL) {
 		PUSH_ERROR(400, "Request not a string");
-		goto ok_wait;
+		goto done;
 	}
 	// US_JLOG_INFO("main", "Message: %s", request_str);
 
@@ -413,10 +444,10 @@ static struct janus_plugin_result *_plugin_handle_message(
 			json_t *const m_result = json_object(); \
 			json_object_set_new(m_result, "status", json_string(x_status)); \
 			if (x_payload != NULL) { \
-				json_object_set_new(m_result, x_status, x_payload); \
+				json_object_set(m_result, x_status, x_payload); \
 			} \
 			json_object_set_new(m_event, "result", m_result); \
-			_g_gw->push_event(session, create(), transaction, m_event, x_jsep); \
+			_g_gw->push_event(session, create(), NULL, m_event, x_jsep); \
 			json_decref(m_event); \
 		}
 
@@ -427,13 +458,33 @@ static struct janus_plugin_result *_plugin_handle_message(
 		PUSH_STATUS("stopped", NULL, NULL);
 
 	} else if (!strcmp(request_str, "watch")) {
-		bool with_audio = false;
+		uint video_orient = 0;
+		bool with_acap = false;
+		bool with_aplay = false;
 		{
 			json_t *const params = json_object_get(msg, "params");
 			if (params != NULL) {
-				json_t *const audio = json_object_get(params, "audio");
-				if (audio != NULL && json_is_boolean(audio)) {
-					with_audio = (_g_rtpa != NULL && json_boolean_value(audio));
+				{
+					json_t *const obj = json_object_get(params, "audio");
+					if (obj != NULL && json_is_boolean(obj)) {
+						with_acap = (_g_rtpa != NULL && json_boolean_value(obj));
+					}
+				}
+				{
+					json_t *const obj = json_object_get(params, "microphone");
+					if (obj != NULL && json_is_boolean(obj)) {
+						with_aplay = (with_acap && json_boolean_value(obj)); // FIXME: also check playback
+					}
+				}
+				{
+					json_t *const obj = json_object_get(params, "orientation");
+					if (obj != NULL && json_is_integer(obj)) {
+						video_orient = json_integer_value(obj);
+						switch (video_orient) {
+							case 90: case 180: case 270: break;
+							default: video_orient = 0; break;
+						}
+					}
 				}
 			}
 		}
@@ -441,7 +492,7 @@ static struct janus_plugin_result *_plugin_handle_message(
 		{
 			char *sdp;
 			char *const video_sdp = us_rtpv_make_sdp(_g_rtpv);
-			char *const audio_sdp = (with_audio ? us_rtpa_make_sdp(_g_rtpa) : us_strdup(""));
+			char *const audio_sdp = (with_acap ? us_rtpa_make_sdp(_g_rtpa, with_aplay) : us_strdup(""));
 			US_ASPRINTF(sdp,
 				"v=0" RN
 				"o=- %" PRIu64 " 1 IN IP4 0.0.0.0" RN
@@ -472,16 +523,17 @@ static struct janus_plugin_result *_plugin_handle_message(
 			bool has_listeners = false;
 			US_LIST_ITERATE(_g_clients, client, {
 				if (client->session == session) {
-					atomic_store(&client->transmit_audio, with_audio);
+					atomic_store(&client->transmit_acap, with_acap);
+					atomic_store(&client->video_orient, video_orient);
 				}
-				has_listeners = (has_listeners || atomic_load(&client->transmit_audio));
+				has_listeners = (has_listeners || atomic_load(&client->transmit_acap));
 			});
 			atomic_store(&_g_has_listeners, has_listeners);
 			_UNLOCK_ALL;
 		}
 
 	} else if (!strcmp(request_str, "features")) {
-		json_t *const features = json_pack("{sb}", "audio", (_g_rtpa != NULL));
+		json_t *const features = json_pack("{sbsb}", "audio", (_g_rtpa != NULL), "microphone", false);
 		PUSH_STATUS("features", features, NULL);
 		json_decref(features);
 
@@ -493,16 +545,22 @@ static struct janus_plugin_result *_plugin_handle_message(
 		PUSH_ERROR(405, "Not implemented");
 	}
 
-	ok_wait:
-		FREE_MSG_JSEP;
-		return janus_plugin_result_new(JANUS_PLUGIN_OK_WAIT, NULL, NULL);
+done:
+	US_DELETE(transaction, free);
+	US_DELETE(msg, json_decref);
+	US_DELETE(jsep, json_decref);
+
+	return janus_plugin_result_new(
+		result_type, result_msg,
+		(result_type == JANUS_PLUGIN_OK ? json_pack("{sb}", "ok", 1) : NULL));
 
 #	undef PUSH_STATUS
 #	undef PUSH_ERROR
-#	undef FREE_MSG_JSEP
 }
 
-static void _plugin_incoming_rtcp(UNUSED janus_plugin_session *handle, UNUSED janus_plugin_rtcp *packet) {
+static void _plugin_incoming_rtcp(janus_plugin_session *handle, janus_plugin_rtcp *packet) {
+	(void)handle;
+	(void)packet;
 	if (packet->video && janus_rtcp_has_pli(packet->buffer, packet->length)) {
 		// US_JLOG_INFO("main", "Got video PLI");
 		atomic_store(&_g_key_required, true);

janus/src/rtp.c

@@ -5,7 +5,7 @@
 #    This source file is partially based on this code:                       #
 #      - https://github.com/catid/kvm/blob/master/kvm_pipeline/src           #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,29 +25,30 @@
 
 #include "rtp.h"
 
+#include <stdlib.h>
 
-us_rtp_s *us_rtp_init(unsigned payload, bool video) {
+#include "uslibs/types.h"
+#include "uslibs/tools.h"
+
+
+us_rtp_s *us_rtp_init(void) {
 	us_rtp_s *rtp;
 	US_CALLOC(rtp, 1);
-	rtp->payload = payload;
-	rtp->video = video;
-	rtp->ssrc = us_triple_u32(us_get_now_monotonic_u64());
 	return rtp;
 }
 
-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);
 }
 
-void us_rtp_write_header(us_rtp_s *rtp, uint32_t pts, bool marked) {
-	uint32_t word0 = 0x80000000;
+void us_rtp_assign(us_rtp_s *rtp, uint payload, bool video) {
+	rtp->payload = payload;
+	rtp->video = video;
+	rtp->ssrc = us_triple_u32(us_get_now_monotonic_u64());
+}
+
+void us_rtp_write_header(us_rtp_s *rtp, u32 pts, bool marked) {
+	u32 word0 = 0x80000000;
 	if (marked) {
 		word0 |= 1 << 23;
 	}
@@ -55,7 +56,8 @@ void us_rtp_write_header(us_rtp_s *rtp, uint32_t pts, bool marked) {
 	word0 |= rtp->seq;
 	++rtp->seq;
 
-#	define WRITE_BE_U32(_offset, _value) *((uint32_t *)(rtp->datagram + _offset)) = __builtin_bswap32(_value)
+#	define WRITE_BE_U32(x_offset, x_value) \
+		*((u32*)(rtp->datagram + x_offset)) = __builtin_bswap32(x_value)
 	WRITE_BE_U32(0, word0);
 	WRITE_BE_U32(4, pts);
 	WRITE_BE_U32(8, rtp->ssrc);

janus/src/rtp.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,13 +22,7 @@
 
 #pragma once
 
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdbool.h>
-
-#include <sys/types.h>
-
-#include "uslibs/tools.h"
+#include "uslibs/types.h"
 
 
 // https://stackoverflow.com/questions/47635545/why-webrtc-chose-rtp-max-packet-size-to-1200-bytes
@@ -37,21 +31,21 @@
 
 
 typedef struct {
-	unsigned	payload;
-	bool		video;
-	uint32_t	ssrc;
+	uint	payload;
+	bool	video;
+	u32		ssrc;
 
-	uint16_t	seq;
-	uint8_t		datagram[US_RTP_DATAGRAM_SIZE];
-	size_t		used;
-	bool		zero_playout_delay;
+	u16		seq;
+	u8		datagram[US_RTP_DATAGRAM_SIZE];
+	uz		used;
+	bool	zero_playout_delay;
 } us_rtp_s;
 
 typedef void (*us_rtp_callback_f)(const us_rtp_s *rtp);
 
 
-us_rtp_s *us_rtp_init(unsigned payload, bool video);
-us_rtp_s *us_rtp_dup(const us_rtp_s *rtp);
+us_rtp_s *us_rtp_init(void);
 void us_rtp_destroy(us_rtp_s *rtp);
 
-void us_rtp_write_header(us_rtp_s *rtp, uint32_t pts, bool marked);
+void us_rtp_assign(us_rtp_s *rtp, uint payload, bool video);
+void us_rtp_write_header(us_rtp_s *rtp, u32 pts, bool marked);

janus/src/rtpa.c

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,18 @@
 
 #include "rtpa.h"
 
+#include <stdlib.h>
+#include <inttypes.h>
+
+#include "uslibs/types.h"
+#include "uslibs/tools.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);
+	rtpa->rtp = us_rtp_init();
+	us_rtp_assign(rtpa->rtp, 111, false);
 	rtpa->callback = callback;
 	return rtpa;
 }
@@ -36,27 +43,27 @@ void us_rtpa_destroy(us_rtpa_s *rtpa) {
 	free(rtpa);
 }
 
-char *us_rtpa_make_sdp(us_rtpa_s *rtpa) {
-#	define PAYLOAD rtpa->rtp->payload
+char *us_rtpa_make_sdp(us_rtpa_s *rtpa, bool mic) {
+	const uint pl = 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=fmtp:%u sprop-stereo=1" RN // useinbandfec=1
 		"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
+		"a=%s" RN,
+		pl, pl, pl, pl, pl, pl,
+		rtpa->rtp->ssrc,
+		(mic ? "sendrecv" : "sendonly")
 	);
-#	undef PAYLOAD
 	return sdp;
 }
 
-void us_rtpa_wrap(us_rtpa_s *rtpa, const uint8_t *data, size_t size, uint32_t pts) {
+void us_rtpa_wrap(us_rtpa_s *rtpa, const u8 *data, uz size, u32 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);

janus/src/rtpa.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,15 +22,7 @@
 
 #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 "uslibs/types.h"
 
 #include "rtp.h"
 
@@ -44,5 +36,5 @@ typedef struct {
 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);
+char *us_rtpa_make_sdp(us_rtpa_s *rtpa, bool mic);
+void us_rtpa_wrap(us_rtpa_s *rtpa, const u8 *data, uz size, u32 pts);

janus/src/rtpv.c

@@ -5,7 +5,7 @@
 #    This source file is partially based on this code:                       #
 #      - https://github.com/catid/kvm/blob/master/kvm_pipeline/src           #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,16 +25,27 @@
 
 #include "rtpv.h"
 
+#include <stdlib.h>
+#include <inttypes.h>
+#include <assert.h>
 
-void _rtpv_process_nalu(us_rtpv_s *rtpv, const uint8_t *data, size_t size, uint32_t pts, bool marked);
+#include <linux/videodev2.h>
 
-static ssize_t _find_annexb(const uint8_t *data, size_t size);
+#include "uslibs/types.h"
+#include "uslibs/tools.h"
+#include "uslibs/frame.h"
+
+
+void _rtpv_process_nalu(us_rtpv_s *rtpv, const u8 *data, uz size, u32 pts, bool marked);
+
+static sz _find_annexb(const u8 *data, uz size);
 
 
 us_rtpv_s *us_rtpv_init(us_rtp_callback_f callback) {
 	us_rtpv_s *rtpv;
 	US_CALLOC(rtpv, 1);
-	rtpv->rtp = us_rtp_init(96, true);
+	rtpv->rtp = us_rtp_init();
+	us_rtp_assign(rtpv->rtp, 96, true);
 	rtpv->callback = callback;
 	return rtpv;
 }
@@ -45,9 +56,9 @@ void us_rtpv_destroy(us_rtpv_s *rtpv) {
 }
 
 char *us_rtpv_make_sdp(us_rtpv_s *rtpv) {
-#	define PAYLOAD rtpv->rtp->payload
 	// https://tools.ietf.org/html/rfc6184
 	// https://github.com/meetecho/janus-gateway/issues/2443
+	const uint pl = rtpv->rtp->payload;
 	char *sdp;
 	US_ASPRINTF(sdp,
 		"m=video 1 RTP/SAVPF %u" RN
@@ -60,39 +71,39 @@ char *us_rtpv_make_sdp(us_rtpv_s *rtpv) {
 		"a=rtcp-fb:%u goog-remb" RN
 		"a=ssrc:%" PRIu32 " cname:ustreamer" RN
 		"a=extmap:1 http://www.webrtc.org/experiments/rtp-hdrext/playout-delay" RN
+		"a=extmap:2 urn:3gpp:video-orientation" RN
 		"a=sendonly" RN,
-		PAYLOAD, PAYLOAD, PAYLOAD, PAYLOAD,
-		PAYLOAD, PAYLOAD, PAYLOAD,
+		pl, pl, pl, pl,
+		pl, pl, pl,
 		rtpv->rtp->ssrc
 	);
 	return sdp;
-#	undef PAYLOAD
 }
 
 #define _PRE 3 // Annex B prefix length
 
-void us_rtpv_wrap(us_rtpv_s *rtpv, const us_frame_s *frame) {
+void us_rtpv_wrap(us_rtpv_s *rtpv, const us_frame_s *frame, bool zero_playout_delay) {
 	// 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);
 
-	rtpv->rtp->zero_playout_delay = (frame->gop == 0);
+	rtpv->rtp->zero_playout_delay = zero_playout_delay;
 
-	const uint32_t pts = us_get_now_monotonic_u64() * 9 / 100; // PTS units are in 90 kHz
-	ssize_t last_offset = -_PRE;
+	const u32 pts = us_get_now_monotonic_u64() * 9 / 100; // PTS units are in 90 kHz
+	sz 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);
+		const uz next_start = last_offset + _PRE;
+		sz 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;
+			const u8 *const data = frame->data + last_offset + _PRE;
+			uz size = offset - last_offset - _PRE;
 			if (data[size - 1] == 0) { // Check for extra 00
 				--size;
 			}
@@ -103,34 +114,33 @@ void us_rtpv_wrap(us_rtpv_s *rtpv, const us_frame_s *frame) {
 	}
 
 	if (last_offset >= 0) {
-		const uint8_t *const data = frame->data + last_offset + _PRE;
-		size_t size = frame->used - last_offset - _PRE;
+		const u8 *const data = frame->data + last_offset + _PRE;
+		uz 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) {
-#	define DG rtpv->rtp->datagram
-
-	const unsigned ref_idc = (data[0] >> 5) & 3;
-	const unsigned type = data[0] & 0x1F;
+void _rtpv_process_nalu(us_rtpv_s *rtpv, const u8 *data, uz size, u32 pts, bool marked) {
+	const uint ref_idc = (data[0] >> 5) & 3;
+	const uint type = data[0] & 0x1F;
+	u8 *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);
+		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 uz fu_overhead = US_RTP_HEADER_SIZE + 2; // FU-A overhead
 
-	const uint8_t *src = data + 1;
-	ssize_t remaining = size - 1;
+	const u8 *src = data + 1;
+	sz remaining = size - 1;
 
 	bool first = true;
 	while (remaining > 0) {
-		ssize_t frag_size = US_RTP_DATAGRAM_SIZE - fu_overhead;
+		sz frag_size = US_RTP_DATAGRAM_SIZE - fu_overhead;
 		const bool last = (remaining <= frag_size);
 		if (last) {
 			frag_size = remaining;
@@ -138,18 +148,18 @@ void _rtpv_process_nalu(us_rtpv_s *rtpv, const uint8_t *data, size_t size, uint3
 
 		us_rtp_write_header(rtpv->rtp, pts, (marked && last));
 
-		DG[US_RTP_HEADER_SIZE] = 28 | (ref_idc << 5);
+		dg[US_RTP_HEADER_SIZE] = 28 | (ref_idc << 5);
 
-		uint8_t fu = type;
+		u8 fu = type;
 		if (first) {
 			fu |= 0x80;
 		}
 		if (last) {
 			fu |= 0x40;
 		}
-		DG[US_RTP_HEADER_SIZE + 1] = fu;
+		dg[US_RTP_HEADER_SIZE + 1] = fu;
 
-		memcpy(DG + fu_overhead, src, frag_size);
+		memcpy(dg + fu_overhead, src, frag_size);
 		rtpv->rtp->used = fu_overhead + frag_size;
 		rtpv->callback(rtpv->rtp);
 
@@ -157,14 +167,12 @@ void _rtpv_process_nalu(us_rtpv_s *rtpv, const uint8_t *data, size_t size, uint3
 		remaining -= frag_size;
 		first = false;
 	}
-
-#	undef DG
 }
 
-static ssize_t _find_annexb(const uint8_t *data, size_t size) {
+static sz _find_annexb(const u8 *data, uz size) {
 	// Parses buffer for 00 00 01 start codes
 	if (size >= _PRE) {
-		for (size_t index = 0; index <= size - _PRE; ++index) {
+		for (uz index = 0; index <= size - _PRE; ++index) {
 			if (data[index] == 0 && data[index + 1] == 0 && data[index + 2] == 1) {
 				return index;
 			}

janus/src/rtpv.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,16 +22,7 @@
 
 #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 "uslibs/tools.h"
+#include "uslibs/types.h"
 #include "uslibs/frame.h"
 
 #include "rtp.h"
@@ -47,4 +38,4 @@ us_rtpv_s *us_rtpv_init(us_rtp_callback_f callback);
 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);
+void us_rtpv_wrap(us_rtpv_s *rtpv, const us_frame_s *frame, bool zero_playout_delay);

janus/src/uslibs/errors.h

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

janus/src/uslibs/memsinksh.c

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

janus/src/uslibs/queue.c

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

janus/src/uslibs/queue.h

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

janus/src/uslibs/ring.c

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

janus/src/uslibs/ring.h

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

janus/src/uslibs/tc358743.c

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

janus/src/uslibs/tc358743.h

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

janus/src/uslibs/types.h

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

linters/cppcheck.h

@@ -2,5 +2,3 @@
 #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

@@ -33,7 +33,7 @@ max-line-length = 160
 
 [BASIC]
 # Good variable names which should always be accepted, separated by a comma
-good-names = _, __, x, y, ws, make-html-h, make-jpeg-h, make-ico-h
+good-names = _, __, x, y, ws, make-html-h, make-ico-h
 
 # Regular expression matching correct method names
 method-rgx = [a-z_][a-z0-9_]{2,50}$

linters/tox.ini

@@ -3,30 +3,31 @@ envlist = cppcheck, flake8, pylint, mypy, vulture, htmlhint
 skipsdist = true
 
 [testenv]
-basepython = python3.11
+basepython = python3.13
 changedir = /src
 
 [testenv:cppcheck]
 allowlist_externals = cppcheck
 commands = cppcheck \
-			-j4 \
 			--force \
 			--std=c17 \
 			--error-exitcode=1 \
 			--quiet \
-			--enable=warning,unusedFunction,portability,performance,style \
+			--check-level=exhaustive \
+			--enable=warning,portability,performance,style \
 			--suppress=assignmentInAssert \
+			--suppress=assertWithSideEffect \
 			--suppress=variableScope \
 			--inline-suppr \
 			--library=python \
 			--include=linters/cppcheck.h \
-		src python/*.? janus/*.?
+		src python/src/*.? janus/src/*.?
 
 [testenv:flake8]
 allowlist_externals = bash
 commands = bash -c 'flake8 --config=linters/flake8.ini tools/*.py' python/*.py
 deps =
-	flake8==5.0.4
+	flake8
 	flake8-quotes
 
 [testenv:pylint]
@@ -34,6 +35,7 @@ allowlist_externals = bash
 commands = bash -c 'pylint --rcfile=linters/pylint.ini --output-format=colorized --reports=no tools/*.py python/*.py'
 deps =
 	pylint
+	setuptools
 
 [testenv:mypy]
 allowlist_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 5.40" "January 2021"
+.TH USTREAMER-DUMP 1 "version 6.23" "January 2021"
 
 .SH NAME
 ustreamer-dump \- Dump uStreamer's memory sink to file

man/ustreamer.1

@@ -1,6 +1,6 @@
 .\" Manpage for ustreamer.
 .\" Open an issue or pull request to https://github.com/pikvm/ustreamer to correct errors or typos
-.TH USTREAMER 1 "version 5.40" "November 2020"
+.TH USTREAMER 1 "version 6.23" "November 2020"
 
 .SH NAME
 ustreamer \- stream MJPEG video from any V4L2 device to the network
@@ -17,7 +17,7 @@ Without arguments, \fBustreamer\fR will try to open \fB/dev/video0\fR with 640x4
 
 Please note that since µStreamer v2\.0 cross\-domain requests were disabled by default for security reasons\. To enable the old behavior, use the option \fB\-\-allow\-origin=\e*\fR\.
 
-For example, the recommended way of running µStreamer with Auvidea B101 on a Raspberry Pi is:
+For example, the recommended way of running µStreamer with TC358743-based capture device on a Raspberry Pi is:
 
 \fBustreamer \e\fR
 .RS
@@ -27,7 +27,7 @@ For example, the recommended way of running µStreamer with Auvidea B101 on a Ra
 .nf
 \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)
+\fB\-\-persistent \e\fR # Suppress repetitive signal source errors (for example when HDMI cable was disconnected)
 .nf
 \fB\-\-dv\-timings \e\fR # Use DV\-timings
 .nf
@@ -52,7 +52,7 @@ Initial image resolution. Default: 640x480.
 .TP
 .BR \-m\ \fIfmt ", " \-\-format\ \fIfmt
 Image format.
-Available: YUYV, UYVY, RGB565, RGB24, JPEG; default: YUYV.
+Available: YUYV, YVYU, UYVY, RGB565, RGB24, JPEG; default: YUYV.
 .TP
 .BR \-a\ \fIstd ", " \-\-tv\-standard\ \fIstd
 Force TV standard.
@@ -68,8 +68,11 @@ Desired FPS. Default: maximum possible.
 .BR \-z\ \fIN ", " \-\-min\-frame\-size\ \fIN
 Drop frames smaller then this limit. Useful if the device produces small\-sized garbage frames. Default: 128 bytes.
 .TP
+.BR \-T ", " \-\-allow\-truncated\-frames
+Allows to handle truncated frames. Useful if the device produces incorrect but still acceptable frames. Default: disabled.
+.TP
 .BR \-n ", " \-\-persistent
-Don't re\-initialize device on timeout. Default: disabled.
+Suppress repetitive signal source errors. Default: disabled.
 .TP
 .BR \-t ", " \-\-dv\-timings
 Enable DV-timings querying and events processing to automatic resolution change. Default: disabled.
@@ -96,17 +99,15 @@ HW ─ Use pre-encoded MJPEG frames directly from camera hardware.
 M2M-VIDEO ─ GPU-accelerated MJPEG encoding.
 
 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.
 .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'.
+It doesn't do anything. Still here for compatibility.
 .TP
 .BR \-K\ \fIsec ", " \-\-last\-as\-blank\ \fIsec
-Show the last frame received from the camera after it was disconnected, but no more than specified time (or endlessly if 0 is specified). If the device has not yet been online, display 'NO SIGNAL' or the image specified by option \-\-blank. Note: currently this option has no effect on memory sinks. Default: disabled.
+It doesn't do anything. Still here for compatibility.
 .TP
 .BR \-l ", " \-\-slowdown
 Slowdown capturing to 1 FPS or less when no stream or sink clients are connected. Useful to reduce CPU consumption. Default: disabled.
@@ -212,25 +213,25 @@ Timeout for client connections. Default: 10.
 .SS "JPEG sink options"
 With shared memory sink you can write a stream to a file. See \fBustreamer-dump\fR(1) for more info.
 .TP
-.BR \-\-sink\ \fIname
-Use the specified shared memory object to sink JPEG frames. Default: disabled.
+.BR \-\-jpeg\-sink\ \fIname
+Use the specified shared memory object to sink JPEG frames. The name should end with a suffix ".jpeg" or ":jpeg". Default: disabled.
 .TP
-.BR \-\-sink\-mode\ \fImode
+.BR \-\-jpeg\-sink\-mode\ \fImode
 Set JPEG sink permissions (like 777). Default: 660.
 .TP
-.BR \-\-sink\-rm
+.BR \-\-jpeg\-sink\-rm
 Remove shared memory on stop. Default: disabled.
 .TP
-.BR \-\-sink\-client\-ttl\ \fIsec
+.BR \-\-jpeg\-sink\-client\-ttl\ \fIsec
 Client TTL. Default: 10.
 .TP
-.BR \-\-sink\-timeout\ \fIsec
+.BR \-\-jpeg\-sink\-timeout\ \fIsec
 Timeout for lock. Default: 1.
 
 .SS "H264 sink options"
 .TP
 .BR \-\-h264\-sink\ \fIname
-Use the specified shared memory object to sink H264 frames. Default: disabled.
+Use the specified shared memory object to sink H264 frames. The name should end with a suffix ".h264" or ":h264". Default: disabled.
 .TP
 .BR \-\-h264\-sink\-mode\ \fImode
 Set H264 sink permissions (like 777). Default: 660.
@@ -248,11 +249,27 @@ Timeout for lock. Default: 1.
 H264 bitrate in Kbps. Default: 5000.
 .TP
 .BR \-\-h264\-gop\ \fIN
-Intarval between keyframes. Default: 30.
+Interval between keyframes. Default: 30.
 .TP
 .BR \-\-h264\-m2m\-device\ \fI/dev/path
 Path to V4L2 mem-to-mem encoder device. Default: auto-select.
 
+.SS "RAW sink options"
+.TP
+.BR \-\-raw\-sink\ \fIname
+Use the specified shared memory object to sink RAW frames. The name should end with a suffix ".raw" or ":raw". Default: disabled.
+.TP
+.BR \-\-raw\-sink\-mode\ \fImode
+Set RAW sink permissions (like 777). Default: 660.
+.TP
+.BR \-\-raw\-sink\-rm
+Remove shared memory on stop. Default: disabled.
+.TP
+.BR \-\-raw\-sink\-client\-ttl\ \fIsec
+Client TTL. Default: 10.
+.TP
+.BR \-\-raw\-sink\-timeout\ \fIsec
+Timeout for lock. Default: 1.
 
 .SS "Process options"
 .TP

pkg/arch/PKGBUILD

@@ -3,14 +3,14 @@
 
 
 pkgname=ustreamer
-pkgver=5.40
+pkgver=6.23
 pkgrel=1
 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 systemd)
-makedepends=(gcc make systemd)
+makedepends=(gcc make pkgconf systemd)
 source=(${pkgname}::"git+https://github.com/pikvm/ustreamer#commit=v${pkgver}")
 md5sums=(SKIP)
 
@@ -19,7 +19,7 @@ _options="WITH_GPIO=1 WITH_SYSTEMD=1"
 if [ -e /usr/bin/python3 ]; then
 	_options="$_options WITH_PYTHON=1"
 	depends+=(python)
-	makedepends+=(python-setuptools)
+	makedepends+=(python-setuptools python-pip python-build python-wheel)
 fi
 if [ -e /usr/include/janus/plugins/plugin.h ];then
 	depends+=(janus-gateway alsa-lib opus)
@@ -28,12 +28,6 @@ if [ -e /usr/include/janus/plugins/plugin.h ];then
 fi
 
 
-# LD does not link mmal with this option
-# This DOESN'T affect setup.py
-LDFLAGS="${LDFLAGS//--as-needed/}"
-export LDFLAGS="${LDFLAGS//,,/,}"
-
-
 build() {
 	cd "$srcdir"
 	rm -rf $pkgname-build

pkg/docker/Dockerfile.alpine

@@ -24,7 +24,7 @@ RUN apk add --no-cache \
 WORKDIR /ustreamer
 COPY --from=build /build/ustreamer/src/ustreamer.bin ustreamer
 
-RUN wget https://raw.githubusercontent.com/pikvm/kvmd/master/configs/kvmd/edid/v3-hdmi.hex -O /edid.hex
+RUN wget https://raw.githubusercontent.com/pikvm/kvmd/master/configs/kvmd/edid/v2.hex -O /edid.hex
 COPY pkg/docker/entry.sh /
 
 EXPOSE 8080

pkg/openwrt/Makefile

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

python/MANIFEST.in

@@ -0,0 +1,2 @@
+include setup.py
+recursive-include src *.c *h

python/Makefile

@@ -1,20 +1,23 @@
 -include ../config.mk
 
-DESTDIR ?=
+R_DESTDIR ?=
 PREFIX ?= /usr/local
 
 PY ?= python3
 
 
 # =====
-all:
+all: root
+root: $(shell find src -type f,l)
 	$(info == PY_BUILD ustreamer-*.so)
-	@ $(PY) setup.py build
+	rm -rf root
+	$(ECHO) $(PY) -m build --skip-dependency-check --no-isolation
+	$(ECHO) $(PY) -m pip install dist/*.whl --ignore-installed --root=./root
 
 
 install:
-	$(PY) setup.py install --prefix=$(PREFIX) --root=$(if $(DESTDIR),$(DESTDIR),/)
+	$(PY) -m pip install dist/*.whl --ignore-installed --prefix=$(PREFIX) --root=$(if $(R_DESTDIR),$(R_DESTDIR),/)
 
 
 clean:
-	rm -rf build
+	rm -rf root dist ustreamer.egg-info

python/setup.py

@@ -17,7 +17,7 @@ def _find_sources(suffix: str) -> list[str]:
 if __name__ == "__main__":
     setup(
         name="ustreamer",
-        version="5.40",
+        version="6.23",
         description="uStreamer tools",
         author="Maxim Devaev",
         author_email="mdevaev@gmail.com",
@@ -29,7 +29,6 @@ if __name__ == "__main__":
                 extra_compile_args=["-std=c17", "-D_GNU_SOURCE"],
                 undef_macros=["NDEBUG"],
                 sources=_find_sources(".c"),
-                depends=_find_sources(".h"),
             ),
         ],
     )

python/src/uslibs/errors.h

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

python/src/uslibs/memsinksh.c

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

python/src/uslibs/types.h

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

python/src/ustreamer.c

@@ -13,6 +13,8 @@
 
 #include <Python.h>
 
+#include "uslibs/types.h"
+#include "uslibs/errors.h"
 #include "uslibs/tools.h"
 #include "uslibs/frame.h"
 #include "uslibs/memsinksh.h"
@@ -25,33 +27,24 @@ typedef struct {
 	double	lock_timeout;
 	double	wait_timeout;
 	double	drop_same_frames;
+	uz		data_size;
 
 	int					fd;
 	us_memsink_shared_s	*mem;
 
-	uint64_t		frame_id;
-	long double		frame_ts;
+	u64				frame_id;
+	ldf				frame_ts;
 	us_frame_s		*frame;
 } _MemsinkObject;
 
 
-#define _MEM(x_next)	self->mem->x_next
-#define _FRAME(x_next)	self->frame->x_next
-
-
 static void _MemsinkObject_destroy_internals(_MemsinkObject *self) {
 	if (self->mem != NULL) {
-		us_memsink_shared_unmap(self->mem);
+		us_memsink_shared_unmap(self->mem, self->data_size);
 		self->mem = NULL;
 	}
-	if (self->fd >= 0) {
-		close(self->fd);
-		self->fd = -1;
-	}
-	if (self->frame != NULL) {
-		us_frame_destroy(self->frame);
-		self->frame = NULL;
-	}
+	US_CLOSE_FD(self->fd);
+	US_DELETE(self->frame, us_frame_destroy);
 }
 
 static int _MemsinkObject_init(_MemsinkObject *self, PyObject *args, PyObject *kwargs) {
@@ -65,41 +58,42 @@ static int _MemsinkObject_init(_MemsinkObject *self, PyObject *args, PyObject *k
 		return -1;
 	}
 
-#	define SET_DOUBLE(_field, _cond) { \
-			if (!(self->_field _cond)) { \
-				PyErr_SetString(PyExc_ValueError, #_field " must be " #_cond); \
+#	define SET_DOUBLE(x_field, x_cond) { \
+			if (!(self->x_field x_cond)) { \
+				PyErr_SetString(PyExc_ValueError, #x_field " must be " #x_cond); \
 				return -1; \
 			} \
 		}
-
 	SET_DOUBLE(lock_timeout, > 0);
 	SET_DOUBLE(wait_timeout, > 0);
 	SET_DOUBLE(drop_same_frames, >= 0);
-
 #	undef SET_DOUBLE
 
+	if ((self->data_size = us_memsink_calculate_size(self->obj)) == 0) {
+		PyErr_SetString(PyExc_ValueError, "Invalid memsink object suffix");
+		return -1;
+	}
+
 	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 = us_memsink_shared_map(self->fd)) == NULL) {
+	if ((self->mem = us_memsink_shared_map(self->fd, self->data_size)) == NULL) {
 		PyErr_SetFromErrno(PyExc_OSError);
 		goto error;
 	}
-
 	return 0;
 
-	error:
-		_MemsinkObject_destroy_internals(self);
-		return -1;
+error:
+	_MemsinkObject_destroy_internals(self);
+	return -1;
 }
 
 static PyObject *_MemsinkObject_repr(_MemsinkObject *self) {
 	char repr[1024];
-	snprintf(repr, 1023, "<Memsink(%s)>", self->obj);
+	US_SNPRINTF(repr, 1023, "<Memsink(%s)>", self->obj);
 	return Py_BuildValue("s", repr);
 }
 
@@ -115,70 +109,76 @@ static PyObject *_MemsinkObject_close(_MemsinkObject *self, PyObject *Py_UNUSED(
 
 static PyObject *_MemsinkObject_enter(_MemsinkObject *self, PyObject *Py_UNUSED(ignored)) {
 	Py_INCREF(self);
-	return (PyObject *)self;
+	return (PyObject*)self;
 }
 
 static PyObject *_MemsinkObject_exit(_MemsinkObject *self, PyObject *Py_UNUSED(ignored)) {
-	return PyObject_CallMethod((PyObject *)self, "close", "");
+	return PyObject_CallMethod((PyObject*)self, "close", "");
 }
 
 static int _wait_frame(_MemsinkObject *self) {
-	const long double deadline_ts = us_get_now_monotonic() + self->wait_timeout;
+	const ldf deadline_ts = us_get_now_monotonic() + self->wait_timeout;
 
-#	define RETURN_OS_ERROR { \
-			Py_BLOCK_THREADS \
-			PyErr_SetFromErrno(PyExc_OSError); \
-			return -1; \
-		}
-
-	long double now;
+	int locked = -1;
+	ldf now_ts;
 	do {
 		Py_BEGIN_ALLOW_THREADS
 
-		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) == US_MEMSINK_MAGIC && _MEM(version) == US_MEMSINK_VERSION && _MEM(id) != self->frame_id) {
-				if (self->drop_same_frames > 0) {
-					if (
-						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))
-					) {
-						self->frame_id = _MEM(id);
-						goto drop;
-					}
-				}
-
-				Py_BLOCK_THREADS
-				return 0;
+		locked = us_flock_timedwait_monotonic(self->fd, self->lock_timeout);
+		now_ts = us_get_now_monotonic();
+		if (locked < 0) {
+			if (errno == EWOULDBLOCK) {
+				goto retry;
 			}
+			goto os_error;
+		}
 
-			if (flock(self->fd, LOCK_UN) < 0) {
-				RETURN_OS_ERROR;
+		us_memsink_shared_s *mem = self->mem;
+		if (mem->magic != US_MEMSINK_MAGIC || mem->version != US_MEMSINK_VERSION) {
+			goto retry;
+		}
+
+		// Let the sink know that the client is alive
+		mem->last_client_ts = now_ts;
+
+		if (mem->id == self->frame_id) {
+			goto retry;
+		}
+
+		if (self->drop_same_frames > 0) {
+			if (
+				US_FRAME_COMPARE_GEOMETRY(self->mem, self->frame)
+				&& (self->frame_ts + self->drop_same_frames > now_ts)
+				&& !memcmp(self->frame->data, us_memsink_get_data(mem), mem->used)
+			) {
+				self->frame_id = mem->id;
+				goto retry;
 			}
 		}
 
-		drop:
+		// New frame found
+		Py_BLOCK_THREADS
+		return 0;
 
+	os_error:
+		Py_BLOCK_THREADS
+		PyErr_SetFromErrno(PyExc_OSError);
+		return -1;
+
+	retry:
+		if (locked >= 0 && flock(self->fd, LOCK_UN) < 0) {
+			goto os_error;
+		}
 		if (usleep(1000) < 0) {
-			RETURN_OS_ERROR;
+			goto os_error;
 		}
-
 		Py_END_ALLOW_THREADS
-
 		if (PyErr_CheckSignals() < 0) {
 			return -1;
 		}
-	} while (now < deadline_ts);
+	} while (now_ts < deadline_ts);
 
-#	undef RETURN_OS_ERROR
-
-	return -2;
+	return US_ERROR_NO_DATA;
 }
 
 static PyObject *_MemsinkObject_wait_frame(_MemsinkObject *self, PyObject *args, PyObject *kwargs) {
@@ -195,17 +195,17 @@ static PyObject *_MemsinkObject_wait_frame(_MemsinkObject *self, PyObject *args,
 
 	switch (_wait_frame(self)) {
 		case 0: break;
-		case -2: Py_RETURN_NONE;
+		case US_ERROR_NO_DATA: Py_RETURN_NONE;
 		default: return NULL;
 	}
 
-	us_frame_set_data(self->frame, _MEM(data), _MEM(used));
+	us_memsink_shared_s *mem = self->mem;
+	us_frame_set_data(self->frame, us_memsink_get_data(mem), mem->used);
 	US_FRAME_COPY_META(self->mem, self->frame);
-	self->frame_id = _MEM(id);
+	self->frame_id = mem->id;
 	self->frame_ts = us_get_now_monotonic();
-	_MEM(last_client_ts) = self->frame_ts;
 	if (key_required) {
-		_MEM(key_requested) = true;
+		mem->key_requested = true;
 	}
 
 	if (flock(self->fd, LOCK_UN) < 0) {
@@ -217,18 +217,18 @@ static PyObject *_MemsinkObject_wait_frame(_MemsinkObject *self, PyObject *args,
 		return NULL;
 	}
 
-#	define SET_VALUE(_key, _maker) { \
-			PyObject *_tmp = _maker; \
-			if (_tmp == NULL) { \
+#	define SET_VALUE(x_key, x_maker) { \
+			PyObject *m_tmp = x_maker; \
+			if (m_tmp == NULL) { \
 				return NULL; \
 			} \
-			if (PyDict_SetItemString(dict_frame, _key, _tmp) < 0) { \
-				Py_DECREF(_tmp); \
+			if (PyDict_SetItemString(dict_frame, x_key, m_tmp) < 0) { \
+				Py_DECREF(m_tmp); \
 				return NULL; \
 			} \
-			Py_DECREF(_tmp); \
+			Py_DECREF(m_tmp); \
 		}
-#	define SET_NUMBER(_key, _from, _to) SET_VALUE(#_key, Py##_to##_From##_from(_FRAME(_key)))
+#	define SET_NUMBER(x_key, x_from, x_to) SET_VALUE(#x_key, Py##x_to##_From##x_from(self->frame->x_key))
 
 	SET_NUMBER(width, Long, Long);
 	SET_NUMBER(height, Long, Long);
@@ -240,7 +240,7 @@ static PyObject *_MemsinkObject_wait_frame(_MemsinkObject *self, PyObject *args,
 	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*)self->frame->data, self->frame->used));
 
 #	undef SET_NUMBER
 #	undef SET_VALUE
@@ -252,21 +252,19 @@ static PyObject *_MemsinkObject_is_opened(_MemsinkObject *self, PyObject *Py_UNU
 	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)) { \
-		return Py##_to##_From##_from(self->_field); \
+#define FIELD_GETTER(x_field, x_from, x_to) \
+	static PyObject *_MemsinkObject_getter_##x_field(_MemsinkObject *self, void *Py_UNUSED(closure)) { \
+		return Py##x_to##_From##x_from(self->x_field); \
 	}
-
 FIELD_GETTER(obj, String, Unicode)
 FIELD_GETTER(lock_timeout, Double, Float)
 FIELD_GETTER(wait_timeout, Double, Float)
 FIELD_GETTER(drop_same_frames, Double, Float)
-
 #undef FIELD_GETTER
 
 static PyMethodDef _MemsinkObject_methods[] = {
-#	define ADD_METHOD(_name, _method, _flags) \
-		{.ml_name = _name, .ml_meth = (PyCFunction)_MemsinkObject_##_method, .ml_flags = (_flags)}
+#	define ADD_METHOD(x_name, x_method, x_flags) \
+		{.ml_name = x_name, .ml_meth = (PyCFunction)_MemsinkObject_##x_method, .ml_flags = (x_flags)}
 	ADD_METHOD("close", close, METH_NOARGS),
 	ADD_METHOD("__enter__", enter, METH_NOARGS),
 	ADD_METHOD("__exit__", exit, METH_VARARGS),
@@ -277,7 +275,7 @@ static PyMethodDef _MemsinkObject_methods[] = {
 };
 
 static PyGetSetDef _MemsinkObject_getsets[] = {
-#	define ADD_GETTER(_field) {.name = #_field, .get = (getter)_MemsinkObject_getter_##_field}
+#	define ADD_GETTER(x_field) {.name = #x_field, .get = (getter)_MemsinkObject_getter_##x_field}
 	ADD_GETTER(obj),
 	ADD_GETTER(lock_timeout),
 	ADD_GETTER(wait_timeout),
@@ -305,7 +303,7 @@ static PyModuleDef _Module = {
 	.m_size = -1,
 };
 
-PyMODINIT_FUNC PyInit_ustreamer(void) { // cppcheck-suppress unusedFunction
+PyMODINIT_FUNC PyInit_ustreamer(void) {
 	PyObject *module = PyModule_Create(&_Module);
 	if (module == NULL) {
 		return NULL;
@@ -317,7 +315,7 @@ PyMODINIT_FUNC PyInit_ustreamer(void) { // cppcheck-suppress unusedFunction
 
 	Py_INCREF(&_MemsinkType);
 
-	if (PyModule_AddObject(module, "Memsink", (PyObject *)&_MemsinkType) < 0) {
+	if (PyModule_AddObject(module, "Memsink", (PyObject*)&_MemsinkType) < 0) {
 		return NULL;
 	}
 

src/Makefile

@@ -1,4 +1,4 @@
-DESTDIR ?=
+R_DESTDIR ?=
 PREFIX ?= /usr/local
 
 CC ?= gcc
@@ -9,13 +9,14 @@ LDFLAGS ?=
 # =====
 _USTR = ustreamer.bin
 _DUMP = ustreamer-dump.bin
+_V4P = ustreamer-v4p.bin
 
 _CFLAGS = -MD -c -std=c17 -Wall -Wextra -D_GNU_SOURCE $(CFLAGS)
-_LDFLAGS = $(LDFLAGS)
 
-_COMMON_LIBS = -lm -ljpeg -pthread -lrt
+_USTR_LDFLAGS = $(LDFLAGS) -lm -ljpeg -pthread -lrt -latomic -levent -levent_pthreads
+_DUMP_LDFLAGS = $(LDFLAGS) -lm -ljpeg -pthread -lrt -latomic
+_V4P_LDFLAGS = $(LDFLAGS) -lm -ljpeg -pthread -lrt -latomic
 
-_USTR_LIBS = $(_COMMON_LIBS) -levent -levent_pthreads
 _USTR_SRCS = $(shell ls \
 	libs/*.c \
 	ustreamer/*.c \
@@ -26,31 +27,40 @@ _USTR_SRCS = $(shell ls \
 	ustreamer/*.c \
 )
 
-_DUMP_LIBS = $(_COMMON_LIBS)
 _DUMP_SRCS = $(shell ls \
 	libs/*.c \
 	dump/*.c \
 )
 
+_V4P_SRCS = $(shell ls \
+	libs/*.c \
+	libs/drm/*.c \
+	v4p/*.c \
+)
+
 _BUILD = build
 
 
+_TARGETS = $(_USTR) $(_DUMP)
+_OBJS = $(_USTR_SRCS:%.c=$(_BUILD)/%.o) $(_DUMP_SRCS:%.c=$(_BUILD)/%.o)
+
+
 define optbool
 $(filter $(shell echo $(1) | tr A-Z a-z), yes on 1)
 endef
 
 
 ifneq ($(call optbool,$(WITH_GPIO)),)
-_USTR_LIBS += -lgpiod
-override _CFLAGS += -DWITH_GPIO
-_USTR_SRCS += $(shell ls ustreamer/gpio/*.c)
+override _CFLAGS += -DWITH_GPIO $(shell pkg-config --atleast-version=2 libgpiod 2> /dev/null && echo -DHAVE_GPIOD2)
+override _USTR_LDFLAGS += -lgpiod
+override _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)
+override _USTR_LDFLAGS += -lsystemd
+override _USTR_SRCS += $(shell ls ustreamer/http/systemd/*.c)
 endif
 
 
@@ -62,47 +72,64 @@ endif
 
 WITH_SETPROCTITLE ?= 1
 ifneq ($(call optbool,$(WITH_SETPROCTITLE)),)
-ifeq ($(shell uname -s | tr A-Z a-z),linux)
-_USTR_LIBS += -lbsd
-endif
 override _CFLAGS += -DWITH_SETPROCTITLE
+ifeq ($(shell uname -s | tr A-Z a-z),linux)
+override _USTR_LDFLAGS += -lbsd
+endif
+endif
+
+
+WITH_V4P ?= 0
+ifneq ($(call optbool,$(WITH_V4P)),)
+override _TARGETS += $(_V4P)
+override _OBJS += $(_V4P_SRCS:%.c=$(_BUILD)/%.o)
+override _CFLAGS += -DWITH_V4P $(shell pkg-config --cflags libdrm)
+override _V4P_LDFLAGS += $(shell pkg-config --libs libdrm)
+override _USTR_SRCS += $(shell ls libs/drm/*.c)
+override _USTR_LDFLAGS += $(shell pkg-config --libs libdrm)
 endif
 
 
 # =====
-all: $(_USTR) $(_DUMP)
+all: $(_TARGETS)
 
 
 install: all
-	mkdir -p $(DESTDIR)$(PREFIX)/bin
-	install -m755 $(_USTR) $(DESTDIR)$(PREFIX)/bin/$(subst .bin,,$(_USTR))
-	install -m755 $(_DUMP) $(DESTDIR)$(PREFIX)/bin/$(subst .bin,,$(_DUMP))
+	mkdir -p $(R_DESTDIR)$(PREFIX)/bin
+	for i in $(subst .bin,,$(_TARGETS)); do \
+		install -m755 $$i.bin $(R_DESTDIR)$(PREFIX)/bin/$$i; \
+	done
 
 
 install-strip: install
-	strip $(DESTDIR)$(PREFIX)/bin/$(subst .bin,,$(_USTR))
-	strip $(DESTDIR)$(PREFIX)/bin/$(subst .bin,,$(_DUMP))
+	for i in $(subst .bin,,$(_TARGETS)); do \
+		strip $(R_DESTDIR)$(PREFIX)/bin/$$i; \
+	done
 
 
 $(_USTR): $(_USTR_SRCS:%.c=$(_BUILD)/%.o)
 	$(info == LD $@)
-	@ $(CC) $^ -o $@ $(_LDFLAGS) $(_USTR_LIBS)
+	$(ECHO) $(CC) $^ -o $@ $(_USTR_LDFLAGS)
 
 
 $(_DUMP): $(_DUMP_SRCS:%.c=$(_BUILD)/%.o)
 	$(info == LD $@)
-	@ $(CC) $^ -o $@ $(_LDFLAGS) $(_DUMP_LIBS)
+	$(ECHO) $(CC) $^ -o $@ $(_DUMP_LDFLAGS)
+
+
+$(_V4P): $(_V4P_SRCS:%.c=$(_BUILD)/%.o)
+	$(info == LD $@)
+	$(ECHO) $(CC) $^ -o $@ $(_V4P_LDFLAGS)
 
 
 $(_BUILD)/%.o: %.c
 	$(info -- CC $<)
-	@ mkdir -p $(dir $@) || true
-	@ $(CC) $< -o $@ $(_CFLAGS)
+	$(ECHO) mkdir -p $(dir $@) || true
+	$(ECHO) $(CC) $< -o $@ $(_CFLAGS)
 
 
 clean:
-	rm -rf $(_USTR) $(_DUMP) $(_BUILD)
+	rm -rf $(_USTR) $(_DUMP) $(_V4P) $(_BUILD)
 
 
-_OBJS = $(_USTR_SRCS:%.c=$(_BUILD)/%.o) $(_DUMP_SRCS:%.c=$(_BUILD)/%.o)
 -include $(_OBJS:%.o=%.d)

src/dump/file.c

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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    #
@@ -47,7 +47,7 @@ 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) {
-	us_output_file_s *output = (us_output_file_s *)v_output;
+	us_output_file_s *output = v_output;
 	if (output->json) {
 		us_base64_encode(frame->data, frame->used, &output->base64_data, &output->base64_allocated);
 		fprintf(output->fp,
@@ -66,7 +66,7 @@ void us_output_file_write(void *v_output, const us_frame_s *frame) {
 }
 
 void us_output_file_destroy(void *v_output) {
-	us_output_file_s *output = (us_output_file_s *)v_output;
+	us_output_file_s *output = v_output;
 	US_DELETE(output->base64_data, free);
 	if (output->fp && output->fp != stdout) {
 		if (fclose(output->fp) < 0) {

src/dump/file.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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    #

src/dump/main.c

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,6 @@
 #include <stdlib.h>
 #include <stdbool.h>
 #include <unistd.h>
-#include <signal.h>
 #include <limits.h>
 #include <float.h>
 #include <getopt.h>
@@ -32,10 +31,13 @@
 #include <assert.h>
 
 #include "../libs/const.h"
+#include "../libs/errors.h"
 #include "../libs/tools.h"
 #include "../libs/logging.h"
 #include "../libs/frame.h"
 #include "../libs/memsink.h"
+#include "../libs/fpsi.h"
+#include "../libs/signal.h"
 #include "../libs/options.h"
 
 #include "file.h"
@@ -95,7 +97,6 @@ typedef struct {
 
 
 static void _signal_handler(int signum);
-static void _install_signal_handlers(void);
 
 static int _dump_sink(
 	const char *sink_name, unsigned sink_timeout,
@@ -110,9 +111,9 @@ int main(int argc, char *argv[]) {
 	US_LOGGING_INIT;
 	US_THREAD_RENAME("main");
 
-	char *sink_name = NULL;
+	const char *sink_name = NULL;
 	unsigned sink_timeout = 1;
-	char *output_path = NULL;
+	const char *output_path = NULL;
 	bool output_json = false;
 	long long count = 0;
 	long double interval = 0;
@@ -183,14 +184,14 @@ int main(int argc, char *argv[]) {
 	_output_context_s ctx = {0};
 
 	if (output_path && output_path[0] != '\0') {
-		if ((ctx.v_output = (void *)us_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 = us_output_file_write;
 		ctx.destroy = us_output_file_destroy;
 	}
 
-	_install_signal_handlers();
+	us_install_signals_handler(_signal_handler, false);
 	const int retval = abs(_dump_sink(sink_name, sink_timeout, count, interval, key_required, &ctx));
 	if (ctx.v_output && ctx.destroy) {
 		ctx.destroy(ctx.v_output);
@@ -206,31 +207,14 @@ static void _signal_handler(int signum) {
 	_g_stop = true;
 }
 
-static void _install_signal_handlers(void) {
-	struct sigaction sig_act = {0};
-
-	assert(!sigemptyset(&sig_act.sa_mask));
-	sig_act.sa_handler = _signal_handler;
-	assert(!sigaddset(&sig_act.sa_mask, SIGINT));
-	assert(!sigaddset(&sig_act.sa_mask, SIGTERM));
-	assert(!sigaddset(&sig_act.sa_mask, SIGPIPE));
-
-	US_LOG_DEBUG("Installing SIGINT handler ...");
-	assert(!sigaction(SIGINT, &sig_act, NULL));
-
-	US_LOG_DEBUG("Installing SIGTERM handler ...");
-	assert(!sigaction(SIGTERM, &sig_act, NULL));
-
-	US_LOG_DEBUG("Installing SIGTERM handler ...");
-	assert(!sigaction(SIGPIPE, &sig_act, NULL));
-}
-
 static int _dump_sink(
 	const char *sink_name, unsigned sink_timeout,
 	long long count, long double interval,
 	bool key_required,
 	_output_context_s *ctx) {
 
+	int retval = -1;
+
 	if (count == 0) {
 		count = -1;
 	}
@@ -238,26 +222,22 @@ static int _dump_sink(
 	const useconds_t interval_us = interval * 1000000;
 
 	us_frame_s *frame = us_frame_init();
+	us_fpsi_s *fpsi = us_fpsi_init("SINK", false);
 	us_memsink_s *sink = NULL;
 
-	if ((sink = us_memsink_init("input", sink_name, false, 0, false, 0, sink_timeout)) == NULL) {
+	if ((sink = us_memsink_init_opened("input", sink_name, false, 0, false, 0, sink_timeout)) == NULL) {
 		goto error;
 	}
 
-	unsigned fps = 0;
-	unsigned fps_accum = 0;
-	long long fps_second = 0;
-
 	long double last_ts = 0;
 
 	while (!_g_stop) {
 		bool key_requested;
-		const int error = us_memsink_client_get(sink, frame, &key_requested, key_required);
-		if (error == 0) {
+		const int got = us_memsink_client_get(sink, frame, &key_requested, key_required);
+		if (got == 0) {
 			key_required = false;
 
 			const long double now = us_get_now_monotonic();
-			const long long now_second = us_floor_ms(now);
 
 			char fourcc_str[8];
 			US_LOG_VERBOSE("Frame: %s - %ux%u -- online=%d, key=%d, kr=%d, gop=%u, latency=%.3Lf, backlog=%.3Lf, size=%zu",
@@ -271,13 +251,7 @@ static int _dump_sink(
 			US_LOG_DEBUG("       stride=%u, grab_ts=%.3Lf, encode_begin_ts=%.3Lf, encode_end_ts=%.3Lf",
 				frame->stride, 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;
-				US_LOG_PERF_FPS("A new second has come; captured_fps=%u", fps);
-			}
-			fps_accum += 1;
+			us_fpsi_update(fpsi, true, NULL);
 
 			if (ctx->v_output != NULL) {
 				ctx->write(ctx->v_output, frame);
@@ -293,25 +267,21 @@ static int _dump_sink(
 			if (interval_us > 0) {
 				usleep(interval_us);
 			}
-		} else if (error == -2) {
+		} else if (got == US_ERROR_NO_DATA) {
 			usleep(1000);
 		} else {
 			goto error;
 		}
 	}
 
-	int retval = 0;
-	goto ok;
+	retval = 0;
 
-	error:
-		retval = -1;
-
-	ok:
-		US_DELETE(sink, us_memsink_destroy);
-		us_frame_destroy(frame);
-
-		US_LOG_INFO("Bye-bye");
-		return retval;
+error:
+	US_DELETE(sink, us_memsink_destroy);
+	us_fpsi_destroy(fpsi);
+	us_frame_destroy(frame);
+	US_LOG_INFO("Bye-bye");
+	return retval;
 }
 
 static void _help(FILE *fp) {
@@ -319,7 +289,7 @@ static void _help(FILE *fp) {
 	SAY("\nuStreamer-dump - Dump uStreamer's memory sink to file");
 	SAY("═════════════════════════════════════════════════════");
 	SAY("Version: %s; license: GPLv3", US_VERSION);
-	SAY("Copyright (C) 2018-2023 Maxim Devaev <mdevaev@gmail.com>\n");
+	SAY("Copyright (C) 2018-2024 Maxim Devaev <mdevaev@gmail.com>\n");
 	SAY("Example:");
 	SAY("════════");
 	SAY("    ustreamer-dump --sink test --output - \\");

src/libs/array.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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    #

src/libs/base64.c

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,6 +22,13 @@
 
 #include "base64.h"
 
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "types.h"
+#include "tools.h"
+
 
 static const char _ENCODING_TABLE[] = {
 	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
@@ -34,11 +41,11 @@ static const char _ENCODING_TABLE[] = {
 	'4', '5', '6', '7', '8', '9', '+', '/',
 };
 
-static const unsigned _MOD_TABLE[] = {0, 2, 1};
+static const uint _MOD_TABLE[] = {0, 2, 1};
 
 
-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'
+void us_base64_encode(const u8 *data, uz size, char **encoded, uz *allocated) {
+	const uz encoded_size = 4 * ((size + 2) / 3) + 1; // +1 for '\0'
 
 	if (*encoded == NULL || (allocated && *allocated < encoded_size)) {
 		US_REALLOC(*encoded, encoded_size);
@@ -47,14 +54,14 @@ void us_base64_encode(const uint8_t *data, size_t size, char **encoded, size_t *
 		}
 	}
 
-	for (unsigned data_index = 0, encoded_index = 0; data_index < size;) {
-#		define OCTET(_name) unsigned _name = (data_index < size ? (uint8_t)data[data_index++] : 0)
+	for (uint data_index = 0, encoded_index = 0; data_index < size;) {
+#		define OCTET(_name) uint _name = (data_index < size ? (u8)data[data_index++] : 0)
 		OCTET(octet_a);
 		OCTET(octet_b);
 		OCTET(octet_c);
 #		undef OCTET
 
-		const unsigned triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;
+		const uint triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;
 
 #		define ENCODE(_offset) (*encoded)[encoded_index++] = _ENCODING_TABLE[(triple >> _offset * 6) & 0x3F]
 		ENCODE(3);
@@ -64,7 +71,7 @@ void us_base64_encode(const uint8_t *data, size_t size, char **encoded, size_t *
 #		undef ENCODE
 	}
 
-	for (unsigned index = 0; index < _MOD_TABLE[size % 3]; index++) {
+	for (uint index = 0; index < _MOD_TABLE[size % 3]; index++) {
 		(*encoded)[encoded_size - 2 - index] = '=';
 	}
 

src/libs/base64.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,13 +22,7 @@
 
 #pragma once
 
-#include <stdlib.h>
-#include <stdint.h>
-#include <string.h>
-
-#include <sys/types.h>
-
-#include "tools.h"
+#include "types.h"
 
 
-void us_base64_encode(const uint8_t *data, size_t size, char **encoded, size_t *allocated);
+void us_base64_encode(const u8 *data, uz size, char **encoded, uz *allocated);

src/libs/capture.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,48 +22,24 @@
 
 #pragma once
 
-#include <stdlib.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <string.h>
-#include <strings.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <assert.h>
+#include <stdatomic.h>
 
-#include <sys/select.h>
-#include <sys/mman.h>
-#include <sys/time.h>
-
-#include <pthread.h>
 #include <linux/videodev2.h>
-#include <linux/v4l2-controls.h>
 
-#include "../libs/tools.h"
-#include "../libs/array.h"
-#include "../libs/logging.h"
-#include "../libs/threading.h"
-#include "../libs/frame.h"
-#include "../libs/xioctl.h"
+#include "types.h"
+#include "frame.h"
 
 
-#define US_VIDEO_MIN_WIDTH		((unsigned)160)
-#define US_VIDEO_MAX_WIDTH		((unsigned)10240)
+#define US_VIDEO_MIN_WIDTH		((uint)160)
+#define US_VIDEO_MAX_WIDTH		((uint)15360) // Remember about stream->run->http_capture_state;
 
-#define US_VIDEO_MIN_HEIGHT		((unsigned)120)
-#define US_VIDEO_MAX_HEIGHT		((unsigned)4320)
+#define US_VIDEO_MIN_HEIGHT		((uint)120)
+#define US_VIDEO_MAX_HEIGHT		((uint)8640)
 
-#define US_VIDEO_MAX_FPS		((unsigned)120)
+#define US_VIDEO_MAX_FPS		((uint)120)
 
-#define US_STANDARD_UNKNOWN		V4L2_STD_UNKNOWN
 #define US_STANDARDS_STR		"PAL, NTSC, SECAM"
-
-#define US_FORMAT_UNKNOWN		-1
-#define US_FORMATS_STR			"YUYV, UYVY, RGB565, RGB24, MJPEG, JPEG"
-
-#define US_IO_METHOD_UNKNOWN	-1
+#define US_FORMATS_STR			"YUYV, YVYU, UYVY, RGB565, RGB24, BGR24, MJPEG, JPEG"
 #define US_IO_METHODS_STR		"MMAP, USERPTR"
 
 
@@ -72,22 +48,27 @@ typedef struct {
 	struct v4l2_buffer	buf;
 	int					dma_fd;
 	bool				grabbed;
-} us_hw_buffer_s;
+	atomic_int			refs;
+} us_capture_hwbuf_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;
-	us_hw_buffer_s	*hw_bufs;
-	bool			capturing;
-	bool			persistent_timeout_reported;
-} us_device_runtime_s;
+	int					fd;
+	uint				width;
+	uint				height;
+	uint				format;
+	uint				stride;
+	float				hz;
+	uint				hw_fps;
+	uint				jpeg_quality;
+	uz					raw_size;
+	uint				n_bufs;
+	us_capture_hwbuf_s	*bufs;
+	bool				dma;
+	enum v4l2_buf_type	capture_type;
+	bool				capture_mplane;
+	bool				streamon;
+	int					open_error_once;
+} us_capture_runtime_s;
 
 typedef enum {
 	CTL_MODE_NONE = 0,
@@ -119,39 +100,41 @@ typedef struct {
 
 typedef struct {
 	char				*path;
-	unsigned			input;
-	unsigned			width;
-	unsigned			height;
-	unsigned			format;
-	unsigned			jpeg_quality;
+	uint				input;
+	uint				width;
+	uint				height;
+	uint				format;
+
+	bool				format_swap_rgb;
+	uint				jpeg_quality;
 	v4l2_std_id			standard;
 	enum v4l2_memory	io_method;
 	bool				dv_timings;
-	unsigned			n_bufs;
-	unsigned			desired_fps;
-	size_t				min_frame_size;
+	uint				n_bufs;
+	bool				dma_export;
+	bool				dma_required;
+	uint				desired_fps;
+	uz					min_frame_size;
+	bool				allow_truncated_frames;
 	bool				persistent;
-	unsigned			timeout;
-
+	uint				timeout;
 	us_controls_s 		ctl;
-
-	us_device_runtime_s *run;
-} us_device_s;
+	us_capture_runtime_s *run;
+} us_capture_s;
 
 
-us_device_s *us_device_init(void);
-void us_device_destroy(us_device_s *dev);
+us_capture_s *us_capture_init(void);
+void us_capture_destroy(us_capture_s *cap);
 
-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 us_capture_parse_format(const char *str);
+int us_capture_parse_standard(const char *str);
+int us_capture_parse_io_method(const char *str);
 
-int us_device_open(us_device_s *dev);
-void us_device_close(us_device_s *dev);
+int us_capture_open(us_capture_s *cap);
+void us_capture_close(us_capture_s *cap);
 
-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);
+int us_capture_hwbuf_grab(us_capture_s *cap, us_capture_hwbuf_s **hw);
+int us_capture_hwbuf_release(const us_capture_s *cap, us_capture_hwbuf_s *hw);
+
+void us_capture_hwbuf_incref(us_capture_hwbuf_s *hw);
+void us_capture_hwbuf_decref(us_capture_hwbuf_s *hw);

src/libs/const.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,14 @@
 
 #pragma once
 
-#define US_VERSION_MAJOR 5
-#define US_VERSION_MINOR 40
+#include "types.h"
+
+
+#define US_VERSION_MAJOR 6
+#define US_VERSION_MINOR 23
 
 #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))
+#define US_VERSION_U ((uint)(US_VERSION_MAJOR * 1000 + US_VERSION_MINOR))

src/libs/drm/drm.c

@@ -0,0 +1,777 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  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 "drm.h"
+
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/sysmacros.h>
+
+#include <linux/videodev2.h>
+
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+#include <drm_fourcc.h>
+#include <libdrm/drm.h>
+
+#include "../types.h"
+#include "../errors.h"
+#include "../tools.h"
+#include "../logging.h"
+#include "../frame.h"
+#include "../frametext.h"
+#include "../capture.h"
+
+
+static void _drm_vsync_callback(int fd, uint n_frame, uint sec, uint usec, void *v_buf);
+static int _drm_check_status(us_drm_s *drm);
+static void _drm_ensure_dpms_power(us_drm_s *drm, bool on);
+static int _drm_init_buffers(us_drm_s *drm, const us_capture_s *cap);
+static int _drm_find_sink(us_drm_s *drm, uint width, uint height, float hz);
+
+static drmModeModeInfo *_find_best_mode(drmModeConnector *conn, uint width, uint height, float hz);
+static u32 _find_dpms(int fd, drmModeConnector *conn);
+static u32 _find_crtc(int fd, drmModeRes *res, drmModeConnector *conn, u32 *taken_crtcs);
+static const char *_connector_type_to_string(u32 type);
+static float _get_refresh_rate(const drmModeModeInfo *mode);
+
+
+#define _LOG_ERROR(x_msg, ...)	US_LOG_ERROR("DRM: " x_msg, ##__VA_ARGS__)
+#define _LOG_PERROR(x_msg, ...)	US_LOG_PERROR("DRM: " x_msg, ##__VA_ARGS__)
+#define _LOG_INFO(x_msg, ...)		US_LOG_INFO("DRM: " x_msg, ##__VA_ARGS__)
+#define _LOG_VERBOSE(x_msg, ...)	US_LOG_VERBOSE("DRM: " x_msg, ##__VA_ARGS__)
+#define _LOG_DEBUG(x_msg, ...)	US_LOG_DEBUG("DRM: " x_msg, ##__VA_ARGS__)
+
+
+us_drm_s *us_drm_init(void) {
+	us_drm_runtime_s *run;
+	US_CALLOC(run, 1);
+	run->fd = -1;
+	run->status_fd = -1;
+	run->dpms_state = -1;
+	run->opened = -1;
+	run->has_vsync = true;
+	run->exposing_dma_fd = -1;
+	run->ft = us_frametext_init();
+
+	us_drm_s *drm;
+	US_CALLOC(drm, 1);
+	// drm->path = "/dev/dri/card0";
+	drm->path = "/dev/dri/by-path/platform-gpu-card";
+	drm->port = "HDMI-A-2"; // OUT2 on PiKVM V4 Plus
+	drm->timeout = 5;
+	drm->blank_after = 5;
+	drm->run = run;
+	return drm;
+}
+
+void us_drm_destroy(us_drm_s *drm) {
+	us_frametext_destroy(drm->run->ft);
+	US_DELETE(drm->run, free);
+	US_DELETE(drm, free); // cppcheck-suppress uselessAssignmentPtrArg
+}
+
+int us_drm_open(us_drm_s *drm, const us_capture_s *cap) {
+	us_drm_runtime_s *const run = drm->run;
+
+	assert(run->fd < 0);
+
+	switch (_drm_check_status(drm)) {
+		case 0: break;
+		case US_ERROR_NO_DEVICE: goto unplugged;
+		default: goto error;
+	}
+
+	_LOG_INFO("Using passthrough: %s[%s]", drm->path, drm->port);
+	_LOG_INFO("Configuring DRM device for %s ...", (cap == NULL ? "STUB" : "DMA"));
+
+	if ((run->fd = open(drm->path, O_RDWR | O_CLOEXEC | O_NONBLOCK)) < 0) {
+		_LOG_PERROR("Can't open DRM device");
+		goto error;
+	}
+	_LOG_DEBUG("DRM device fd=%d opened", run->fd);
+
+	int stub = 0; // Open the real device with DMA
+	if (cap == NULL) {
+		stub = US_DRM_STUB_USER;
+	} else if (cap->run->format != V4L2_PIX_FMT_RGB24 && cap->run->format != V4L2_PIX_FMT_BGR24) {
+		stub = US_DRM_STUB_BAD_FORMAT;
+		char fourcc_str[8];
+		us_fourcc_to_string(cap->run->format, fourcc_str, 8);
+		_LOG_ERROR("Input format %s is not supported, forcing to STUB ...", fourcc_str);
+	}
+
+#	define CHECK_CAP(x_cap) { \
+			_LOG_DEBUG("Checking %s ...", #x_cap); \
+			u64 m_check; \
+			if (drmGetCap(run->fd, x_cap, &m_check) < 0) { \
+				_LOG_PERROR("Can't check " #x_cap); \
+				goto error; \
+			} \
+			if (!m_check) { \
+				_LOG_ERROR(#x_cap " is not supported"); \
+				goto error; \
+			} \
+		}
+	CHECK_CAP(DRM_CAP_DUMB_BUFFER);
+	if (stub == 0) {
+		CHECK_CAP(DRM_CAP_PRIME);
+	}
+#	undef CHECK_CAP
+
+	const uint width = (stub > 0 ? 0 : cap->run->width);
+	const uint height = (stub > 0 ? 0 : cap->run->height);
+	const uint hz = (stub > 0 ? 0 : cap->run->hz);
+	switch (_drm_find_sink(drm, width, height, hz)) {
+		case 0: break;
+		case US_ERROR_NO_DEVICE: goto unplugged;
+		default: goto error;
+	}
+	if ((stub == 0) && (width != run->mode.hdisplay || height < run->mode.vdisplay)) {
+		// We'll try to show something instead of nothing if height != vdisplay
+		stub = US_DRM_STUB_BAD_RESOLUTION;
+		_LOG_ERROR("There is no appropriate modes for the capture, forcing to STUB ...");
+	}
+
+	if (_drm_init_buffers(drm, (stub > 0 ? NULL : cap)) < 0) {
+		goto error;
+	}
+
+	run->saved_crtc = drmModeGetCrtc(run->fd, run->crtc_id);
+	_LOG_DEBUG("Setting up CRTC ...");
+	if (drmModeSetCrtc(run->fd, run->crtc_id, run->bufs[0].id, 0, 0, &run->conn_id, 1, &run->mode) < 0) {
+		_LOG_PERROR("Can't set CRTC");
+		goto error;
+	}
+
+	_LOG_INFO("Opened for %s ...", (stub > 0 ? "STUB" : "DMA"));
+	run->exposing_dma_fd = -1;
+	run->blank_at_ts = 0;
+	run->opened = stub;
+	run->once = 0;
+	return run->opened;
+
+error:
+	us_drm_close(drm);
+	return run->opened; // -1 after us_drm_close()
+
+unplugged:
+	US_ONCE_FOR(run->once, __LINE__, {
+		_LOG_ERROR("Display is not plugged");
+	});
+	us_drm_close(drm);
+	run->opened = US_ERROR_NO_DEVICE;
+	return run->opened;
+}
+
+void us_drm_close(us_drm_s *drm) {
+	us_drm_runtime_s *const run = drm->run;
+
+	if (run->exposing_dma_fd >= 0) {
+		// Нужно подождать, пока dma_fd не освободится, прежде чем прерывать процесс.
+		// Просто на всякий случай.
+		assert(run->fd >= 0);
+		us_drm_wait_for_vsync(drm);
+		run->exposing_dma_fd = -1;
+	}
+
+	if (run->saved_crtc != NULL) {
+		_LOG_DEBUG("Restoring CRTC ...");
+		if (drmModeSetCrtc(run->fd,
+			run->saved_crtc->crtc_id, run->saved_crtc->buffer_id,
+			run->saved_crtc->x, run->saved_crtc->y,
+			&run->conn_id, 1, &run->saved_crtc->mode
+		) < 0 && errno != ENOENT) {
+			_LOG_PERROR("Can't restore CRTC");
+		}
+		drmModeFreeCrtc(run->saved_crtc);
+		run->saved_crtc = NULL;
+	}
+
+	if (run->bufs != NULL) {
+		_LOG_DEBUG("Releasing buffers ...");
+		for (uint n_buf = 0; n_buf < run->n_bufs; ++n_buf) {
+			us_drm_buffer_s *const buf = &run->bufs[n_buf];
+			if (buf->fb_added && drmModeRmFB(run->fd, buf->id) < 0) {
+				_LOG_PERROR("Can't remove buffer=%u", n_buf);
+			}
+			if (buf->dumb_created) {
+				struct drm_mode_destroy_dumb destroy = {.handle = buf->handle};
+				if (drmIoctl(run->fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy) < 0) {
+					_LOG_PERROR("Can't destroy dumb buffer=%u", n_buf);
+				}
+			}
+			if (buf->data != NULL && munmap(buf->data, buf->allocated)) {
+				_LOG_PERROR("Can't unmap buffer=%u", n_buf);
+			}
+		}
+		US_DELETE(run->bufs, free);
+		run->n_bufs = 0;
+	}
+
+	const bool say = (run->fd >= 0);
+	US_CLOSE_FD(run->status_fd);
+	US_CLOSE_FD(run->fd);
+
+	run->crtc_id = 0;
+	run->dpms_state = -1;
+	run->opened = -1;
+	run->has_vsync = true;
+	run->stub_n_buf = 0;
+
+	if (say) {
+		_LOG_INFO("Closed");
+	}
+}
+
+int us_drm_ensure_no_signal(us_drm_s *drm) {
+	us_drm_runtime_s *const run = drm->run;
+
+	assert(run->fd >= 0);
+	assert(run->opened > 0);
+
+	const ldf now_ts = us_get_now_monotonic();
+	if (run->blank_at_ts == 0) {
+		run->blank_at_ts = now_ts + drm->blank_after;
+	}
+	const ldf saved_ts = run->blank_at_ts; // us_drm*() rewrites it to 0
+
+	int retval;
+	if (now_ts <= run->blank_at_ts) {
+		retval = us_drm_wait_for_vsync(drm);
+		if (retval == 0) {
+			retval = us_drm_expose_stub(drm, US_DRM_STUB_NO_SIGNAL, NULL);
+		}
+	} else {
+		US_ONCE_FOR(run->once, __LINE__, {
+			_LOG_INFO("Turning off the display by timeout ...");
+		});
+		retval = us_drm_dpms_power_off(drm);
+	}
+	run->blank_at_ts = saved_ts;
+	return retval;
+}
+
+int us_drm_dpms_power_off(us_drm_s *drm) {
+	assert(drm->run->fd >= 0);
+	switch (_drm_check_status(drm)) {
+		case 0: break;
+		case US_ERROR_NO_DEVICE: return 0; // Unplugged, nice
+		// Во время переключения DPMS монитор моргает один раз состоянием disconnected,
+		// а потом почему-то снова оказывается connected. Так что просто считаем,
+		// что отсоединенный монитор на этом этапе - это нормально.
+		default: return -1;
+	}
+	_drm_ensure_dpms_power(drm, false);
+	return 0;
+}
+
+int us_drm_wait_for_vsync(us_drm_s *drm) {
+	us_drm_runtime_s *const run = drm->run;
+
+	assert(run->fd >= 0);
+	run->blank_at_ts = 0;
+
+	switch (_drm_check_status(drm)) {
+		case 0: break;
+		case US_ERROR_NO_DEVICE: return US_ERROR_NO_DEVICE;
+		default: return -1;
+	}
+	_drm_ensure_dpms_power(drm, true);
+
+	if (run->has_vsync) {
+		return 0;
+	}
+
+	struct timeval timeout = {.tv_sec = drm->timeout};
+	fd_set fds;
+	FD_ZERO(&fds);
+	FD_SET(run->fd, &fds);
+
+	_LOG_DEBUG("Calling select() for VSync ...");
+	const int result = select(run->fd + 1, &fds, NULL, NULL, &timeout);
+	if (result < 0) {
+		_LOG_PERROR("Can't select(%d) device for VSync", run->fd);
+		return -1;
+	} else if (result == 0) {
+		_LOG_ERROR("Device timeout while waiting VSync");
+		return -1;
+	}
+
+	drmEventContext ctx = {
+		.version = DRM_EVENT_CONTEXT_VERSION,
+		.page_flip_handler = _drm_vsync_callback,
+	};
+	_LOG_DEBUG("Handling DRM event (maybe VSync) ...");
+	if (drmHandleEvent(run->fd, &ctx) < 0) {
+		_LOG_PERROR("Can't handle DRM event");
+		return -1;
+	}
+	return 0;
+}
+
+static void _drm_vsync_callback(int fd, uint n_frame, uint sec, uint usec, void *v_buf) {
+	(void)fd;
+	(void)n_frame;
+	(void)sec;
+	(void)usec;
+	us_drm_buffer_s *const buf = v_buf;
+	*buf->ctx.has_vsync = true;
+	*buf->ctx.exposing_dma_fd = -1;
+	_LOG_DEBUG("Got VSync signal");
+}
+
+int us_drm_expose_stub(us_drm_s *drm, us_drm_stub_e stub, const us_capture_s *cap) {
+	us_drm_runtime_s *const run = drm->run;
+
+	assert(run->fd >= 0);
+	assert(run->opened > 0);
+	run->blank_at_ts = 0;
+
+	switch (_drm_check_status(drm)) {
+		case 0: break;
+		case US_ERROR_NO_DEVICE: return US_ERROR_NO_DEVICE;
+		default: return -1;
+	}
+	_drm_ensure_dpms_power(drm, true);
+
+#	define DRAW_MSG(x_msg) us_frametext_draw(run->ft, (x_msg), run->mode.hdisplay, run->mode.vdisplay)
+	switch (stub) {
+		case US_DRM_STUB_BAD_RESOLUTION: {
+			assert(cap != NULL);
+			char msg[1024];
+			US_SNPRINTF(msg, 1023,
+				"=== PiKVM ==="
+				"\n \n< UNSUPPORTED RESOLUTION >"
+				"\n \n< %ux%up%.02f >"
+				"\n \nby this display",
+				cap->run->width, cap->run->height, cap->run->hz);
+			DRAW_MSG(msg);
+			break;
+		};
+		case US_DRM_STUB_BAD_FORMAT:
+			DRAW_MSG("=== PiKVM ===\n \n< UNSUPPORTED CAPTURE FORMAT >");
+			break;
+		case US_DRM_STUB_NO_SIGNAL:
+			DRAW_MSG("=== PiKVM ===\n \n< NO SIGNAL >");
+			break;
+		case US_DRM_STUB_BUSY:
+			DRAW_MSG("=== PiKVM ===\n \n< ONLINE IS ACTIVE >");
+			break;
+		default:
+			DRAW_MSG("=== PiKVM ===\n \n< ??? >");
+			break;
+	}
+#	undef DRAW_MSG
+
+	us_drm_buffer_s *const buf = &run->bufs[run->stub_n_buf];
+
+	run->has_vsync = false;
+
+	_LOG_DEBUG("Copying STUB frame ...")
+	memcpy(buf->data, run->ft->frame->data, US_MIN(run->ft->frame->used, buf->allocated));
+
+	_LOG_DEBUG("Exposing STUB framebuffer n_buf=%u ...", run->stub_n_buf);
+	const int retval = drmModePageFlip(
+		run->fd, run->crtc_id, buf->id,
+		DRM_MODE_PAGE_FLIP_EVENT | DRM_MODE_PAGE_FLIP_ASYNC,
+		buf);
+	if (retval < 0) {
+		_LOG_PERROR("Can't expose STUB framebuffer n_buf=%u ...", run->stub_n_buf);
+	}
+	_LOG_DEBUG("Exposed STUB framebuffer n_buf=%u", run->stub_n_buf);
+
+	run->stub_n_buf = (run->stub_n_buf + 1) % run->n_bufs;
+	return retval;
+}
+
+int us_drm_expose_dma(us_drm_s *drm, const us_capture_hwbuf_s *hw) {
+	us_drm_runtime_s *const run = drm->run;
+	us_drm_buffer_s *const buf = &run->bufs[hw->buf.index];
+
+	assert(run->fd >= 0);
+	assert(run->opened == 0);
+	run->blank_at_ts = 0;
+
+	switch (_drm_check_status(drm)) {
+		case 0: break;
+		case US_ERROR_NO_DEVICE: return US_ERROR_NO_DEVICE;
+		default: return -1;
+	}
+	_drm_ensure_dpms_power(drm, true);
+
+	run->has_vsync = false;
+
+	_LOG_DEBUG("Exposing DMA framebuffer n_buf=%u ...", hw->buf.index);
+	const int retval = drmModePageFlip(
+		run->fd, run->crtc_id, buf->id,
+		DRM_MODE_PAGE_FLIP_EVENT | DRM_MODE_PAGE_FLIP_ASYNC,
+		buf);
+	if (retval < 0) {
+		_LOG_PERROR("Can't expose DMA framebuffer n_buf=%u ...", run->stub_n_buf);
+	}
+	_LOG_DEBUG("Exposed DMA framebuffer n_buf=%u", run->stub_n_buf);
+	run->exposing_dma_fd = hw->dma_fd;
+	return retval;
+}
+
+static int _drm_check_status(us_drm_s *drm) {
+	us_drm_runtime_s *run = drm->run;
+
+	if (run->status_fd < 0) {
+		_LOG_DEBUG("Trying to find status file ...");
+		struct stat st;
+		if (stat(drm->path, &st) < 0) {
+			_LOG_PERROR("Can't stat() DRM device");
+			goto error;
+		}
+		const uint mi = minor(st.st_rdev);
+		_LOG_DEBUG("DRM device minor(st_rdev)=%u", mi);
+
+		char path[128];
+		US_SNPRINTF(path, 127, "/sys/class/drm/card%u-%s/status", mi, drm->port);
+		_LOG_DEBUG("Opening status file %s ...", path);
+		if ((run->status_fd = open(path, O_RDONLY | O_CLOEXEC)) < 0) {
+			_LOG_PERROR("Can't open status file: %s", path);
+			goto error;
+		}
+		_LOG_DEBUG("Status file fd=%d opened", run->status_fd);
+	}
+
+	char status_ch;
+	if (read(run->status_fd, &status_ch, 1) != 1) {
+		_LOG_PERROR("Can't read status file");
+		goto error;
+	}
+	if (lseek(run->status_fd, 0, SEEK_SET) != 0) {
+		_LOG_PERROR("Can't rewind status file");
+		goto error;
+	}
+	_LOG_DEBUG("Current display status: %c", status_ch);
+	return (status_ch == 'd' ? US_ERROR_NO_DEVICE : 0);
+
+error:
+	US_CLOSE_FD(run->status_fd);
+	return -1;
+}
+
+static void _drm_ensure_dpms_power(us_drm_s *drm, bool on) {
+	us_drm_runtime_s *const run = drm->run;
+	if (run->dpms_id > 0 && run->dpms_state != (int)on) {
+		_LOG_INFO("Changing DPMS power mode: %d -> %u ...", run->dpms_state, on);
+		if (drmModeConnectorSetProperty(
+			run->fd, run->conn_id, run->dpms_id,
+			(on ? DRM_MODE_DPMS_ON : DRM_MODE_DPMS_OFF)
+		) < 0) {
+			_LOG_PERROR("Can't set DPMS power=%u (ignored)", on);
+		}
+	}
+	run->dpms_state = (int)on;
+}
+
+static int _drm_init_buffers(us_drm_s *drm, const us_capture_s *cap) {
+	us_drm_runtime_s *const run = drm->run;
+
+	const uint n_bufs = (cap == NULL ? 4 : cap->run->n_bufs);
+	const char *name = (cap == NULL ? "STUB" : "DMA");
+
+	_LOG_DEBUG("Initializing %u %s buffers ...", n_bufs, name);
+
+	uint format = DRM_FORMAT_RGB888;
+
+	US_CALLOC(run->bufs, n_bufs);
+	for (run->n_bufs = 0; run->n_bufs < n_bufs; ++run->n_bufs) {
+		const uint n_buf = run->n_bufs;
+		us_drm_buffer_s *const buf = &run->bufs[n_buf];
+
+		buf->ctx.has_vsync = &run->has_vsync;
+		buf->ctx.exposing_dma_fd = &run->exposing_dma_fd;
+
+		u32 handles[4] = {0};
+		u32 strides[4] = {0};
+		u32 offsets[4] = {0};
+
+		if (cap == NULL) {
+			struct drm_mode_create_dumb create = {
+				.width = run->mode.hdisplay,
+				.height = run->mode.vdisplay,
+				.bpp = 24,
+			};
+			if (drmIoctl(run->fd, DRM_IOCTL_MODE_CREATE_DUMB, &create) < 0) {
+				_LOG_PERROR("Can't create %s buffer=%u", name, n_buf);
+				return -1;
+			}
+			buf->handle = create.handle;
+			buf->dumb_created = true;
+
+			struct drm_mode_map_dumb map = {.handle = create.handle};
+			if (drmIoctl(run->fd, DRM_IOCTL_MODE_MAP_DUMB, &map) < 0) {
+				_LOG_PERROR("Can't prepare dumb buffer=%u to mapping", n_buf);
+				return -1;
+			}
+			if ((buf->data = mmap(
+				NULL, create.size,
+				PROT_READ | PROT_WRITE, MAP_SHARED,
+				run->fd, map.offset
+			)) == MAP_FAILED) {
+				_LOG_PERROR("Can't map buffer=%u", n_buf);
+				return -1;
+			}
+			memset(buf->data, 0, create.size);
+			buf->allocated = create.size;
+
+			handles[0] = create.handle;
+			strides[0] = create.pitch;
+
+		} else {
+			if (drmPrimeFDToHandle(run->fd, cap->run->bufs[n_buf].dma_fd, &buf->handle) < 0) {
+				_LOG_PERROR("Can't import DMA buffer=%u from capture device", n_buf);
+				return -1;
+			}
+			handles[0] = buf->handle;
+			strides[0] = cap->run->stride;
+
+			switch (cap->run->format) {
+				case V4L2_PIX_FMT_RGB24: format = (DRM_FORMAT_BIG_ENDIAN ? DRM_FORMAT_BGR888 : DRM_FORMAT_RGB888); break;
+				case V4L2_PIX_FMT_BGR24: format = (DRM_FORMAT_BIG_ENDIAN ? DRM_FORMAT_RGB888 : DRM_FORMAT_BGR888); break;
+			}
+		}
+
+		if (drmModeAddFB2(
+			run->fd,
+			run->mode.hdisplay, run->mode.vdisplay, format,
+			handles, strides, offsets, &buf->id, 0
+		)) {
+			_LOG_PERROR("Can't setup buffer=%u", n_buf);
+			return -1;
+		}
+		buf->fb_added = true;
+	}
+	return 0;
+}
+
+static int _drm_find_sink(us_drm_s *drm, uint width, uint height, float hz) {
+	us_drm_runtime_s *const run = drm->run;
+
+	run->crtc_id = 0;
+
+	_LOG_DEBUG("Trying to find the appropriate sink ...");
+
+	drmModeRes *res = drmModeGetResources(run->fd);
+	if (res == NULL) {
+		_LOG_PERROR("Can't get resources info");
+		goto done;
+	}
+	if (res->count_connectors <= 0) {
+		_LOG_ERROR("Can't find any connectors");
+		goto done;
+	}
+
+	for (int ci = 0; ci < res->count_connectors; ++ci) {
+		drmModeConnector *conn = drmModeGetConnector(run->fd, res->connectors[ci]);
+		if (conn == NULL) {
+			_LOG_PERROR("Can't get connector index=%d", ci);
+			goto done;
+		}
+
+		char port[32];
+		US_SNPRINTF(port, 31, "%s-%u",
+			_connector_type_to_string(conn->connector_type),
+			conn->connector_type_id);
+		if (strcmp(port, drm->port) != 0) {
+			drmModeFreeConnector(conn);
+			continue;
+		}
+		_LOG_INFO("Using connector %s: conn_type=%d, conn_type_id=%d",
+			drm->port, conn->connector_type, conn->connector_type_id);
+
+		if (conn->connection != DRM_MODE_CONNECTED) {
+			_LOG_ERROR("Connector for port %s has !DRM_MODE_CONNECTED", drm->port);
+			drmModeFreeConnector(conn);
+			goto done;
+		}
+
+		const drmModeModeInfo *best;
+		if ((best = _find_best_mode(conn, width, height, hz)) == NULL) {
+			_LOG_ERROR("Can't find any appropriate display modes");
+			drmModeFreeConnector(conn);
+			goto unplugged;
+		}
+		_LOG_INFO("Using best mode: %ux%up%.02f",
+			best->hdisplay, best->vdisplay, _get_refresh_rate(best));
+
+		if ((run->dpms_id = _find_dpms(run->fd, conn)) > 0) {
+			_LOG_INFO("Using DPMS: id=%u", run->dpms_id);
+		} else {
+			_LOG_INFO("Using DPMS: None");
+		}
+
+		u32 taken_crtcs = 0; // Unused here
+		if ((run->crtc_id = _find_crtc(run->fd, res, conn, &taken_crtcs)) == 0) {
+			_LOG_ERROR("Can't find CRTC");
+			drmModeFreeConnector(conn);
+			goto done;
+		}
+		_LOG_INFO("Using CRTC: id=%u", run->crtc_id);
+
+		run->conn_id = conn->connector_id;
+		memcpy(&run->mode, best, sizeof(drmModeModeInfo));
+
+		drmModeFreeConnector(conn);
+		break;
+	}
+
+done:
+	drmModeFreeResources(res);
+	return (run->crtc_id > 0 ? 0 : -1);
+
+unplugged:
+	drmModeFreeResources(res);
+	return US_ERROR_NO_DEVICE;
+}
+
+static drmModeModeInfo *_find_best_mode(drmModeConnector *conn, uint width, uint height, float hz) {
+	drmModeModeInfo *best = NULL;
+	drmModeModeInfo *closest = NULL;
+	drmModeModeInfo *pref = NULL;
+
+	for (int mi = 0; mi < conn->count_modes; ++mi) {
+		drmModeModeInfo *const mode = &conn->modes[mi];
+		if (mode->flags & DRM_MODE_FLAG_INTERLACE) {
+			continue; // Discard interlaced
+		}
+		const float mode_hz = _get_refresh_rate(mode);
+		if (mode->hdisplay == width && mode->vdisplay == height) {
+			best = mode; // Any mode with exact resolution
+			if (hz > 0 && mode_hz == hz) {
+				break; // Exact mode with same freq
+			}
+		}
+		if (mode->hdisplay == width && mode->vdisplay < height) {
+			if (closest == NULL || _get_refresh_rate(closest) != hz) {
+				closest = mode; // Something like 1920x1080p60 for 1920x1200p60 source
+			}
+		}
+		if (pref == NULL && (mode->type & DRM_MODE_TYPE_PREFERRED)) {
+			pref = mode; // Preferred mode if nothing is found
+		}
+	}
+
+	if (best == NULL) {
+		best = closest;
+	}
+	if (best == NULL) {
+		best = pref;
+	}
+	if (best == NULL) {
+		best = (conn->count_modes > 0 ? &conn->modes[0] : NULL);
+	}
+	assert(best == NULL || best->hdisplay > 0);
+	assert(best == NULL || best->vdisplay > 0);
+	return best;
+}
+
+static u32 _find_dpms(int fd, drmModeConnector *conn) {
+	for (int pi = 0; pi < conn->count_props; pi++) {
+		drmModePropertyPtr prop = drmModeGetProperty(fd, conn->props[pi]);
+		if (prop != NULL) {
+			if (!strcmp(prop->name, "DPMS")) {
+				const u32 id = prop->prop_id;
+				drmModeFreeProperty(prop);
+				return id;
+			}
+			drmModeFreeProperty(prop);
+		}
+	}
+	return 0;
+}
+
+static u32 _find_crtc(int fd, drmModeRes *res, drmModeConnector *conn, u32 *taken_crtcs) {
+	for (int ei = 0; ei < conn->count_encoders; ++ei) {
+		drmModeEncoder *enc = drmModeGetEncoder(fd, conn->encoders[ei]);
+		if (enc == NULL) {
+			continue;
+		}
+		for (int ci = 0; ci < res->count_crtcs; ++ci) {
+			u32 bit = (1 << ci);
+			if (!(enc->possible_crtcs & bit)) {
+				continue; // Not compatible
+			}
+			if (*taken_crtcs & bit) {
+				continue; // Already taken
+			}
+			drmModeFreeEncoder(enc);
+			*taken_crtcs |= bit;
+			return res->crtcs[ci];
+		}
+		drmModeFreeEncoder(enc);
+	}
+	return 0;
+}
+
+static const char *_connector_type_to_string(u32 type) {
+	switch (type) {
+#		define CASE_NAME(x_suffix, x_name) \
+			case DRM_MODE_CONNECTOR_##x_suffix: return x_name;
+		CASE_NAME(VGA,			"VGA");
+		CASE_NAME(DVII,			"DVI-I");
+		CASE_NAME(DVID,			"DVI-D");
+		CASE_NAME(DVIA,			"DVI-A");
+		CASE_NAME(Composite,	"Composite");
+		CASE_NAME(SVIDEO,		"SVIDEO");
+		CASE_NAME(LVDS,			"LVDS");
+		CASE_NAME(Component,	"Component");
+		CASE_NAME(9PinDIN,		"DIN");
+		CASE_NAME(DisplayPort,	"DP");
+		CASE_NAME(HDMIA,		"HDMI-A");
+		CASE_NAME(HDMIB,		"HDMI-B");
+		CASE_NAME(TV,			"TV");
+		CASE_NAME(eDP,			"eDP");
+		CASE_NAME(VIRTUAL,		"Virtual");
+		CASE_NAME(DSI,			"DSI");
+		CASE_NAME(DPI,			"DPI");
+		CASE_NAME(WRITEBACK,	"Writeback");
+		CASE_NAME(SPI,			"SPI");
+		CASE_NAME(USB,			"USB");
+		case DRM_MODE_CONNECTOR_Unknown: break;
+#		undef CASE_NAME
+	}
+	return "Unknown";
+}
+
+static float _get_refresh_rate(const drmModeModeInfo *mode) {
+	int mhz = (mode->clock * 1000000LL / mode->htotal + mode->vtotal / 2) / mode->vtotal;
+	if (mode->flags & DRM_MODE_FLAG_INTERLACE) {
+		mhz *= 2;
+	}
+	if (mode->flags & DRM_MODE_FLAG_DBLSCAN) {
+		mhz /= 2;
+	}
+	if (mode->vscan > 1) {
+		mhz /= mode->vscan;
+	}
+	return (float)mhz / 1000;
+}

src/libs/drm/drm.h

@@ -0,0 +1,97 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  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 <xf86drmMode.h>
+
+#include "../types.h"
+#include "../frame.h"
+#include "../frametext.h"
+#include "../capture.h"
+
+
+typedef enum {
+	US_DRM_STUB_USER = 1,
+	US_DRM_STUB_BAD_RESOLUTION,
+	US_DRM_STUB_BAD_FORMAT,
+	US_DRM_STUB_NO_SIGNAL,
+	US_DRM_STUB_BUSY,
+} us_drm_stub_e;
+
+typedef struct {
+	u32		id;
+	u32		handle;
+	u8		*data;
+	uz		allocated;
+	bool	dumb_created;
+	bool	fb_added;
+	struct {
+		bool	*has_vsync;
+		int		*exposing_dma_fd;
+	} ctx;
+} us_drm_buffer_s;
+
+typedef struct {
+	int				status_fd;
+	int				fd;
+	u32				crtc_id;
+	u32				conn_id;
+	u32				dpms_id;
+	drmModeModeInfo	mode;
+	us_drm_buffer_s	*bufs;
+	uint			n_bufs;
+	drmModeCrtc		*saved_crtc;
+	int				dpms_state;
+	int				opened;
+
+	bool			has_vsync;
+	int				exposing_dma_fd;
+	uint			stub_n_buf;
+	ldf				blank_at_ts;
+
+	int				once;
+	us_frametext_s	*ft;
+} us_drm_runtime_s;
+
+typedef struct {
+	char	*path;
+	char	*port;
+	uint	timeout;
+	uint	blank_after;
+
+	us_drm_runtime_s *run;
+} us_drm_s;
+
+
+us_drm_s *us_drm_init(void);
+void us_drm_destroy(us_drm_s *drm);
+
+int us_drm_open(us_drm_s *drm, const us_capture_s *cap);
+void us_drm_close(us_drm_s *drm);
+
+int us_drm_dpms_power_off(us_drm_s *drm);
+int us_drm_wait_for_vsync(us_drm_s *drm);
+int us_drm_expose_stub(us_drm_s *drm, us_drm_stub_e stub, const us_capture_s *cap);
+int us_drm_expose_dma(us_drm_s *drm, const us_capture_hwbuf_s *hw);
+int us_drm_ensure_no_signal(us_drm_s *drm);

src/libs/errors.h

@@ -0,0 +1,27 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  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_ERROR_COMMON		-1
+#define US_ERROR_NO_DEVICE	-2
+#define US_ERROR_NO_DATA	-3

src/libs/fpsi.c

@@ -0,0 +1,112 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  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 "fpsi.h"
+
+#include <stdatomic.h>
+
+#include <pthread.h>
+
+#include "types.h"
+#include "tools.h"
+#include "threading.h"
+#include "logging.h"
+#include "frame.h"
+
+
+us_fpsi_s *us_fpsi_init(const char *name, bool with_meta) {
+	us_fpsi_s *fpsi;
+	US_CALLOC(fpsi, 1);
+	fpsi->name = us_strdup(name);
+	fpsi->with_meta = with_meta;
+	atomic_init(&fpsi->state_sec_ts, 0);
+	atomic_init(&fpsi->state, 0);
+	return fpsi;
+}
+
+void us_fpsi_destroy(us_fpsi_s *fpsi) {
+	free(fpsi->name);
+	free(fpsi);
+}
+
+void us_fpsi_frame_to_meta(const us_frame_s *frame, us_fpsi_meta_s *meta) {
+	meta->width = frame->width;
+	meta->height = frame->height;
+	meta->online = frame->online;
+}
+
+void us_fpsi_update(us_fpsi_s *fpsi, bool bump, const us_fpsi_meta_s *meta) {
+	if (meta != NULL) {
+		assert(fpsi->with_meta);
+	} else {
+		assert(!fpsi->with_meta);
+	}
+
+	const sll now_sec_ts = us_floor_ms(us_get_now_monotonic());
+	if (atomic_load(&fpsi->state_sec_ts) != now_sec_ts) {
+		US_LOG_PERF_FPS("FPS: %s: %u", fpsi->name, fpsi->accum);
+
+		// Fast mutex-less store method
+		ull state = (ull)fpsi->accum & 0xFFFF;
+		if (fpsi->with_meta) {
+			assert(meta != NULL);
+			state |= (ull)(meta->width & 0xFFFF) << 16;
+			state |= (ull)(meta->height & 0xFFFF) << 32;
+			state |= (ull)(meta->online ? 1 : 0) << 48;
+		}
+		atomic_store(&fpsi->state, state); // Сначала инфа
+		atomic_store(&fpsi->state_sec_ts, now_sec_ts); // Потом время, это важно
+		fpsi->accum = 0;
+	}
+	if (bump) {
+		++fpsi->accum;
+	}
+}
+
+uint us_fpsi_get(us_fpsi_s *fpsi, us_fpsi_meta_s *meta) {
+	if (meta != NULL) {
+		assert(fpsi->with_meta);
+	} else {
+		assert(!fpsi->with_meta);
+	}
+
+	// Между чтением инфы и времени может быть гонка,
+	// но это неважно. Если время свежее, до данные тоже
+	// будут свежмими, обратный случай не так важен.
+	const sll now_sec_ts = us_floor_ms(us_get_now_monotonic());
+	const sll state_sec_ts = atomic_load(&fpsi->state_sec_ts); // Сначала время
+	const ull state = atomic_load(&fpsi->state); // Потом инфа
+
+	uint current = state & 0xFFFF;
+	if (fpsi->with_meta) {
+		assert(meta != NULL);
+		meta->width = (state >> 16) & 0xFFFF;
+		meta->height = (state >> 32) & 0xFFFF;
+		meta->online = (state >> 48) & 1;
+	}
+
+	if (state_sec_ts != now_sec_ts && (state_sec_ts + 1) != now_sec_ts) {
+		// Только текущая или прошлая секунда
+		current = 0;
+	}
+	return current;
+}

src/libs/fpsi.h

@@ -0,0 +1,51 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  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 <stdatomic.h>
+
+#include "types.h"
+#include "frame.h"
+
+
+typedef struct {
+	uint	width;
+	uint	height;
+	bool	online;
+} us_fpsi_meta_s;
+
+typedef struct {
+	char			*name;
+	bool			with_meta;
+	uint			accum;
+	atomic_llong	state_sec_ts;
+	atomic_ullong	state;
+} us_fpsi_s;
+
+
+us_fpsi_s *us_fpsi_init(const char *name, bool with_meta);
+void us_fpsi_destroy(us_fpsi_s *fpsi);
+
+void us_fpsi_frame_to_meta(const us_frame_s *frame, us_fpsi_meta_s *meta);
+void us_fpsi_update(us_fpsi_s *fpsi, bool bump, const us_fpsi_meta_s *meta);
+uint us_fpsi_get(us_fpsi_s *fpsi, us_fpsi_meta_s *meta);

src/libs/frame.c

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,6 +22,16 @@
 
 #include "frame.h"
 
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include <linux/videodev2.h>
+
+#include "types.h"
+#include "tools.h"
+
 
 us_frame_s *us_frame_init(void) {
 	us_frame_s *frame;
@@ -36,21 +46,21 @@ void us_frame_destroy(us_frame_s *frame) {
 	free(frame);
 }
 
-void us_frame_realloc_data(us_frame_s *frame, size_t size) {
+void us_frame_realloc_data(us_frame_s *frame, uz size) {
 	if (frame->allocated < size) {
 		US_REALLOC(frame->data, size);
 		frame->allocated = size;
 	}
 }
 
-void us_frame_set_data(us_frame_s *frame, const uint8_t *data, size_t size) {
+void us_frame_set_data(us_frame_s *frame, const u8 *data, uz size) {
 	us_frame_realloc_data(frame, size);
 	memcpy(frame->data, data, size);
 	frame->used = size;
 }
 
-void us_frame_append_data(us_frame_s *frame, const uint8_t *data, size_t size) {
-	const size_t new_used = frame->used + size;
+void us_frame_append_data(us_frame_s *frame, const u8 *data, uz size) {
+	const uz new_used = frame->used + size;
 	us_frame_realloc_data(frame, new_used);
 	memcpy(frame->data + frame->used, data, size);
 	frame->used = new_used;
@@ -64,17 +74,19 @@ 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) {
 	return (
 		a->allocated && b->allocated
-		&& US_FRAME_COMPARE_META_USED_NOTS(a, b)
+		&& US_FRAME_COMPARE_GEOMETRY(a, b)
 		&& !memcmp(a->data, b->data, b->used)
 	);
 }
 
-unsigned us_frame_get_padding(const us_frame_s *frame) {
-	unsigned bytes_per_pixel = 0;
+uint us_frame_get_padding(const us_frame_s *frame) {
+	uint bytes_per_pixel = 0;
 	switch (frame->format) {
 		case V4L2_PIX_FMT_YUYV:
+		case V4L2_PIX_FMT_YVYU:
 		case V4L2_PIX_FMT_UYVY:
 		case V4L2_PIX_FMT_RGB565: bytes_per_pixel = 2; break;
+		case V4L2_PIX_FMT_BGR24:
 		case V4L2_PIX_FMT_RGB24: bytes_per_pixel = 3; break;
 		// case V4L2_PIX_FMT_H264:
 		case V4L2_PIX_FMT_MJPEG:
@@ -87,13 +99,17 @@ unsigned us_frame_get_padding(const us_frame_s *frame) {
 	return 0;
 }
 
-const char *us_fourcc_to_string(unsigned format, char *buf, size_t size) {
+bool us_is_jpeg(uint format) {
+	return (format == V4L2_PIX_FMT_JPEG || format == V4L2_PIX_FMT_MJPEG);
+}
+
+const char *us_fourcc_to_string(uint format, char *buf, uz size) {
 	assert(size >= 8);
 	buf[0] = format & 0x7F;
 	buf[1] = (format >> 8) & 0x7F;
 	buf[2] = (format >> 16) & 0x7F;
 	buf[3] = (format >> 24) & 0x7F;
-	if (format & ((unsigned)1 << 31)) {
+	if (format & ((uint)1 << 31)) {
 		buf[4] = '-';
 		buf[5] = 'B';
 		buf[6] = 'E';

src/libs/frame.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,74 +22,68 @@
 
 #pragma once
 
-#include <stddef.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-
-#include <linux/videodev2.h>
-
+#include "types.h"
 #include "tools.h"
 
 
+#define US_FRAME_META_DECLARE \
+	uint	width; \
+	uint	height; \
+	uint	format; \
+	uint	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; \
+	uint	gop; \
+	\
+	ldf		grab_ts; \
+	ldf		encode_begin_ts; \
+	ldf		encode_end_ts;
+
+
 typedef struct {
-	uint8_t		*data;
-	size_t		used;
-	size_t		allocated;
-	int			dma_fd;
+	u8		*data;
+	uz		used;
+	uz		allocated;
+	int		dma_fd;
 
-	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;
-	unsigned	gop;
-
-	long double	grab_ts;
-	long double	encode_begin_ts;
-	long double	encode_end_ts;
+	US_FRAME_META_DECLARE;
 } us_frame_s;
 
 
 #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->gop = x_src->gop; \
-		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; \
+		(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)->gop = (x_src)->gop; \
+		\
+		(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; \
 	}
 
-static inline void us_frame_copy_meta(const us_frame_s *src, us_frame_s *dest) {
-	US_FRAME_COPY_META(src, dest);
-}
-
-#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 \
-		&& x_a->gop == x_b->gop \
+#define US_FRAME_COMPARE_GEOMETRY(x_a, x_b) ( \
+		/* Compare the used size and significant meta (no timings) */ \
+		(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 \
+		&& (x_a)->gop == (x_b)->gop \
 	)
 
 
-static inline void us_frame_encoding_begin(const us_frame_s *src, us_frame_s *dest, unsigned format) {
+static inline void us_frame_encoding_begin(const us_frame_s *src, us_frame_s *dest, uint format) {
 	assert(src->used > 0);
-	us_frame_copy_meta(src, dest);
+	US_FRAME_COPY_META(src, dest);
 	dest->encode_begin_ts = us_get_now_monotonic();
 	dest->format = format;
 	dest->stride = 0;
@@ -105,17 +99,14 @@ static inline void us_frame_encoding_end(us_frame_s *dest) {
 us_frame_s *us_frame_init(void);
 void us_frame_destroy(us_frame_s *frame);
 
-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);
+void us_frame_realloc_data(us_frame_s *frame, uz size);
+void us_frame_set_data(us_frame_s *frame, const u8 *data, uz size);
+void us_frame_append_data(us_frame_s *frame, const u8 *data, uz size);
 
 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);
+uint 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);
-}
+bool us_is_jpeg(uint format);
+const char *us_fourcc_to_string(uint format, char *buf, uz size);

src/libs/frametext.c

@@ -0,0 +1,186 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  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 "frametext.h"
+
+#include <string.h>
+
+#include <sys/types.h>
+
+#include <linux/videodev2.h>
+
+#include "tools.h"
+#include "frame.h"
+#include "frametext_font.h"
+
+
+static void _frametext_draw_line(
+	us_frametext_s *ft, const char *line,
+	uint scale_x, uint scale_y,
+	uint start_x, uint start_y);
+
+
+us_frametext_s *us_frametext_init(void) {
+	us_frametext_s *ft;
+	US_CALLOC(ft, 1);
+	ft->frame = us_frame_init();
+	return ft;
+}
+
+void us_frametext_destroy(us_frametext_s *ft) {
+	us_frame_destroy(ft->frame);
+	US_DELETE(ft->text, free);
+	free(ft);
+}
+
+/*
+Every character in the font is encoded row-wise in 8 bytes.
+The least significant bit of each byte corresponds to the first pixel in a row. 
+The character 'A' (0x41 / 65) is encoded as { 0x0C, 0x1E, 0x33, 0x33, 0x3F, 0x33, 0x33, 0x00}
+
+    0x0C => 0000 1100 => ..XX....
+    0X1E => 0001 1110 => .XXXX...
+    0x33 => 0011 0011 => XX..XX..
+    0x33 => 0011 0011 => XX..XX..
+    0x3F => 0011 1111 => xxxxxx..
+    0x33 => 0011 0011 => XX..XX..
+    0x33 => 0011 0011 => XX..XX..
+    0x00 => 0000 0000 => ........
+
+To access the nth pixel in a row, right-shift by n.
+
+                         . . X X . . . .
+                         | | | | | | | |
+    (0x0C >> 0) & 1 == 0-+ | | | | | | |
+    (0x0C >> 1) & 1 == 0---+ | | | | | |
+    (0x0C >> 2) & 1 == 1-----+ | | | | |
+    (0x0C >> 3) & 1 == 1-------+ | | | |
+    (0x0C >> 4) & 1 == 0---------+ | | |
+    (0x0C >> 5) & 1 == 0-----------+ | |
+    (0x0C >> 6) & 1 == 0-------------+ |
+    (0x0C >> 7) & 1 == 0---------------+
+*/
+
+void us_frametext_draw(us_frametext_s *ft, const char *text, uint width, uint height) {
+	assert(width > 0);
+	assert(height > 0);
+
+	us_frame_s *const frame = ft->frame;
+
+	if (
+		frame->width == width && frame->height == height
+		&& ft->text != NULL && !strcmp(ft->text, text)
+	) {
+		return;
+	}
+
+	US_DELETE(ft->text, free);
+	ft->text = us_strdup(text);
+	strcpy(ft->text, text);
+	frame->width = width;
+	frame->height = height;
+	frame->format = V4L2_PIX_FMT_RGB24;
+	frame->stride = width * 3;
+	frame->used = width * height * 3;
+	us_frame_realloc_data(frame, frame->used);
+	memset(frame->data, 0, frame->used);
+
+	if (frame->width == 0 || frame->height == 0) {
+		return;
+	}
+
+	char *str = us_strdup(text);
+	char *line;
+	char *rest;
+
+	uint block_width = 0;
+	uint block_height = 0;
+	while ((line = strtok_r((block_height == 0 ? str : NULL), "\n", &rest)) != NULL) {
+		block_width = US_MAX(strlen(line) * 8, block_width);
+		block_height += 8;
+	}
+	if (block_width == 0 || block_height == 0) {
+		goto empty;
+	}
+	uint scale_x = frame->width / block_width / 2;
+	uint scale_y = frame->height / block_height / 3;
+	if (scale_x < scale_y / 1.5) {
+		scale_y = scale_x * 1.5;
+	} else if (scale_y < scale_x * 1.5) {
+		scale_x = scale_y / 1.5;
+	}
+
+	strcpy(str, text);
+
+	const uint start_y = (frame->height >= (block_height * scale_y)
+		? ((frame->height - (block_height * scale_y)) / 2)
+		: 0);
+	uint n_line = 0;
+	while ((line = strtok_r((n_line == 0 ? str : NULL), "\n", &rest)) != NULL) {
+		const uint line_width = strlen(line) * 8 * scale_x;
+		const uint start_x = (frame->width >= line_width
+			? ((frame->width - line_width) / 2)
+			: 0);
+		_frametext_draw_line(ft, line, scale_x, scale_y, start_x, start_y + n_line * 8 * scale_y);
+		++n_line;
+	}
+
+empty:
+	free(str);
+}
+
+void _frametext_draw_line(
+	us_frametext_s *ft, const char *line,
+	uint scale_x, uint scale_y,
+	uint start_x, uint start_y) {
+
+	us_frame_s *const frame = ft->frame;
+
+	const size_t len = strlen(line);
+
+	for (uint ch_y = 0; ch_y < 8 * scale_y; ++ch_y) {
+		const uint canvas_y = start_y + ch_y;
+		for (uint ch_x = 0; ch_x < 8 * len * scale_x; ++ch_x) {
+			if ((start_x + ch_x) >= frame->width) {
+				break;
+			}
+			const uint canvas_x = (start_x + ch_x) * 3;
+			const uint offset = canvas_y * frame->stride + canvas_x;
+			if (offset >= frame->used) {
+				break;
+			}
+
+			const u8 ch = US_MIN((u8)line[ch_x / 8 / scale_x], sizeof(US_FRAMETEXT_FONT) / 8 - 1);
+			const uint ch_byte = (ch_y / scale_y) % 8;
+			const uint ch_bit = (ch_x / scale_x) % 8;
+			const bool pix_on = !!(US_FRAMETEXT_FONT[ch][ch_byte] & (1 << ch_bit));
+
+			u8 *const r = &frame->data[offset];
+			u8 *const g = r + 1;
+			u8 *const b = r + 2;
+
+			*r = pix_on * 0x65; // RGB/BGR-friendly
+			*g = pix_on * 0x65;
+			*b = pix_on * 0x65;
+		}
+	}
+}

src/libs/frametext.h

@@ -0,0 +1,39 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  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 "types.h"
+#include "frame.h"
+
+
+typedef struct {
+	char		*text;
+	us_frame_s	*frame;
+} us_frametext_s;
+
+
+us_frametext_s *us_frametext_init(void);
+void us_frametext_destroy(us_frametext_s *ft);
+
+void us_frametext_draw(us_frametext_s *ft, const char *text, uint width, uint height);

src/libs/frametext_font.c

@@ -0,0 +1,160 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  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 "frametext_font.h"
+
+#include "types.h"
+
+
+const u8 US_FRAMETEXT_FONT[128][8] = {
+	// https://github.com/dhepper/font8x8/blob/master/font8x8_basic.h
+	// Author: Daniel Hepper <daniel@hepper.net>
+	// License: Public Domain
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0000 (nul)
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0001
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0002
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0003
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0004
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0005
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0006
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0007
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0008
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0009
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000A
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000B
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000C
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000D
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000E
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000F
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0010
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0011
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0012
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0013
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0014
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0015
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0016
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0017
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0018
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0019
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001A
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001B
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001C
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001D
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001E
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001F
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0020 (space)
+	{0x18, 0x3C, 0x3C, 0x18, 0x18, 0x00, 0x18, 0x00}, // U+0021 (!)
+	{0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0022 (")
+	{0x36, 0x36, 0x7F, 0x36, 0x7F, 0x36, 0x36, 0x00}, // U+0023 (#)
+	{0x0C, 0x3E, 0x03, 0x1E, 0x30, 0x1F, 0x0C, 0x00}, // U+0024 ($)
+	{0x00, 0x63, 0x33, 0x18, 0x0C, 0x66, 0x63, 0x00}, // U+0025 (%)
+	{0x1C, 0x36, 0x1C, 0x6E, 0x3B, 0x33, 0x6E, 0x00}, // U+0026 (&)
+	{0x06, 0x06, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0027 (')
+	{0x18, 0x0C, 0x06, 0x06, 0x06, 0x0C, 0x18, 0x00}, // U+0028 (()
+	{0x06, 0x0C, 0x18, 0x18, 0x18, 0x0C, 0x06, 0x00}, // U+0029 ())
+	{0x00, 0x66, 0x3C, 0xFF, 0x3C, 0x66, 0x00, 0x00}, // U+002A (*)
+	{0x00, 0x0C, 0x0C, 0x3F, 0x0C, 0x0C, 0x00, 0x00}, // U+002B (+)
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x0C, 0x06}, // U+002C (,)
+	{0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x00}, // U+002D (-)
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x0C, 0x00}, // U+002E (.)
+	{0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x01, 0x00}, // U+002F (/)
+	{0x3E, 0x63, 0x73, 0x7B, 0x6F, 0x67, 0x3E, 0x00}, // U+0030 (0)
+	{0x0C, 0x0E, 0x0C, 0x0C, 0x0C, 0x0C, 0x3F, 0x00}, // U+0031 (1)
+	{0x1E, 0x33, 0x30, 0x1C, 0x06, 0x33, 0x3F, 0x00}, // U+0032 (2)
+	{0x1E, 0x33, 0x30, 0x1C, 0x30, 0x33, 0x1E, 0x00}, // U+0033 (3)
+	{0x38, 0x3C, 0x36, 0x33, 0x7F, 0x30, 0x78, 0x00}, // U+0034 (4)
+	{0x3F, 0x03, 0x1F, 0x30, 0x30, 0x33, 0x1E, 0x00}, // U+0035 (5)
+	{0x1C, 0x06, 0x03, 0x1F, 0x33, 0x33, 0x1E, 0x00}, // U+0036 (6)
+	{0x3F, 0x33, 0x30, 0x18, 0x0C, 0x0C, 0x0C, 0x00}, // U+0037 (7)
+	{0x1E, 0x33, 0x33, 0x1E, 0x33, 0x33, 0x1E, 0x00}, // U+0038 (8)
+	{0x1E, 0x33, 0x33, 0x3E, 0x30, 0x18, 0x0E, 0x00}, // U+0039 (9)
+	{0x00, 0x0C, 0x0C, 0x00, 0x00, 0x0C, 0x0C, 0x00}, // U+003A (:)
+	{0x00, 0x0C, 0x0C, 0x00, 0x00, 0x0C, 0x0C, 0x06}, // U+003B (;)
+	{0x18, 0x0C, 0x06, 0x03, 0x06, 0x0C, 0x18, 0x00}, // U+003C (<)
+	{0x00, 0x00, 0x3F, 0x00, 0x00, 0x3F, 0x00, 0x00}, // U+003D (=)
+	{0x06, 0x0C, 0x18, 0x30, 0x18, 0x0C, 0x06, 0x00}, // U+003E (>)
+	{0x1E, 0x33, 0x30, 0x18, 0x0C, 0x00, 0x0C, 0x00}, // U+003F (?)
+	{0x3E, 0x63, 0x7B, 0x7B, 0x7B, 0x03, 0x1E, 0x00}, // U+0040 (@)
+	{0x0C, 0x1E, 0x33, 0x33, 0x3F, 0x33, 0x33, 0x00}, // U+0041 (A)
+	{0x3F, 0x66, 0x66, 0x3E, 0x66, 0x66, 0x3F, 0x00}, // U+0042 (B)
+	{0x3C, 0x66, 0x03, 0x03, 0x03, 0x66, 0x3C, 0x00}, // U+0043 (C)
+	{0x1F, 0x36, 0x66, 0x66, 0x66, 0x36, 0x1F, 0x00}, // U+0044 (D)
+	{0x7F, 0x46, 0x16, 0x1E, 0x16, 0x46, 0x7F, 0x00}, // U+0045 (E)
+	{0x7F, 0x46, 0x16, 0x1E, 0x16, 0x06, 0x0F, 0x00}, // U+0046 (F)
+	{0x3C, 0x66, 0x03, 0x03, 0x73, 0x66, 0x7C, 0x00}, // U+0047 (G)
+	{0x33, 0x33, 0x33, 0x3F, 0x33, 0x33, 0x33, 0x00}, // U+0048 (H)
+	{0x1E, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x1E, 0x00}, // U+0049 (I)
+	{0x78, 0x30, 0x30, 0x30, 0x33, 0x33, 0x1E, 0x00}, // U+004A (J)
+	{0x67, 0x66, 0x36, 0x1E, 0x36, 0x66, 0x67, 0x00}, // U+004B (K)
+	{0x0F, 0x06, 0x06, 0x06, 0x46, 0x66, 0x7F, 0x00}, // U+004C (L)
+	{0x63, 0x77, 0x7F, 0x7F, 0x6B, 0x63, 0x63, 0x00}, // U+004D (M)
+	{0x63, 0x67, 0x6F, 0x7B, 0x73, 0x63, 0x63, 0x00}, // U+004E (N)
+	{0x1C, 0x36, 0x63, 0x63, 0x63, 0x36, 0x1C, 0x00}, // U+004F (O)
+	{0x3F, 0x66, 0x66, 0x3E, 0x06, 0x06, 0x0F, 0x00}, // U+0050 (P)
+	{0x1E, 0x33, 0x33, 0x33, 0x3B, 0x1E, 0x38, 0x00}, // U+0051 (Q)
+	{0x3F, 0x66, 0x66, 0x3E, 0x36, 0x66, 0x67, 0x00}, // U+0052 (R)
+	{0x1E, 0x33, 0x07, 0x0E, 0x38, 0x33, 0x1E, 0x00}, // U+0053 (S)
+	{0x3F, 0x2D, 0x0C, 0x0C, 0x0C, 0x0C, 0x1E, 0x00}, // U+0054 (T)
+	{0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x3F, 0x00}, // U+0055 (U)
+	{0x33, 0x33, 0x33, 0x33, 0x33, 0x1E, 0x0C, 0x00}, // U+0056 (V)
+	{0x63, 0x63, 0x63, 0x6B, 0x7F, 0x77, 0x63, 0x00}, // U+0057 (W)
+	{0x63, 0x63, 0x36, 0x1C, 0x1C, 0x36, 0x63, 0x00}, // U+0058 (X)
+	{0x33, 0x33, 0x33, 0x1E, 0x0C, 0x0C, 0x1E, 0x00}, // U+0059 (Y)
+	{0x7F, 0x63, 0x31, 0x18, 0x4C, 0x66, 0x7F, 0x00}, // U+005A (Z)
+	{0x1E, 0x06, 0x06, 0x06, 0x06, 0x06, 0x1E, 0x00}, // U+005B ([)
+	{0x03, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x40, 0x00}, // U+005C (\)
+	{0x1E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1E, 0x00}, // U+005D (])
+	{0x08, 0x1C, 0x36, 0x63, 0x00, 0x00, 0x00, 0x00}, // U+005E (^)
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF}, // U+005F (_)
+	{0x0C, 0x0C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0060 (`)
+	{0x00, 0x00, 0x1E, 0x30, 0x3E, 0x33, 0x6E, 0x00}, // U+0061 (a)
+	{0x07, 0x06, 0x06, 0x3E, 0x66, 0x66, 0x3B, 0x00}, // U+0062 (b)
+	{0x00, 0x00, 0x1E, 0x33, 0x03, 0x33, 0x1E, 0x00}, // U+0063 (c)
+	{0x38, 0x30, 0x30, 0x3e, 0x33, 0x33, 0x6E, 0x00}, // U+0064 (d)
+	{0x00, 0x00, 0x1E, 0x33, 0x3f, 0x03, 0x1E, 0x00}, // U+0065 (e)
+	{0x1C, 0x36, 0x06, 0x0f, 0x06, 0x06, 0x0F, 0x00}, // U+0066 (f)
+	{0x00, 0x00, 0x6E, 0x33, 0x33, 0x3E, 0x30, 0x1F}, // U+0067 (g)
+	{0x07, 0x06, 0x36, 0x6E, 0x66, 0x66, 0x67, 0x00}, // U+0068 (h)
+	{0x0C, 0x00, 0x0E, 0x0C, 0x0C, 0x0C, 0x1E, 0x00}, // U+0069 (i)
+	{0x30, 0x00, 0x30, 0x30, 0x30, 0x33, 0x33, 0x1E}, // U+006A (j)
+	{0x07, 0x06, 0x66, 0x36, 0x1E, 0x36, 0x67, 0x00}, // U+006B (k)
+	{0x0E, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x1E, 0x00}, // U+006C (l)
+	{0x00, 0x00, 0x33, 0x7F, 0x7F, 0x6B, 0x63, 0x00}, // U+006D (m)
+	{0x00, 0x00, 0x1F, 0x33, 0x33, 0x33, 0x33, 0x00}, // U+006E (n)
+	{0x00, 0x00, 0x1E, 0x33, 0x33, 0x33, 0x1E, 0x00}, // U+006F (o)
+	{0x00, 0x00, 0x3B, 0x66, 0x66, 0x3E, 0x06, 0x0F}, // U+0070 (p)
+	{0x00, 0x00, 0x6E, 0x33, 0x33, 0x3E, 0x30, 0x78}, // U+0071 (q)
+	{0x00, 0x00, 0x3B, 0x6E, 0x66, 0x06, 0x0F, 0x00}, // U+0072 (r)
+	{0x00, 0x00, 0x3E, 0x03, 0x1E, 0x30, 0x1F, 0x00}, // U+0073 (s)
+	{0x08, 0x0C, 0x3E, 0x0C, 0x0C, 0x2C, 0x18, 0x00}, // U+0074 (t)
+	{0x00, 0x00, 0x33, 0x33, 0x33, 0x33, 0x6E, 0x00}, // U+0075 (u)
+	{0x00, 0x00, 0x33, 0x33, 0x33, 0x1E, 0x0C, 0x00}, // U+0076 (v)
+	{0x00, 0x00, 0x63, 0x6B, 0x7F, 0x7F, 0x36, 0x00}, // U+0077 (w)
+	{0x00, 0x00, 0x63, 0x36, 0x1C, 0x36, 0x63, 0x00}, // U+0078 (x)
+	{0x00, 0x00, 0x33, 0x33, 0x33, 0x3E, 0x30, 0x1F}, // U+0079 (y)
+	{0x00, 0x00, 0x3F, 0x19, 0x0C, 0x26, 0x3F, 0x00}, // U+007A (z)
+	{0x38, 0x0C, 0x0C, 0x07, 0x0C, 0x0C, 0x38, 0x00}, // U+007B ({)
+	{0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x00}, // U+007C (|)
+	{0x07, 0x0C, 0x0C, 0x38, 0x0C, 0x0C, 0x07, 0x00}, // U+007D (})
+	{0x6E, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+007E (~)
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+007F
+};

src/libs/frametext_font.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,13 +22,7 @@
 
 #pragma once
 
-#include <stdint.h>
-
-#include <sys/types.h>
+#include "types.h"
 
 
-extern const unsigned US_BLANK_JPEG_WIDTH;
-extern const unsigned US_BLANK_JPEG_HEIGHT;
-
-extern const size_t US_BLANK_JPEG_DATA_SIZE;
-extern const uint8_t US_BLANK_JPEG_DATA[];
+extern const u8 US_FRAMETEXT_FONT[128][8];

src/libs/list.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,9 +25,9 @@
 #include <assert.h>
 
 
-#define US_LIST_STRUCT(...) \
-	__VA_ARGS__ *prev; \
-	__VA_ARGS__ *next;
+#define US_LIST_DECLARE \
+	void *prev; \
+	void *next;
 
 #define US_LIST_ITERATE(x_first, x_item, ...) { \
 		for (__typeof__(x_first) x_item = x_first; x_item;) { \
@@ -42,10 +42,11 @@
 			x_first = x_item; \
 		} else { \
 			__typeof__(x_first) m_last = x_first; \
-			for (; m_last->next; m_last = m_last->next); \
+			for (; m_last->next != NULL; m_last = m_last->next); \
 			x_item->prev = m_last; \
 			m_last->next = x_item; \
 		} \
+		x_item->next = NULL; \
 	}
 
 #define US_LIST_APPEND_C(x_first, x_item, x_count) { \
@@ -57,11 +58,15 @@
 		if (x_item->prev == NULL) { \
 			x_first = x_item->next; \
 		} else { \
-			x_item->prev->next = x_item->next; \
+			__typeof__(x_first) m_prev = x_item->prev; \
+			m_prev->next = x_item->next; \
 		} \
 		if (x_item->next != NULL) { \
-			x_item->next->prev = x_item->prev; \
+			__typeof__(x_first) m_next = x_item->next; \
+			m_next->prev = x_item->prev; \
 		} \
+		x_item->prev = NULL; \
+		x_item->next = NULL; \
 	}
 
 #define US_LIST_REMOVE_C(x_first, x_item, x_count) { \

src/libs/logging.c

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,6 +22,10 @@
 
 #include "logging.h"
 
+#include <stdbool.h>
+
+#include <pthread.h>
+
 
 enum us_log_level_t us_g_log_level;
 

src/libs/logging.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,6 @@
 #pragma once
 
 #include <stdio.h>
-#include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
@@ -33,6 +32,7 @@
 
 #include <pthread.h>
 
+#include "types.h"
 #include "tools.h"
 #include "threading.h"
 
@@ -91,7 +91,7 @@ extern pthread_mutex_t us_g_log_mutex;
 
 
 #define US_LOG_PRINTF_NOLOCK(x_label_color, x_label, x_msg_color, x_msg, ...) { \
-		char m_tname_buf[US_MAX_THREAD_NAME] = {0}; \
+		char m_tname_buf[US_THREAD_NAME_SIZE] = {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 \

src/libs/memsink.c

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,10 +22,27 @@
 
 #include "memsink.h"
 
+#include <stdatomic.h>
+#include <string.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <assert.h>
 
-us_memsink_s *us_memsink_init(
+#include <sys/file.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+
+#include "types.h"
+#include "errors.h"
+#include "tools.h"
+#include "logging.h"
+#include "frame.h"
+#include "memsinksh.h"
+
+
+us_memsink_s *us_memsink_init_opened(
 	const char *name, const char *obj, bool server,
-	mode_t mode, bool rm, unsigned client_ttl, unsigned timeout) {
+	mode_t mode, bool rm, uint client_ttl, uint timeout) {
 
 	us_memsink_s *sink;
 	US_CALLOC(sink, 1);
@@ -40,6 +57,11 @@ us_memsink_s *us_memsink_init(
 
 	US_LOG_INFO("Using %s-sink: %s", name, obj);
 
+	if ((sink->data_size = us_memsink_calculate_size(obj)) == 0) {
+		US_LOG_ERROR("%s-sink: Invalid object suffix", name);
+		goto error;
+	}
+
 	const mode_t mask = umask(0);
 	sink->fd = shm_open(sink->obj, (server ? O_RDWR | O_CREAT : O_RDWR), mode);
 	umask(mask);
@@ -49,26 +71,25 @@ us_memsink_s *us_memsink_init(
 		goto error;
 	}
 
-	if (sink->server && ftruncate(sink->fd, sizeof(us_memsink_shared_s)) < 0) {
+	if (sink->server && ftruncate(sink->fd, sizeof(us_memsink_shared_s) + sink->data_size) < 0) {
 		US_LOG_PERROR("%s-sink: Can't truncate shared memory", name);
 		goto error;
 	}
 
-	if ((sink->mem = us_memsink_shared_map(sink->fd)) == NULL) {
+	if ((sink->mem = us_memsink_shared_map(sink->fd, sink->data_size)) == NULL) {
 		US_LOG_PERROR("%s-sink: Can't mmap shared memory", name);
 		goto error;
 	}
-
 	return sink;
 
-	error:
-		us_memsink_destroy(sink);
-		return NULL;
+error:
+	us_memsink_destroy(sink);
+	return NULL;
 }
 
 void us_memsink_destroy(us_memsink_s *sink) {
 	if (sink->mem != NULL) {
-		if (us_memsink_shared_unmap(sink->mem) < 0) {
+		if (us_memsink_shared_unmap(sink->mem, sink->data_size) < 0) {
 			US_LOG_PERROR("%s-sink: Can't unmap shared memory", sink->name);
 		}
 	}
@@ -86,16 +107,35 @@ void us_memsink_destroy(us_memsink_s *sink) {
 }
 
 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;
-	//   - We have some active clients by last_client_ts;
-	//   - Frame meta differs (like size, format, but not timestamp).
+	// Если frame == NULL, то только проверяем наличие клиентов
+	// или необходимость инициализировать память.
 
 	assert(sink->server);
 
+	if (sink->mem->magic != US_MEMSINK_MAGIC || sink->mem->version != US_MEMSINK_VERSION) {
+		// Если регион памяти не был инициализирован, то нужно что-то туда положить.
+		// Блокировка не нужна, потому что только сервер пишет в эти переменные.
+		return true;
+	}
+
+	const ldf unsafe_ts = sink->mem->last_client_ts;
+	if (unsafe_ts != sink->unsafe_last_client_ts) {
+		// Клиент пишет в синке свою отметку last_client_ts при любом действии.
+		// Мы не берем блокировку здесь, а просто проверяем, является ли это число тем же самым,
+		// что было прочитано нами в предыдущих итерациях. Значению не нужно быть консистентным,
+		// и даже если мы прочитали мусор из-за гонки в памяти между чтением здеси и записью
+		// из клиента, мы все равно можем сделать вывод, есть ли у нас клиенты вообще.
+		// Если число число поменялось то у нас точно есть клиенты и дальнейшие проверки
+		// проводить не требуется. Если же число неизменно, то стоит поставить блокировку
+		// и проверить, нужно ли записать что-нибудь в память для инициализации фрейма.
+		sink->unsafe_last_client_ts = unsafe_ts;
+		atomic_store(&sink->has_clients, true);
+		return true;
+	}
+
 	if (flock(sink->fd, LOCK_EX | LOCK_NB) < 0) {
 		if (errno == EWOULDBLOCK) {
+			// Есть живой клиент, который прямо сейчас взял блокировку и читает фрейм из синка
 			atomic_store(&sink->has_clients, true);
 			return true;
 		}
@@ -103,10 +143,7 @@ bool us_memsink_server_check(us_memsink_s *sink, const us_frame_s *frame) {
 		return false;
 	}
 
-	if (sink->mem->magic != US_MEMSINK_MAGIC || sink->mem->version != US_MEMSINK_VERSION) {
-		return true;
-	}
-
+	// Проверяем, есть ли у нас живой клиент по таймауту
 	const bool has_clients = (sink->mem->last_client_ts + sink->client_ttl > us_get_now_monotonic());
 	atomic_store(&sink->has_clients, has_clients);
 
@@ -114,31 +151,39 @@ bool us_memsink_server_check(us_memsink_s *sink, const us_frame_s *frame) {
 		US_LOG_PERROR("%s-sink: Can't unlock memory", sink->name);
 		return false;
 	}
-	return (has_clients || !US_FRAME_COMPARE_META_USED_NOTS(sink->mem, frame));;
+	if (has_clients) {
+		return true;
+	}
+	if (frame != NULL && !US_FRAME_COMPARE_GEOMETRY(sink->mem, frame)) {
+		// Если есть изменения в геометрии/формате фрейма, то их тоже нобходимо сразу записать в синк
+		return true;
+	}
+	return false;
 }
 
-int us_memsink_server_put(us_memsink_s *sink, const us_frame_s *frame, bool *const key_requested) {
+int us_memsink_server_put(us_memsink_s *sink, const us_frame_s *frame, bool *key_requested) {
 	assert(sink->server);
 
-	const long double now = us_get_now_monotonic();
+	const ldf now = us_get_now_monotonic();
 
-	if (frame->used > US_MEMSINK_MAX_DATA) {
+	if (frame->used > sink->data_size) {
 		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
+			sink->name, frame->used, sink->data_size);
+		return 0;
 	}
 
 	if (us_flock_timedwait_monotonic(sink->fd, 1) == 0) {
 		US_LOG_VERBOSE("%s-sink: >>>>> Exposing new frame ...", sink->name);
 
-		sink->last_id = us_get_now_id();
-		sink->mem->id = sink->last_id;
+		sink->mem->id = us_get_now_id();
 		if (sink->mem->key_requested && frame->key) {
 			sink->mem->key_requested = false;
 		}
-		*key_requested = sink->mem->key_requested;
+		if (key_requested != NULL) { // We don't need it for non-H264 sinks
+			*key_requested = sink->mem->key_requested;
+		}
 
-		memcpy(sink->mem->data, frame->data, frame->used);
+		memcpy(us_memsink_get_data(sink->mem), frame->data, frame->used);
 		sink->mem->used = frame->used;
 		US_FRAME_COPY_META(frame, sink->mem);
 
@@ -164,42 +209,52 @@ int us_memsink_server_put(us_memsink_s *sink, const us_frame_s *frame, bool *con
 	return 0;
 }
 
-int us_memsink_client_get(us_memsink_s *sink, us_frame_s *frame, bool *const key_requested, bool key_required) { // cppcheck-suppress unusedFunction
+int us_memsink_client_get(us_memsink_s *sink, us_frame_s *frame, bool *key_requested, bool key_required) {
 	assert(!sink->server); // Client only
 
 	if (us_flock_timedwait_monotonic(sink->fd, sink->timeout) < 0) {
 		if (errno == EWOULDBLOCK) {
-			return -2;
+			return US_ERROR_NO_DATA;
 		}
 		US_LOG_PERROR("%s-sink: Can't lock memory", sink->name);
 		return -1;
 	}
 
-	int retval = -2; // Not updated
-	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;
-			us_frame_set_data(frame, sink->mem->data, sink->mem->used);
-			US_FRAME_COPY_META(sink->mem, frame);
-			*key_requested = sink->mem->key_requested;
-			retval = 0;
-		}
-		sink->mem->last_client_ts = us_get_now_monotonic();
-		if (key_required) {
-			sink->mem->key_requested = true;
-		}
+	int retval = 0;
+
+	if (sink->mem->magic != US_MEMSINK_MAGIC) {
+		retval = US_ERROR_NO_DATA; // Not updated
+		goto done;
+	}
+	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;
 	}
 
-	done:
-		if (flock(sink->fd, LOCK_UN) < 0) {
-			US_LOG_PERROR("%s-sink: Can't unlock memory", sink->name);
-			return -1;
-		}
-		return retval;
+	// Let the sink know that the client is alive
+	sink->mem->last_client_ts = us_get_now_monotonic();
+
+	if (sink->mem->id == sink->last_readed_id) {
+		retval = US_ERROR_NO_DATA; // Not updated
+		goto done;
+	}
+
+	sink->last_readed_id = sink->mem->id;
+	us_frame_set_data(frame, us_memsink_get_data(sink->mem), sink->mem->used);
+	US_FRAME_COPY_META(sink->mem, frame);
+	if (key_requested != NULL) { // We don't need it for non-H264 sinks
+		*key_requested = sink->mem->key_requested;
+	}
+	if (key_required) {
+		sink->mem->key_requested = true;
+	}
+
+done:
+	if (flock(sink->fd, LOCK_UN) < 0) {
+		US_LOG_PERROR("%s-sink: Can't unlock memory", sink->name);
+		retval = -1;
+	}
+	return retval;
 }

src/libs/memsink.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,47 +22,41 @@
 
 #pragma once
 
-#include <stdint.h>
-#include <stdbool.h>
 #include <stdatomic.h>
-#include <string.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <assert.h>
 
-#include <sys/types.h>
-#include <sys/file.h>
 #include <sys/stat.h>
-#include <sys/mman.h>
 
-#include "tools.h"
-#include "logging.h"
+#include "types.h"
 #include "frame.h"
 #include "memsinksh.h"
 
 
 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;
+	uz			data_size;
+	bool		server;
+	bool		rm;
+	uint		client_ttl; // Only for server
+	uint		timeout;
 
 	int					fd;
 	us_memsink_shared_s	*mem;
-	uint64_t			last_id;
-	atomic_bool			has_clients; // Only for server
+
+	u64			last_readed_id; // Only for client
+
+	atomic_bool	has_clients; // Only for server results
+	ldf			unsafe_last_client_ts; // Only for server
 } us_memsink_s;
 
 
-us_memsink_s *us_memsink_init(
+us_memsink_s *us_memsink_init_opened(
 	const char *name, const char *obj, bool server,
-	mode_t mode, bool rm, unsigned client_ttl, unsigned timeout);
+	mode_t mode, bool rm, uint client_ttl, uint timeout);
 
 void us_memsink_destroy(us_memsink_s *sink);
 
 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, bool *const key_requested);
+int us_memsink_server_put(us_memsink_s *sink, const us_frame_s *frame, bool *key_requested);
 
-int us_memsink_client_get(us_memsink_s *sink, us_frame_s *frame, bool *const key_requested, bool key_required);
+int us_memsink_client_get(us_memsink_s *sink, us_frame_s *frame, bool *key_requested, bool key_required);

src/libs/memsinksh.c

@@ -0,0 +1,72 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  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 "memsinksh.h"
+
+#include <string.h>
+#include <strings.h>
+#include <assert.h>
+
+#include <sys/mman.h>
+
+#include "types.h"
+
+
+us_memsink_shared_s *us_memsink_shared_map(int fd, uz data_size) {
+	us_memsink_shared_s *mem = mmap(
+		NULL,
+		sizeof(us_memsink_shared_s) + data_size,
+		PROT_READ | PROT_WRITE, MAP_SHARED,
+		fd, 0);
+	if (mem == MAP_FAILED) {
+		return NULL;
+	}
+	assert(mem != NULL);
+	return mem;
+}
+
+int us_memsink_shared_unmap(us_memsink_shared_s *mem, uz data_size) {
+	assert(mem != NULL);
+	return munmap(mem, sizeof(us_memsink_shared_s) + data_size);
+}
+
+uz us_memsink_calculate_size(const char *obj) {
+	const char *ptr = strrchr(obj, ':');
+	if (ptr == NULL) {
+		ptr = strrchr(obj, '.');
+	}
+	if (ptr != NULL) {
+		ptr += 1;
+		if (!strcasecmp(ptr, "jpeg")) {
+			return 4 * 1024 * 1024;
+		} else if (!strcasecmp(ptr, "h264")) {
+			return 2 * 1024 * 1024;
+		} else if (!strcasecmp(ptr, "raw")) {
+			return 1920 * 1200 * 3; // RGB
+		}
+	}
+	return 0;
+}
+
+u8 *us_memsink_get_data(us_memsink_shared_s *mem) {
+	return (u8*)(mem) + sizeof(us_memsink_shared_s);
+}

src/libs/memsinksh.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,65 +22,29 @@
 
 #pragma once
 
-#include <stdint.h>
-#include <stdbool.h>
-
-#include <sys/types.h>
-#include <sys/mman.h>
+#include "types.h"
+#include "frame.h"
 
 
-#define US_MEMSINK_MAGIC	((uint64_t)0xCAFEBABECAFEBABE)
-#define US_MEMSINK_VERSION	((uint32_t)4)
-
-#ifndef US_CFG_MEMSINK_MAX_DATA
-#	define US_CFG_MEMSINK_MAX_DATA 33554432
-#endif
-#define US_MEMSINK_MAX_DATA ((size_t)(US_CFG_MEMSINK_MAX_DATA))
+#define US_MEMSINK_MAGIC	((u64)0xCAFEBABECAFEBABE)
+#define US_MEMSINK_VERSION	((u32)7)
 
 
 typedef struct {
-	uint64_t	magic;
-	uint32_t	version;
+	u64		magic;
+	u32		version;
+	u64		id;
+	uz		used;
 
-	uint64_t	id;
+	ldf		last_client_ts;
+	bool	key_requested;
 
-	size_t		used;
-	unsigned	width;
-	unsigned	height;
-	unsigned	format;
-	unsigned	stride;
-	bool		online;
-	bool		key;
-	unsigned	gop;
-
-	long double	grab_ts;
-	long double	encode_begin_ts;
-	long double	encode_end_ts;
-
-	long double	last_client_ts;
-	bool		key_requested;
-
-	uint8_t		data[US_MEMSINK_MAX_DATA];
+	US_FRAME_META_DECLARE;
 } us_memsink_shared_s;
 
 
-INLINE us_memsink_shared_s *us_memsink_shared_map(int fd) {
-	us_memsink_shared_s *mem = mmap(
-		NULL,
-		sizeof(us_memsink_shared_s),
-		PROT_READ | PROT_WRITE,
-		MAP_SHARED,
-		fd,
-		0
-	);
-	if (mem == MAP_FAILED) {
-		return NULL;
-	}
-	assert(mem != NULL);
-	return mem;
-}
+us_memsink_shared_s *us_memsink_shared_map(int fd, uz data_size);
+int us_memsink_shared_unmap(us_memsink_shared_s *mem, uz data_size);
 
-INLINE int us_memsink_shared_unmap(us_memsink_shared_s *mem) {
-	assert(mem != NULL);
-	return munmap(mem, sizeof(us_memsink_shared_s));
-}
+uz us_memsink_calculate_size(const char *obj);
+u8 *us_memsink_get_data(us_memsink_shared_s *mem);

src/libs/options.c

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,10 +22,17 @@
 
 #include "options.h"
 
+#include <string.h>
+#include <ctype.h>
+#include <getopt.h>
+#include <assert.h>
 
-void us_build_short_options(const struct option opts[], char *short_opts, size_t size) {
+#include "types.h"
+
+
+void us_build_short_options(const struct option opts[], char *short_opts, uz size) {
 	memset(short_opts, 0, size);
-    for (unsigned short_index = 0, opt_index = 0; opts[opt_index].name != NULL; ++opt_index) {
+    for (uint short_index = 0, opt_index = 0; opts[opt_index].name != NULL; ++opt_index) {
 		assert(short_index < size - 3);
         if (isalpha(opts[opt_index].val)) {
             short_opts[short_index] = opts[opt_index].val;

src/libs/options.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,12 +22,9 @@
 
 #pragma once
 
-#include <string.h>
-#include <ctype.h>
 #include <getopt.h>
-#include <assert.h>
 
-#include <sys/types.h>
+#include "types.h"
 
 
-void us_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, uz size);

src/libs/process.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,8 +25,6 @@
 #include <signal.h>
 #include <unistd.h>
 
-#include <sys/types.h>
-
 
 #if defined(__linux__)
 #	define HAS_PDEATHSIG
@@ -58,6 +56,7 @@
 #		include <sys/procctl.h>
 #	endif
 #endif
+#include "types.h"
 #ifdef WITH_SETPROCTITLE
 #	include "tools.h"
 #endif
@@ -98,18 +97,18 @@ INLINE int us_process_track_parent_death(void) {
 #ifdef WITH_SETPROCTITLE
 #	pragma GCC diagnostic ignored "-Wunused-parameter"
 #	pragma GCC diagnostic push
-INLINE void us_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) { // cppcheck-suppress constParameter
 #	pragma GCC diagnostic pop
 
 	char *cmdline = NULL;
-	size_t allocated = 2048;
-	size_t used = 0;
+	uz allocated = 2048;
+	uz used = 0;
 
 	US_REALLOC(cmdline, allocated);
 	cmdline[0] = '\0';
 
 	for (int index = 0; index < argc; ++index) {
-		size_t arg_len = strlen(argv[index]);
+		uz arg_len = strlen(argv[index]);
 		if (used + arg_len + 16 >= allocated) {
 			allocated += arg_len + 2048;
 			US_REALLOC(cmdline, allocated); // cppcheck-suppress memleakOnRealloc // False-positive (ok with assert)

src/libs/queue.c

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,8 +22,18 @@
 
 #include "queue.h"
 
+#include <errno.h>
+#include <time.h>
+#include <assert.h>
 
-us_queue_s *us_queue_init(unsigned capacity) {
+#include <pthread.h>
+
+#include "types.h"
+#include "tools.h"
+#include "threading.h"
+
+
+us_queue_s *us_queue_init(uint capacity) {
 	us_queue_s *queue;
 	US_CALLOC(queue, 1);
 	US_CALLOC(queue->items, capacity);
@@ -61,7 +71,7 @@ void us_queue_destroy(us_queue_s *queue) {
 		} \
 	}
 
-int us_queue_put(us_queue_s *queue, void *item, long double timeout) {
+int us_queue_put(us_queue_s *queue, void *item, ldf timeout) {
 	US_MUTEX_LOCK(queue->mutex);
 	if (timeout == 0) {
 		if (queue->size == queue->capacity) {
@@ -80,7 +90,7 @@ int us_queue_put(us_queue_s *queue, void *item, long double timeout) {
 	return 0;
 }
 
-int us_queue_get(us_queue_s *queue, void **item, long double timeout) {
+int us_queue_get(us_queue_s *queue, void **item, ldf timeout) {
 	US_MUTEX_LOCK(queue->mutex);
 	_WAIT_OR_UNLOCK(queue->size == 0, queue->empty_cond);
 	*item = queue->items[queue->out];
@@ -94,9 +104,9 @@ int us_queue_get(us_queue_s *queue, void **item, long double timeout) {
 
 #undef _WAIT_OR_UNLOCK
 
-int us_queue_get_free(us_queue_s *queue) {
+bool us_queue_is_empty(us_queue_s *queue) {
 	US_MUTEX_LOCK(queue->mutex);
-	const unsigned size = queue->size;
+	const uint size = queue->size;
 	US_MUTEX_UNLOCK(queue->mutex);
-	return queue->capacity - size;
+	return (bool)(queue->capacity - size);
 }

src/libs/queue.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,24 +22,20 @@
 
 #pragma once
 
-#include <errno.h>
-#include <time.h>
-#include <assert.h>
-
 #include <pthread.h>
 
-#include "uslibs/tools.h"
-#include "uslibs/threading.h"
+#include "types.h"
+#include "tools.h"
 
 
 // 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;
+	uint			size;
+	uint			capacity;
+	uint			in;
+	uint			out;
 
 	pthread_mutex_t	mutex;
 	pthread_cond_t	full_cond;
@@ -49,7 +45,7 @@ typedef struct {
 
 #define US_QUEUE_DELETE_WITH_ITEMS(x_queue, x_free_item) { \
 		if (x_queue) { \
-			while (!us_queue_get_free(x_queue)) { \
+			while (!us_queue_is_empty(x_queue)) { \
 				void *m_ptr; \
 				if (!us_queue_get(x_queue, &m_ptr, 0)) { \
 					US_DELETE(m_ptr, x_free_item); \
@@ -60,9 +56,9 @@ typedef struct {
 	}
 
 
-us_queue_s *us_queue_init(unsigned capacity);
+us_queue_s *us_queue_init(uint capacity);
 void us_queue_destroy(us_queue_s *queue);
 
-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);
+int us_queue_put(us_queue_s *queue, void *item, ldf timeout);
+int us_queue_get(us_queue_s *queue, void **item, ldf timeout);
+bool us_queue_is_empty(us_queue_s *queue);

src/libs/ring.c

@@ -0,0 +1,86 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  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 <assert.h>
+
+#include "ring.h"
+
+#include "types.h"
+#include "tools.h"
+#include "queue.h"
+
+
+int _acquire(us_ring_s *ring, us_queue_s *queue, ldf timeout);
+void _release(us_ring_s *ring, us_queue_s *queue, uint index);
+
+
+us_ring_s *us_ring_init(uint capacity) {
+	us_ring_s *ring;
+	US_CALLOC(ring, 1);
+	US_CALLOC(ring->items, capacity);
+	US_CALLOC(ring->places, capacity);
+	ring->capacity = capacity;
+	ring->producer = us_queue_init(capacity);
+	ring->consumer = us_queue_init(capacity);
+	for (uint index = 0; index < capacity; ++index) {
+		ring->places[index] = index; // XXX: Just to avoid casting between pointer and uint
+		assert(!us_queue_put(ring->producer, (void*)(ring->places + index), 0));
+	}
+	return ring;
+}
+
+void us_ring_destroy(us_ring_s *ring) {
+	us_queue_destroy(ring->consumer);
+	us_queue_destroy(ring->producer);
+	free(ring->places);
+	free(ring->items);
+	free(ring);
+}
+
+int us_ring_producer_acquire(us_ring_s *ring, ldf timeout) {
+	return _acquire(ring, ring->producer, timeout);
+}
+
+void us_ring_producer_release(us_ring_s *ring, uint index) {
+	_release(ring, ring->consumer, index);
+}
+
+int us_ring_consumer_acquire(us_ring_s *ring, ldf timeout) {
+	return _acquire(ring, ring->consumer, timeout);
+}
+
+void us_ring_consumer_release(us_ring_s *ring, uint index) {
+	_release(ring, ring->producer, index);
+}
+
+int _acquire(us_ring_s *ring, us_queue_s *queue, ldf timeout) {
+	(void)ring;
+	uint *place;
+	if (us_queue_get(queue, (void**)&place, timeout) < 0) {
+		return -1;
+	}
+	return *place;
+}
+
+void _release(us_ring_s *ring, us_queue_s *queue, uint index) {
+	assert(!us_queue_put(queue, (void*)(ring->places + index), 0));
+}

src/libs/ring.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,28 +22,42 @@
 
 #pragma once
 
-#include <stdbool.h>
-#include <stdatomic.h>
-#include <assert.h>
 
-#include "../libs/tools.h"
-#include "../libs/logging.h"
-#include "../libs/frame.h"
-#include "../libs/memsink.h"
-#include "../libs/unjpeg.h"
-#include "m2m.h"
+#include "types.h"
+#include "queue.h"
 
 
 typedef struct {
-	us_memsink_s		*sink;
-	bool				key_requested;
-	us_frame_s			*tmp_src;
-	us_frame_s			*dest;
-	us_m2m_encoder_s	*enc;
-	atomic_bool			online;
-} us_h264_stream_s;
+	uz			capacity;
+	void		**items;
+	uint		*places;
+	us_queue_s	*producer;
+	us_queue_s	*consumer;
+} us_ring_s;
 
 
-us_h264_stream_s *us_h264_stream_init(us_memsink_s *sink, const char *path, unsigned bitrate, unsigned gop);
-void us_h264_stream_destroy(us_h264_stream_s *h264);
-void us_h264_stream_process(us_h264_stream_s *h264, const us_frame_s *frame, bool force_key);
+#define US_RING_INIT_WITH_ITEMS(x_ring, x_capacity, x_init_item) { \
+		(x_ring) = us_ring_init(x_capacity); \
+		for (uz m_index = 0; m_index < (x_ring)->capacity; ++m_index) { \
+			(x_ring)->items[m_index] = x_init_item(); \
+		} \
+	}
+
+#define US_RING_DELETE_WITH_ITEMS(x_ring, x_destroy_item) { \
+		if (x_ring) { \
+			for (uz m_index = 0; m_index < (x_ring)->capacity; ++m_index) { \
+				x_destroy_item((x_ring)->items[m_index]); \
+			} \
+			us_ring_destroy(x_ring); \
+		} \
+	}
+
+
+us_ring_s *us_ring_init(uint capacity);
+void us_ring_destroy(us_ring_s *ring);
+
+int us_ring_producer_acquire(us_ring_s *ring, ldf timeout);
+void us_ring_producer_release(us_ring_s *ring, uint index);
+
+int us_ring_consumer_acquire(us_ring_s *ring, ldf timeout);
+void us_ring_consumer_release(us_ring_s *ring, uint index);

src/libs/signal.c

@@ -0,0 +1,82 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2024  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 "signal.h"
+
+#include <string.h>
+#include <signal.h>
+#include <assert.h>
+
+#if defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 32
+#	define HAS_SIGABBREV_NP
+#endif
+
+#include "types.h"
+#include "tools.h"
+#include "logging.h"
+
+
+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;
+}
+
+void us_install_signals_handler(us_signal_handler_f handler, bool ignore_sigpipe) {
+	struct sigaction sig_act = {0};
+
+	assert(!sigemptyset(&sig_act.sa_mask));
+	sig_act.sa_handler = handler;
+	assert(!sigaddset(&sig_act.sa_mask, SIGINT));
+	assert(!sigaddset(&sig_act.sa_mask, SIGTERM));
+	if (!ignore_sigpipe) {
+	    assert(!sigaddset(&sig_act.sa_mask, SIGPIPE));
+	}
+
+	US_LOG_DEBUG("Installing SIGINT handler ...");
+	assert(!sigaction(SIGINT, &sig_act, NULL));
+
+	US_LOG_DEBUG("Installing SIGTERM handler ...");
+	assert(!sigaction(SIGTERM, &sig_act, NULL));
+
+	if (!ignore_sigpipe) {
+		US_LOG_DEBUG("Installing SIGPIPE handler ...");
+		assert(!sigaction(SIGPIPE, &sig_act, NULL));
+	} else {
+		US_LOG_DEBUG("Ignoring SIGPIPE ...");
+		assert(signal(SIGPIPE, SIG_IGN) != SIG_ERR);
+	}
+}

src/libs/signal.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,14 +22,11 @@
 
 #pragma once
 
-#include <string.h>
-#include <errno.h>
-
-#include <event2/util.h>
-#include <event2/bufferevent.h>
-
-#include "../../libs/tools.h"
-#include "../../libs/logging.h"
+#include "types.h"
 
 
-char *us_bufferevent_format_reason(short what);
+typedef void (*us_signal_handler_f)(int);
+
+
+char *us_signum_to_string(int signum);
+void us_install_signals_handler(us_signal_handler_f handler, bool ignore_sigpipe);

src/libs/tc358743.c

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,6 +22,16 @@
 
 #include "tc358743.h"
 
+#include <unistd.h>
+#include <fcntl.h>
+
+#include <linux/videodev2.h>
+#include <linux/v4l2-controls.h>
+
+#include "types.h"
+#include "tools.h"
+#include "xioctl.h"
+
 
 #ifndef V4L2_CID_USER_TC358743_BASE
 #	define V4L2_CID_USER_TC358743_BASE (V4L2_CID_USER_BASE + 0x1080)
@@ -34,31 +44,22 @@
 #endif
 
 
-int us_tc358743_read_info(const char *path, us_tc358743_info_s *info) {
-	US_MEMSET_ZERO(*info);
+int us_tc358743_xioctl_get_audio_hz(int fd, uint *audio_hz) {
+	*audio_hz = 0;
 
-	int fd = -1;
-	if ((fd = open(path, O_RDWR)) < 0) {
-		US_JLOG_PERROR("audio", "Can't open TC358743 V4L2 device");
+	struct v4l2_control ctl = {.id = TC358743_CID_AUDIO_PRESENT};
+	if (us_xioctl(fd, VIDIOC_G_CTRL, &ctl) < 0) {
 		return -1;
 	}
+	if (!ctl.value) {
+		return 0; // No audio
+	}
 
-#	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);
+	US_MEMSET_ZERO(ctl);
+	ctl.id = TC358743_CID_AUDIO_SAMPLING_RATE;
+	if (us_xioctl(fd, VIDIOC_G_CTRL, &ctl) < 0) {
+		return -1;
+	}
+	*audio_hz = ctl.value;
 	return 0;
 }

src/libs/tc358743.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,12 +22,7 @@
 
 #pragma once
 
-#include <stdbool.h>
-
-#include <event2/util.h>
-#include <event2/http.h>
-#include <event2/keyvalq_struct.h>
+#include "types.h"
 
 
-bool us_uri_get_true(struct evkeyvalq *params, const char *key);
-char *us_uri_get_string(struct evkeyvalq *params, const char *key);
+int us_tc358743_xioctl_get_audio_hz(int fd, uint *audio_hz);

src/libs/threading.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,9 +24,9 @@
 
 #include <stdio.h>
 #include <unistd.h>
+#include <signal.h>
 #include <assert.h>
 
-#include <sys/types.h>
 #include <sys/syscall.h>
 
 #include <pthread.h>
@@ -37,13 +37,14 @@
 #	endif
 #endif
 
+#include "types.h"
 #include "tools.h"
 
 
 #ifdef PTHREAD_MAX_NAMELEN_NP
-#	define US_MAX_THREAD_NAME ((size_t)(PTHREAD_MAX_NAMELEN_NP))
+#	define US_THREAD_NAME_SIZE ((uz)(PTHREAD_MAX_NAMELEN_NP))
 #else
-#	define US_MAX_THREAD_NAME ((size_t)16)
+#	define US_THREAD_NAME_SIZE ((uz)16)
 #endif
 
 #define US_THREAD_CREATE(x_tid, x_func, x_arg)	assert(!pthread_create(&(x_tid), NULL, (x_func), (x_arg)))
@@ -51,14 +52,19 @@
 
 #ifdef WITH_PTHREAD_NP
 #	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); \
+			char m_new_tname_buf[US_THREAD_NAME_SIZE] = {0}; \
+			US_SNPRINTF(m_new_tname_buf, (US_THREAD_NAME_SIZE - 1), (x_fmt), ##__VA_ARGS__); \
 			us_thread_set_name(m_new_tname_buf); \
 		}
 #else
-#	define US_THREAD_RENAME(_fmt, ...)
+#	define US_THREAD_RENAME(x_fmt, ...)
 #endif
 
+#define US_THREAD_SETTLE(x_fmt, ...) { \
+		US_THREAD_RENAME((x_fmt), ##__VA_ARGS__); \
+		us_thread_block_signals(); \
+	}
+
 #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)))
@@ -78,7 +84,7 @@ INLINE void us_thread_set_name(const char *name) {
 #	elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
 	pthread_set_name_np(pthread_self(), name);
 #	elif defined(__NetBSD__)
-	pthread_setname_np(pthread_self(), "%s", (void *)name);
+	pthread_setname_np(pthread_self(), "%s", (void*)name);
 #	else
 #		error us_thread_set_name() not implemented, you can disable it using WITH_PTHREAD_NP=0
 #	endif
@@ -89,12 +95,12 @@ 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, US_MAX_THREAD_NAME);
+	retval = pthread_getname_np(pthread_self(), name, US_THREAD_NAME_SIZE - 1);
 #	elif \
 		(defined(__FreeBSD__) && defined(__FreeBSD_version) && __FreeBSD_version >= 1103500) \
 		|| (defined(__OpenBSD__) && defined(OpenBSD) && OpenBSD >= 201905) \
 		|| defined(__DragonFly__)
-	pthread_get_name_np(pthread_self(), name, US_MAX_THREAD_NAME);
+	pthread_get_name_np(pthread_self(), name, US_THREAD_NAME_SIZE - 1);
 	if (name[0] != '\0') {
 		retval = 0;
 	}
@@ -107,7 +113,9 @@ INLINE void us_thread_get_name(char *name) { // Always required for logging
 #if defined(__linux__)
 		const pid_t tid = syscall(SYS_gettid);
 #elif defined(__FreeBSD__)
-		const pid_t tid = syscall(SYS_thr_self);
+		long id;
+		assert(!syscall(SYS_thr_self, &id));
+		const pid_t tid = id;
 #elif defined(__OpenBSD__)
 		const pid_t tid = syscall(SYS_getthrid);
 #elif defined(__NetBSD__)
@@ -118,9 +126,17 @@ INLINE void us_thread_get_name(char *name) { // Always required for logging
 		const pid_t tid = 0; // Makes cppcheck happy
 #	warning gettid() not implemented
 #endif
-		assert(snprintf(name, US_MAX_THREAD_NAME, "tid=%d", tid) > 0);
+		US_SNPRINTF(name, (US_THREAD_NAME_SIZE - 1), "tid=%d", tid);
 
 #ifdef WITH_PTHREAD_NP
 	}
 #endif
 }
+
+INLINE void us_thread_block_signals(void) {
+	sigset_t mask;
+	assert(!sigemptyset(&mask));
+	assert(!sigaddset(&mask, SIGINT));
+	assert(!sigaddset(&mask, SIGTERM));
+	assert(!pthread_sigmask(SIG_BLOCK, &mask, NULL));
+}

src/libs/tools.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,26 +23,19 @@
 #pragma once
 
 #include <stdio.h>
-#include <stdint.h>
 #include <stdlib.h>
-#include <stdbool.h>
 #include <string.h>
 #include <unistd.h>
 #include <limits.h>
-#include <locale.h>
+#include <locale.h> // Make C locale for strerror_l()
 #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
+#include "types.h"
 
 
 #ifdef NDEBUG
@@ -57,14 +50,37 @@
 #define RN "\r\n"
 
 #define INLINE inline __attribute__((always_inline))
-#define UNUSED __attribute__((unused))
 
 #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_DELETE(x_dest, x_free)		{ if (x_dest) { x_free(x_dest); x_dest = NULL; } }
+#define US_CLOSE_FD(x_dest)				{ if (x_dest >= 0) { close(x_dest); x_dest = -1; } }
 #define US_MEMSET_ZERO(x_obj)			memset(&(x_obj), 0, sizeof(x_obj))
 
-#define US_ASPRINTF(x_dest, x_fmt, ...) assert(asprintf(&(x_dest), (x_fmt), ##__VA_ARGS__) >= 0)
+#define US_SNPRINTF(x_dest, x_size, x_fmt, ...)	assert(snprintf((x_dest), (x_size), (x_fmt), ##__VA_ARGS__) > 0)
+#define US_ASPRINTF(x_dest, x_fmt, ...)			assert(asprintf(&(x_dest), (x_fmt), ##__VA_ARGS__) > 0)
+
+#define US_MIN(x_a, x_b) ({ \
+		__typeof__(x_a) m_a = (x_a); \
+		__typeof__(x_b) m_b = (x_b); \
+		(m_a < m_b ? m_a : m_b); \
+	})
+
+#define US_MAX(x_a, x_b) ({ \
+		__typeof__(x_a) m_a = (x_a); \
+		__typeof__(x_b) m_b = (x_b); \
+		(m_a > m_b ? m_a : m_b); \
+	})
+
+#define US_ONCE_FOR(x_once, x_value, ...) { \
+		const int m_reported = (x_value); \
+		if (m_reported != (x_once)) { \
+			__VA_ARGS__; \
+			(x_once) = m_reported; \
+		} \
+	}
+
+#define US_ONCE(...) US_ONCE_FOR(once, __LINE__, ##__VA_ARGS__)
 
 
 INLINE char *us_strdup(const char *str) {
@@ -77,23 +93,15 @@ INLINE const char *us_bool_to_string(bool flag) {
 	return (flag ? "true" : "false");
 }
 
-INLINE size_t us_align_size(size_t size, size_t to) {
+INLINE uz us_align_size(uz size, uz to) {
 	return ((size + (to - 1)) & ~(to - 1));
 }
 
-INLINE unsigned us_min_u(unsigned a, unsigned b) {
-	return (a < b ? a : b);
+INLINE sll us_floor_ms(ldf now) {
+	return (sll)now - (now < (sll)now); // floor()
 }
 
-INLINE unsigned us_max_u(unsigned a, unsigned b) {
-	return (a > b ? a : b);
-}
-
-INLINE long long us_floor_ms(long double now) {
-	return (long long)now - (now < (long long)now); // floor()
-}
-
-INLINE uint32_t us_triple_u32(uint32_t x) {
+INLINE u32 us_triple_u32(u32 x) {
 	// https://nullprogram.com/blog/2018/07/31/
 	x ^= x >> 17;
 	x *= UINT32_C(0xED5AD4BB);
@@ -117,48 +125,38 @@ INLINE void us_get_now(clockid_t clk_id, time_t *sec, long *msec) {
 	}
 }
 
-#if defined(CLOCK_MONOTONIC_RAW)
-#	define _X_CLOCK_MONOTONIC CLOCK_MONOTONIC_RAW
-#elif defined(CLOCK_MONOTONIC_FAST)
-#	define _X_CLOCK_MONOTONIC CLOCK_MONOTONIC_FAST
-#else
-#	define _X_CLOCK_MONOTONIC CLOCK_MONOTONIC
-#endif
-
-INLINE long double us_get_now_monotonic(void) {
+INLINE ldf us_get_now_monotonic(void) {
 	time_t sec;
 	long msec;
-	us_get_now(_X_CLOCK_MONOTONIC, &sec, &msec);
-	return (long double)sec + ((long double)msec) / 1000;
+	us_get_now(CLOCK_MONOTONIC, &sec, &msec);
+	return (ldf)sec + ((ldf)msec) / 1000;
 }
 
-INLINE uint64_t us_get_now_monotonic_u64(void) {
+INLINE u64 us_get_now_monotonic_u64(void) {
 	struct timespec ts;
-	assert(!clock_gettime(_X_CLOCK_MONOTONIC, &ts));
-	return (uint64_t)(ts.tv_nsec / 1000) + (uint64_t)ts.tv_sec * 1000000;
+	assert(!clock_gettime(CLOCK_MONOTONIC, &ts));
+	return (u64)(ts.tv_nsec / 1000) + (u64)ts.tv_sec * 1000000;
 }
 
-#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);
+INLINE u64 us_get_now_id(void) {
+	const u64 now = us_get_now_monotonic_u64();
+	return (u64)us_triple_u32(now) | ((u64)us_triple_u32(now + 12345) << 32);
 }
 
-INLINE long double us_get_now_real(void) {
+INLINE ldf us_get_now_real(void) {
 	time_t sec;
 	long msec;
 	us_get_now(CLOCK_REALTIME, &sec, &msec);
-	return (long double)sec + ((long double)msec) / 1000;
+	return (ldf)sec + ((ldf)msec) / 1000;
 }
 
-INLINE unsigned us_get_cores_available(void) {
+INLINE uint us_get_cores_available(void) {
 	long cores_sysconf = sysconf(_SC_NPROCESSORS_ONLN);
 	cores_sysconf = (cores_sysconf < 0 ? 0 : cores_sysconf);
-	return us_max_u(us_min_u(cores_sysconf, 4), 1);
+	return US_MAX(US_MIN(cores_sysconf, 4), 1);
 }
 
-INLINE void us_ld_to_timespec(long double ld, struct timespec *ts) {
+INLINE void us_ld_to_timespec(ldf ld, struct timespec *ts) {
 	ts->tv_sec = (long)ld;
 	ts->tv_nsec = (ld - ts->tv_sec) * 1000000000L;
 	if (ts->tv_nsec > 999999999L) {
@@ -167,12 +165,12 @@ INLINE void us_ld_to_timespec(long double ld, struct timespec *ts) {
 	}
 }
 
-INLINE long double us_timespec_to_ld(const struct timespec *ts) {
-	return ts->tv_sec + ((long double)ts->tv_nsec) / 1000000000;
+INLINE ldf us_timespec_to_ld(const struct timespec *ts) {
+	return ts->tv_sec + ((ldf)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;
+INLINE int us_flock_timedwait_monotonic(int fd, ldf timeout) {
+	const ldf deadline_ts = us_get_now_monotonic() + timeout;
 	int retval = -1;
 
 	while (true) {
@@ -188,33 +186,26 @@ INLINE int us_flock_timedwait_monotonic(int fd, long double timeout) {
 }
 
 INLINE char *us_errno_to_string(int error) {
-	locale_t locale = newlocale(LC_MESSAGES_MASK, "C", NULL);
-	char *buf;
-	if (locale) {
-		buf = us_strdup(strerror_l(error, locale));
-		freelocale(locale);
-	} else {
-		buf = us_strdup("!!! newlocale() error !!!");
+#	if (_POSIX_C_SOURCE >= 200112L) && !defined(_GNU_SOURCE) // XSI
+	char buf[2048];
+	const uz max_len = sizeof(buf) - 1;
+	if (strerror_r(error, buf, max_len) != 0) {
+		US_SNPRINTF(buf, max_len, "Errno = %d", error);
 	}
-	return buf;
-}
+	return us_strdup(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);
+#	elif defined(__GLIBC__) && defined(_GNU_SOURCE) // GNU
+	char buf[2048];
+	const uz max_len = sizeof(buf) - 1;
+	return us_strdup(strerror_r(error, buf, max_len));
+
+#	else // BSD
+	locale_t locale = newlocale(LC_MESSAGES_MASK, "C", NULL);
+	if (locale) {
+		char *ptr = us_strdup(strerror_l(error, locale));
+		freelocale(locale);
+		return ptr;
 	}
-	return buf;
+	return us_strdup("!!! newlocale() error !!!");
+#	endif
 }

src/libs/types.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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    #
@@ -19,28 +19,28 @@
 #                                                                            #
 *****************************************************************************/
 
-
 #pragma once
 
-#include <unistd.h>
-#include <fcntl.h>
+#include <stdio.h>
 #include <stdbool.h>
+#include <stdint.h>
 
 #include <sys/types.h>
 
-#include <linux/videodev2.h>
-#include <linux/v4l2-controls.h>
 
-#include "uslibs/tools.h"
-#include "uslibs/xioctl.h"
+typedef long long sll;
+typedef ssize_t sz;
+typedef int8_t s8;
+typedef int16_t s16;
+typedef int32_t s32;
+typedef int64_t s64;
 
-#include "logging.h"
+typedef unsigned uint;
+typedef unsigned long long ull;
+typedef size_t uz;
+typedef uint8_t u8;
+typedef uint16_t u16;
+typedef uint32_t u32;
+typedef uint64_t u64;
 
-
-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);
+typedef long double ldf;

src/libs/unjpeg.c

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,6 +22,17 @@
 
 #include "unjpeg.h"
 
+#include <stdio.h>
+#include <setjmp.h>
+#include <assert.h>
+
+#include <jpeglib.h>
+#include <linux/videodev2.h>
+
+#include "types.h"
+#include "logging.h"
+#include "frame.h"
+
 
 typedef struct {
 	struct jpeg_error_mgr	mgr; // Default manager
@@ -43,7 +54,7 @@ int us_unjpeg(const us_frame_s *src, us_frame_s *dest, bool decode) {
 
 	// https://stackoverflow.com/questions/19857766/error-handling-in-libjpeg
 	_jpeg_error_manager_s jpeg_error;
-	jpeg.err = jpeg_std_error((struct jpeg_error_mgr *)&jpeg_error);
+	jpeg.err = jpeg_std_error((struct jpeg_error_mgr*)&jpeg_error);
 	jpeg_error.mgr.error_exit = _jpeg_error_handler;
 	jpeg_error.frame = src;
 	if (setjmp(jpeg_error.jmp) < 0) {
@@ -57,12 +68,12 @@ int us_unjpeg(const us_frame_s *src, us_frame_s *dest, bool decode) {
 
 	jpeg_start_decompress(&jpeg);
 
-	us_frame_copy_meta(src, dest);
-	dest->format = V4L2_PIX_FMT_RGB24;
-	dest->width = jpeg.output_width;
-	dest->height = jpeg.output_height;
-	dest->stride = jpeg.output_width * jpeg.output_components; // Row stride
-	dest->used = 0;
+	US_FRAME_COPY_META(src, dest); // cppcheck-suppress redundantAssignment
+	dest->format = V4L2_PIX_FMT_RGB24; // cppcheck-suppress redundantAssignment
+	dest->width = jpeg.output_width; // cppcheck-suppress redundantAssignment
+	dest->height = jpeg.output_height; // cppcheck-suppress redundantAssignment
+	dest->stride = jpeg.output_width * jpeg.output_components; // cppcheck-suppress redundantAssignment
+	dest->used = 0; // cppcheck-suppress redundantAssignment
 
 	if (decode) {
 		JSAMPARRAY scanlines;
@@ -77,13 +88,13 @@ int us_unjpeg(const us_frame_s *src, us_frame_s *dest, bool decode) {
 		jpeg_finish_decompress(&jpeg);
 	}
 
-	done:
-		jpeg_destroy_decompress(&jpeg);
-		return retval;
+done:
+	jpeg_destroy_decompress(&jpeg);
+	return retval;
 }
 
 static void _jpeg_error_handler(j_common_ptr jpeg) {
-	_jpeg_error_manager_s *jpeg_error = (_jpeg_error_manager_s *)jpeg->err;
+	_jpeg_error_manager_s *jpeg_error = (_jpeg_error_manager_s*)jpeg->err;
 	char msg[JMSG_LENGTH_MAX];
 
 	(*jpeg_error->mgr.format_message)(jpeg, msg);

src/libs/unjpeg.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,18 +22,7 @@
 
 #pragma once
 
-#include <stdio.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <setjmp.h>
-#include <assert.h>
-
-#include <sys/types.h>
-
-#include <jpeglib.h>
-#include <linux/videodev2.h>
-
-#include "logging.h"
+#include "types.h"
 #include "frame.h"
 
 

src/libs/xioctl.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,11 +26,13 @@
 
 #include <sys/ioctl.h>
 
+#include "types.h"
+
 
 #ifndef US_CFG_XIOCTL_RETRIES
 #	define US_CFG_XIOCTL_RETRIES 4
 #endif
-#define _XIOCTL_RETRIES ((unsigned)(US_CFG_XIOCTL_RETRIES))
+#define _XIOCTL_RETRIES ((uint)(US_CFG_XIOCTL_RETRIES))
 
 
 INLINE int us_xioctl(int fd, int request, void *arg) {

src/ustreamer/blank.c

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,84 +22,31 @@
 
 #include "blank.h"
 
+#include "../libs/types.h"
+#include "../libs/tools.h"
+#include "../libs/frame.h"
+#include "../libs/frametext.h"
 
-static us_frame_s *_init_internal(void);
-static us_frame_s *_init_external(const char *path);
+#include "encoders/cpu/encoder.h"
 
 
-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 != NULL) {
-		US_LOG_INFO("Using external blank placeholder: %s", path);
-	} else {
-		blank = _init_internal();
-		US_LOG_INFO("Using internal blank placeholder");
-	}
+us_blank_s *us_blank_init(void) {
+	us_blank_s *blank;
+	US_CALLOC(blank, 1);
+	blank->ft = us_frametext_init();
+	blank->raw = blank->ft->frame;
+	blank->jpeg = us_frame_init();
+	us_blank_draw(blank, "< NO SIGNAL >", 640, 480);
 	return blank;
 }
 
-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;
+void us_blank_draw(us_blank_s *blank, const char *text, uint width, uint height) {
+	us_frametext_draw(blank->ft, text, width, height);
+	us_cpu_encoder_compress(blank->raw, blank->jpeg, 95);
 }
 
-static us_frame_s *_init_external(const char *path) {
-	FILE *fp = NULL;
-
-	us_frame_s *blank = us_frame_init();
-	blank->format = V4L2_PIX_FMT_JPEG;
-
-	if ((fp = fopen(path, "rb")) == NULL) {
-		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) {
-			us_frame_realloc_data(blank, blank->used + CHUNK_SIZE * 2);
-		}
-
-		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 {
-				US_LOG_PERROR("Can't read blank placeholder");
-				goto error;
-			}
-		}
-	}
-#	undef CHUNK_SIZE
-
-	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;
-	us_frame_destroy(decoded);
-
-	goto ok;
-
-	error:
-		us_frame_destroy(blank);
-		blank = NULL;
-
-	ok:
-		US_DELETE(fp, fclose);
-
-	return blank;
+void us_blank_destroy(us_blank_s *blank) {
+	us_frame_destroy(blank->jpeg);
+	us_frametext_destroy(blank->ft);
+	free(blank);
 }

src/ustreamer/blank.h

@@ -2,7 +2,7 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    Copyright (C) 2018-2023  Maxim Devaev <mdevaev@gmail.com>               #
+#    Copyright (C) 2018-2024  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,17 +22,19 @@
 
 #pragma once
 
-#include <stdio.h>
-#include <stdbool.h>
-
-#include <linux/videodev2.h>
-
-#include "../libs/tools.h"
-#include "../libs/logging.h"
+#include "../libs/types.h"
 #include "../libs/frame.h"
-#include "../libs/unjpeg.h"
-
-#include "data/blank_jpeg.h"
+#include "../libs/frametext.h"
 
 
-us_frame_s *us_blank_frame_init(const char *path);
+typedef struct {
+	us_frametext_s	*ft;
+	us_frame_s		*raw;
+	us_frame_s		*jpeg;
+} us_blank_s;
+
+
+us_blank_s *us_blank_init(void);
+void us_blank_destroy(us_blank_s *blank);
+
+void us_blank_draw(us_blank_s *blank, const char *text, uint width, uint height);