Bump version: 5.6 → 5.7

Better CORS support

.bumpversion.cfg

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

README.md

@@ -40,6 +40,7 @@ You'll need  ```make```, ```gcc```, ```libevent``` with ```pthreads``` support,
 * Arch: `sudo pacman -S libevent libjpeg-turbo libutil-linux libbsd`.
 * Raspbian: `sudo apt install libevent-dev libjpeg8-dev libbsd-dev`. Add `libgpiod-dev` for `WITH_GPIO=1` and `libsystemd-dev` for `WITH_SYSTEMD=1`.
 * Debian/Ubuntu: `sudo apt install build-essential libevent-dev libjpeg-dev libbsd-dev`.
+* Alpine: `sudo apk add libevent-dev libbsd-dev libjpeg-turbo-dev musl-dev`. Build with `WITH_PTHREAD_NP=0`.
 
 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```.
 
@@ -99,6 +100,9 @@ $ modprobe bcm2835-v4l2 max_video_width=2592 max_video_height=1944
 -----
 # Integrations
 
+## Janus
+µStreamer supports bandwidth-efficient streaming using [H.264 compression](https://en.wikipedia.org/wiki/Advanced_Video_Coding) and the Janus WebRTC server. See the [Janus integration guide](docs/h264.md) for full details.
+
 ## Nginx
 When uStreamer is behind an Nginx proxy, it's buffering behavior introduces latency into the video stream. It's possible to disable Nginx's buffering to eliminate the additional latency:
 

docs/h264.md

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

janus/Makefile

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

janus/src/audio.c

@@ -0,0 +1,261 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2022  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "audio.h"
+
+
+#define JLOG_PERROR_ALSA(_err, _prefix, _msg, ...)	JLOG_ERROR(_prefix, _msg ": %s", ##__VA_ARGS__, snd_strerror(_err))
+#define JLOG_PERROR_RES(_err, _prefix, _msg, ...)	JLOG_ERROR(_prefix, _msg ": %s", ##__VA_ARGS__, speex_resampler_strerror(_err))
+#define JLOG_PERROR_OPUS(_err, _prefix, _msg, ...)	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);
+
+
+audio_s *audio_init(const char *name, unsigned pcm_hz) {
+	audio_s *audio;
+	A_CALLOC(audio, 1);
+	audio->pcm_hz = pcm_hz;
+	audio->pcm_queue = queue_init(8);
+	audio->enc_queue = 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) {
+			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
+	}
+
+	JLOG_INFO("audio", "Pipeline configured on %uHz; capturing ...", audio->pcm_hz);
+	audio->tids_created = true;
+	A_THREAD_CREATE(&audio->enc_tid, _encoder_thread, audio);
+	A_THREAD_CREATE(&audio->pcm_tid, _pcm_thread, audio);
+
+	return audio;
+
+	error:
+		audio_destroy(audio);
+		return NULL;
+}
+
+void audio_destroy(audio_s *audio) {
+	if (audio->tids_created) {
+		atomic_store(&audio->stop, true);
+		A_THREAD_JOIN(audio->pcm_tid);
+		A_THREAD_JOIN(audio->enc_tid);
+	}
+	if (audio->enc) {
+		opus_encoder_destroy(audio->enc);
+	}
+	if (audio->res) {
+		speex_resampler_destroy(audio->res);
+	}
+	if (audio->pcm) {
+		snd_pcm_close(audio->pcm);
+	}
+	if (audio->pcm_params) {
+		snd_pcm_hw_params_free(audio->pcm_params);
+	}
+#	define FREE_QUEUE(_suffix) { \
+			while (!queue_get_free(audio->_suffix##_queue)) { \
+				_##_suffix##_buffer_s *ptr; \
+				assert(!queue_get(audio->_suffix##_queue, (void **)&ptr, 1)); \
+				free(ptr); \
+			} \
+			queue_destroy(audio->_suffix##_queue); \
+		}
+	FREE_QUEUE(enc);
+	FREE_QUEUE(pcm);
+#	undef FREE_QUEUE
+	if (audio->tids_created) {
+		JLOG_INFO("audio", "Pipeline closed");
+	}
+	free(audio);
+}
+
+int audio_get_encoded(audio_s *audio, uint8_t *data, size_t *size, uint64_t *pts) {
+	if (atomic_load(&audio->stop)) {
+		return -1;
+	}
+	_enc_buffer_s *buf;
+	if (!queue_get(audio->enc_queue, (void **)&buf, 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) {
+	A_THREAD_RENAME("us_a_pcm");
+
+	audio_s *audio = (audio_s *)v_audio;
+	uint8_t in[MAX_BUF8];
+
+	while (!atomic_load(&audio->stop)) {
+		int frames = snd_pcm_readi(audio->pcm, in, audio->pcm_frames);
+		if (frames < 0) {
+			JLOG_PERROR_ALSA(frames, "audio", "Can't capture PCM frames; breaking audio ...");
+			break;
+		} else if (frames < (int)audio->pcm_frames) {
+			JLOG_ERROR("audio", "Too few PCM frames captured; breaking audio ...");
+			break;
+		}
+
+		if (queue_get_free(audio->pcm_queue)) {
+			_pcm_buffer_s *out;
+			A_CALLOC(out, 1);
+			memcpy(out->data, in, audio->pcm_size);
+			assert(!queue_put(audio->pcm_queue, out, 1));
+		} else {
+			JLOG_ERROR("audio", "PCM queue is full");
+		}
+	}
+
+	atomic_store(&audio->stop, true);
+	return NULL;
+}
+
+static void *_encoder_thread(void *v_audio) {
+	A_THREAD_RENAME("us_a_enc");
+
+	audio_s *audio = (audio_s *)v_audio;
+	int16_t in_res[MAX_BUF16];
+
+	while (!atomic_load(&audio->stop)) {
+		_pcm_buffer_s *in;
+		if (!queue_get(audio->pcm_queue, (void **)&in, 1)) {
+			int16_t *in_ptr;
+			if (audio->res) {
+				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;
+			A_CALLOC(out, 1);
+			int size = opus_encode(audio->enc, in_ptr, HZ_TO_FRAMES(ENCODER_INPUT_HZ), out->data, ARRAY_LEN(out->data));
+			free(in);
+			if (size < 0) {
+				JLOG_PERROR_OPUS(size, "audio", "Can't encode PCM frame to OPUS; breaking audio ...");
+				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 (queue_get_free(audio->enc_queue)) {
+				assert(!queue_put(audio->enc_queue, out, 1));
+			} else {
+				JLOG_ERROR("audio", "OPUS encoder queue is full");
+				free(out);
+			}
+		}
+	}
+
+	atomic_store(&audio->stop, true);
+	return NULL;
+}

janus/src/audio.h

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

janus/src/base64.c

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

janus/src/base64.h

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

janus/src/config.h

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

janus/src/frame.c

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

janus/src/frame.h

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

janus/src/jlogging.h

@@ -0,0 +1,36 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2022  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include <janus/plugins/plugin.h>
+
+#include "uslibs/tools.h"
+
+
+#define JLOG_INFO(_prefix, _msg, ...)	JANUS_LOG(LOG_INFO, "== ustreamer/%-9s -- " _msg "\n", _prefix, ##__VA_ARGS__)
+#define JLOG_WARN(_prefix, _msg, ...)	JANUS_LOG(LOG_WARN, "== ustreamer/%-9s -- " _msg "\n", _prefix, ##__VA_ARGS__)
+#define JLOG_ERROR(_prefix, _msg, ...)	JANUS_LOG(LOG_ERR, "== ustreamer/%-9s -- " _msg "\n", _prefix, ##__VA_ARGS__)
+
+#define JLOG_PERROR(_prefix, _msg, ...) { \
+		char _perror_buf[1024] = {0}; \
+		char *_perror_ptr = errno_to_string(errno, _perror_buf, 1023); \
+		JANUS_LOG(LOG_ERR, "[ustreamer/%-9s] " _msg ": %s\n", _prefix, ##__VA_ARGS__, _perror_ptr); \
+	}

janus/src/list.h

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

janus/src/memsinksh.h

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

janus/src/plugin.c

@@ -24,6 +24,7 @@
 #include <stdbool.h>
 #include <stdatomic.h>
 #include <stdlib.h>
+#include <inttypes.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <assert.h>
@@ -37,20 +38,24 @@
 #include <janus/config.h>
 #include <janus/plugins/plugin.h>
 
-#include "config.h"
-#include "tools.h"
-#include "threading.h"
-#include "list.h"
-#include "memsinksh.h"
+#include "uslibs/config.h"
+#include "uslibs/tools.h"
+#include "uslibs/threading.h"
+#include "uslibs/list.h"
+#include "uslibs/memsinksh.h"
 
-#include "rtp.h"
+#include "jlogging.h"
+#include "audio.h"
+#include "tc358743.h"
+#include "rtpv.h"
+#include "rtpa.h"
 
 
 static int _plugin_init(janus_callbacks *gw, const char *config_file_path);
 static void _plugin_destroy(void);
 
-static void _plugin_create_session(janus_plugin_session *session, int *error);
-static void _plugin_destroy_session(janus_plugin_session *session, int *error);
+static void _plugin_create_session(janus_plugin_session *session, int *err);
+static void _plugin_destroy_session(janus_plugin_session *session, int *err);
 static json_t *_plugin_query_session(janus_plugin_session *session);
 
 static void _plugin_setup_media(janus_plugin_session *session);
@@ -59,14 +64,17 @@ static void _plugin_hangup_media(janus_plugin_session *session);
 static struct janus_plugin_result *_plugin_handle_message(
 	janus_plugin_session *session, char *transaction, json_t *msg, json_t *jsep);
 
-static int _plugin_get_api_compatibility(void);
-static int _plugin_get_version(void);
-static const char *_plugin_get_version_string(void);
-static const char *_plugin_get_description(void);
-static const char *_plugin_get_name(void);
-static const char *_plugin_get_author(void);
-static const char *_plugin_get_package(void);
 
+static int _plugin_get_api_compatibility(void)		{ return JANUS_PLUGIN_API_VERSION; }
+static int _plugin_get_version(void)				{ return VERSION_U; }
+static const char *_plugin_get_version_string(void)	{ return VERSION; }
+static const char *_plugin_get_description(void)	{ return "PiKVM uStreamer Janus plugin for H.264 video"; }
+static const char *_plugin_get_name(void)			{ return "ustreamer"; }
+static const char *_plugin_get_author(void)			{ return "Maxim Devaev <mdevaev@gmail.com>"; }
+static const char *_plugin_get_package(void)		{ return "janus.plugin.ustreamer"; }
+
+// Just a stub to avoid logging spam about the plugin's purpose.
+static void _plugin_incoming_rtp(UNUSED janus_plugin_session *handle, UNUSED janus_plugin_rtp *packet) {}
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Woverride-init"
@@ -90,6 +98,8 @@ static janus_plugin _plugin = JANUS_PLUGIN_INIT(
 	.get_name = _plugin_get_name,
 	.get_author = _plugin_get_author,
 	.get_package = _plugin_get_package,
+
+	.incoming_rtp = _plugin_incoming_rtp,
 );
 #pragma GCC diagnostic pop
 
@@ -112,27 +122,25 @@ const long double		_g_lock_timeout = 1;
 const useconds_t		_g_lock_polling = 1000;
 const useconds_t		_g_watchers_polling = 100000;
 
+static char				*_g_audio_dev = NULL;
+static char				*_g_tc358743_dev = NULL;
+
 static _client_s		*_g_clients = NULL;
 static janus_callbacks	*_g_gw = NULL;
-static rtp_s			*_g_rtp = NULL;
+static rtpv_s			*_g_rtpv = NULL;
+static rtpa_s			*_g_rtpa = NULL;
+
+static pthread_t		_g_video_tid;
+static atomic_bool		_g_video_tid_created = false;
+static pthread_t		_g_audio_tid;
+static atomic_bool		_g_audio_tid_created = false;
 
-static pthread_t		_g_tid;
 static pthread_mutex_t	_g_lock = PTHREAD_MUTEX_INITIALIZER;
-static atomic_bool		_g_ready = ATOMIC_VAR_INIT(false);
-static atomic_bool		_g_stop = ATOMIC_VAR_INIT(false);
-static atomic_bool		_g_has_watchers = ATOMIC_VAR_INIT(false);
+static atomic_bool		_g_ready = false;
+static atomic_bool		_g_stop = false;
+static atomic_bool		_g_has_watchers = false;
 
 
-#define JLOG_INFO(_msg, ...)	JANUS_LOG(LOG_INFO, "== %s -- " _msg "\n", _plugin_get_name(), ##__VA_ARGS__)
-#define JLOG_WARN(_msg, ...)	JANUS_LOG(LOG_WARN, "== %s -- " _msg "\n", _plugin_get_name(), ##__VA_ARGS__)
-#define JLOG_ERROR(_msg, ...)	JANUS_LOG(LOG_ERR, "== %s -- " _msg "\n", _plugin_get_name(), ##__VA_ARGS__)
-
-#define JLOG_PERROR(_msg, ...) { \
-		char _perror_buf[1024] = {0}; \
-		char *_perror_ptr = errno_to_string(errno, _perror_buf, 1023); \
-		JANUS_LOG(LOG_ERR, "[%s] " _msg ": %s\n", _plugin_get_name(), ##__VA_ARGS__, _perror_ptr); \
-	}
-
 #define LOCK			A_MUTEX_LOCK(&_g_lock)
 #define UNLOCK			A_MUTEX_UNLOCK(&_g_lock)
 #define READY			atomic_load(&_g_ready)
@@ -140,35 +148,21 @@ static atomic_bool		_g_has_watchers = ATOMIC_VAR_INIT(false);
 #define HAS_WATCHERS	atomic_load(&_g_has_watchers)
 
 
-static void _relay_rtp_clients(const uint8_t *datagram, size_t size) {
-	janus_plugin_rtp packet = {
-		.video = true,
-		.buffer = (char *)datagram,
-		.length = size,
-	};
-	janus_plugin_rtp_extensions_reset(&packet.extensions);
-	LIST_ITERATE(_g_clients, client, {
-		if (client->transmit) {
-			_g_gw->relay_rtp(client->session, &packet);
-		}
-	});
-}
-
 static int _wait_frame(int fd, memsink_shared_s* mem, uint64_t last_id) {
 	long double deadline_ts = get_now_monotonic() + _g_wait_timeout;
 	long double now;
 	do {
-		int retval = flock_timedwait_monotonic(fd, _g_lock_timeout);
+		int result = flock_timedwait_monotonic(fd, _g_lock_timeout);
 		now = get_now_monotonic();
-		if (retval < 0 && errno != EWOULDBLOCK) {
-			JLOG_PERROR("Can't lock memsink");
+		if (result < 0 && errno != EWOULDBLOCK) {
+			JLOG_PERROR("video", "Can't lock memsink");
 			return -1;
-		} else if (retval == 0) {
+		} else if (result == 0) {
 			if (mem->magic == MEMSINK_MAGIC && mem->version == MEMSINK_VERSION && mem->id != last_id) {
 				return 0;
 			}
 			if (flock(fd, LOCK_UN) < 0) {
-				JLOG_PERROR("Can't unlock memsink");
+				JLOG_PERROR("video", "Can't unlock memsink");
 				return -1;
 			}
 		}
@@ -184,18 +178,32 @@ static int _get_frame(int fd, memsink_shared_s *mem, frame_s *frame, uint64_t *f
 	mem->last_client_ts = get_now_monotonic();
 	int retval = 0;
 	if (frame->format != V4L2_PIX_FMT_H264) {
-		JLOG_ERROR("Got non-H264 frame from memsink");
+		JLOG_ERROR("video", "Got non-H264 frame from memsink");
 		retval = -1;
 	}
 	if (flock(fd, LOCK_UN) < 0) {
-		JLOG_PERROR("Can't unlock memsink");
+		JLOG_PERROR("video", "Can't unlock memsink");
 		retval = -1;
 	}
 	return retval;
 }
 
-static void *_clients_thread(UNUSED void *arg) {
-	A_THREAD_RENAME("us_clients");
+static void _relay_rtp_clients(const rtp_s *rtp) {
+	janus_plugin_rtp packet = {0};
+	packet.video = rtp->video;
+	packet.buffer = (char *)rtp->datagram;
+	packet.length = rtp->used;
+	janus_plugin_rtp_extensions_reset(&packet.extensions);
+	LIST_ITERATE(_g_clients, client, {
+		if (client->transmit) {
+			_g_gw->relay_rtp(client->session, &packet);
+		}
+	});
+}
+
+static void *_clients_video_thread(UNUSED void *arg) {
+	A_THREAD_RENAME("us_v_clients");
+	atomic_store(&_g_video_tid_created, true);
 	atomic_store(&_g_ready, true);
 
 	frame_s *frame = frame_init();
@@ -209,9 +217,7 @@ static void *_clients_thread(UNUSED void *arg) {
 
 	while (!STOP) {
 		if (!HAS_WATCHERS) {
-			IF_NOT_REPORTED(1, {
-				JLOG_INFO("No active watchers, memsink disconnected");
-			});
+			IF_NOT_REPORTED(1, { JLOG_INFO("video", "No active watchers, memsink disconnected"); });
 			usleep(_g_watchers_polling);
 			continue;
 		}
@@ -220,22 +226,18 @@ static void *_clients_thread(UNUSED void *arg) {
 		memsink_shared_s *mem = NULL;
 
 		if ((fd = shm_open(_g_memsink_obj, O_RDWR, 0)) <= 0) {
-			IF_NOT_REPORTED(2, {
-				JLOG_PERROR("Can't open memsink");
-			});
+			IF_NOT_REPORTED(2, { JLOG_PERROR("video", "Can't open memsink"); });
 			goto close_memsink;
 		}
 
 		if ((mem = memsink_shared_map(fd)) == NULL) {
-			IF_NOT_REPORTED(3, {
-				JLOG_PERROR("Can't map memsink");
-			});
+			IF_NOT_REPORTED(3, { JLOG_PERROR("video", "Can't map memsink"); });
 			goto close_memsink;
 		}
 
 		error_reported = 0;
 
-		JLOG_INFO("Memsink opened; reading frames ...");
+		JLOG_INFO("video", "Memsink opened; reading frames ...");
 		while (!STOP && HAS_WATCHERS) {
 			int result = _wait_frame(fd, mem, frame_id);
 			if (result == 0) {
@@ -243,7 +245,7 @@ static void *_clients_thread(UNUSED void *arg) {
 					goto close_memsink;
 				}
 				LOCK;
-				rtp_wrap_h264(_g_rtp, frame, _relay_rtp_clients);
+				rtpv_wrap(_g_rtpv, frame);
 				UNLOCK;
 			} else if (result == -1) {
 				goto close_memsink;
@@ -252,7 +254,7 @@ static void *_clients_thread(UNUSED void *arg) {
 
 		close_memsink:
 			if (mem != NULL) {
-				JLOG_INFO("Memsink closed");
+				JLOG_INFO("video", "Memsink closed");
 				memsink_shared_unmap(mem);
 				mem = NULL;
 			}
@@ -269,27 +271,94 @@ static void *_clients_thread(UNUSED void *arg) {
 	return NULL;
 }
 
+static void *_clients_audio_thread(UNUSED void *arg) {
+	A_THREAD_RENAME("us_a_clients");
+	atomic_store(&_g_audio_tid_created, true);
+	assert(_g_audio_dev);
+	assert(_g_tc358743_dev);
+
+	while (!STOP) {
+		if (!HAS_WATCHERS) {
+			usleep(_g_watchers_polling);
+			continue;
+		}
+
+		tc358743_info_s info = {0};
+		audio_s *audio = NULL;
+
+		if (
+			tc358743_read_info(_g_tc358743_dev, &info) < 0
+			|| !info.has_audio
+			|| (audio = audio_init(_g_audio_dev, info.audio_hz)) == NULL
+		) {
+			goto close_audio;
+		}
+
+		while (!STOP && HAS_WATCHERS) {
+			if (
+				tc358743_read_info(_g_tc358743_dev, &info) < 0
+				|| !info.has_audio
+				|| audio->pcm_hz != info.audio_hz
+			) {
+				goto close_audio;
+			}
+
+			size_t size = RTP_DATAGRAM_SIZE - RTP_HEADER_SIZE;
+			uint8_t data[size];
+			uint64_t pts;
+			int result = audio_get_encoded(audio, data, &size, &pts);
+			if (result == 0) {
+				LOCK;
+				rtpa_wrap(_g_rtpa, data, size, pts);
+				UNLOCK;
+			} else if (result == -1) {
+				goto close_audio;
+			}
+		}
+
+		close_audio:
+			if (audio != NULL) {
+				audio_destroy(audio);
+			}
+			sleep(1); // error_delay
+	}
+	return NULL;
+}
+
+static char *_get_config_value(janus_config *config, const char *section, const char *option) {
+	janus_config_category *section_obj = janus_config_get_create(config, NULL, janus_config_type_category, section);
+	janus_config_item *option_obj = janus_config_get(config, section_obj, janus_config_type_item, option);
+	if (option_obj == NULL || option_obj->value == NULL || option_obj->value[0] == '\0') {
+		return NULL;
+	}
+	return strdup(option_obj->value);
+}
+
 static int _read_config(const char *config_dir_path) {
 	char *config_file_path;
 	janus_config *config = NULL;
 
 	A_ASPRINTF(config_file_path, "%s/%s.jcfg", config_dir_path, _plugin_get_package());
-	JLOG_INFO("Reading config file '%s' ...", config_file_path);
+	JLOG_INFO("main", "Reading config file '%s' ...", config_file_path);
 
 	config = janus_config_parse(config_file_path);
 	if (config == NULL) {
-		JLOG_ERROR("Can't read config");
+		JLOG_ERROR("main", "Can't read config");
 		goto error;
 	}
 	janus_config_print(config);
 
-	janus_config_category *config_memsink = janus_config_get_create(config, NULL, janus_config_type_category, "memsink");
-	janus_config_item *config_memsink_obj = janus_config_get(config, config_memsink, janus_config_type_item, "object");
-	if (config_memsink_obj == NULL || config_memsink_obj->value == NULL || config_memsink_obj->value[0] == '\0') {
-		JLOG_ERROR("Missing config value: memsink.object");
+	if ((_g_memsink_obj = _get_config_value(config, "memsink", "object")) == NULL) {
+		JLOG_ERROR("main", "Missing config value: memsink.object");
 		goto error;
 	}
-	_g_memsink_obj = strdup(config_memsink_obj->value);
+	if ((_g_audio_dev = _get_config_value(config, "audio", "device")) != NULL) {
+		JLOG_INFO("main", "Enabled the experimental AUDIO feature");
+		if ((_g_tc358743_dev = _get_config_value(config, "audio", "tc358743")) == NULL) {
+			JLOG_INFO("main", "Missing config value: audio.tc358743");
+			goto error;
+		}
+	}
 
 	int retval = 0;
 	goto ok;
@@ -310,23 +379,32 @@ static int _plugin_init(janus_callbacks *gw, const char *config_dir_path) {
 	// sysctl -w net.core.rmem_max=1000000 
 	// sysctl -w net.core.wmem_max=1000000
 
-	JLOG_INFO("Initializing plugin ...");
+	JLOG_INFO("main", "Initializing plugin ...");
+	assert(!atomic_load(&_g_video_tid_created));
+	assert(!atomic_load(&_g_audio_tid_created));
 	assert(!READY);
 	assert(!STOP);
 	if (gw == NULL || config_dir_path == NULL || _read_config(config_dir_path) < 0) {
 		return -1;
 	}
 	_g_gw = gw;
-	_g_rtp = rtp_init();
-	A_THREAD_CREATE(&_g_tid, _clients_thread, NULL);
+	_g_rtpv = rtpv_init(_relay_rtp_clients);
+	if (_g_audio_dev) {
+		_g_rtpa = rtpa_init(_relay_rtp_clients);
+		A_THREAD_CREATE(&_g_audio_tid, _clients_audio_thread, NULL);
+	}
+	A_THREAD_CREATE(&_g_video_tid, _clients_video_thread, NULL);
 	return 0;
 }
 
 static void _plugin_destroy(void) {
-	JLOG_INFO("Destroying plugin ...");
+	JLOG_INFO("main", "Destroying plugin ...");
 	atomic_store(&_g_stop, true);
-	if (READY) {
-		A_THREAD_JOIN(_g_tid);
+	if (atomic_load(&_g_video_tid_created)) {
+		A_THREAD_JOIN(_g_video_tid);
+	}
+	if (atomic_load(&_g_audio_tid_created)) {
+		A_THREAD_JOIN(_g_audio_tid);
 	}
 
 	LIST_ITERATE(_g_clients, client, {
@@ -335,23 +413,22 @@ static void _plugin_destroy(void) {
 	});
 	_g_clients = NULL;
 
-	rtp_destroy(_g_rtp);
-	_g_rtp = NULL;
-
+#	define DEL(_func, _var) { if (_var) { _func(_var); _var = NULL; } }
+	DEL(rtpa_destroy, _g_rtpa);
+	DEL(rtpv_destroy, _g_rtpv);
 	_g_gw = NULL;
-
-	if (_g_memsink_obj) {
-		free(_g_memsink_obj);
-		_g_memsink_obj = NULL;
-	}
+	DEL(free, _g_tc358743_dev);
+	DEL(free, _g_audio_dev);
+	DEL(free, _g_memsink_obj);
+#	undef DEL
 }
 
 #define IF_DISABLED(...) { if (!READY || STOP) { __VA_ARGS__ } }
 
-static void _plugin_create_session(janus_plugin_session *session, int *error) {
-	IF_DISABLED({ *error = -1; return; });
+static void _plugin_create_session(janus_plugin_session *session, int *err) {
+	IF_DISABLED({ *err = -1; return; });
 	LOCK;
-	JLOG_INFO("Creating session %p ...", session);
+	JLOG_INFO("main", "Creating session %p ...", session);
 	_client_s *client;
 	A_CALLOC(client, 1);
 	client->session = session;
@@ -361,14 +438,14 @@ static void _plugin_create_session(janus_plugin_session *session, int *error) {
 	UNLOCK;
 }
 
-static void _plugin_destroy_session(janus_plugin_session* session, int *error) {
-	IF_DISABLED({ *error = -1; return; });
+static void _plugin_destroy_session(janus_plugin_session* session, int *err) {
+	IF_DISABLED({ *err = -1; return; });
 	LOCK;
 	bool found = false;
 	bool has_watchers = false;
 	LIST_ITERATE(_g_clients, client, {
 		if (client->session == session) {
-			JLOG_INFO("Removing session %p ...", session);
+			JLOG_INFO("main", "Removing session %p ...", session);
 			LIST_REMOVE(_g_clients, client);
 			free(client);
 			found = true;
@@ -377,8 +454,8 @@ static void _plugin_destroy_session(janus_plugin_session* session, int *error) {
 		}
 	});
 	if (!found) {
-		JLOG_WARN("No session %p", session);
-		*error = -2;
+		JLOG_WARN("main", "No session %p", session);
+		*err = -2;
 	}
 	atomic_store(&_g_has_watchers, has_watchers);
 	UNLOCK;
@@ -406,13 +483,13 @@ static void _set_transmit(janus_plugin_session *session, UNUSED const char *msg,
 	LIST_ITERATE(_g_clients, client, {
 		if (client->session == session) {
 			client->transmit = transmit;
-			//JLOG_INFO("%s session %p", msg, session);
+			// JLOG_INFO("main", "%s session %p", msg, session);
 			found = true;
 		}
 		has_watchers = (has_watchers || client->transmit);
 	});
 	if (!found) {
-		JLOG_WARN("No session %p", session);
+		JLOG_WARN("main", "No session %p", session);
 	}
 	atomic_store(&_g_has_watchers, has_watchers);
 	UNLOCK;
@@ -440,7 +517,7 @@ static struct janus_plugin_result *_plugin_handle_message(
 	}
 
 #	define PUSH_ERROR(_error, _reason) { \
-			/*JLOG_ERROR("Message error in session %p: %s", session, _reason);*/ \
+			/*JLOG_ERROR("main", "Message error in session %p: %s", session, _reason);*/ \
 			json_t *_event = json_object(); \
 			json_object_set_new(_event, "ustreamer", json_string("event")); \
 			json_object_set_new(_event, "error_code", json_integer(_error)); \
@@ -460,7 +537,7 @@ static struct janus_plugin_result *_plugin_handle_message(
 		PUSH_ERROR(400, "Request not a string");
 		goto ok_wait;
 	}
-	//JLOG_INFO("Message: %s", request_str);
+	// JLOG_INFO("main", "Message: %s", request_str);
 
 #	define PUSH_STATUS(_status, _jsep) { \
 			json_t *_event = json_object(); \
@@ -479,12 +556,25 @@ static struct janus_plugin_result *_plugin_handle_message(
 		PUSH_STATUS("stopped", NULL);
 
 	} else if (!strcmp(request_str, "watch")) {
-		char *sdp = rtp_make_sdp(_g_rtp);
-		if (sdp == NULL) {
-			PUSH_ERROR(503, "Haven't received SPS/PPS from memsink yet");
-			goto ok_wait;
+		char *sdp;
+		{
+			char *video_sdp = rtpv_make_sdp(_g_rtpv);
+			if (video_sdp == NULL) {
+				PUSH_ERROR(503, "Haven't received SPS/PPS from memsink yet");
+				goto ok_wait;
+			}
+			char *audio_sdp = (_g_rtpa ? rtpa_make_sdp(_g_rtpa) : strdup(""));
+			A_ASPRINTF(sdp,
+				"v=0" RN
+				"o=- %" PRIu64 " 1 IN IP4 0.0.0.0" RN
+				"s=PiKVM uStreamer" RN
+				"t=0 0" RN
+				"%s%s",
+				get_now_id() >> 1, audio_sdp, video_sdp
+			);
+			free(audio_sdp);
+			free(video_sdp);
 		}
-		//JLOG_INFO("SDP generated:\n%s", sdp);
 		json_t *offer_jsep = json_pack("{ssss}", "type", "offer", "sdp", sdp);
 		free(sdp);
 		PUSH_STATUS("started", offer_jsep);
@@ -501,22 +591,3 @@ static struct janus_plugin_result *_plugin_handle_message(
 #	undef PUSH_ERROR
 #	undef FREE_MSG_JSEP
 }
-
-static int _plugin_get_api_compatibility(void)		{ return JANUS_PLUGIN_API_VERSION; }
-static int _plugin_get_version(void)				{ return VERSION_U; }
-static const char *_plugin_get_version_string(void)	{ return VERSION; }
-static const char *_plugin_get_description(void)	{ return "Pi-KVM uStreamer Janus plugin for H.264 video"; }
-static const char *_plugin_get_name(void)			{ return "ustreamer"; }
-static const char *_plugin_get_author(void)			{ return "Maxim Devaev <mdevaev@gmail.com>"; }
-static const char *_plugin_get_package(void)		{ return "janus.plugin.ustreamer"; }
-
-
-#undef STOP
-#undef READY
-#undef UNLOCK
-#undef LOCK
-
-#undef JLOG_PERROR
-#undef JLOG_ERROR
-#undef JLOG_WARN
-#undef JLOG_INFO

janus/src/queue.c

@@ -0,0 +1,92 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2022  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "queue.h"
+
+
+queue_s *queue_init(unsigned capacity) {
+	queue_s *queue;
+	A_CALLOC(queue, 1);
+	A_CALLOC(queue->items, capacity);
+	queue->capacity = capacity;
+	A_MUTEX_INIT(&queue->mutex);
+
+	pthread_condattr_t attrs;
+	assert(!pthread_condattr_init(&attrs));
+	assert(!pthread_condattr_setclock(&attrs, CLOCK_MONOTONIC));
+	assert(!pthread_cond_init(&queue->full_cond, &attrs));
+	assert(!pthread_cond_init(&queue->empty_cond, &attrs));
+	assert(!pthread_condattr_destroy(&attrs));
+	return queue;
+}
+
+void queue_destroy(queue_s *queue) {
+	free(queue->items);
+	free(queue);
+}
+
+#define WAIT_OR_UNLOCK(_var, _cond) { \
+		struct timespec ts; \
+		assert(!clock_gettime(CLOCK_MONOTONIC, &ts)); \
+		ts.tv_sec += timeout; \
+		while (_var) { \
+			int err = pthread_cond_timedwait(_cond, &queue->mutex, &ts); \
+			if (err == ETIMEDOUT) { \
+				A_MUTEX_UNLOCK(&queue->mutex); \
+				return -1; \
+			} \
+			assert(!err); \
+		} \
+	}
+
+int queue_put(queue_s *queue, void *item, unsigned timeout) {
+	A_MUTEX_LOCK(&queue->mutex);
+	WAIT_OR_UNLOCK(queue->size == queue->capacity, &queue->full_cond);
+	queue->items[queue->in] = item;
+	++queue->size;
+	++queue->in;
+	queue->in %= queue->capacity;
+	A_MUTEX_UNLOCK(&queue->mutex);
+	assert(!pthread_cond_broadcast(&queue->empty_cond));
+	return 0;
+}
+
+int queue_get(queue_s *queue, void **item, unsigned timeout) {
+	A_MUTEX_LOCK(&queue->mutex);
+	WAIT_OR_UNLOCK(queue->size == 0, &queue->empty_cond);
+	*item = queue->items[queue->out];
+	--queue->size;
+	++queue->out;
+	queue->out %= queue->capacity;
+	A_MUTEX_UNLOCK(&queue->mutex);
+	assert(!pthread_cond_broadcast(&queue->full_cond));
+	return 0;
+}
+
+#undef WAIT_OR_UNLOCK
+
+int queue_get_free(queue_s *queue) {
+	A_MUTEX_LOCK(&queue->mutex);
+	unsigned size = queue->size;
+	A_MUTEX_UNLOCK(&queue->mutex);
+	return queue->capacity - size;
+}

janus/src/queue.h

@@ -0,0 +1,54 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2022  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#pragma once
+
+#include <errno.h>
+#include <time.h>
+
+#include <pthread.h>
+
+#include "uslibs/tools.h"
+#include "uslibs/threading.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;
+
+	pthread_mutex_t	mutex;
+	pthread_cond_t	full_cond;
+	pthread_cond_t	empty_cond;
+} queue_s;
+
+
+queue_s *queue_init(unsigned capacity);
+void queue_destroy(queue_s *queue);
+
+int queue_put(queue_s *queue, void *item, unsigned timeout);
+int queue_get(queue_s *queue, void **item, unsigned timeout);
+int queue_get_free(queue_s *queue);

janus/src/rtp.c

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

janus/src/rtp.h

@@ -2,9 +2,6 @@
 #                                                                            #
 #    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
 #                                                                            #
-#    This source file is partially based on this code:                       #
-#      - https://github.com/catid/kvm/blob/master/kvm_pipeline/src           #
-#                                                                            #
 #    Copyright (C) 2018-2022  Maxim Devaev <mdevaev@gmail.com>               #
 #                                                                            #
 #    This program is free software: you can redistribute it and/or modify    #
@@ -26,44 +23,33 @@
 #pragma once
 
 #include <stdlib.h>
-#include <stdbool.h>
 #include <stdint.h>
-#include <inttypes.h>
-#include <string.h>
-#include <assert.h>
+#include <stdbool.h>
 
 #include <sys/types.h>
-#include <linux/videodev2.h>
 
-#include <pthread.h>
-
-#include "tools.h"
-#include "threading.h"
-#include "frame.h"
-#include "base64.h"
+#include "uslibs/tools.h"
 
 
 // https://stackoverflow.com/questions/47635545/why-webrtc-chose-rtp-max-packet-size-to-1200-bytes
-#define RTP_DATAGRAM_SIZE 1200
+#define RTP_DATAGRAM_SIZE	1200
+#define RTP_HEADER_SIZE		12
 
 
 typedef struct {
-	uint32_t ssrc;
-	uint16_t seq;
+	unsigned	payload;
+	bool		video;
+	uint32_t	ssrc;
 
-	uint8_t datagram[RTP_DATAGRAM_SIZE];
-
-	frame_s *sps; // Actually not a frame, just a bytes storage
-	frame_s *pps;
-
-	pthread_mutex_t mutex;
+	uint16_t	seq;
+	uint8_t		datagram[RTP_DATAGRAM_SIZE];
+	size_t		used;
 } rtp_s;
 
-typedef void (*rtp_callback_f)(const uint8_t *datagram, size_t size);
+typedef void (*rtp_callback_f)(const rtp_s *rtp);
 
 
-rtp_s *rtp_init(void);
+rtp_s *rtp_init(unsigned payload, bool video);
 void rtp_destroy(rtp_s *rtp);
 
-char *rtp_make_sdp(rtp_s *rtp);
-void rtp_wrap_h264(rtp_s *rtp, const frame_s *frame, rtp_callback_f callback);
+void rtp_write_header(rtp_s *rtp, uint32_t pts, bool marked);

janus/src/rtpa.c

@@ -0,0 +1,66 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2022  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "rtpa.h"
+
+
+rtpa_s *rtpa_init(rtp_callback_f callback) {
+	rtpa_s *rtpa;
+	A_CALLOC(rtpa, 1);
+	rtpa->rtp = rtp_init(111, false);
+	rtpa->callback = callback;
+	return rtpa;
+}
+
+void rtpa_destroy(rtpa_s *rtpa) {
+	rtp_destroy(rtpa->rtp);
+	free(rtpa);
+}
+
+char *rtpa_make_sdp(rtpa_s *rtpa) {
+#	define PAYLOAD rtpa->rtp->payload
+	char *sdp;
+	A_ASPRINTF(sdp,
+		"m=audio 1 RTP/SAVPF %u" RN
+		"c=IN IP4 0.0.0.0" RN
+		"a=rtpmap:%u OPUS/48000/2" RN
+		// "a=fmtp:%u useinbandfec=1" RN
+		"a=rtcp-fb:%u nack" RN
+		"a=rtcp-fb:%u nack pli" RN
+		"a=rtcp-fb:%u goog-remb" RN
+		"a=ssrc:%" PRIu32 " cname:ustreamer" RN
+		"a=sendonly" RN,
+		PAYLOAD, PAYLOAD, PAYLOAD, PAYLOAD, PAYLOAD, // PAYLOAD,
+		rtpa->rtp->ssrc
+	);
+#	undef PAYLOAD
+	return sdp;
+}
+
+void rtpa_wrap(rtpa_s *rtpa, const uint8_t *data, size_t size, uint32_t pts) {
+    if (size + RTP_HEADER_SIZE <= RTP_DATAGRAM_SIZE) {
+        rtp_write_header(rtpa->rtp, pts, false);
+        memcpy(rtpa->rtp->datagram + RTP_HEADER_SIZE, data, size);
+		rtpa->rtp->used = size + RTP_HEADER_SIZE;
+        rtpa->callback(rtpa->rtp);
+	}
+}

janus/src/rtpa.h

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

janus/src/rtpv.c

@@ -0,0 +1,211 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    This source file is partially based on this code:                       #
+#      - https://github.com/catid/kvm/blob/master/kvm_pipeline/src           #
+#                                                                            #
+#    Copyright (C) 2018-2022  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "rtpv.h"
+
+
+void _rtpv_process_nalu(rtpv_s *rtpv, const uint8_t *data, size_t size, uint32_t pts, bool marked);
+
+static ssize_t _find_annexb(const uint8_t *data, size_t size);
+
+
+rtpv_s *rtpv_init(rtp_callback_f callback) {
+	rtpv_s *rtpv;
+	A_CALLOC(rtpv, 1);
+	rtpv->rtp = rtp_init(96, true);
+	rtpv->callback = callback;
+	rtpv->sps = frame_init();
+	rtpv->pps = frame_init();
+	A_MUTEX_INIT(&rtpv->mutex);
+	return rtpv;
+}
+
+void rtpv_destroy(rtpv_s *rtpv) {
+	A_MUTEX_DESTROY(&rtpv->mutex);
+	frame_destroy(rtpv->pps);
+	frame_destroy(rtpv->sps);
+	rtp_destroy(rtpv->rtp);
+	free(rtpv);
+}
+
+char *rtpv_make_sdp(rtpv_s *rtpv) {
+	A_MUTEX_LOCK(&rtpv->mutex);
+
+	if (rtpv->sps->used == 0 || rtpv->pps->used == 0) {
+		A_MUTEX_UNLOCK(&rtpv->mutex);
+		return NULL;
+	}
+
+	char *sps = NULL;
+	char *pps = NULL;
+	base64_encode(rtpv->sps->data, rtpv->sps->used, &sps, NULL);
+	base64_encode(rtpv->pps->data, rtpv->pps->used, &pps, NULL);
+
+	A_MUTEX_UNLOCK(&rtpv->mutex);
+
+#	define PAYLOAD rtpv->rtp->payload
+	// https://tools.ietf.org/html/rfc6184
+	// https://github.com/meetecho/janus-gateway/issues/2443
+	char *sdp;
+	A_ASPRINTF(sdp,
+		"m=video 1 RTP/SAVPF %u" RN
+		"c=IN IP4 0.0.0.0" RN
+		"a=rtpmap:%u H264/90000" RN
+		"a=fmtp:%u profile-level-id=42E01F" RN
+		"a=fmtp:%u packetization-mode=1" RN
+		"a=fmtp:%u sprop-sps=%s" RN
+		"a=fmtp:%u sprop-pps=%s" RN
+		"a=rtcp-fb:%u nack" RN
+		"a=rtcp-fb:%u nack pli" RN
+		"a=rtcp-fb:%u goog-remb" RN
+		"a=ssrc:%" PRIu32 " cname:ustreamer" RN
+		"a=sendonly" RN,
+		PAYLOAD, PAYLOAD, PAYLOAD, PAYLOAD,
+		PAYLOAD, sps,
+		PAYLOAD, pps,
+		PAYLOAD, PAYLOAD, PAYLOAD,
+		rtpv->rtp->ssrc
+	);
+#	undef PAYLOAD
+
+	free(sps);
+	free(pps);
+	return sdp;
+}
+
+#define PRE 3 // Annex B prefix length
+
+void rtpv_wrap(rtpv_s *rtpv, const frame_s *frame) {
+	// There is a complicated logic here but everything works as it should:
+	//   - https://github.com/pikvm/ustreamer/issues/115#issuecomment-893071775
+
+	assert(frame->format == V4L2_PIX_FMT_H264);
+
+	const uint32_t pts = get_now_monotonic_u64() * 9 / 100; // PTS units are in 90 kHz
+	ssize_t last_offset = -PRE;
+
+	while (true) { // Find and iterate by nalus
+		const size_t next_start = last_offset + PRE;
+		ssize_t offset = _find_annexb(frame->data + next_start, frame->used - next_start);
+		if (offset < 0) {
+			break;
+		}
+		offset += next_start;
+
+		if (last_offset >= 0) {
+			const uint8_t *data = frame->data + last_offset + PRE;
+			size_t size = offset - last_offset - PRE;
+			if (data[size - 1] == 0) { // Check for extra 00
+				--size;
+			}
+			_rtpv_process_nalu(rtpv, data, size, pts, false);
+		}
+
+		last_offset = offset;
+	}
+
+	if (last_offset >= 0) {
+		const uint8_t *data = frame->data + last_offset + PRE;
+		size_t size = frame->used - last_offset - PRE;
+		_rtpv_process_nalu(rtpv, data, size, pts, true);
+	}
+}
+
+void _rtpv_process_nalu(rtpv_s *rtpv, const uint8_t *data, size_t size, uint32_t pts, bool marked) {
+	const unsigned ref_idc = (data[0] >> 5) & 3;
+	const unsigned type = data[0] & 0x1F;
+
+	frame_s *ps = NULL;
+	switch (type) {
+		case 7: ps = rtpv->sps; break;
+		case 8: ps = rtpv->pps; break;
+	}
+	if (ps) {
+		A_MUTEX_LOCK(&rtpv->mutex);
+		frame_set_data(ps, data, size);
+		A_MUTEX_UNLOCK(&rtpv->mutex);
+	}
+
+#	define DG rtpv->rtp->datagram
+
+	if (size + RTP_HEADER_SIZE <= RTP_DATAGRAM_SIZE) {
+		rtp_write_header(rtpv->rtp, pts, marked);
+		memcpy(DG + RTP_HEADER_SIZE, data, size);
+		rtpv->rtp->used = size + RTP_HEADER_SIZE;
+		rtpv->callback(rtpv->rtp);
+		return;
+	}
+
+	const size_t fu_overhead = RTP_HEADER_SIZE + 2; // FU-A overhead
+
+	const uint8_t *src = data + 1;
+	ssize_t remaining = size - 1;
+
+	bool first = true;
+	while (remaining > 0) {
+		ssize_t frag_size = RTP_DATAGRAM_SIZE - fu_overhead;
+		const bool last = (remaining <= frag_size);
+		if (last) {
+			frag_size = remaining;
+		}
+
+		rtp_write_header(rtpv->rtp, pts, (marked && last));
+
+		DG[RTP_HEADER_SIZE] = 28 | (ref_idc << 5);
+
+		uint8_t fu = type;
+		if (first) {
+			fu |= 0x80;
+		}
+		if (last) {
+			fu |= 0x40;
+		}
+		DG[RTP_HEADER_SIZE + 1] = fu;
+
+		memcpy(DG + fu_overhead, src, frag_size);
+		rtpv->rtp->used = fu_overhead + frag_size;
+		rtpv->callback(rtpv->rtp);
+
+		src += frag_size;
+		remaining -= frag_size;
+		first = false;
+	}
+
+#	undef DG
+}
+
+static ssize_t _find_annexb(const uint8_t *data, size_t size) {
+	// Parses buffer for 00 00 01 start codes
+	if (size >= PRE) {
+		for (size_t index = 0; index <= size - PRE; ++index) {
+			if (data[index] == 0 && data[index + 1] == 0 && data[index + 2] == 1) {
+				return index;
+			}
+		}
+	}
+	return -1;
+}
+
+#undef PRE

janus/src/rtpv.h

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

janus/src/tc358743.c

@@ -0,0 +1,64 @@
+/*****************************************************************************
+#                                                                            #
+#    uStreamer - Lightweight and fast MJPEG-HTTP streamer.                   #
+#                                                                            #
+#    Copyright (C) 2018-2022  Maxim Devaev <mdevaev@gmail.com>               #
+#                                                                            #
+#    This program is free software: you can redistribute it and/or modify    #
+#    it under the terms of the GNU General Public License as published by    #
+#    the Free Software Foundation, either version 3 of the License, or       #
+#    (at your option) any later version.                                     #
+#                                                                            #
+#    This program is distributed in the hope that it will be useful,         #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of          #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           #
+#    GNU General Public License for more details.                            #
+#                                                                            #
+#    You should have received a copy of the GNU General Public License       #
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.  #
+#                                                                            #
+*****************************************************************************/
+
+
+#include "tc358743.h"
+
+
+#ifndef V4L2_CID_USER_TC358743_BASE
+#	define V4L2_CID_USER_TC358743_BASE (V4L2_CID_USER_BASE + 0x1080)
+#endif
+#ifndef TC358743_CID_AUDIO_PRESENT
+#	define TC358743_CID_AUDIO_PRESENT (V4L2_CID_USER_TC358743_BASE + 1)
+#endif
+#ifndef TC358743_CID_AUDIO_SAMPLING_RATE
+#	define TC358743_CID_AUDIO_SAMPLING_RATE (V4L2_CID_USER_TC358743_BASE + 0)
+#endif
+
+
+int tc358743_read_info(const char *path, tc358743_info_s *info) {
+	MEMSET_ZERO(*info);
+
+	int fd = -1;
+	if ((fd = open(path, O_RDWR)) < 0) {
+		JLOG_PERROR("audio", "Can't open TC358743 V4L2 device");
+		return -1;
+	}
+
+#	define READ_CID(_cid, _field) { \
+			struct v4l2_control ctl = {0}; \
+			ctl.id = _cid; \
+			if (xioctl(fd, VIDIOC_G_CTRL, &ctl) < 0) { \
+				JLOG_PERROR("audio", "Can't get value of " #_cid); \
+				close(fd); \
+				return -1; \
+			} \
+			info->_field = ctl.value; \
+		}
+
+	READ_CID(TC358743_CID_AUDIO_PRESENT,		has_audio);
+	READ_CID(TC358743_CID_AUDIO_SAMPLING_RATE,	audio_hz);
+
+#	undef READ_CID
+
+	close(fd);
+	return 0;
+}

janus/src/tc358743.h

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

janus/src/threading.h

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

janus/src/tools.h

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

janus/src/uslibs/base64.c

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

janus/src/uslibs/base64.h

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

janus/src/uslibs/config.h

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

janus/src/uslibs/frame.c

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

janus/src/uslibs/frame.h

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

janus/src/uslibs/list.h

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

janus/src/uslibs/memsinksh.h

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

janus/src/uslibs/threading.h

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

janus/src/uslibs/tools.h

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

janus/src/uslibs/xioctl.h

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

linters/cppcheck.h

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

linters/pylint.ini

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

linters/tox.ini

@@ -9,8 +9,9 @@ changedir = /src
 [testenv:cppcheck]
 whitelist_externals = cppcheck
 commands = cppcheck \
+			-j4 \
 			--force \
-			--std=c11 \
+			--std=c17 \
 			--error-exitcode=1 \
 			--quiet \
 			--enable=warning,unusedFunction,portability,performance,style \
@@ -19,7 +20,7 @@ commands = cppcheck \
 			--inline-suppr \
 			--library=python \
 			--include=linters/cppcheck.h \
-		src python/ustreamer.c janus/rtp.h janus/rtp.c janus/plugin.c
+		src python/*.? janus/*.?
 
 [testenv:flake8]
 whitelist_externals = bash

man/ustreamer-dump.1

@@ -1,6 +1,6 @@
 .\" Manpage for ustreamer-dump.
 .\" Open an issue or pull request to https://github.com/pikvm/ustreamer to correct errors or typos
-.TH USTREAMER-DUMP 1 "version 5.3" "January 2021"
+.TH USTREAMER-DUMP 1 "version 5.7" "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.3" "November 2020"
+.TH USTREAMER 1 "version 5.7" "November 2020"
 
 .SH NAME
 ustreamer \- stream MJPEG video from any V4L2 device to the network

pkg/arch/PKGBUILD

@@ -3,7 +3,7 @@
 
 
 pkgname=ustreamer
-pkgver=5.3
+pkgver=5.7
 pkgrel=1
 pkgdesc="Lightweight and fast MJPEG-HTTP streamer"
 url="https://github.com/pikvm/ustreamer"
@@ -22,8 +22,8 @@ if [ -e /usr/bin/python3 ]; then
 	makedepends+=(python-setuptools)
 fi
 if [ -e /usr/include/janus/plugins/plugin.h ];then
-	depends+=(janus-gateway-pikvm)
-	makedepends+=(janus-gateway-pikvm)
+	depends+=(janus-gateway-pikvm alsa-lib opus)
+	makedepends+=(janus-gateway-pikvm alsa-lib opus)
 	_options="$_options WITH_JANUS=1"
 fi
 

pkg/openwrt/Makefile

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

python/setup.py

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

python/src/frame.c

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

python/src/frame.h

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

python/src/memsinksh.h

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

python/src/tools.h

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

python/src/uslibs/frame.c

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

python/src/uslibs/frame.h

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

python/src/uslibs/memsinksh.h

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

python/src/uslibs/tools.h

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

python/src/ustreamer.c

@@ -13,9 +13,9 @@
 
 #include <Python.h>
 
-#include "tools.h"
-#include "frame.h"
-#include "memsinksh.h"
+#include "uslibs/tools.h"
+#include "uslibs/frame.h"
+#include "uslibs/memsinksh.h"
 
 
 typedef struct {

src/Makefile

@@ -10,7 +10,7 @@ LDFLAGS ?=
 _USTR = ustreamer.bin
 _DUMP = ustreamer-dump.bin
 
-_CFLAGS = -MD -c -std=c11 -Wall -Wextra -D_GNU_SOURCE $(CFLAGS)
+_CFLAGS = -MD -c -std=c17 -Wall -Wextra -D_GNU_SOURCE $(CFLAGS)
 _LDFLAGS = $(LDFLAGS)
 
 _COMMON_LIBS = -lm -ljpeg -pthread -lrt

src/libs/config.h

@@ -23,7 +23,7 @@
 #pragma once
 
 #define VERSION_MAJOR 5
-#define VERSION_MINOR 3
+#define VERSION_MINOR 7
 
 #define MAKE_VERSION2(_major, _minor) #_major "." #_minor
 #define MAKE_VERSION1(_major, _minor) MAKE_VERSION2(_major, _minor)

src/libs/threading.h

@@ -67,7 +67,7 @@
 #define A_COND_INIT(_cond)		assert(!pthread_cond_init(_cond, NULL))
 #define A_COND_DESTROY(_cond)	assert(!pthread_cond_destroy(_cond))
 #define A_COND_SIGNAL(...)		assert(!pthread_cond_signal(__VA_ARGS__))
-#define A_COND_WAIT_TRUE(_var, _cond, _mutex) { while(!_var) assert(!pthread_cond_wait(_cond, _mutex)); }
+#define A_COND_WAIT_TRUE(_var, _cond, _mutex) { while(!(_var)) assert(!pthread_cond_wait(_cond, _mutex)); }
 
 
 #ifdef WITH_PTHREAD_NP

src/libs/tools.h

@@ -35,6 +35,7 @@
 #include <time.h>
 #include <assert.h>
 
+#include <sys/types.h>
 #include <sys/file.h>
 
 
@@ -126,13 +127,13 @@ INLINE uint64_t get_now_monotonic_u64(void) {
 	return (uint64_t)(ts.tv_nsec / 1000) + (uint64_t)ts.tv_sec * 1000000;
 }
 
+#undef X_CLOCK_MONOTONIC
+
 INLINE uint64_t get_now_id(void) {
 	uint64_t now = get_now_monotonic_u64();
 	return (uint64_t)triple_u32(now) | ((uint64_t)triple_u32(now + 12345) << 32);
 }
 
-#undef X_CLOCK_MONOTONIC
-
 INLINE long double get_now_real(void) {
 	time_t sec;
 	long msec;

src/libs/xioctl.h

@@ -26,8 +26,7 @@
 
 #include <sys/ioctl.h>
 
-#include "../libs/tools.h"
-#include "../libs/logging.h"
+#include "tools.h"
 
 
 #ifndef CFG_XIOCTL_RETRIES
@@ -51,10 +50,5 @@ INLINE int xioctl(int fd, int request, void *arg) {
 			|| errno == ETIMEDOUT
 		)
 	);
-
-	// cppcheck-suppress knownConditionTrueFalse
-	if (retval && retries <= 0) {
-		LOG_PERROR("ioctl(%d) retried %u times; giving up", request, XIOCTL_RETRIES);
-	}
 	return retval;
 }

src/ustreamer/device.c

@@ -80,7 +80,8 @@ static const char *_standard_to_string(v4l2_std_id standard);
 static const char *_io_method_to_string_supported(enum v4l2_memory io_method);
 
 
-#define RUN(_next) dev->run->_next
+#define RUN(_next)		dev->run->_next
+#define D_XIOCTL(...)	xioctl(RUN(fd), __VA_ARGS__)
 
 
 device_s *device_init(void) {
@@ -222,7 +223,7 @@ int device_export_to_dma(device_s *dev) {
 		exp.index = index;
 
 		LOG_DEBUG("Exporting device buffer=%u to DMA ...", index);
-		if (xioctl(RUN(fd), VIDIOC_EXPBUF, &exp) < 0) {
+		if (D_XIOCTL(VIDIOC_EXPBUF, &exp) < 0) {
 			LOG_PERROR("Can't export device buffer=%u to DMA", index);
 			goto error;
 		}
@@ -248,7 +249,7 @@ int device_switch_capturing(device_s *dev, bool enable) {
 		enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
 		LOG_DEBUG("%s device capturing ...", (enable ? "Starting" : "Stopping"));
-		if (xioctl(RUN(fd), (enable ? VIDIOC_STREAMON : VIDIOC_STREAMOFF), &type) < 0) {
+		if (D_XIOCTL((enable ? VIDIOC_STREAMON : VIDIOC_STREAMOFF), &type) < 0) {
 			LOG_PERROR("Can't %s capturing", (enable ? "start" : "stop"));
 			if (enable) {
 				return -1;
@@ -315,7 +316,7 @@ int device_grab_buffer(device_s *dev, hw_buffer_s **hw) {
 	buf.memory = dev->io_method;
 
 	LOG_DEBUG("Grabbing device buffer ...");
-	if (xioctl(RUN(fd), VIDIOC_DQBUF, &buf) < 0) {
+	if (D_XIOCTL(VIDIOC_DQBUF, &buf) < 0) {
 		LOG_PERROR("Can't grab device buffer");
 		return -1;
 	}
@@ -336,7 +337,7 @@ int device_grab_buffer(device_s *dev, hw_buffer_s **hw) {
 		LOG_DEBUG("Dropped too small frame, assuming it was broken: buffer=%u, bytesused=%u",
 			buf.index, buf.bytesused);
 		LOG_DEBUG("Releasing device buffer=%u (broken frame) ...", buf.index);
-		if (xioctl(RUN(fd), VIDIOC_QBUF, &buf) < 0) {
+		if (D_XIOCTL(VIDIOC_QBUF, &buf) < 0) {
 			LOG_PERROR("Can't release device buffer=%u (broken frame)", buf.index);
 			return -1;
 		}
@@ -370,7 +371,7 @@ int device_release_buffer(device_s *dev, hw_buffer_s *hw) {
 	const unsigned index = hw->buf.index;
 	LOG_DEBUG("Releasing device buffer=%u ...", index);
 
-	if (xioctl(RUN(fd), VIDIOC_QBUF, &hw->buf) < 0) {
+	if (D_XIOCTL(VIDIOC_QBUF, &hw->buf) < 0) {
 		LOG_PERROR("Can't release device buffer=%u", index);
 		return -1;
 	}
@@ -382,7 +383,7 @@ int device_consume_event(device_s *dev) {
 	struct v4l2_event event;
 
 	LOG_DEBUG("Consuming V4L2 event ...");
-	if (xioctl(RUN(fd), VIDIOC_DQEVENT, &event) == 0) {
+	if (D_XIOCTL(VIDIOC_DQEVENT, &event) == 0) {
 		switch (event.type) {
 			case V4L2_EVENT_SOURCE_CHANGE:
 				LOG_INFO("Got V4L2_EVENT_SOURCE_CHANGE: source changed");
@@ -401,7 +402,7 @@ static int _device_open_check_cap(device_s *dev) {
 	struct v4l2_capability cap = {0};
 
 	LOG_DEBUG("Querying device capabilities ...");
-	if (xioctl(RUN(fd), VIDIOC_QUERYCAP, &cap) < 0) {
+	if (D_XIOCTL(VIDIOC_QUERYCAP, &cap) < 0) {
 		LOG_PERROR("Can't query device capabilities");
 		return -1;
 	}
@@ -418,14 +419,14 @@ static int _device_open_check_cap(device_s *dev) {
 
 	int input = dev->input; // Needs a pointer to int for ioctl()
 	LOG_INFO("Using input channel: %d", input);
-	if (xioctl(RUN(fd), VIDIOC_S_INPUT, &input) < 0) {
+	if (D_XIOCTL(VIDIOC_S_INPUT, &input) < 0) {
 		LOG_ERROR("Can't set input channel");
 		return -1;
 	}
 
 	if (dev->standard != V4L2_STD_UNKNOWN) {
 		LOG_INFO("Using TV standard: %s", _standard_to_string(dev->standard));
-		if (xioctl(RUN(fd), VIDIOC_S_STD, &dev->standard) < 0) {
+		if (D_XIOCTL(VIDIOC_S_STD, &dev->standard) < 0) {
 			LOG_ERROR("Can't set video standard");
 			return -1;
 		}
@@ -448,7 +449,7 @@ static int _device_open_dv_timings(device_s *dev) {
 		sub.type = V4L2_EVENT_SOURCE_CHANGE;
 
 		LOG_DEBUG("Subscribing to DV-timings events ...")
-		if (xioctl(RUN(fd), VIDIOC_SUBSCRIBE_EVENT, &sub) < 0) {
+		if (D_XIOCTL(VIDIOC_SUBSCRIBE_EVENT, &sub) < 0) {
 			LOG_PERROR("Can't subscribe to DV-timings events");
 			return -1;
 		}
@@ -459,8 +460,8 @@ static int _device_open_dv_timings(device_s *dev) {
 static int _device_apply_dv_timings(device_s *dev) {
 	struct v4l2_dv_timings dv = {0};
 
-	LOG_DEBUG("Calling ioctl(VIDIOC_QUERY_DV_TIMINGS) ...");
-	if (xioctl(RUN(fd), VIDIOC_QUERY_DV_TIMINGS, &dv) == 0) {
+	LOG_DEBUG("Calling xioctl(VIDIOC_QUERY_DV_TIMINGS) ...");
+	if (D_XIOCTL(VIDIOC_QUERY_DV_TIMINGS, &dv) == 0) {
 		if (dv.type == V4L2_DV_BT_656_1120) {
 			// See v4l2_print_dv_timings() in the kernel
 			unsigned htot = V4L2_DV_BT_FRAME_WIDTH(&dv.bt);
@@ -478,8 +479,8 @@ static int _device_apply_dv_timings(device_s *dev) {
 				(unsigned long long)dv.bt.pixelclock, dv.bt.vsync, dv.bt.hsync);
 		}
 
-		LOG_DEBUG("Calling ioctl(VIDIOC_S_DV_TIMINGS) ...");
-		if (xioctl(RUN(fd), VIDIOC_S_DV_TIMINGS, &dv) < 0) {
+		LOG_DEBUG("Calling xioctl(VIDIOC_S_DV_TIMINGS) ...");
+		if (D_XIOCTL(VIDIOC_S_DV_TIMINGS, &dv) < 0) {
 			LOG_PERROR("Failed to set DV-timings");
 			return -1;
 		}
@@ -489,10 +490,10 @@ static int _device_apply_dv_timings(device_s *dev) {
 		}
 
 	} else {
-		LOG_DEBUG("Calling ioctl(VIDIOC_QUERYSTD) ...");
-		if (xioctl(RUN(fd), VIDIOC_QUERYSTD, &dev->standard) == 0) {
+		LOG_DEBUG("Calling xioctl(VIDIOC_QUERYSTD) ...");
+		if (D_XIOCTL(VIDIOC_QUERYSTD, &dev->standard) == 0) {
 			LOG_INFO("Applying the new VIDIOC_S_STD: %s ...", _standard_to_string(dev->standard));
-			if (xioctl(RUN(fd), VIDIOC_S_STD, &dev->standard) < 0) {
+			if (D_XIOCTL(VIDIOC_S_STD, &dev->standard) < 0) {
 				LOG_PERROR("Can't set video standard");
 				return -1;
 			}
@@ -515,7 +516,7 @@ static int _device_open_format(device_s *dev, bool first) {
 	// Set format
 	LOG_DEBUG("Probing device format=%s, stride=%u, resolution=%ux%u ...",
 		_format_to_string_supported(dev->format), stride, RUN(width), RUN(height));
-	if (xioctl(RUN(fd), VIDIOC_S_FMT, &fmt) < 0) {
+	if (D_XIOCTL(VIDIOC_S_FMT, &fmt) < 0) {
 		LOG_PERROR("Can't set device format");
 		return -1;
 	}
@@ -566,7 +567,7 @@ static void _device_open_hw_fps(device_s *dev) {
 	setfps.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
 	LOG_DEBUG("Querying HW FPS ...");
-	if (xioctl(RUN(fd), VIDIOC_G_PARM, &setfps) < 0) {
+	if (D_XIOCTL(VIDIOC_G_PARM, &setfps) < 0) {
 		if (errno == ENOTTY) { // Quiet message for TC358743
 			LOG_INFO("Querying HW FPS changing is not supported");
 		} else {
@@ -587,7 +588,7 @@ static void _device_open_hw_fps(device_s *dev) {
 	SETFPS_TPF(numerator) = 1;
 	SETFPS_TPF(denominator) = (dev->desired_fps == 0 ? 255 : dev->desired_fps);
 
-	if (xioctl(RUN(fd), VIDIOC_S_PARM, &setfps) < 0) {
+	if (D_XIOCTL(VIDIOC_S_PARM, &setfps) < 0) {
 		LOG_PERROR("Can't set HW FPS");
 		return;
 	}
@@ -618,11 +619,11 @@ static void _device_open_jpeg_quality(device_s *dev) {
 	if (is_jpeg(RUN(format))) {
 		struct v4l2_jpegcompression comp = {0};
 
-		if (xioctl(RUN(fd), VIDIOC_G_JPEGCOMP, &comp) < 0) {
+		if (D_XIOCTL(VIDIOC_G_JPEGCOMP, &comp) < 0) {
 			LOG_ERROR("Device doesn't support setting of HW encoding quality parameters");
 		} else {
 			comp.quality = dev->jpeg_quality;
-			if (xioctl(RUN(fd), VIDIOC_S_JPEGCOMP, &comp) < 0) {
+			if (D_XIOCTL(VIDIOC_S_JPEGCOMP, &comp) < 0) {
 				LOG_ERROR("Can't change MJPEG quality for JPEG source with HW pass-through encoder");
 			} else {
 				quality = dev->jpeg_quality;
@@ -650,7 +651,7 @@ static int _device_open_io_method_mmap(device_s *dev) {
 	req.memory = V4L2_MEMORY_MMAP;
 
 	LOG_DEBUG("Requesting %u device buffers for MMAP ...", req.count);
-	if (xioctl(RUN(fd), VIDIOC_REQBUFS, &req) < 0) {
+	if (D_XIOCTL(VIDIOC_REQBUFS, &req) < 0) {
 		LOG_PERROR("Device '%s' doesn't support MMAP method", dev->path);
 		return -1;
 	}
@@ -671,8 +672,8 @@ static int _device_open_io_method_mmap(device_s *dev) {
 		buf.memory = V4L2_MEMORY_MMAP;
 		buf.index = RUN(n_bufs);
 
-		LOG_DEBUG("Calling ioctl(VIDIOC_QUERYBUF) for device buffer=%u ...", RUN(n_bufs));
-		if (xioctl(RUN(fd), VIDIOC_QUERYBUF, &buf) < 0) {
+		LOG_DEBUG("Calling xioctl(VIDIOC_QUERYBUF) for device buffer=%u ...", RUN(n_bufs));
+		if (D_XIOCTL(VIDIOC_QUERYBUF, &buf) < 0) {
 			LOG_PERROR("Can't VIDIOC_QUERYBUF");
 			return -1;
 		}
@@ -707,7 +708,7 @@ static int _device_open_io_method_userptr(device_s *dev) {
 	req.memory = V4L2_MEMORY_USERPTR;
 
 	LOG_DEBUG("Requesting %u device buffers for USERPTR ...", req.count);
-	if (xioctl(RUN(fd), VIDIOC_REQBUFS, &req) < 0) {
+	if (D_XIOCTL(VIDIOC_REQBUFS, &req) < 0) {
 		LOG_PERROR("Device '%s' doesn't support USERPTR method", dev->path);
 		return -1;
 	}
@@ -747,8 +748,8 @@ static int _device_open_queue_buffers(device_s *dev) {
 			buf.length = RUN(hw_bufs)[index].raw.allocated;
 		}
 
-		LOG_DEBUG("Calling ioctl(VIDIOC_QBUF) for buffer=%u ...", index);
-		if (xioctl(RUN(fd), VIDIOC_QBUF, &buf) < 0) {
+		LOG_DEBUG("Calling xioctl(VIDIOC_QBUF) for buffer=%u ...", index);
+		if (D_XIOCTL(VIDIOC_QBUF, &buf) < 0) {
 			LOG_PERROR("Can't VIDIOC_QBUF");
 			return -1;
 		}
@@ -836,7 +837,7 @@ static int _device_query_control(
 	MEMSET_ZERO(*query);
 	query->id = cid;
 
-	if (xioctl(RUN(fd), VIDIOC_QUERYCTRL, query) < 0 || query->flags & V4L2_CTRL_FLAG_DISABLED) {
+	if (D_XIOCTL(VIDIOC_QUERYCTRL, query) < 0 || query->flags & V4L2_CTRL_FLAG_DISABLED) {
 		if (!quiet) {
 			LOG_ERROR("Changing control %s is unsupported", name);
 		}
@@ -861,7 +862,7 @@ static void _device_set_control(
 	ctl.id = cid;
 	ctl.value = value;
 
-	if (xioctl(RUN(fd), VIDIOC_S_CTRL, &ctl) < 0) {
+	if (D_XIOCTL(VIDIOC_S_CTRL, &ctl) < 0) {
 		if (!quiet) {
 			LOG_PERROR("Can't set control %s", name);
 		}
@@ -902,4 +903,5 @@ static const char *_io_method_to_string_supported(enum v4l2_memory io_method) {
 	return "unsupported";
 }
 
-#	undef RUN
+#undef D_XIOCTL
+#undef RUN

src/ustreamer/device.h

@@ -45,8 +45,7 @@
 #include "../libs/logging.h"
 #include "../libs/threading.h"
 #include "../libs/frame.h"
-
-#include "xioctl.h"
+#include "../libs/xioctl.h"
 
 
 #define VIDEO_MIN_WIDTH		((unsigned)160)

src/ustreamer/http/server.c

@@ -76,7 +76,7 @@ server_s *server_init(stream_s *stream) {
 	assert(!evthread_use_pthreads());
 	assert((run->base = event_base_new()));
 	assert((run->http = evhttp_new(run->base)));
-	evhttp_set_allowed_methods(run->http, EVHTTP_REQ_GET|EVHTTP_REQ_HEAD);
+	evhttp_set_allowed_methods(run->http, EVHTTP_REQ_GET|EVHTTP_REQ_HEAD|EVHTTP_REQ_OPTIONS);
 	return server;
 }
 
@@ -212,14 +212,36 @@ void server_loop_break(server_s *server) {
 	event_base_loopbreak(RUN(base));
 }
 
+#define GET_HEADER(_key) \
+	evhttp_find_header(evhttp_request_get_input_headers(request), _key)
+
 #define ADD_HEADER(_key, _value) \
 	assert(!evhttp_add_header(evhttp_request_get_output_headers(request), _key, _value))
 
 static int _http_preprocess_request(struct evhttp_request *request, server_s *server) {
 	RUN(last_request_ts) = get_now_monotonic();
 
+	if (server->allow_origin[0] != '\0') {
+		const char *cors_headers = GET_HEADER("Access-Control-Request-Headers");
+		const char *cors_method = GET_HEADER("Access-Control-Request-Method");
+
+		ADD_HEADER("Access-Control-Allow-Origin", server->allow_origin);
+		ADD_HEADER("Access-Control-Allow-Credentials", "true");
+		if (cors_headers != NULL) {
+			ADD_HEADER("Access-Control-Allow-Headers", cors_headers);
+		}
+		if (cors_method != NULL) {
+			ADD_HEADER("Access-Control-Allow-Methods", cors_method);
+		}
+	}
+
+	if (evhttp_request_get_command(request) == EVHTTP_REQ_OPTIONS) {
+		evhttp_send_reply(request, HTTP_OK, "OK", NULL);
+		return -1;
+	}
+
 	if (RUN(auth_token)) {
-		const char *token = evhttp_find_header(evhttp_request_get_input_headers(request), "Authorization");
+		const char *token = GET_HEADER("Authorization");
 
 		if (token == NULL || strcmp(token, RUN(auth_token)) != 0) {
 			ADD_HEADER("WWW-Authenticate", "Basic realm=\"Restricted area\"");
@@ -228,8 +250,8 @@ static int _http_preprocess_request(struct evhttp_request *request, server_s *se
 		}
 	}
 
-	if (evhttp_request_get_command(request) == EVHTTP_REQ_HEAD) { \
-		evhttp_send_reply(request, HTTP_OK, "OK", NULL); \
+	if (evhttp_request_get_command(request) == EVHTTP_REQ_HEAD) {
+		evhttp_send_reply(request, HTTP_OK, "OK", NULL);
 		return -1;
 	}
 
@@ -464,9 +486,6 @@ static void _http_callback_snapshot(struct evhttp_request *request, void *v_serv
 	assert((buf = evbuffer_new()));
 	assert(!evbuffer_add(buf, (const void *)EX(frame->data), EX(frame->used)));
 
-	if (server->allow_origin[0] != '\0') {
-		ADD_HEADER("Access-Control-Allow-Origin", server->allow_origin);
-	}
 	ADD_HEADER("Cache-Control", "no-store, no-cache, must-revalidate, proxy-revalidate, pre-check=0, post-check=0, max-age=0");
 	ADD_HEADER("Pragma", "no-cache");
 	ADD_HEADER("Expires", "Mon, 3 Jan 2000 12:34:56 GMT");
@@ -580,6 +599,7 @@ static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_c
 #	define BOUNDARY "boundarydonotcross"
 
 	stream_client_s *client = (stream_client_s *)v_client;
+	struct evhttp_request *request = client->request; // for GET_HEADER
 	server_s *server = client->server;
 
 	long double now = get_now_monotonic();
@@ -620,9 +640,24 @@ static void _http_callback_stream_write(struct bufferevent *buf_event, void *v_c
 
 	if (client->need_initial) {
 		assert(evbuffer_add_printf(buf, "HTTP/1.0 200 OK" RN));
+		
 		if (client->server->allow_origin[0] != '\0') {
-			assert(evbuffer_add_printf(buf, "Access-Control-Allow-Origin: %s" RN, client->server->allow_origin));
+			const char *cors_headers = GET_HEADER("Access-Control-Request-Headers");
+			const char *cors_method = GET_HEADER("Access-Control-Request-Method");
+
+			assert(evbuffer_add_printf(buf,
+				"Access-Control-Allow-Origin: %s" RN
+				"Access-Control-Allow-Credentials: true" RN,
+				client->server->allow_origin				
+			));
+			if (cors_headers != NULL) {
+				assert(evbuffer_add_printf(buf, "Access-Control-Allow-Headers: %s" RN, cors_headers));
+			}
+			if (cors_method != NULL) {
+				assert(evbuffer_add_printf(buf, "Access-Control-Allow-Methods: %s" RN, cors_method));
+			}
 		}
+
 		assert(evbuffer_add_printf(buf,
 			"Cache-Control: no-store, no-cache, must-revalidate, proxy-revalidate, pre-check=0, post-check=0, max-age=0" RN
 			"Pragma: no-cache" RN
@@ -895,7 +930,7 @@ static char *_http_get_client_hostport(struct evhttp_request *request) {
 		assert(addr = strdup(peer));
 	}
 
-	const char *xff = evhttp_find_header(evhttp_request_get_input_headers(request), "X-Forwarded-For");
+	const char *xff = GET_HEADER("X-Forwarded-For");
 	if (xff) {
 		if (addr) {
 			free(addr);
@@ -918,3 +953,5 @@ static char *_http_get_client_hostport(struct evhttp_request *request) {
 	free(addr);
 	return hostport;
 }
+
+#undef GET_HEADER

src/ustreamer/m2m.h

@@ -39,8 +39,7 @@
 #include "../libs/tools.h"
 #include "../libs/logging.h"
 #include "../libs/frame.h"
-
-#include "xioctl.h"
+#include "../libs/xioctl.h"
 
 
 typedef struct {