aboutsummaryrefslogtreecommitdiffhomepage
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/args_parser.c3
-rw-r--r--src/cli/ipc.c555
-rw-r--r--src/cli/main.c81
-rw-r--r--src/recorder/audio_capture.c8
-rw-r--r--src/recorder/recorder.c48
-rw-r--r--src/recorder/replay_save.c8
-rw-r--r--src/recorder/screenshot.c6
7 files changed, 669 insertions, 40 deletions
diff --git a/src/args_parser.c b/src/args_parser.c
index 0adb5ef..d10da67 100644
--- a/src/args_parser.c
+++ b/src/args_parser.c
@@ -206,7 +206,7 @@ static void usage_header(void) {
"[-cursor yes|no] [-keyint <value>] [-restore-portal-session yes|no] [-portal-session-token-filepath filepath] [-encoder gpu|cpu] "
"[-fallback-cpu-encoding yes|no] [-o <output_file>] [-ro <output_directory>] [-ffmpeg-opts <options>] [--list-capture-options [card_path]] "
"[--list-monitors] [--list-audio-devices] [--list-application-audio] [--list-v4l2-devices] [-write-first-frame-ts yes|no] [-low-power yes|no] "
- "[-v yes|no] [-gl-debug yes|no] [-exclude-metadata yes|no] [--version] [-h|--help]\n", program_name);
+ "[-ipc <socket_path>] [-v yes|no] [-gl-debug yes|no] [-exclude-metadata yes|no] [--version] [-h|--help]\n", program_name);
fflush(stdout);
}
@@ -571,6 +571,7 @@ args_parse_result args_parser_parse(args_parser *self, int argc, char **argv, co
self->args[arg_index++] = (Arg){ .key = "-write-first-frame-ts", .optional = true, .list = false, .type = ARG_TYPE_BOOLEAN };
self->args[arg_index++] = (Arg){ .key = "-low-power", .optional = true, .list = false, .type = ARG_TYPE_BOOLEAN };
self->args[arg_index++] = (Arg){ .key = "-exclude-metadata", .optional = true, .list = false, .type = ARG_TYPE_BOOLEAN };
+ self->args[arg_index++] = (Arg){ .key = "-ipc", .optional = true, .list = false, .type = ARG_TYPE_STRING };
assert(arg_index == NUM_ARGS);
for(int i = 1; i < argc; i += 2) {
diff --git a/src/cli/ipc.c b/src/cli/ipc.c
new file mode 100644
index 0000000..6d555c0
--- /dev/null
+++ b/src/cli/ipc.c
@@ -0,0 +1,555 @@
+#include "../../include/cli/ipc.h"
+#include "../../include/recorder/error.h"
+#include "../../include/recorder/replay_save.h"
+#include "../../include/log.h"
+
+#define SJ_IMPL
+#include "../../external/sj.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <poll.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/un.h>
+
+#define GSR_IPC_MAX_REQUEST_NAME_SIZE 64
+#define GSR_IPC_MAX_ESCAPED_ERROR_MESSAGE_SIZE (GSR_IPC_MAX_ERROR_MESSAGE_SIZE*6)
+#define GSR_IPC_MAX_REPLY_SIZE (GSR_IPC_MAX_ESCAPED_ERROR_MESSAGE_SIZE + 128)
+#define GSR_IPC_SEND_TIMEOUT_MILLISECONDS 1000
+#define GSR_IPC_SOCKET_MODE 0600
+
+typedef struct {
+ int64_t id;
+ char name[GSR_IPC_MAX_REQUEST_NAME_SIZE];
+ sj_Value data;
+ bool has_data;
+} gsr_ipc_request;
+
+static void json_escape_string(char *buffer, size_t buffer_size, const char *str) {
+ char escape_buffer[8];
+ size_t offset = 0;
+ buffer[0] = '\0';
+
+ for(size_t i = 0; str[i] != '\0'; ++i) {
+ const unsigned char c = str[i];
+ const char *escaped = escape_buffer;
+ switch(c) {
+ case '"': escaped = "\\\""; break;
+ case '\\': escaped = "\\\\"; break;
+ case '\n': escaped = "\\n"; break;
+ case '\r': escaped = "\\r"; break;
+ case '\t': escaped = "\\t"; break;
+ default: {
+ if(c < 0x20)
+ snprintf(escape_buffer, sizeof(escape_buffer), "\\u%04x", c);
+ else
+ snprintf(escape_buffer, sizeof(escape_buffer), "%c", c);
+ break;
+ }
+ }
+
+ const size_t escaped_size = strlen(escaped);
+ if(offset + escaped_size >= buffer_size)
+ break;
+
+ memcpy(buffer + offset, escaped, escaped_size);
+ offset += escaped_size;
+ buffer[offset] = '\0';
+ }
+}
+
+static bool json_string_equals(const sj_Value *value, const char *str) {
+ const size_t value_size = value->end - value->start;
+ return strlen(str) == value_size && memcmp(value->start, str, value_size) == 0;
+}
+
+static bool json_number_to_int64(const sj_Value *value, int64_t *result) {
+ char buffer[32];
+ const size_t value_size = value->end - value->start;
+ if(value_size == 0 || value_size >= sizeof(buffer))
+ return false;
+
+ memcpy(buffer, value->start, value_size);
+ buffer[value_size] = '\0';
+
+ char *number_end = NULL;
+ errno = 0;
+ const long long parsed_value = strtoll(buffer, &number_end, 10);
+ if(errno != 0 || number_end != buffer + value_size)
+ return false;
+
+ *result = parsed_value;
+ return true;
+}
+
+static bool string_is_only_whitespace(const char *str, size_t size) {
+ for(size_t i = 0; i < size; ++i) {
+ if(str[i] != ' ' && str[i] != '\t' && str[i] != '\r' && str[i] != '\n')
+ return false;
+ }
+ return true;
+}
+
+static bool ipc_send_all(int fd, const char *data, size_t size) {
+ size_t offset = 0;
+ while(offset < size) {
+ const ssize_t bytes_written = send(fd, data + offset, size - offset, MSG_NOSIGNAL);
+ if(bytes_written > 0) {
+ offset += bytes_written;
+ continue;
+ }
+
+ if(bytes_written == -1 && errno == EINTR)
+ continue;
+
+ if(bytes_written == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
+ struct pollfd poll_fd;
+ poll_fd.fd = fd;
+ poll_fd.events = POLLOUT;
+ poll_fd.revents = 0;
+
+ const int poll_result = poll(&poll_fd, 1, GSR_IPC_SEND_TIMEOUT_MILLISECONDS);
+ if(poll_result == -1 && errno == EINTR)
+ continue;
+
+ if(poll_result <= 0)
+ return false;
+
+ continue;
+ }
+
+ return false;
+ }
+ return true;
+}
+
+static bool ipc_client_send_reply(gsr_ipc_client *client, int64_t id, bool success, const char *error_message) {
+ char reply[GSR_IPC_MAX_REPLY_SIZE];
+ int reply_size = 0;
+
+ if(success) {
+ reply_size = snprintf(reply, sizeof(reply), "{\"id\":%" PRIi64 ",\"result\":\"ok\"}\n", id);
+ } else {
+ char escaped_error_message[GSR_IPC_MAX_ESCAPED_ERROR_MESSAGE_SIZE];
+ json_escape_string(escaped_error_message, sizeof(escaped_error_message), error_message ? error_message : "");
+ reply_size = snprintf(reply, sizeof(reply), "{\"id\":%" PRIi64 ",\"result\":\"error\",\"data\":\"%s\"}\n", id, escaped_error_message);
+ }
+
+ if(reply_size < 0 || reply_size >= (int)sizeof(reply)) {
+ gsr_log(GSR_LOG_LEVEL_ERROR, "gsr_ipc: failed to create a reply to request %" PRIi64, id);
+ return false;
+ }
+
+ return ipc_send_all(client->fd, reply, reply_size);
+}
+
+static bool ipc_request_parse(char *data, size_t size, gsr_ipc_request *request, char *error_message, size_t error_message_size) {
+ memset(request, 0, sizeof(*request));
+
+ sj_Reader reader = sj_reader(data, size);
+ const sj_Value root = sj_read(&reader);
+ if(root.type != SJ_OBJECT) {
+ snprintf(error_message, error_message_size, "expected the request to be a json object");
+ return false;
+ }
+
+ sj_Value id_value;
+ sj_Value name_value;
+ bool has_id = false;
+ bool has_name = false;
+
+ sj_Value key;
+ sj_Value value;
+ while(sj_iter_object(&reader, root, &key, &value)) {
+ if(json_string_equals(&key, "id")) {
+ id_value = value;
+ has_id = true;
+ } else if(json_string_equals(&key, "name")) {
+ name_value = value;
+ has_name = true;
+ } else if(json_string_equals(&key, "data")) {
+ request->data = value;
+ request->has_data = true;
+ }
+ }
+
+ if(reader.error) {
+ snprintf(error_message, error_message_size, "failed to parse the request: %s", reader.error);
+ return false;
+ }
+
+ if(!has_id) {
+ snprintf(error_message, error_message_size, "the request is missing the 'id' field");
+ return false;
+ }
+
+ if(id_value.type != SJ_NUMBER || !json_number_to_int64(&id_value, &request->id)) {
+ snprintf(error_message, error_message_size, "expected 'id' to be an integer");
+ return false;
+ }
+
+ if(!has_name) {
+ snprintf(error_message, error_message_size, "the request is missing the 'name' field");
+ return false;
+ }
+
+ if(name_value.type != SJ_STRING) {
+ snprintf(error_message, error_message_size, "expected 'name' to be a string");
+ return false;
+ }
+
+ snprintf(request->name, sizeof(request->name), "%.*s", (int)(name_value.end - name_value.start), name_value.start);
+ return true;
+}
+
+static bool ipc_request_get_save_replay_seconds(const gsr_ipc_request *request, int *seconds, char *error_message, size_t error_message_size) {
+ *seconds = GSR_SAVE_REPLAY_SECONDS_FULL;
+ if(!request->has_data || request->data.type == SJ_NULL)
+ return true;
+
+ int64_t data_seconds = 0;
+ if(request->data.type != SJ_NUMBER || !json_number_to_int64(&request->data, &data_seconds) || data_seconds <= 0 || data_seconds > INT_MAX) {
+ snprintf(error_message, error_message_size, "expected 'data' to be the number of seconds to save, which has to be larger than 0");
+ return false;
+ }
+
+ *seconds = data_seconds;
+ return true;
+}
+
+static bool ipc_handle_request(gsr_ipc *self, const gsr_ipc_request *request, char *error_message, size_t error_message_size) {
+ if(strcmp(request->name, "stop") == 0)
+ return self->handlers.stop(error_message, error_message_size, self->handlers.userdata);
+
+ if(strcmp(request->name, "toggle-pause") == 0)
+ return self->handlers.toggle_pause(error_message, error_message_size, self->handlers.userdata);
+
+ if(strcmp(request->name, "toggle-replay-recording") == 0)
+ return self->handlers.toggle_replay_recording(error_message, error_message_size, self->handlers.userdata);
+
+ if(strcmp(request->name, "save-replay") == 0) {
+ int seconds = GSR_SAVE_REPLAY_SECONDS_FULL;
+ if(!ipc_request_get_save_replay_seconds(request, &seconds, error_message, error_message_size))
+ return false;
+
+ return self->handlers.save_replay(seconds, error_message, error_message_size, self->handlers.userdata);
+ }
+
+ snprintf(error_message, error_message_size, "unknown request name '%s'", request->name);
+ return false;
+}
+
+static bool ipc_client_on_request(gsr_ipc *self, gsr_ipc_client *client) {
+ if(client->request_too_large)
+ return ipc_client_send_reply(client, 0, false, "the request is too large");
+
+ if(string_is_only_whitespace(client->request, client->request_size))
+ return ipc_client_send_reply(client, 0, false, "the request is empty");
+
+ char error_message[GSR_IPC_MAX_ERROR_MESSAGE_SIZE];
+ error_message[0] = '\0';
+
+ gsr_ipc_request request;
+ if(!ipc_request_parse(client->request, client->request_size, &request, error_message, sizeof(error_message)))
+ return ipc_client_send_reply(client, request.id, false, error_message);
+
+ if(!ipc_handle_request(self, &request, error_message, sizeof(error_message)))
+ return ipc_client_send_reply(client, request.id, false, error_message);
+
+ return ipc_client_send_reply(client, request.id, true, NULL);
+}
+
+static bool ipc_client_on_byte(gsr_ipc *self, gsr_ipc_client *client, char c) {
+ if(c != '\n') {
+ if(client->request_size < GSR_IPC_MAX_REQUEST_SIZE)
+ client->request[client->request_size++] = c;
+ else
+ client->request_too_large = true;
+ return true;
+ }
+
+ const bool keep_client = ipc_client_on_request(self, client);
+ client->request_size = 0;
+ client->request_too_large = false;
+ return keep_client;
+}
+
+static bool ipc_client_receive(gsr_ipc *self, gsr_ipc_client *client) {
+ for(;;) {
+ char buffer[1024];
+ const ssize_t bytes_read = recv(client->fd, buffer, sizeof(buffer), 0);
+ if(bytes_read == 0)
+ return false;
+
+ if(bytes_read == -1) {
+ if(errno == EINTR)
+ continue;
+
+ return errno == EAGAIN || errno == EWOULDBLOCK;
+ }
+
+ for(ssize_t i = 0; i < bytes_read; ++i) {
+ if(!ipc_client_on_byte(self, client, buffer[i]))
+ return false;
+ }
+ }
+}
+
+static bool fd_set_cloexec(int fd) {
+ const int flags = fcntl(fd, F_GETFD);
+ return flags != -1 && fcntl(fd, F_SETFD, flags | FD_CLOEXEC) != -1;
+}
+
+static bool fd_set_nonblocking(int fd) {
+ const int flags = fcntl(fd, F_GETFL);
+ return flags != -1 && fcntl(fd, F_SETFL, flags | O_NONBLOCK) != -1;
+}
+
+static void ipc_add_client(gsr_ipc *self, int client_fd) {
+ if(self->num_clients == GSR_IPC_MAX_CLIENTS) {
+ gsr_log(GSR_LOG_LEVEL_WARNING, "gsr_ipc: too many ipc clients are connected, rejecting the new connection");
+ close(client_fd);
+ return;
+ }
+
+ if(!fd_set_cloexec(client_fd) || !fd_set_nonblocking(client_fd)) {
+ gsr_log(GSR_LOG_LEVEL_ERROR, "gsr_ipc: failed to setup the ipc client socket, error: %s", strerror(errno));
+ close(client_fd);
+ return;
+ }
+
+ gsr_ipc_client *client = &self->clients[self->num_clients];
+ client->fd = client_fd;
+ client->request_size = 0;
+ client->request_too_large = false;
+ ++self->num_clients;
+}
+
+static void ipc_accept_client(gsr_ipc *self) {
+ const int client_fd = accept(self->socket_fd, NULL, NULL);
+ if(client_fd == -1)
+ return;
+
+ ipc_add_client(self, client_fd);
+}
+
+static void ipc_remove_client(gsr_ipc *self, int index) {
+ close(self->clients[index].fd);
+ for(int i = index; i < self->num_clients - 1; ++i) {
+ self->clients[i] = self->clients[i + 1];
+ }
+ --self->num_clients;
+}
+
+static void* ipc_thread(void *userdata) {
+ gsr_ipc *self = userdata;
+ struct pollfd poll_fds[2 + GSR_IPC_MAX_CLIENTS];
+
+ for(;;) {
+ poll_fds[0].fd = self->wakeup_pipe[0];
+ poll_fds[0].events = POLLIN;
+ poll_fds[0].revents = 0;
+ poll_fds[1].fd = self->socket_fd;
+ poll_fds[1].events = POLLIN;
+ poll_fds[1].revents = 0;
+
+ const int num_polled_clients = self->num_clients;
+ for(int i = 0; i < num_polled_clients; ++i) {
+ poll_fds[2 + i].fd = self->clients[i].fd;
+ poll_fds[2 + i].events = POLLIN;
+ poll_fds[2 + i].revents = 0;
+ }
+
+ if(poll(poll_fds, 2 + num_polled_clients, -1) == -1) {
+ if(errno == EINTR)
+ continue;
+
+ gsr_log(GSR_LOG_LEVEL_ERROR, "gsr_ipc: failed to poll the ipc sockets, error: %s", strerror(errno));
+ break;
+ }
+
+ if(poll_fds[0].revents != 0)
+ break;
+
+ if(poll_fds[1].revents & POLLIN)
+ ipc_accept_client(self);
+
+ for(int i = num_polled_clients - 1; i >= 0; --i) {
+ bool keep_client = true;
+ if(poll_fds[2 + i].revents & POLLIN)
+ keep_client = ipc_client_receive(self, &self->clients[i]);
+ else if(poll_fds[2 + i].revents & (POLLHUP | POLLERR | POLLNVAL))
+ keep_client = false;
+
+ if(!keep_client)
+ ipc_remove_client(self, i);
+ }
+ }
+
+ return NULL;
+}
+
+static bool ipc_socket_filepath_in_use(const char *socket_filepath) {
+ struct sockaddr_un addr;
+ memset(&addr, 0, sizeof(addr));
+ addr.sun_family = AF_UNIX;
+ snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", socket_filepath);
+
+ const int fd = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
+ if(fd == -1)
+ return true;
+
+ const bool in_use = connect(fd, (const struct sockaddr*)&addr, sizeof(addr)) == 0;
+ close(fd);
+ return in_use;
+}
+
+static bool ipc_bind(gsr_ipc *self, const struct sockaddr_un *addr) {
+ const mode_t prev_mask = umask(0777 & ~GSR_IPC_SOCKET_MODE);
+ int bind_result = bind(self->socket_fd, (const struct sockaddr*)addr, sizeof(*addr));
+ if(bind_result == -1 && errno == EADDRINUSE && !ipc_socket_filepath_in_use(self->socket_filepath)) {
+ unlink(self->socket_filepath);
+ bind_result = bind(self->socket_fd, (const struct sockaddr*)addr, sizeof(*addr));
+ }
+ const int bind_error = errno;
+ umask(prev_mask);
+
+ if(bind_result == -1) {
+ gsr_log(GSR_LOG_LEVEL_ERROR, "gsr_ipc_init: failed to bind the ipc socket to \"%s\", error: %s", self->socket_filepath, strerror(bind_error));
+ return false;
+ }
+
+ self->socket_bound = true;
+ return true;
+}
+
+static void ipc_close(gsr_ipc *self) {
+ for(int i = 0; i < self->num_clients; ++i) {
+ close(self->clients[i].fd);
+ }
+ self->num_clients = 0;
+
+ for(int i = 0; i < 2; ++i) {
+ if(self->wakeup_pipe[i] != -1) {
+ close(self->wakeup_pipe[i]);
+ self->wakeup_pipe[i] = -1;
+ }
+ }
+
+ if(self->socket_fd != -1) {
+ close(self->socket_fd);
+ self->socket_fd = -1;
+ }
+
+ if(self->socket_bound) {
+ unlink(self->socket_filepath);
+ self->socket_bound = false;
+ }
+}
+
+int gsr_ipc_init(gsr_ipc *self, const char *socket_filepath) {
+ memset(self, 0, sizeof(*self));
+ self->socket_fd = -1;
+ self->wakeup_pipe[0] = -1;
+ self->wakeup_pipe[1] = -1;
+
+ struct sockaddr_un addr;
+ memset(&addr, 0, sizeof(addr));
+ addr.sun_family = AF_UNIX;
+ if(snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", socket_filepath) >= (int)sizeof(addr.sun_path)) {
+ gsr_log(GSR_LOG_LEVEL_ERROR, "gsr_ipc_init: the ipc socket path is too long, it can be at most %d characters: \"%s\"", (int)sizeof(addr.sun_path) - 1, socket_filepath);
+ goto err;
+ }
+
+ snprintf(self->socket_filepath, sizeof(self->socket_filepath), "%s", socket_filepath);
+
+ if(pipe(self->wakeup_pipe) == -1) {
+ gsr_log(GSR_LOG_LEVEL_ERROR, "gsr_ipc_init: failed to create the ipc wakeup pipe, error: %s", strerror(errno));
+ self->wakeup_pipe[0] = -1;
+ self->wakeup_pipe[1] = -1;
+ goto err;
+ }
+
+ if(!fd_set_cloexec(self->wakeup_pipe[0]) || !fd_set_cloexec(self->wakeup_pipe[1])) {
+ gsr_log(GSR_LOG_LEVEL_ERROR, "gsr_ipc_init: failed to setup the ipc wakeup pipe, error: %s", strerror(errno));
+ goto err;
+ }
+
+ self->socket_fd = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0);
+ if(self->socket_fd == -1) {
+ gsr_log(GSR_LOG_LEVEL_ERROR, "gsr_ipc_init: failed to create the ipc socket, error: %s", strerror(errno));
+ goto err;
+ }
+
+ if(!ipc_bind(self, &addr))
+ goto err;
+
+ if(listen(self->socket_fd, GSR_IPC_MAX_CLIENTS) == -1) {
+ gsr_log(GSR_LOG_LEVEL_ERROR, "gsr_ipc_init: failed to listen on the ipc socket, error: %s", strerror(errno));
+ goto err;
+ }
+
+ self->initialized = true;
+ return GSR_ERROR_OK;
+
+ err:
+ ipc_close(self);
+ return GSR_ERROR_GENERIC;
+}
+
+void gsr_ipc_deinit(gsr_ipc *self) {
+ if(!self->initialized)
+ return;
+
+ gsr_ipc_stop(self);
+ ipc_close(self);
+ self->initialized = false;
+}
+
+int gsr_ipc_start(gsr_ipc *self, const gsr_ipc_handlers *handlers) {
+ if(!self->initialized)
+ return GSR_ERROR_OK;
+
+ self->handlers = *handlers;
+
+ /* Block all signals in the ipc thread to keep the signal handlers running on the main thread */
+ sigset_t all_signals;
+ sigset_t prev_signals;
+ sigfillset(&all_signals);
+ pthread_sigmask(SIG_SETMASK, &all_signals, &prev_signals);
+ const int thread_create_result = pthread_create(&self->thread, NULL, ipc_thread, self);
+ pthread_sigmask(SIG_SETMASK, &prev_signals, NULL);
+
+ if(thread_create_result != 0) {
+ gsr_log(GSR_LOG_LEVEL_ERROR, "gsr_ipc_start: failed to create the ipc thread, error: %s", strerror(thread_create_result));
+ return GSR_ERROR_GENERIC;
+ }
+
+ self->thread_running = true;
+ return GSR_ERROR_OK;
+}
+
+void gsr_ipc_stop(gsr_ipc *self) {
+ if(!self->thread_running)
+ return;
+
+ const char wakeup_value = 1;
+ ssize_t bytes_written = 0;
+ do {
+ bytes_written = write(self->wakeup_pipe[1], &wakeup_value, 1);
+ } while(bytes_written == -1 && errno == EINTR);
+
+ if(bytes_written == -1)
+ gsr_log(GSR_LOG_LEVEL_ERROR, "gsr_ipc_stop: failed to wake up the ipc thread, error: %s", strerror(errno));
+
+ pthread_join(self->thread, NULL);
+ self->thread_running = false;
+}
diff --git a/src/cli/main.c b/src/cli/main.c
index 9d5f7e2..5ead4a4 100644
--- a/src/cli/main.c
+++ b/src/cli/main.c
@@ -16,6 +16,7 @@
*/
#include "../../include/cli/commands.h"
+#include "../../include/cli/ipc.h"
#include "../../include/recorder/recorder.h"
#include "../../include/recorder/screenshot.h"
#include "../../include/recorder/capture_source.h"
@@ -39,10 +40,11 @@
#include <assert.h>
#include <locale.h>
#include <signal.h>
+#include <stdatomic.h>
#include <unistd.h>
#include <malloc.h>
-static volatile sig_atomic_t running = 1;
+static atomic_int running = 1;
static gsr_recorder *recorder = NULL;
/* Signals that are received before the recorder has been created are applied when it has been created */
static volatile sig_atomic_t pending_toggle_pause = 0;
@@ -51,7 +53,7 @@ static volatile sig_atomic_t pending_save_replay_seconds = 0;
static void stop_handler(int signal_value) {
(void)signal_value;
- running = 0;
+ atomic_store(&running, 0);
if(recorder)
gsr_recorder_stop(recorder);
}
@@ -132,6 +134,48 @@ static void save_replay_30_minutes_handler(int signal_value) {
save_replay_seconds_handler(recorder, 60*30);
}
+static bool ipc_stop_handler(char *error_message, size_t error_message_size, void *userdata) {
+ (void)error_message;
+ (void)error_message_size;
+ (void)userdata;
+ atomic_store(&running, 0);
+ gsr_recorder_stop(recorder);
+ return true;
+}
+
+static bool ipc_toggle_pause_handler(char *error_message, size_t error_message_size, void *userdata) {
+ const gsr_recorder_settings *settings = userdata;
+ if(settings->is_replaying) {
+ snprintf(error_message, error_message_size, "pausing is not supported when recording a replay");
+ return false;
+ }
+
+ gsr_recorder_toggle_pause(recorder);
+ return true;
+}
+
+static bool ipc_toggle_replay_recording_handler(char *error_message, size_t error_message_size, void *userdata) {
+ const gsr_recorder_settings *settings = userdata;
+ if(!settings->replay_recording_directory) {
+ snprintf(error_message, error_message_size, "option -ro is required to start a recording");
+ return false;
+ }
+
+ gsr_recorder_toggle_replay_recording(recorder);
+ return true;
+}
+
+static bool ipc_save_replay_handler(int seconds, char *error_message, size_t error_message_size, void *userdata) {
+ const gsr_recorder_settings *settings = userdata;
+ if(!settings->is_replaying) {
+ snprintf(error_message, error_message_size, "option -r is required to save a replay");
+ return false;
+ }
+
+ gsr_recorder_save_replay(recorder, seconds);
+ return true;
+}
+
static void install_signal_handlers(void) {
signal(SIGINT, stop_handler);
signal(SIGTERM, stop_handler);
@@ -366,7 +410,7 @@ static int take_screenshot(args_parser *arg_parser, gsr_windowing *windowing, gs
return gsr_screenshot_take(&screenshot_params);
}
-static int record(args_parser *arg_parser, gsr_windowing *windowing, gsr_capture_deps *capture_deps, gsr_capture_sources *capture_sources, gsr_audio_input_tracks *audio_input_tracks) {
+static int record(args_parser *arg_parser, gsr_windowing *windowing, gsr_capture_deps *capture_deps, gsr_capture_sources *capture_sources, gsr_audio_input_tracks *audio_input_tracks, gsr_ipc *ipc) {
const Arg *plugin_arg = args_parser_get_arg(arg_parser, "-p");
assert(plugin_arg);
@@ -396,10 +440,21 @@ static int record(args_parser *arg_parser, gsr_windowing *windowing, gsr_capture
return error;
apply_pending_signals(recorder);
- if(!running)
+ if(!atomic_load(&running))
gsr_recorder_stop(recorder);
- const int run_result = gsr_recorder_run(recorder);
+ gsr_ipc_handlers ipc_handlers;
+ ipc_handlers.stop = ipc_stop_handler;
+ ipc_handlers.toggle_pause = ipc_toggle_pause_handler;
+ ipc_handlers.toggle_replay_recording = ipc_toggle_replay_recording_handler;
+ ipc_handlers.save_replay = ipc_save_replay_handler;
+ ipc_handlers.userdata = &arg_parser->settings;
+
+ int run_result = gsr_ipc_start(ipc, &ipc_handlers);
+ if(run_result == GSR_ERROR_OK)
+ run_result = gsr_recorder_run(recorder);
+
+ gsr_ipc_stop(ipc);
gsr_recorder_destroy(recorder);
recorder = NULL;
return run_result;
@@ -413,11 +468,16 @@ static int run(args_parser *arg_parser) {
gsr_app_audio_names app_audio_names;
gsr_windowing windowing;
gsr_capture_deps capture_deps;
+ gsr_ipc ipc;
memset(&audio_input_tracks, 0, sizeof(audio_input_tracks));
memset(&app_audio_names, 0, sizeof(app_audio_names));
memset(&windowing, 0, sizeof(windowing));
+ memset(&ipc, 0, sizeof(ipc));
gsr_capture_deps_init(&capture_deps);
+ const Arg *ipc_arg = args_parser_get_arg(arg_parser, "-ipc");
+ assert(ipc_arg);
+
const int parse_capture_sources_result = gsr_capture_sources_parse(&capture_sources, arg_parser->settings.capture_source, arg_parser->settings.region_position, arg_parser->settings.region_size);
if(parse_capture_sources_result != GSR_ERROR_OK) {
exit_code = gsr_error_to_exit_code(parse_capture_sources_result);
@@ -437,6 +497,11 @@ static int run(args_parser *arg_parser) {
goto done;
}
+ if(ipc_arg->num_values > 0 && gsr_ipc_init(&ipc, ipc_arg->values[0]) != GSR_ERROR_OK) {
+ exit_code = 1;
+ goto done;
+ }
+
const int parse_audio_inputs_result = parse_audio_inputs(arg_parser, &audio_input_tracks);
if(parse_audio_inputs_result != GSR_ERROR_OK) {
exit_code = gsr_error_to_exit_code(parse_audio_inputs_result);
@@ -518,12 +583,16 @@ static int run(args_parser *arg_parser) {
goto done;
}
+ if(ipc_arg->num_values > 0)
+ gsr_log(GSR_LOG_LEVEL_WARNING, "option -ipc has no effect when taking a screenshot");
+
exit_code = gsr_error_to_exit_code(take_screenshot(arg_parser, &windowing, &capture_deps, &capture_sources, image_format));
} else {
- exit_code = gsr_error_to_exit_code(record(arg_parser, &windowing, &capture_deps, &capture_sources, &audio_input_tracks));
+ exit_code = gsr_error_to_exit_code(record(arg_parser, &windowing, &capture_deps, &capture_sources, &audio_input_tracks, &ipc));
}
done:
+ gsr_ipc_deinit(&ipc);
gsr_capture_deps_deinit(&capture_deps);
gsr_windowing_deinit(&windowing);
#ifdef GSR_APP_AUDIO
diff --git a/src/recorder/audio_capture.c b/src/recorder/audio_capture.c
index ee1c75f..6275c93 100644
--- a/src/recorder/audio_capture.c
+++ b/src/recorder/audio_capture.c
@@ -155,7 +155,7 @@ static void* audio_device_thread(void *userdata) {
gsr_audio_track *track = thread_userdata->track;
gsr_audio_device_capture *device = thread_userdata->device;
gsr_recording_clock *clock = self->clock;
- const volatile sig_atomic_t *running = self->running;
+ const atomic_int *running = self->running;
const enum AVSampleFormat sound_device_sample_format = audio_format_to_sample_format(audio_codec_context_get_audio_format(track->codec_context));
/* TODO: Always do conversion for now. This fixes issue with stuttering audio on pulseaudio with opus + multiple audio sources merged */
@@ -194,7 +194,7 @@ static void* audio_device_thread(void *userdata) {
if(device->sound_device.handle)
sound_device_flush(&device->sound_device);
- while(*running) {
+ while(atomic_load(running)) {
void *sound_buffer;
int sound_buffer_size = -1;
const double time_before_read_seconds = clock_get_monotonic_seconds();
@@ -332,7 +332,7 @@ static void* audio_device_thread(void *userdata) {
static void* amix_thread(void *userdata) {
gsr_audio_capture *self = userdata;
AVFrame *aframe = av_frame_alloc();
- while(*self->running) {
+ while(atomic_load(self->running)) {
pthread_mutex_lock(&self->filter_mutex);
for(size_t i = 0; i < self->num_tracks; ++i) {
gsr_audio_track *track = &self->tracks[i];
@@ -360,7 +360,7 @@ static void* amix_thread(void *userdata) {
return NULL;
}
-int gsr_audio_capture_init(gsr_audio_capture *self, gsr_encoder *encoder, gsr_recording_clock *clock, const volatile sig_atomic_t *running) {
+int gsr_audio_capture_init(gsr_audio_capture *self, gsr_encoder *encoder, gsr_recording_clock *clock, const atomic_int *running) {
memset(self, 0, sizeof(*self));
self->encoder = encoder;
self->clock = clock;
diff --git a/src/recorder/recorder.c b/src/recorder/recorder.c
index 7c45594..6f9ea12 100644
--- a/src/recorder/recorder.c
+++ b/src/recorder/recorder.c
@@ -26,6 +26,7 @@
#include <assert.h>
#include <limits.h>
#include <unistd.h>
+#include <stdatomic.h>
#include <libavutil/time.h>
#include <libavformat/avformat.h>
@@ -85,10 +86,10 @@ struct gsr_recorder {
int64_t video_prev_pts;
bool hdr_metadata_set;
- volatile sig_atomic_t running;
- volatile sig_atomic_t toggle_pause;
- volatile sig_atomic_t toggle_replay_recording;
- volatile sig_atomic_t save_replay_seconds;
+ atomic_int running;
+ atomic_int toggle_pause;
+ atomic_int toggle_replay_recording;
+ atomic_int save_replay_seconds;
bool should_stop_error;
bool force_iframe_frame;
int audio_max_frame_size;
@@ -400,7 +401,10 @@ gsr_recorder* gsr_recorder_create(const gsr_recorder_params *params, const gsr_r
self->capture_deps = params->capture_deps;
self->capture_sources = params->capture_sources;
self->audio_input_tracks = params->audio_input_tracks;
- self->running = 1;
+ atomic_init(&self->running, 1);
+ atomic_init(&self->toggle_pause, 0);
+ atomic_init(&self->toggle_replay_recording, 0);
+ atomic_init(&self->save_replay_seconds, 0);
self->audio_max_frame_size = 1024;
int error_code = GSR_ERROR_GENERIC;
self->hdr = video_codec_is_hdr(params->settings->video_codec);
@@ -465,7 +469,7 @@ static bool recorder_tick_video_sources(gsr_recorder *self) {
gsr_capture_tick(video_source->capture);
if(gsr_capture_should_stop(video_source->capture, &self->should_stop_error)) {
- self->running = 0;
+ atomic_store(&self->running, 0);
break;
}
@@ -621,23 +625,23 @@ static void recorder_capture_and_encode_frame(gsr_recorder *self, bool damaged)
}
static void recorder_apply_pause_toggle(gsr_recorder *self) {
- if(self->toggle_pause == 1 && !self->settings.is_replaying) {
+ if(atomic_load(&self->toggle_pause) == 1 && !self->settings.is_replaying) {
self->paused = !self->paused;
gsr_recording_clock_set_paused(self->recording_clock, self->paused);
gsr_log(GSR_LOG_LEVEL_INFO, self->paused ? "Paused" : "Unpaused");
- self->toggle_pause = 0;
+ atomic_store(&self->toggle_pause, 0);
}
}
static void recorder_apply_replay_recording_toggle(gsr_recorder *self) {
- if(self->toggle_replay_recording && !self->settings.replay_recording_directory) {
- self->toggle_replay_recording = 0;
+ if(atomic_load(&self->toggle_replay_recording) && !self->settings.replay_recording_directory) {
+ atomic_store(&self->toggle_replay_recording, 0);
if(self->callbacks.recording_started)
self->callbacks.recording_started(NULL, self->callbacks.userdata);
}
- if(self->toggle_replay_recording && self->settings.replay_recording_directory) {
- self->toggle_replay_recording = 0;
+ if(atomic_load(&self->toggle_replay_recording) && self->settings.replay_recording_directory) {
+ atomic_store(&self->toggle_replay_recording, 0);
const bool new_replay_recording_state = !self->replay_recording;
if(new_replay_recording_state) {
gsr_audio_capture_lock_filter(&self->audio_capture);
@@ -704,12 +708,12 @@ static void recorder_poll_replay_save(gsr_recorder *self) {
self->callbacks.replay_saved(replay_save_output_filepath[0] == '\0' || !replay_save_result ? NULL : replay_save_output_filepath, self->callbacks.userdata);
}
- if(self->save_replay_seconds != 0 && !gsr_replay_save_is_running(&self->replay_save) && self->settings.is_replaying) {
- int current_save_replay_seconds = self->save_replay_seconds;
+ if(atomic_load(&self->save_replay_seconds) != 0 && !gsr_replay_save_is_running(&self->replay_save) && self->settings.is_replaying) {
+ int current_save_replay_seconds = atomic_load(&self->save_replay_seconds);
if(current_save_replay_seconds > 0)
current_save_replay_seconds += self->settings.keyint;
- self->save_replay_seconds = 0;
+ atomic_store(&self->save_replay_seconds, 0);
const bool replay_start_result = gsr_replay_save_start(&self->replay_save, self->video_codec_context, GSR_VIDEO_STREAM_INDEX, &self->audio_capture, &self->encoder, &self->settings, self->file_extension, self->hdr, self->video_sources, current_save_replay_seconds);
if(!replay_start_result && self->callbacks.replay_saved)
self->callbacks.replay_saved(NULL, self->callbacks.userdata);
@@ -762,7 +766,7 @@ int gsr_recorder_run(gsr_recorder *self) {
if(gsr_audio_capture_start(&self->audio_capture, self->audio_max_frame_size, self->uses_amix) != GSR_ERROR_OK) {
/* The audio threads that did start have to stop before they can be joined */
- self->running = 0;
+ atomic_store(&self->running, 0);
return GSR_ERROR_GENERIC;
}
@@ -802,7 +806,7 @@ int gsr_recorder_run(gsr_recorder *self) {
}
}
- while(self->running) {
+ while(atomic_load(&self->running)) {
recorder_process_events(self);
const bool damaged = recorder_tick_video_sources(self);
recorder_update_fps_counters(self);
@@ -818,7 +822,7 @@ int gsr_recorder_run(gsr_recorder *self) {
}
static void gsr_recorder_stop_recording(gsr_recorder *self) {
- self->running = 0;
+ atomic_store(&self->running, 0);
bool final_replay_save_result = false;
const char *final_replay_save_output_filepath = NULL;
@@ -894,17 +898,17 @@ void gsr_recorder_destroy(gsr_recorder *self) {
}
void gsr_recorder_stop(gsr_recorder *self) {
- self->running = 0;
+ atomic_store(&self->running, 0);
}
void gsr_recorder_toggle_pause(gsr_recorder *self) {
- self->toggle_pause = 1;
+ atomic_store(&self->toggle_pause, 1);
}
void gsr_recorder_toggle_replay_recording(gsr_recorder *self) {
- self->toggle_replay_recording = 1;
+ atomic_store(&self->toggle_replay_recording, 1);
}
void gsr_recorder_save_replay(gsr_recorder *self, int seconds) {
- self->save_replay_seconds = seconds;
+ atomic_store(&self->save_replay_seconds, seconds);
}
diff --git a/src/recorder/replay_save.c b/src/recorder/replay_save.c
index 6e5bc7b..1d33437 100644
--- a/src/recorder/replay_save.c
+++ b/src/recorder/replay_save.c
@@ -8,7 +8,7 @@
void gsr_replay_save_init(gsr_replay_save *self) {
memset(self, 0, sizeof(*self));
- self->finished = 0;
+ atomic_init(&self->finished, 0);
}
bool gsr_replay_save_is_running(const gsr_replay_save *self) {
@@ -110,7 +110,7 @@ static void* replay_save_thread(void *userdata) {
self->success = success;
gsr_replay_save_cleanup(self);
- self->finished = 1;
+ atomic_store(&self->finished, 1);
return NULL;
}
@@ -123,7 +123,7 @@ bool gsr_replay_save_start(gsr_replay_save *self, AVCodecContext *video_codec_co
self->video_stream_index = video_stream_index;
self->output_filepath[0] = '\0';
self->success = false;
- self->finished = 0;
+ atomic_store(&self->finished, 0);
pthread_mutex_lock(&encoder->replay_mutex);
self->cloned_replay_buffer = gsr_replay_buffer_clone(encoder->replay_buffer);
@@ -193,7 +193,7 @@ static bool gsr_replay_save_finish(gsr_replay_save *self, bool *success, const c
}
bool gsr_replay_save_poll(gsr_replay_save *self, bool *success, const char **output_filepath) {
- if(!self->thread_created || !self->finished)
+ if(!self->thread_created || !atomic_load(&self->finished))
return false;
return gsr_replay_save_finish(self, success, output_filepath);
diff --git a/src/recorder/screenshot.c b/src/recorder/screenshot.c
index 47fedef..2e4357d 100644
--- a/src/recorder/screenshot.c
+++ b/src/recorder/screenshot.c
@@ -67,7 +67,7 @@ int gsr_screenshot_take(const gsr_screenshot_params *params) {
gsr_window *window = params->window;
gsr_capture_deps *capture_deps = params->capture_deps;
gsr_capture_sources *capture_sources = params->capture_sources;
- const volatile sig_atomic_t *running = params->running;
+ const atomic_int *running = params->running;
const int image_quality = video_quality_to_image_quality_value(settings->video_quality);
const gsr_color_range color_range = image_format_to_color_range(params->image_format, image_quality);
@@ -122,7 +122,7 @@ int gsr_screenshot_take(const gsr_screenshot_params *params) {
bool should_stop_error = false;
egl->glClear(0);
- while(*running) {
+ while(atomic_load(running)) {
while(gsr_window_process_event(window)) {
if(capture_deps->x11_cursor_display && settings->record_cursor)
gsr_cursor_on_event(&capture_deps->x11_cursor, gsr_window_get_event_data(window));
@@ -175,7 +175,7 @@ int gsr_screenshot_take(const gsr_screenshot_params *params) {
if(all_sources_captured)
break;
- if(*running)
+ if(atomic_load(running))
usleep(30 * 1000); // 30 ms
}
generated by cgit v1.2.3 (git 2.46.0) at 2026-08-22 22:32:58 +0000