public/gpu-screen-recorder
1
0
Fork 0
mirror of https://repo.dec05eba.com/gpu-screen-recorder synced 2026-04-06 03:26:38 +09:00
Code Issues Actions Packages Projects Releases Wiki Activity

Compare commits

base: public:5.4.0
Branches Tags
public:master
public:5.12.5 public:5.12.4 public:5.12.3 public:5.12.2 public:5.12.1 public:5.12.0 public:5.11.5 public:5.11.4 public:5.11.3 public:5.11.2 public:5.11.1 public:5.11.0 public:5.10.2 public:5.10.1 public:5.10.0 public:5.9.4 public:5.9.3 public:5.9.2 public:5.9.1 public:5.9.0 public:5.8.2 public:5.8.1 public:5.8.0 public:5.7.4 public:5.7.3 public:5.7.2 public:5.7.1 public:5.7.0 public:5.6.8 public:5.6.7 public:5.6.6 public:5.6.5 public:5.6.4 public:5.6.3 public:5.6.2 public:5.6.1 public:5.6.0 public:5.5.10 public:5.5.9 public:5.5.8 public:5.5.7 public:5.5.6 public:5.5.5 public:5.5.4 public:5.5.3 public:5.5.2 public:5.5.1 public:5.5.0 public:5.4.1 public:5.4.0 public:5.3.8 public:5.3.7 public:5.3.6 public:5.3.5 public:5.3.4 public:5.3.3 public:5.3.2 public:5.3.1 public:5.3.0 public:5.2.3 public:5.2.2 public:5.2.1 public:5.2.0 public:5.1.3 public:5.1.2 public:5.1.1 public:5.1.0 public:5.0.3 public:5.0.2 public:5.0.1 public:5.0.0 public:4.3.5 public:4.3.4 public:4.3.3 public:4.3.2 public:4.3.1 public:4.3.0 public:4.2.6 public:4.2.5 public:4.2.4 public:4.2.3 public:4.2.2 public:4.2.1 public:4.2.0 public:4.1.11
...
compare: public:5.5.0
Branches Tags
public:master
public:5.12.5 public:5.12.4 public:5.12.3 public:5.12.2 public:5.12.1 public:5.12.0 public:5.11.5 public:5.11.4 public:5.11.3 public:5.11.2 public:5.11.1 public:5.11.0 public:5.10.2 public:5.10.1 public:5.10.0 public:5.9.4 public:5.9.3 public:5.9.2 public:5.9.1 public:5.9.0 public:5.8.2 public:5.8.1 public:5.8.0 public:5.7.4 public:5.7.3 public:5.7.2 public:5.7.1 public:5.7.0 public:5.6.8 public:5.6.7 public:5.6.6 public:5.6.5 public:5.6.4 public:5.6.3 public:5.6.2 public:5.6.1 public:5.6.0 public:5.5.10 public:5.5.9 public:5.5.8 public:5.5.7 public:5.5.6 public:5.5.5 public:5.5.4 public:5.5.3 public:5.5.2 public:5.5.1 public:5.5.0 public:5.4.1 public:5.4.0 public:5.3.8 public:5.3.7 public:5.3.6 public:5.3.5 public:5.3.4 public:5.3.3 public:5.3.2 public:5.3.1 public:5.3.0 public:5.2.3 public:5.2.2 public:5.2.1 public:5.2.0 public:5.1.3 public:5.1.2 public:5.1.1 public:5.1.0 public:5.0.3 public:5.0.2 public:5.0.1 public:5.0.0 public:4.3.5 public:4.3.4 public:4.3.3 public:4.3.2 public:4.3.1 public:4.3.0 public:4.2.6 public:4.2.5 public:4.2.4 public:4.2.3 public:4.2.2 public:4.2.1 public:4.2.0 public:4.1.11

11 Commits
5.4.0 ... 5.5.0

Author SHA1 Message Date
dec05eba
c1fefb6afb 5.5.0 2025-05-04 22:01:23 +02:00
dec05eba
a409f3b3c3 Fix replay to disk not working properly when restarting replay 2025-05-04 21:52:17 +02:00
dec05eba
36c74d3411 Add -replay-storage option to specify if temporary replay data should be stored in ram or disk 2025-05-04 21:24:07 +02:00
dec05eba
2ca5f3361c Dont list region capture option if not monitors are available for capture 2025-05-03 22:50:44 +02:00
dec05eba
200c32f08a m 2025-05-03 20:43:28 +02:00
dec05eba
0cdc359931 Fix audio capture not working with noisetorch if combined with another source with some audio devices. Remove the ability to set audio track name for now. If you need this, email me 2025-05-03 19:29:04 +02:00
dec05eba
39bc110a20 Fix h264 software encoding not working 2025-05-03 14:12:10 +02:00
dec05eba
b4bbed2402 Fix build issues on older ffmpeg (disable unused vulkan encoder for now), fix incorrect wayland protocol file 2025-04-25 11:14:40 +02:00
dec05eba
06b559ecef 5.4.1 2025-04-23 19:48:42 +02:00
dec05eba
28bc8a0bd2 Update readme 2025-04-23 19:24:52 +02:00
dec05eba
15176579cb Fix replay saving freeze, unable to save replay if audio is not provided 2025-04-23 19:11:58 +02:00
22 changed files with 1044 additions and 345 deletions
Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -12,6 +12,7 @@ tests/compile_commands.json
.vscode/
build/
debug-build/
*.o
gpu-screen-recorder

9
README.md
View File

@@ -26,7 +26,7 @@ Supported image formats:
* JPEG
* PNG
This software works on X11 and Wayland on AMD, Intel and NVIDIA. Replay data is stored in RAM, not disk.
This software works on X11 and Wayland on AMD, Intel and NVIDIA. Replay data is stored in RAM by default but there is an option to store it on disk instead.
### TEMPORARY ISSUES
1) Videos are in variable framerate format. Use MPV to play such videos, otherwise you might experience stuttering in the video if you are using a buggy video player. You can try saving the video into a .mkv file instead as some software may have better support for .mkv files (such as kdenlive). You can use the "-fm cfr" option to to use constant framerate mode.
2) FLAC audio codec is disabled at the moment because of temporary issues.
@@ -85,9 +85,7 @@ These are the dependencies needed to build GPU Screen Recorder:
* libva (and libva-drm)
* libdrm
* libcap
* wayland-client
* wayland-egl
* wayland-scanner
* wayland (wayland-client, wayland-egl, wayland-scanner)
## Runtime dependencies
There are also additional dependencies needed at runtime depending on your GPU vendor:
@@ -137,7 +135,8 @@ This can be used for example to show a notification when a replay has been saved
The replay buffer is stored in ram (as encoded video), so don't use a too large replay time and/or video quality unless you have enough ram to store it.
## Recording while using replay/streaming
You can record a regular video while using replay/streaming by launching GPU Screen Recorder with the `-ro` option to specify a directory where to save the recording.\
To start/stop (and save) recording use the SIGRTMIN signal, for example `pkill -SIGRTMIN -f gpu-screen-recorder`. The name of the video will be displayed in stdout when saving the video.
To start/stop (and save) recording use the SIGRTMIN signal, for example `pkill -SIGRTMIN -f gpu-screen-recorder`. The name of the video will be displayed in stdout when saving the video.\
This way of recording while using replay/streaming is more efficient than running GPU Screen Recorder multiple times since this way it only records the screen and encodes the video once.
## Controlling GPU Screen Recorder remotely
To save a video in replay mode, you need to send signal SIGUSR1 to gpu screen recorder. You can do this by running `pkill -SIGUSR1 -f gpu-screen-recorder`.\
To stop recording send SIGINT to gpu screen recorder. You can do this by running `pkill -SIGINT -f gpu-screen-recorder` or pressing `Ctrl-C` in the terminal that runs gpu screen recorder. When recording a regular non-replay video this will also save the video.\

5
TODO
View File

@@ -278,3 +278,8 @@ Fix constant framerate not working properly on amd/intel because capture framera
It also appears to skip audio frames on nvidia wayland? why? that should be fine, but it causes video stuttering because of audio/video sync.
Add option to pass a fd (from socketpair) to use for rpc. In the rpc have a common header, with protocol version, data type and data in an enum.
Add the option to set audio track name, for example with -a "track-name:blabla|device:default_output|app:firefox"
Maybe disable qp/vbr for replay. In that case we can preallocate all replay data (for both ram and disk) and write to that directly when receiving packet (dont do that when also recording at the same time).
That could improve performance/disk write optimization and maybe even reduce ram usage because of less blocks/fragmentation.

6
include/args_parser.h
View File

@@ -8,8 +8,7 @@
typedef struct gsr_egl gsr_egl;
#define NUM_ARGS 29
#define WINDOW_STR_MAX_SIZE 128
#define NUM_ARGS 30
typedef enum {
ARG_TYPE_STRING,
@@ -68,7 +67,8 @@ typedef struct {
gsr_audio_codec audio_codec;
gsr_bitrate_mode bitrate_mode;
gsr_video_quality video_quality;
char window[WINDOW_STR_MAX_SIZE];
gsr_replay_storage replay_storage;
char window[64];
const char *container_format;
const char *filename;
const char *replay_recording_directory;

15
include/defs.h
View File

@@ -10,7 +10,7 @@ typedef enum {
GSR_GPU_VENDOR_AMD,
GSR_GPU_VENDOR_INTEL,
GSR_GPU_VENDOR_NVIDIA,
GSR_GPU_VENDOR_BROADCOM
GSR_GPU_VENDOR_BROADCOM,
} gsr_gpu_vendor;
typedef struct {
@@ -23,13 +23,13 @@ typedef enum {
GSR_MONITOR_ROT_0,
GSR_MONITOR_ROT_90,
GSR_MONITOR_ROT_180,
GSR_MONITOR_ROT_270
GSR_MONITOR_ROT_270,
} gsr_monitor_rotation;
typedef enum {
GSR_CONNECTION_X11,
GSR_CONNECTION_WAYLAND,
GSR_CONNECTION_DRM
GSR_CONNECTION_DRM,
} gsr_connection_type;
typedef enum {
@@ -88,14 +88,19 @@ typedef enum {
typedef enum {
GSR_COLOR_RANGE_LIMITED,
GSR_COLOR_RANGE_FULL
GSR_COLOR_RANGE_FULL,
} gsr_color_range;
typedef enum {
GSR_COLOR_DEPTH_8_BITS,
GSR_COLOR_DEPTH_10_BITS
GSR_COLOR_DEPTH_10_BITS,
} gsr_color_depth;
typedef enum {
GSR_REPLAY_STORAGE_RAM,
GSR_REPLAY_STORAGE_DISK,
} gsr_replay_storage;
bool video_codec_is_hdr(gsr_video_codec video_codec);
gsr_video_codec hdr_video_codec_to_sdr_video_codec(gsr_video_codec video_codec);
gsr_color_depth video_codec_to_bit_depth(gsr_video_codec video_codec);

7
include/encoder/encoder.h
View File

@@ -1,7 +1,7 @@
#ifndef GSR_ENCODER_H
#define GSR_ENCODER_H
#include "../replay_buffer.h"
#include "../replay_buffer/replay_buffer.h"
#include <stdbool.h>
#include <stdint.h>
#include <stddef.h>
@@ -23,8 +23,7 @@ typedef struct {
} gsr_encoder_recording_destination;
typedef struct {
gsr_replay_buffer replay_buffer;
bool has_replay_buffer;
gsr_replay_buffer *replay_buffer;
pthread_mutex_t file_write_mutex;
bool mutex_created;
@@ -33,7 +32,7 @@ typedef struct {
size_t recording_destination_id_counter;
} gsr_encoder;
bool gsr_encoder_init(gsr_encoder *self, size_t replay_buffer_num_packets);
bool gsr_encoder_init(gsr_encoder *self, gsr_replay_storage replay_storage, size_t replay_buffer_num_packets, double replay_buffer_time, const char *replay_directory);
void gsr_encoder_deinit(gsr_encoder *self);
void gsr_encoder_receive_packets(gsr_encoder *self, AVCodecContext *codec_context, int64_t pts, int stream_index);

41
include/replay_buffer.h
View File

@@ -1,41 +0,0 @@
#ifndef GSR_REPLAY_BUFFER_H
#define GSR_REPLAY_BUFFER_H
#include <pthread.h>
#include <stdbool.h>
#include <libavcodec/packet.h>
typedef struct {
AVPacket packet;
int ref_counter;
double timestamp;
} gsr_av_packet;
gsr_av_packet* gsr_av_packet_create(const AVPacket *av_packet, double timestamp);
gsr_av_packet* gsr_av_packet_ref(gsr_av_packet *self);
void gsr_av_packet_unref(gsr_av_packet *self);
typedef struct {
gsr_av_packet **packets;
size_t capacity_num_packets;
size_t num_packets;
size_t index;
pthread_mutex_t mutex;
bool mutex_initialized;
bool owns_mutex;
} gsr_replay_buffer;
bool gsr_replay_buffer_init(gsr_replay_buffer *self, size_t replay_buffer_num_packets);
void gsr_replay_buffer_deinit(gsr_replay_buffer *self);
bool gsr_replay_buffer_append(gsr_replay_buffer *self, const AVPacket *av_packet, double timestamp);
void gsr_replay_buffer_clear(gsr_replay_buffer *self);
gsr_av_packet* gsr_replay_buffer_get_packet_at_index(gsr_replay_buffer *self, size_t index);
/* The clone has to be deinitialized before the replay buffer it clones */
bool gsr_replay_buffer_clone(const gsr_replay_buffer *self, gsr_replay_buffer *destination);
/* Returns 0 if replay buffer is empty */
size_t gsr_replay_buffer_find_packet_index_by_time_passed(gsr_replay_buffer *self, int seconds);
/* Returns -1 if not found */
size_t gsr_replay_buffer_find_keyframe(gsr_replay_buffer *self, size_t start_index, int stream_index, bool invert_stream_index);
#endif /* GSR_REPLAY_BUFFER_H */

54
include/replay_buffer/replay_buffer.h Normal file
View File

@@ -0,0 +1,54 @@
#ifndef GSR_REPLAY_BUFFER_H
#define GSR_REPLAY_BUFFER_H
#include "../defs.h"
#include <pthread.h>
#include <stdbool.h>
#include <libavcodec/packet.h>
typedef struct gsr_replay_buffer gsr_replay_buffer;
typedef struct {
size_t packet_index;
size_t file_index;
} gsr_replay_buffer_iterator;
struct gsr_replay_buffer {
void (*destroy)(gsr_replay_buffer *self);
bool (*append)(gsr_replay_buffer *self, const AVPacket *av_packet, double timestamp);
void (*clear)(gsr_replay_buffer *self);
AVPacket* (*iterator_get_packet)(gsr_replay_buffer *self, gsr_replay_buffer_iterator iterator);
/* The returned data should be free'd with free */
uint8_t* (*iterator_get_packet_data)(gsr_replay_buffer *self, gsr_replay_buffer_iterator iterator);
/* The clone has to be destroyed before the replay buffer it clones is destroyed */
gsr_replay_buffer* (*clone)(gsr_replay_buffer *self);
/* Returns {0, 0} if replay buffer is empty */
gsr_replay_buffer_iterator (*find_packet_index_by_time_passed)(gsr_replay_buffer *self, int seconds);
/* Returns {-1, 0} if not found */
gsr_replay_buffer_iterator (*find_keyframe)(gsr_replay_buffer *self, gsr_replay_buffer_iterator start_iterator, int stream_index, bool invert_stream_index);
bool (*iterator_next)(gsr_replay_buffer *self, gsr_replay_buffer_iterator *iterator);
pthread_mutex_t mutex;
bool mutex_initialized;
gsr_replay_buffer *original_replay_buffer;
};
gsr_replay_buffer* gsr_replay_buffer_create(gsr_replay_storage replay_storage, const char *replay_directory, double replay_buffer_time, size_t replay_buffer_num_packets);
void gsr_replay_buffer_destroy(gsr_replay_buffer *self);
void gsr_replay_buffer_lock(gsr_replay_buffer *self);
void gsr_replay_buffer_unlock(gsr_replay_buffer *self);
bool gsr_replay_buffer_append(gsr_replay_buffer *self, const AVPacket *av_packet, double timestamp);
void gsr_replay_buffer_clear(gsr_replay_buffer *self);
AVPacket* gsr_replay_buffer_iterator_get_packet(gsr_replay_buffer *self, gsr_replay_buffer_iterator iterator);
/* The returned data should be free'd with free */
uint8_t* gsr_replay_buffer_iterator_get_packet_data(gsr_replay_buffer *self, gsr_replay_buffer_iterator iterator);
/* The clone has to be destroyed before the replay buffer it clones is destroyed */
gsr_replay_buffer* gsr_replay_buffer_clone(gsr_replay_buffer *self);
/* Returns {0, 0} if replay buffer is empty */
gsr_replay_buffer_iterator gsr_replay_buffer_find_packet_index_by_time_passed(gsr_replay_buffer *self, int seconds);
/* Returns {-1, 0} if not found */
gsr_replay_buffer_iterator gsr_replay_buffer_find_keyframe(gsr_replay_buffer *self, gsr_replay_buffer_iterator start_iterator, int stream_index, bool invert_stream_index);
bool gsr_replay_buffer_iterator_next(gsr_replay_buffer *self, gsr_replay_buffer_iterator *iterator);
#endif /* GSR_REPLAY_BUFFER_H */

44
include/replay_buffer/replay_buffer_disk.h Normal file
View File

@@ -0,0 +1,44 @@
#ifndef GSR_REPLAY_BUFFER_DISK_H
#define GSR_REPLAY_BUFFER_DISK_H
#include "replay_buffer.h"
#include <limits.h>
#define GSR_REPLAY_BUFFER_CAPACITY_NUM_FILES 1024
typedef struct {
AVPacket packet;
size_t data_index;
double timestamp;
} gsr_av_packet_disk;
typedef struct {
size_t id;
double start_timestamp;
double end_timestamp;
int ref_counter;
int fd;
gsr_av_packet_disk *packets;
size_t capacity_num_packets;
size_t num_packets;
} gsr_replay_buffer_file;
typedef struct {
gsr_replay_buffer replay_buffer;
double replay_buffer_time;
size_t storage_counter;
size_t storage_num_bytes_written;
int storage_fd;
gsr_replay_buffer_file *files[GSR_REPLAY_BUFFER_CAPACITY_NUM_FILES]; // GSR_REPLAY_BUFFER_CAPACITY_NUM_FILES * REPLAY_BUFFER_FILE_SIZE_BYTES = 256gb, should be enough for everybody
size_t num_files;
char replay_directory[PATH_MAX];
bool owns_directory;
} gsr_replay_buffer_disk;
gsr_replay_buffer* gsr_replay_buffer_disk_create(const char *replay_directory, double replay_buffer_time);
#endif /* GSR_REPLAY_BUFFER_DISK_H */

22
include/replay_buffer/replay_buffer_ram.h Normal file
View File

@@ -0,0 +1,22 @@
#ifndef GSR_REPLAY_BUFFER_RAM_H
#define GSR_REPLAY_BUFFER_RAM_H
#include "replay_buffer.h"
typedef struct {
AVPacket packet;
int ref_counter;
double timestamp;
} gsr_av_packet_ram;
typedef struct {
gsr_replay_buffer replay_buffer;
gsr_av_packet_ram **packets;
size_t capacity_num_packets;
size_t num_packets;
size_t index;
} gsr_replay_buffer_ram;
gsr_replay_buffer* gsr_replay_buffer_ram_create(size_t replay_buffer_num_packets);
#endif /* GSR_REPLAY_BUFFER_RAM_H */

6
meson.build
View File

@@ -1,4 +1,4 @@
project('gpu-screen-recorder', ['c', 'cpp'], version : '5.4.0', default_options : ['warning_level=2'])
project('gpu-screen-recorder', ['c', 'cpp'], version : '5.5.0', default_options : ['warning_level=2'])
add_project_arguments('-Wshadow', language : ['c', 'cpp'])
if get_option('buildtype') == 'debug'
@@ -26,6 +26,9 @@ src = [
'src/window/window.c',
'src/window/x11.c',
'src/window/wayland.c',
'src/replay_buffer/replay_buffer.c',
'src/replay_buffer/replay_buffer_ram.c',
'src/replay_buffer/replay_buffer_disk.c',
'src/egl.c',
'src/cuda.c',
'src/xnvctrl.c',
@@ -40,7 +43,6 @@ src = [
'src/image_writer.c',
'src/args_parser.c',
'src/defs.c',
'src/replay_buffer.c',
'src/sound.cpp',
'src/main.cpp',
]

2
project.conf
View File

@@ -1,7 +1,7 @@
[package]
name = "gpu-screen-recorder"
type = "executable"
version = "5.4.0"
version = "5.5.0"
platforms = ["posix"]
[config]

2
protocol/xdg-output-unstable-v1.xml
View File

@@ -151,7 +151,7 @@
summary="height in global compositor space"/>
</event>
<event name="done" deprecated-since="3">
<event name="done">
<description summary="all information about the output have been sent">
This event is sent after all other properties of an xdg_output
have been sent.

20
src/args_parser.c
View File

@@ -69,6 +69,11 @@ static const ArgEnum tune_enums[] = {
{ .name = "quality", .value = GSR_TUNE_QUALITY },
};
static const ArgEnum replay_storage_enums[] = {
{ .name = "ram", .value = GSR_REPLAY_STORAGE_RAM },
{ .name = "disk", .value = GSR_REPLAY_STORAGE_DISK },
};
static void arg_deinit(Arg *arg) {
if(arg->values) {
free(arg->values);
@@ -185,7 +190,7 @@ static double args_get_double_by_key(Arg *args, int num_args, const char *key, d
static void usage_header() {
const bool inside_flatpak = getenv("FLATPAK_ID") != NULL;
const char *program_name = inside_flatpak ? "flatpak run --command=gpu-screen-recorder com.dec05eba.gpu_screen_recorder" : "gpu-screen-recorder";
printf("usage: %s -w <window_id|monitor|focused|portal|region> [-c <container_format>] [-s WxH] [-region WxH+X+Y] [-f <fps>] [-a <audio_input>] [-q <quality>] [-r <replay_buffer_size_sec>] [-restart-replay-on-save yes|no] [-k h264|hevc|av1|vp8|vp9|hevc_hdr|av1_hdr|hevc_10bit|av1_10bit] [-ac aac|opus|flac] [-ab <bitrate>] [-oc yes|no] [-fm cfr|vfr|content] [-bm auto|qp|vbr|cbr] [-cr limited|full] [-tune performance|quality] [-df yes|no] [-sc <script_path>] [-cursor yes|no] [-keyint <value>] [-restore-portal-session yes|no] [-portal-session-token-filepath filepath] [-encoder gpu|cpu] [-o <output_file>] [-ro <output_directory>] [--list-capture-options [card_path]] [--list-audio-devices] [--list-application-audio] [-v yes|no] [-gl-debug yes|no] [--version] [-h|--help]\n", program_name);
printf("usage: %s -w <window_id|monitor|focused|portal|region> [-c <container_format>] [-s WxH] [-region WxH+X+Y] [-f <fps>] [-a <audio_input>] [-q <quality>] [-r <replay_buffer_size_sec>] [-replay-storage ram|disk] [-restart-replay-on-save yes|no] [-k h264|hevc|av1|vp8|vp9|hevc_hdr|av1_hdr|hevc_10bit|av1_10bit] [-ac aac|opus|flac] [-ab <bitrate>] [-oc yes|no] [-fm cfr|vfr|content] [-bm auto|qp|vbr|cbr] [-cr limited|full] [-tune performance|quality] [-df yes|no] [-sc <script_path>] [-cursor yes|no] [-keyint <value>] [-restore-portal-session yes|no] [-portal-session-token-filepath filepath] [-encoder gpu|cpu] [-o <output_file>] [-ro <output_directory>] [--list-capture-options [card_path]] [--list-audio-devices] [--list-application-audio] [-v yes|no] [-gl-debug yes|no] [--version] [-h|--help]\n", program_name);
fflush(stdout);
}
@@ -229,7 +234,6 @@ static void usage_full() {
printf(" -a Audio device or application to record from (pulse audio device). Can be specified multiple times. Each time this is specified a new audio track is added for the specified audio device or application.\n");
printf(" The audio device can also be \"default_output\" in which case the default output device is used, or \"default_input\" in which case the default input device is used.\n");
printf(" Multiple audio sources can be merged into one audio track by using \"|\" as a separator into one -a argument, for example: -a \"default_output|default_input\".\n");
printf(" A name can be given to the audio track by prefixing the audio with <name>/, for example \"track name/default_output\" or \"track name/default_output|default_input\".\n");
printf(" The audio name can also be prefixed with \"device:\", for example: -a \"device:default_output\".\n");
printf(" To record audio from an application then prefix the audio name with \"app:\", for example: -a \"app:Brave\". The application name is case-insensitive.\n");
printf(" To record audio from all applications except the provided ones prefix the audio name with \"app-inverse:\", for example: -a \"app-inverse:Brave\".\n");
@@ -250,9 +254,14 @@ static void usage_full() {
printf("\n");
printf(" -r Replay buffer time in seconds. If this is set, then only the last seconds as set by this option will be stored\n");
printf(" and the video will only be saved when the gpu-screen-recorder is closed. This feature is similar to Nvidia's instant replay feature This option has be between 5 and 1200.\n");
printf(" Note that the video data is stored in RAM, so don't use too long replay buffer time and use constant bitrate option (-bm cbr) to prevent RAM usage from going too high in busy scenes.\n");
printf(" Note that the video data is stored in RAM (unless -replay-storage disk is used), so don't use too long replay buffer time and use constant bitrate option (-bm cbr) to prevent RAM usage from going too high in busy scenes.\n");
printf(" Optional, disabled by default.\n");
printf("\n");
printf(" -replay-storage\n");
printf(" Specify where temporary replay is stored. Should be either 'ram' or 'disk'. If set to 'disk' then replay data is stored in temporary files in the same directory as -o.\n");
printf(" Preferably avoid setting this to 'disk' unless -o is set to a HDD, as constant writes to a SSD can reduce the life-time of the SSD.\n");
printf(" Optional, set to 'ram' by default.\n");
printf("\n");
printf(" -restart-replay-on-save\n");
printf(" Restart replay on save. For example if this is set to 'no' and replay time (-r) is set to 60 seconds and a replay is saved once then the first replay video is 60 seconds long\n");
printf(" and if a replay is saved 10 seconds later then the second replay video will also be 60 seconds long and contain 50 seconds of the previous video as well.\n");
@@ -390,6 +399,7 @@ static void usage_full() {
printf(" %s -w screen -f 60 -a default_output -a default_input -o video.mp4\n", program_name);
printf(" %s -w screen -f 60 -a \"default_output|default_input\" -o video.mp4\n", program_name);
printf(" %s -w screen -f 60 -a default_output -c mkv -r 60 -o \"$HOME/Videos\"\n", program_name);
printf(" %s -w screen -f 60 -a default_output -c mkv -r 1800 -replay-storage disk -bm cbr -q 40000 -o \"$HOME/Videos\"\n", program_name);
printf(" %s -w screen -f 60 -a default_output -c mkv -sc script.sh -r 60 -o \"$HOME/Videos\"\n", program_name);
printf(" %s -w portal -f 60 -a default_output -restore-portal-session yes -o video.mp4\n", program_name);
printf(" %s -w screen -f 60 -a default_output -bm cbr -q 15000 -o video.mp4\n", program_name);
@@ -437,6 +447,7 @@ static bool args_parser_set_values(args_parser *self) {
self->video_codec = (gsr_video_codec)args_get_enum_by_key(self->args, NUM_ARGS, "-k", GSR_VIDEO_CODEC_AUTO);
self->audio_codec = (gsr_audio_codec)args_get_enum_by_key(self->args, NUM_ARGS, "-ac", GSR_AUDIO_CODEC_OPUS);
self->bitrate_mode = (gsr_bitrate_mode)args_get_enum_by_key(self->args, NUM_ARGS, "-bm", GSR_BITRATE_MODE_AUTO);
self->replay_storage = (gsr_replay_storage)args_get_enum_by_key(self->args, NUM_ARGS, "-replay-storage", GSR_REPLAY_STORAGE_RAM);
const char *window = args_get_value_by_key(self->args, NUM_ARGS, "-w");
snprintf(self->window, sizeof(self->window), "%s", window);
@@ -713,7 +724,7 @@ bool args_parser_parse(args_parser *self, int argc, char **argv, const args_hand
self->args[arg_index++] = (Arg){ .key = "-q", .optional = true, .list = false, .type = ARG_TYPE_STRING };
self->args[arg_index++] = (Arg){ .key = "-o", .optional = true, .list = false, .type = ARG_TYPE_STRING };
self->args[arg_index++] = (Arg){ .key = "-ro", .optional = true, .list = false, .type = ARG_TYPE_STRING };
self->args[arg_index++] = (Arg){ .key = "-r", .optional = true, .list = false, .type = ARG_TYPE_I64, .integer_value_min = 2, .integer_value_max = 10800 };
self->args[arg_index++] = (Arg){ .key = "-r", .optional = true, .list = false, .type = ARG_TYPE_I64, .integer_value_min = 2, .integer_value_max = 86400 };
self->args[arg_index++] = (Arg){ .key = "-restart-replay-on-save", .optional = true, .list = false, .type = ARG_TYPE_BOOLEAN };
self->args[arg_index++] = (Arg){ .key = "-k", .optional = true, .list = false, .type = ARG_TYPE_ENUM, .enum_values = video_codec_enums, .num_enum_values = sizeof(video_codec_enums)/sizeof(ArgEnum) };
self->args[arg_index++] = (Arg){ .key = "-ac", .optional = true, .list = false, .type = ARG_TYPE_ENUM, .enum_values = audio_codec_enums, .num_enum_values = sizeof(audio_codec_enums)/sizeof(ArgEnum) };
@@ -733,6 +744,7 @@ bool args_parser_parse(args_parser *self, int argc, char **argv, const args_hand
self->args[arg_index++] = (Arg){ .key = "-restore-portal-session", .optional = true, .list = false, .type = ARG_TYPE_BOOLEAN };
self->args[arg_index++] = (Arg){ .key = "-portal-session-token-filepath", .optional = true, .list = false, .type = ARG_TYPE_STRING };
self->args[arg_index++] = (Arg){ .key = "-encoder", .optional = true, .list = false, .type = ARG_TYPE_ENUM, .enum_values = video_encoder_enums, .num_enum_values = sizeof(video_encoder_enums)/sizeof(ArgEnum) };
self->args[arg_index++] = (Arg){ .key = "-replay-storage", .optional = true, .list = false, .type = ARG_TYPE_ENUM, .enum_values = replay_storage_enums, .num_enum_values = sizeof(replay_storage_enums)/sizeof(ArgEnum) };
assert(arg_index == NUM_ARGS);
for(int i = 1; i < argc; i += 2) {

2
src/codec_query/vaapi.c
View File

@@ -116,7 +116,7 @@ static bool get_supported_video_codecs(VADisplay va_dpy, gsr_supported_video_cod
int va_minor = 0;
if(vaInitialize(va_dpy, &va_major, &va_minor) != VA_STATUS_SUCCESS) {
fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vaapi: vaInitialize failed\n");
goto fail;
return false;
}
int num_profiles = vaMaxNumProfiles(va_dpy);

17
src/encoder/encoder.c
View File

@@ -7,7 +7,7 @@
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
bool gsr_encoder_init(gsr_encoder *self, size_t replay_buffer_num_packets) {
bool gsr_encoder_init(gsr_encoder *self, gsr_replay_storage replay_storage, size_t replay_buffer_num_packets, double replay_buffer_time, const char *replay_directory) {
memset(self, 0, sizeof(*self));
self->num_recording_destinations = 0;
self->recording_destination_id_counter = 0;
@@ -19,12 +19,12 @@ bool gsr_encoder_init(gsr_encoder *self, size_t replay_buffer_num_packets) {
self->mutex_created = true;
if(replay_buffer_num_packets > 0) {
if(!gsr_replay_buffer_init(&self->replay_buffer, replay_buffer_num_packets)) {
self->replay_buffer = gsr_replay_buffer_create(replay_storage, replay_directory, replay_buffer_time, replay_buffer_num_packets);
if(!self->replay_buffer) {
fprintf(stderr, "gsr error: gsr_encoder_init: failed to create replay buffer\n");
gsr_encoder_deinit(self);
return false;
}
self->has_replay_buffer = true;
}
return true;
@@ -36,8 +36,11 @@ void gsr_encoder_deinit(gsr_encoder *self) {
pthread_mutex_destroy(&self->file_write_mutex);
}
gsr_replay_buffer_deinit(&self->replay_buffer);
self->has_replay_buffer = false;
if(self->replay_buffer) {
gsr_replay_buffer_destroy(self->replay_buffer);
self->replay_buffer = NULL;
}
self->num_recording_destinations = 0;
self->recording_destination_id_counter = 0;
}
@@ -56,9 +59,9 @@ void gsr_encoder_receive_packets(gsr_encoder *self, AVCodecContext *codec_contex
av_packet->pts = pts;
av_packet->dts = pts;
if(self->has_replay_buffer) {
if(self->replay_buffer) {
const double time_now = clock_get_monotonic_seconds();
if(!gsr_replay_buffer_append(&self->replay_buffer, av_packet, time_now))
if(!gsr_replay_buffer_append(self->replay_buffer, av_packet, time_now))
fprintf(stderr, "gsr error: gsr_encoder_receive_packets: failed to add replay buffer data\n");
}

7
src/encoder/video/vulkan.c
View File

@@ -23,7 +23,7 @@ static bool gsr_video_encoder_vulkan_setup_context(gsr_video_encoder_vulkan *sel
AVDictionary *options = NULL;
//av_dict_set(&options, "linear_images", "1", 0);
//av_dict_set(&options, "disable_multiplane", "1", 0);
#if 0
// TODO: Use correct device
if(av_hwdevice_ctx_create(&self->device_ctx, AV_HWDEVICE_TYPE_VULKAN, NULL, options, 0) < 0) {
fprintf(stderr, "gsr error: gsr_video_encoder_vulkan_setup_context: failed to create hardware device context\n");
@@ -57,6 +57,7 @@ static bool gsr_video_encoder_vulkan_setup_context(gsr_video_encoder_vulkan *sel
video_codec_context->hw_frames_ctx = av_buffer_ref(frame_context);
av_buffer_unref(&frame_context);
#endif
return true;
}
@@ -99,7 +100,7 @@ static bool gsr_video_encoder_vulkan_setup_textures(gsr_video_encoder_vulkan *se
}
while(self->params.egl->glGetError()) {}
#if 0
AVVkFrame *target_surface_id = (AVVkFrame*)frame->data[0];
AVVulkanDeviceContext* vv = video_codec_context_get_vulkan_data(video_codec_context);
const size_t luma_size = frame->width * frame->height;
@@ -224,7 +225,7 @@ static bool gsr_video_encoder_vulkan_setup_textures(gsr_video_encoder_vulkan *se
fprintf(stderr, "3 gl error: %d\n", self->params.egl->glGetError());
self->params.egl->glBindTexture(GL_TEXTURE_2D, 0);
}
#endif
return true;
}

129
src/main.cpp
View File

@@ -32,7 +32,6 @@ extern "C" {
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#include <thread>
#include <mutex>
#include <signal.h>
@@ -41,6 +40,7 @@ extern "C" {
#include <sys/wait.h>
#include <inttypes.h>
#include <libgen.h>
#include <malloc.h>
#include "../include/sound.hpp"
@@ -658,7 +658,7 @@ static void open_video_software(AVCodecContext *codec_context, const args_parser
av_dict_set(&options, "preset", "veryfast", 0);
av_dict_set(&options, "tune", "film", 0);
dict_set_profile(codec_context, GSR_GPU_VENDOR_INTEL, color_depth, GSR_VIDEO_CODEC_H264, &options);
av_dict_set(&options, "profile", "high", 0);
if(codec_context->codec_id == AV_CODEC_ID_H264) {
av_dict_set(&options, "coder", "cabac", 0); // TODO: cavlc is faster than cabac but worse compression. Which to use?
@@ -1262,24 +1262,24 @@ static void save_replay_async(AVCodecContext *video_codec_context, int video_str
if(save_replay_thread.valid())
return;
const size_t search_start_index = current_save_replay_seconds == save_replay_seconds_full ? 0 : gsr_replay_buffer_find_packet_index_by_time_passed(replay_buffer, current_save_replay_seconds);
const size_t video_start_index = gsr_replay_buffer_find_keyframe(replay_buffer, search_start_index, video_stream_index, false);
if(video_start_index == (size_t)-1) {
const gsr_replay_buffer_iterator search_start_iterator = current_save_replay_seconds == save_replay_seconds_full ? gsr_replay_buffer_iterator{0, 0} : gsr_replay_buffer_find_packet_index_by_time_passed(replay_buffer, current_save_replay_seconds);
const gsr_replay_buffer_iterator video_start_iterator = gsr_replay_buffer_find_keyframe(replay_buffer, search_start_iterator, video_stream_index, false);
if(video_start_iterator.packet_index == (size_t)-1) {
fprintf(stderr, "gsr error: failed to save replay: failed to find a video keyframe. perhaps replay was saved too fast, before anything has been recorded\n");
return;
}
const size_t audio_start_index = gsr_replay_buffer_find_keyframe(replay_buffer, video_start_index, video_stream_index, true);
if(audio_start_index == (size_t)-1) {
fprintf(stderr, "gsr error: failed to save replay: failed to find an audio keyframe. perhaps replay was saved too fast, before anything has been recorded\n");
return;
}
const gsr_replay_buffer_iterator audio_start_iterator = gsr_replay_buffer_find_keyframe(replay_buffer, video_start_iterator, video_stream_index, true);
// if(audio_start_index == (size_t)-1) {
// fprintf(stderr, "gsr error: failed to save replay: failed to find an audio keyframe. perhaps replay was saved too fast, before anything has been recorded\n");
// return;
// }
const int64_t video_pts_offset = gsr_replay_buffer_get_packet_at_index(replay_buffer, video_start_index)->packet.pts;
const int64_t audio_pts_offset = gsr_replay_buffer_get_packet_at_index(replay_buffer, audio_start_index)->packet.pts;
const int64_t video_pts_offset = gsr_replay_buffer_iterator_get_packet(replay_buffer, video_start_iterator)->pts;
const int64_t audio_pts_offset = audio_start_iterator.packet_index == (size_t)-1 ? 0 : gsr_replay_buffer_iterator_get_packet(replay_buffer, audio_start_iterator)->pts;
gsr_replay_buffer cloned_replay_buffer;
if(!gsr_replay_buffer_clone(replay_buffer, &cloned_replay_buffer)) {
gsr_replay_buffer *cloned_replay_buffer = gsr_replay_buffer_clone(replay_buffer);
if(!cloned_replay_buffer) {
// TODO: Return this error to mark the replay as failed
fprintf(stderr, "gsr error: failed to save replay: failed to clone replay buffer\n");
return;
@@ -1292,20 +1292,35 @@ static void save_replay_async(AVCodecContext *video_codec_context, int video_str
save_replay_output_filepath = std::move(output_filepath);
save_replay_thread = std::async(std::launch::async, [video_stream_index, recording_start_result, video_start_index, video_pts_offset, audio_pts_offset, video_codec_context, cloned_replay_buffer]() mutable {
for(size_t i = video_start_index; i < cloned_replay_buffer.num_packets; ++i) {
const gsr_av_packet *packet = gsr_replay_buffer_get_packet_at_index(&cloned_replay_buffer, i);
save_replay_thread = std::async(std::launch::async, [video_stream_index, recording_start_result, video_start_iterator, video_pts_offset, audio_pts_offset, video_codec_context, cloned_replay_buffer]() mutable {
gsr_replay_buffer_iterator replay_iterator = video_start_iterator;
for(;;) {
AVPacket *replay_packet = gsr_replay_buffer_iterator_get_packet(cloned_replay_buffer, replay_iterator);
uint8_t *replay_packet_data = NULL;
if(replay_packet)
replay_packet_data = gsr_replay_buffer_iterator_get_packet_data(cloned_replay_buffer, replay_iterator);
if(!replay_packet) {
fprintf(stderr, "gsr error: save_replay_async: no replay packet\n");
break;
}
if(!replay_packet->data && !replay_packet_data) {
fprintf(stderr, "gsr error: save_replay_async: no replay packet data\n");
break;
}
// TODO: Check if successful
AVPacket av_packet;
memset(&av_packet, 0, sizeof(av_packet));
//av_packet_from_data(av_packet, packet->packet.data, packet->packet.size);
av_packet.data = packet->packet.data;
av_packet.size = packet->packet.size;
av_packet.stream_index = packet->packet.stream_index;
av_packet.pts = packet->packet.pts;
av_packet.dts = packet->packet.pts;
av_packet.flags = packet->packet.flags;
//av_packet.duration = packet->packet.duration;
//av_packet_from_data(av_packet, replay_packet->data, replay_packet->size);
av_packet.data = replay_packet->data ? replay_packet->data : replay_packet_data;
av_packet.size = replay_packet->size;
av_packet.stream_index = replay_packet->stream_index;
av_packet.pts = replay_packet->pts;
av_packet.dts = replay_packet->pts;
av_packet.flags = replay_packet->flags;
//av_packet.duration = replay_packet->duration;
AVStream *stream = recording_start_result.video_stream;
AVCodecContext *codec_context = video_codec_context;
@@ -1317,8 +1332,10 @@ static void save_replay_async(AVCodecContext *video_codec_context, int video_str
RecordingStartAudio *recording_start_audio = get_recording_start_item_by_stream_index(recording_start_result, av_packet.stream_index);
if(!recording_start_audio) {
fprintf(stderr, "gsr error: save_replay_async: failed to find audio stream by index: %d\n", av_packet.stream_index);
free(replay_packet_data);
continue;
}
const AudioTrack *audio_track = recording_start_audio->audio_track;
stream = recording_start_audio->stream;
codec_context = audio_track->codec_context;
@@ -1332,13 +1349,17 @@ static void save_replay_async(AVCodecContext *video_codec_context, int video_str
const int ret = av_write_frame(recording_start_result.av_format_context, &av_packet);
if(ret < 0)
fprintf(stderr, "Error: Failed to write frame index %d to muxer, reason: %s (%d)\n", packet->packet.stream_index, av_error_to_string(ret), ret);
fprintf(stderr, "Error: Failed to write frame index %d to muxer, reason: %s (%d)\n", av_packet.stream_index, av_error_to_string(ret), ret);
free(replay_packet_data);
//av_packet_free(&av_packet);
if(!gsr_replay_buffer_iterator_next(cloned_replay_buffer, &replay_iterator))
break;
}
stop_recording_close_streams(recording_start_result.av_format_context);
gsr_replay_buffer_deinit(&cloned_replay_buffer);
gsr_replay_buffer_destroy(cloned_replay_buffer);
});
}
@@ -1375,19 +1396,8 @@ static const AudioDevice* get_audio_device_by_name(const std::vector<AudioDevice
return nullptr;
}
static MergedAudioInputs parse_audio_input_arg(const char *str, const AudioDevices &audio_devices) {
static MergedAudioInputs parse_audio_input_arg(const char *str) {
MergedAudioInputs result;
const bool name_is_existing_audio_device = get_audio_device_by_name(audio_devices.audio_inputs, str) != nullptr;
if(name_is_existing_audio_device) {
result.audio_inputs.push_back({str, AudioInputType::DEVICE, false});
return result;
}
const char *track_name_sep_ptr = strchr(str, '/');
if(track_name_sep_ptr) {
result.track_name.assign(str, track_name_sep_ptr - str);
str = track_name_sep_ptr + 1;
}
split_string(str, '|', [&](const char *sub, size_t size) {
AudioInput audio_input;
@@ -1790,10 +1800,11 @@ static bool monitor_capture_use_drm(const gsr_window *window, gsr_gpu_vendor ven
typedef struct {
const gsr_window *window;
int num_monitors;
} capture_options_callback;
static void output_monitor_info(const gsr_monitor *monitor, void *userdata) {
const capture_options_callback *options = (capture_options_callback*)userdata;
capture_options_callback *options = (capture_options_callback*)userdata;
if(gsr_window_get_display_server(options->window) == GSR_DISPLAY_SERVER_WAYLAND) {
vec2i monitor_size = monitor->size;
gsr_monitor_rotation monitor_rotation = GSR_MONITOR_ROT_0;
@@ -1805,6 +1816,7 @@ static void output_monitor_info(const gsr_monitor *monitor, void *userdata) {
} else {
printf("%.*s|%dx%d\n", monitor->name_len, monitor->name, monitor->size.x, monitor->size.y);
}
++options->num_monitors;
}
static void list_supported_capture_options(const gsr_window *window, const char *card_path, bool list_monitors) {
@@ -1813,16 +1825,19 @@ static void list_supported_capture_options(const gsr_window *window, const char
puts("window");
puts("focused");
}
puts("region");
capture_options_callback options;
options.window = window;
options.num_monitors = 0;
if(list_monitors) {
capture_options_callback options;
options.window = window;
const bool is_x11 = gsr_window_get_display_server(window) == GSR_DISPLAY_SERVER_X11;
const gsr_connection_type connection_type = is_x11 ? GSR_CONNECTION_X11 : GSR_CONNECTION_DRM;
for_each_active_monitor_output(window, card_path, connection_type, output_monitor_info, &options);
}
if(options.num_monitors > 0)
puts("region");
#ifdef GSR_PORTAL
// Desktop portal capture on x11 doesn't seem to be hardware accelerated
if(!wayland)
@@ -2379,7 +2394,7 @@ static std::vector<MergedAudioInputs> parse_audio_inputs(const AudioDevices &aud
if(!audio_input || audio_input[0] == '\0')
continue;
requested_audio_inputs.push_back(parse_audio_input_arg(audio_input, audio_devices));
requested_audio_inputs.push_back(parse_audio_input_arg(audio_input));
for(AudioInput &request_audio_input : requested_audio_inputs.back().audio_inputs) {
if(request_audio_input.type != AudioInputType::DEVICE)
continue;
@@ -2896,8 +2911,24 @@ static size_t calculate_estimated_replay_buffer_packets(int64_t replay_buffer_si
return replay_buffer_size_secs * (fps + audio_fps * audio_inputs.size());
}
static void set_display_server_environment_variables() {
// Some users dont have properly setup environments (no display manager that does systemctl --user import-environment DISPLAY WAYLAND_DISPLAY)
const char *display = getenv("DISPLAY");
if(!display) {
display = ":0";
setenv("DISPLAY", display, true);
}
const char *wayland_display = getenv("WAYLAND_DISPLAY");
if(!wayland_display) {
wayland_display = "wayland-1";
setenv("WAYLAND_DISPLAY", wayland_display, true);
}
}
int main(int argc, char **argv) {
setlocale(LC_ALL, "C"); // Sigh... stupid C
mallopt(M_MMAP_THRESHOLD, 65536);
signal(SIGINT, stop_handler);
signal(SIGTERM, stop_handler);
@@ -2911,6 +2942,8 @@ int main(int argc, char **argv) {
signal(SIGRTMIN+5, save_replay_10_minutes_handler);
signal(SIGRTMIN+6, save_replay_30_minutes_handler);
set_display_server_environment_variables();
// Stop nvidia driver from buffering frames
setenv("__GL_MaxFramesAllowed", "1", true);
// If this is set to 1 then cuGraphicsGLRegisterImage will fail for egl context with error: invalid OpenGL or DirectX context,
@@ -3147,7 +3180,7 @@ int main(int argc, char **argv) {
const size_t estimated_replay_buffer_packets = calculate_estimated_replay_buffer_packets(arg_parser.replay_buffer_size_secs, arg_parser.fps, arg_parser.audio_codec, requested_audio_inputs);
gsr_encoder encoder;
if(!gsr_encoder_init(&encoder, estimated_replay_buffer_packets)) {
if(!gsr_encoder_init(&encoder, arg_parser.replay_storage, estimated_replay_buffer_packets, arg_parser.replay_buffer_size_secs, arg_parser.filename)) {
fprintf(stderr, "Error: failed to create encoder\n");
_exit(1);
}
@@ -3618,7 +3651,6 @@ int main(int argc, char **argv) {
if(force_iframe_frame) {
video_frame->pict_type = AV_PICTURE_TYPE_I;
video_frame->flags |= AV_FRAME_FLAG_KEY;
}
int ret = avcodec_send_frame(video_codec_context, video_frame);
@@ -3632,7 +3664,6 @@ int main(int argc, char **argv) {
if(force_iframe_frame) {
force_iframe_frame = false;
video_frame->pict_type = AV_PICTURE_TYPE_NONE;
video_frame->flags &= ~AV_FRAME_FLAG_KEY;
}
}
@@ -3728,10 +3759,10 @@ int main(int argc, char **argv) {
save_replay_seconds = 0;
save_replay_output_filepath.clear();
save_replay_async(video_codec_context, VIDEO_STREAM_INDEX, audio_tracks, &encoder.replay_buffer, arg_parser.filename, arg_parser.container_format, file_extension, arg_parser.date_folders, hdr, capture, current_save_replay_seconds);
save_replay_async(video_codec_context, VIDEO_STREAM_INDEX, audio_tracks, encoder.replay_buffer, arg_parser.filename, arg_parser.container_format, file_extension, arg_parser.date_folders, hdr, capture, current_save_replay_seconds);
if(arg_parser.restart_replay_on_save && current_save_replay_seconds == save_replay_seconds_full) {
gsr_replay_buffer_clear(&encoder.replay_buffer);
gsr_replay_buffer_clear(encoder.replay_buffer);
replay_start_time = clock_get_monotonic_seconds() - paused_time_offset;
}
}

219
src/replay_buffer.c
View File

@@ -1,219 +0,0 @@
#include "../include/replay_buffer.h"
#include "../include/utils.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <libavutil/mem.h>
gsr_av_packet* gsr_av_packet_create(const AVPacket *av_packet, double timestamp) {
gsr_av_packet *self = malloc(sizeof(gsr_av_packet));
if(!self)
return NULL;
self->ref_counter = 1;
self->packet = *av_packet;
// Why are we doing this you ask? there is a new ffmpeg bug that causes cpu usage to increase over time when you have
// packets that are not being free'd until later. So we copy the packet data, free the packet and then reconstruct
// the packet later on when we need it, to keep packets alive only for a short period.
self->packet.data = av_memdup(av_packet->data, av_packet->size);
self->timestamp = timestamp;
if(!self->packet.data) {
free(self);
return NULL;
}
return self;
}
gsr_av_packet* gsr_av_packet_ref(gsr_av_packet *self) {
if(self->ref_counter >= 1)
++self->ref_counter;
return self;
}
static void gsr_av_packet_free(gsr_av_packet *self) {
self->ref_counter = 0;
if(self->packet.data) {
av_free(self->packet.data);
self->packet.data = NULL;
}
free(self);
}
void gsr_av_packet_unref(gsr_av_packet *self) {
if(self->ref_counter >= 1)
--self->ref_counter;
if(self->ref_counter <= 0)
gsr_av_packet_free(self);
}
bool gsr_replay_buffer_init(gsr_replay_buffer *self, size_t replay_buffer_num_packets) {
assert(replay_buffer_num_packets > 0);
memset(self, 0, sizeof(*self));
self->mutex_initialized = false;
self->owns_mutex = true;
if(pthread_mutex_init(&self->mutex, NULL) != 0)
return false;
self->mutex_initialized = true;
self->capacity_num_packets = replay_buffer_num_packets;
self->num_packets = 0;
self->index = 0;
self->packets = calloc(self->capacity_num_packets, sizeof(gsr_av_packet*));
if(!self->packets) {
gsr_replay_buffer_deinit(self);
return false;
}
return true;
}
void gsr_replay_buffer_deinit(gsr_replay_buffer *self) {
if(self->mutex_initialized)
pthread_mutex_lock(&self->mutex);
for(size_t i = 0; i < self->num_packets; ++i) {
if(self->packets[i]) {
gsr_av_packet_unref(self->packets[i]);
self->packets[i] = NULL;
}
}
self->num_packets = 0;
if(self->mutex_initialized)
pthread_mutex_unlock(&self->mutex);
if(self->packets) {
free(self->packets);
self->packets = NULL;
}
self->capacity_num_packets = 0;
self->index = 0;
if(self->mutex_initialized && self->owns_mutex) {
pthread_mutex_destroy(&self->mutex);
self->mutex_initialized = false;
}
}
bool gsr_replay_buffer_append(gsr_replay_buffer *self, const AVPacket *av_packet, double timestamp) {
pthread_mutex_lock(&self->mutex);
gsr_av_packet *packet = gsr_av_packet_create(av_packet, timestamp);
if(!packet) {
pthread_mutex_unlock(&self->mutex);
return false;
}
if(self->packets[self->index]) {
gsr_av_packet_unref(self->packets[self->index]);
self->packets[self->index] = NULL;
}
self->packets[self->index] = packet;
self->index = (self->index + 1) % self->capacity_num_packets;
++self->num_packets;
if(self->num_packets > self->capacity_num_packets)
self->num_packets = self->capacity_num_packets;
pthread_mutex_unlock(&self->mutex);
return true;
}
void gsr_replay_buffer_clear(gsr_replay_buffer *self) {
pthread_mutex_lock(&self->mutex);
for(size_t i = 0; i < self->num_packets; ++i) {
if(self->packets[i]) {
gsr_av_packet_unref(self->packets[i]);
self->packets[i] = NULL;
}
}
self->num_packets = 0;
self->index = 0;
pthread_mutex_unlock(&self->mutex);
}
gsr_av_packet* gsr_replay_buffer_get_packet_at_index(gsr_replay_buffer *self, size_t index) {
assert(index < self->num_packets);
size_t start_index = 0;
if(self->num_packets < self->capacity_num_packets)
start_index = self->num_packets - self->index;
else
start_index = self->index;
const size_t offset = (start_index + index) % self->capacity_num_packets;
return self->packets[offset];
}
bool gsr_replay_buffer_clone(const gsr_replay_buffer *self, gsr_replay_buffer *destination) {
pthread_mutex_lock(&destination->mutex);
memset(destination, 0, sizeof(*destination));
destination->owns_mutex = false;
destination->mutex = self->mutex;
destination->capacity_num_packets = self->capacity_num_packets;
destination->mutex_initialized = self->mutex_initialized;
destination->index = self->index;
destination->packets = calloc(destination->capacity_num_packets, sizeof(gsr_av_packet*));
if(!destination->packets) {
pthread_mutex_unlock(&destination->mutex);
return false;
}
destination->num_packets = self->num_packets;
for(size_t i = 0; i < destination->num_packets; ++i) {
destination->packets[i] = gsr_av_packet_ref(self->packets[i]);
}
pthread_mutex_unlock(&destination->mutex);
return true;
}
/* Binary search */
size_t gsr_replay_buffer_find_packet_index_by_time_passed(gsr_replay_buffer *self, int seconds) {
pthread_mutex_lock(&self->mutex);
const double now = clock_get_monotonic_seconds();
if(self->num_packets == 0) {
pthread_mutex_unlock(&self->mutex);
return 0;
}
size_t lower_bound = 0;
size_t upper_bound = self->num_packets;
size_t index = 0;
for(;;) {
index = lower_bound + (upper_bound - lower_bound) / 2;
const gsr_av_packet *packet = gsr_replay_buffer_get_packet_at_index(self, index);
const double time_passed_since_packet = now - packet->timestamp;
if(time_passed_since_packet >= seconds) {
if(lower_bound == index)
break;
lower_bound = index;
} else {
if(upper_bound == index)
break;
upper_bound = index;
}
}
pthread_mutex_unlock(&self->mutex);
return index;
}
size_t gsr_replay_buffer_find_keyframe(gsr_replay_buffer *self, size_t start_index, int stream_index, bool invert_stream_index) {
assert(start_index < self->num_packets);
size_t keyframe_index = (size_t)-1;
pthread_mutex_lock(&self->mutex);
for(size_t i = start_index; i < self->num_packets; ++i) {
const gsr_av_packet *packet = gsr_replay_buffer_get_packet_at_index(self, i);
if((packet->packet.flags & AV_PKT_FLAG_KEY) && (invert_stream_index ? packet->packet.stream_index != stream_index : packet->packet.stream_index == stream_index)) {
keyframe_index = i;
break;
}
}
pthread_mutex_unlock(&self->mutex);
return keyframe_index;
}

91
src/replay_buffer/replay_buffer.c Normal file
View File

@@ -0,0 +1,91 @@
#include "../../include/replay_buffer/replay_buffer.h"
#include "../../include/replay_buffer/replay_buffer_ram.h"
#include "../../include/replay_buffer/replay_buffer_disk.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
gsr_replay_buffer* gsr_replay_buffer_create(gsr_replay_storage replay_storage, const char *replay_directory, double replay_buffer_time, size_t replay_buffer_num_packets) {
gsr_replay_buffer *replay_buffer = NULL;
switch(replay_storage) {
case GSR_REPLAY_STORAGE_RAM:
replay_buffer = gsr_replay_buffer_ram_create(replay_buffer_num_packets);
break;
case GSR_REPLAY_STORAGE_DISK:
replay_buffer = gsr_replay_buffer_disk_create(replay_directory, replay_buffer_time);
break;
}
replay_buffer->mutex_initialized = false;
replay_buffer->original_replay_buffer = NULL;
if(pthread_mutex_init(&replay_buffer->mutex, NULL) != 0) {
gsr_replay_buffer_destroy(replay_buffer);
return NULL;
}
replay_buffer->mutex_initialized = true;
return replay_buffer;
}
void gsr_replay_buffer_destroy(gsr_replay_buffer *self) {
self->destroy(self);
if(self->mutex_initialized && !self->original_replay_buffer) {
pthread_mutex_destroy(&self->mutex);
self->mutex_initialized = false;
}
self->original_replay_buffer = NULL;
free(self);
}
void gsr_replay_buffer_lock(gsr_replay_buffer *self) {
if(self->original_replay_buffer) {
gsr_replay_buffer_lock(self->original_replay_buffer);
return;
}
if(self->mutex_initialized)
pthread_mutex_lock(&self->mutex);
}
void gsr_replay_buffer_unlock(gsr_replay_buffer *self) {
if(self->original_replay_buffer) {
gsr_replay_buffer_unlock(self->original_replay_buffer);
return;
}
if(self->mutex_initialized)
pthread_mutex_unlock(&self->mutex);
}
bool gsr_replay_buffer_append(gsr_replay_buffer *self, const AVPacket *av_packet, double timestamp) {
return self->append(self, av_packet, timestamp);
}
void gsr_replay_buffer_clear(gsr_replay_buffer *self) {
self->clear(self);
}
AVPacket* gsr_replay_buffer_iterator_get_packet(gsr_replay_buffer *self, gsr_replay_buffer_iterator iterator) {
return self->iterator_get_packet(self, iterator);
}
uint8_t* gsr_replay_buffer_iterator_get_packet_data(gsr_replay_buffer *self, gsr_replay_buffer_iterator iterator) {
return self->iterator_get_packet_data(self, iterator);
}
gsr_replay_buffer* gsr_replay_buffer_clone(gsr_replay_buffer *self) {
return self->clone(self);
}
gsr_replay_buffer_iterator gsr_replay_buffer_find_packet_index_by_time_passed(gsr_replay_buffer *self, int seconds) {
return self->find_packet_index_by_time_passed(self, seconds);
}
gsr_replay_buffer_iterator gsr_replay_buffer_find_keyframe(gsr_replay_buffer *self, gsr_replay_buffer_iterator start_iterator, int stream_index, bool invert_stream_index) {
return self->find_keyframe(self, start_iterator, stream_index, invert_stream_index);
}
bool gsr_replay_buffer_iterator_next(gsr_replay_buffer *self, gsr_replay_buffer_iterator *iterator) {
return self->iterator_next(self, iterator);
}

434
src/replay_buffer/replay_buffer_disk.c Normal file
View File

@@ -0,0 +1,434 @@
#include "../../include/replay_buffer/replay_buffer_disk.h"
#include "../../include/utils.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <time.h>
#include <errno.h>
#include <assert.h>
#define REPLAY_BUFFER_FILE_SIZE_BYTES 1024 * 1024 * 256 /* 256MB */
#define FILE_PREFIX "Replay"
static void gsr_replay_buffer_disk_set_impl_funcs(gsr_replay_buffer_disk *self);
static void gsr_av_packet_disk_init(gsr_av_packet_disk *self, const AVPacket *av_packet, size_t data_index, double timestamp) {
self->packet = *av_packet;
self->packet.data = NULL;
self->data_index = data_index;
self->timestamp = timestamp;
}
static gsr_replay_buffer_file* gsr_replay_buffer_file_create(char *replay_directory, size_t replay_storage_counter, double timestamp, int *replay_storage_fd) {
gsr_replay_buffer_file *self = calloc(1, sizeof(gsr_replay_buffer_file));
if(!self) {
fprintf(stderr, "gsr error: gsr_av_packet_file_init: failed to create buffer file\n");
return NULL;
}
if(create_directory_recursive(replay_directory) != 0) {
fprintf(stderr, "gsr error: gsr_av_packet_file_init: failed to create replay directory: %s\n", replay_directory);
free(self);
return NULL;
}
char filename[PATH_MAX];
snprintf(filename, sizeof(filename), "%s/%s_%d.mp4", replay_directory, FILE_PREFIX, (int)replay_storage_counter);
*replay_storage_fd = creat(filename, 0700);
if(*replay_storage_fd <= 0) {
fprintf(stderr, "gsr error: gsr_av_packet_file_init: failed to create replay file: %s\n", filename);
free(self);
return NULL;
}
self->id = replay_storage_counter;
self->start_timestamp = timestamp;
self->end_timestamp = timestamp;
self->ref_counter = 1;
self->fd = -1;
self->packets = NULL;
self->capacity_num_packets = 0;
self->num_packets = 0;
return self;
}
static gsr_replay_buffer_file* gsr_replay_buffer_file_ref(gsr_replay_buffer_file *self) {
if(self->ref_counter >= 1)
++self->ref_counter;
return self;
}
static void gsr_replay_buffer_file_free(gsr_replay_buffer_file *self, const char *replay_directory) {
self->ref_counter = 0;
if(self->fd > 0) {
close(self->fd);
self->fd = -1;
}
char filename[PATH_MAX];
snprintf(filename, sizeof(filename), "%s/%s_%d.mp4", replay_directory, FILE_PREFIX, (int)self->id);
remove(filename);
if(self->packets) {
free(self->packets);
self->packets = NULL;
}
self->num_packets = 0;
self->capacity_num_packets = 0;
free(self);
}
static void gsr_replay_buffer_file_unref(gsr_replay_buffer_file *self, const char *replay_directory) {
if(self->ref_counter > 0)
--self->ref_counter;
if(self->ref_counter <= 0)
gsr_replay_buffer_file_free(self, replay_directory);
}
static void gsr_replay_buffer_disk_clear(gsr_replay_buffer *replay_buffer) {
gsr_replay_buffer_disk *self = (gsr_replay_buffer_disk*)replay_buffer;
gsr_replay_buffer_lock(&self->replay_buffer);
for(size_t i = 0; i < self->num_files; ++i) {
gsr_replay_buffer_file_unref(self->files[i], self->replay_directory);
}
self->num_files = 0;
if(self->storage_fd > 0) {
close(self->storage_fd);
self->storage_fd = 0;
}
self->storage_num_bytes_written = 0;
gsr_replay_buffer_unlock(&self->replay_buffer);
}
static void gsr_replay_buffer_disk_destroy(gsr_replay_buffer *replay_buffer) {
gsr_replay_buffer_disk *self = (gsr_replay_buffer_disk*)replay_buffer;
gsr_replay_buffer_disk_clear(replay_buffer);
if(self->owns_directory) {
remove(self->replay_directory);
self->owns_directory = false;
}
}
static bool file_write_all(int fd, const uint8_t *data, size_t size, size_t *bytes_written_total) {
*bytes_written_total = 0;
while(*bytes_written_total < size) {
const ssize_t bytes_written = write(fd, data + *bytes_written_total, size - *bytes_written_total);
if(bytes_written == -1) {
if(errno == EAGAIN)
continue;
else
return false;
}
*bytes_written_total += bytes_written;
}
return true;
}
static bool gsr_replay_buffer_disk_create_next_file(gsr_replay_buffer_disk *self, double timestamp) {
if(self->num_files + 1 >= GSR_REPLAY_BUFFER_CAPACITY_NUM_FILES) {
fprintf(stderr, "gsr error: gsr_replay_buffer_disk_create_next_file: too many replay buffer files created! (> %d), either reduce the replay buffer time or report this as a bug\n", (int)GSR_REPLAY_BUFFER_CAPACITY_NUM_FILES);
return false;
}
gsr_replay_buffer_file *replay_buffer_file = gsr_replay_buffer_file_create(self->replay_directory, self->storage_counter, timestamp, &self->storage_fd);
if(!replay_buffer_file)
return false;
self->files[self->num_files] = replay_buffer_file;
++self->num_files;
++self->storage_counter;
return true;
}
static bool gsr_replay_buffer_disk_append_to_current_file(gsr_replay_buffer_disk *self, const AVPacket *av_packet, double timestamp) {
gsr_replay_buffer_file *replay_buffer_file = self->files[self->num_files - 1];
replay_buffer_file->end_timestamp = timestamp;
if(replay_buffer_file->num_packets + 1 >= replay_buffer_file->capacity_num_packets) {
size_t new_capacity_num_packets = replay_buffer_file->capacity_num_packets * 2;
if(new_capacity_num_packets == 0)
new_capacity_num_packets = 256;
void *new_packets = realloc(replay_buffer_file->packets, new_capacity_num_packets * sizeof(gsr_av_packet_disk));
if(!new_packets) {
fprintf(stderr, "gsr error: gsr_replay_buffer_disk_append_to_current_file: failed to reallocate replay buffer file packets\n");
return false;
}
replay_buffer_file->capacity_num_packets = new_capacity_num_packets;
replay_buffer_file->packets = new_packets;
}
gsr_av_packet_disk *packet = &replay_buffer_file->packets[replay_buffer_file->num_packets];
gsr_av_packet_disk_init(packet, av_packet, self->storage_num_bytes_written, timestamp);
++replay_buffer_file->num_packets;
size_t bytes_written = 0;
const bool file_written = file_write_all(self->storage_fd, av_packet->data, av_packet->size, &bytes_written);
self->storage_num_bytes_written += bytes_written;
if(self->storage_num_bytes_written >= REPLAY_BUFFER_FILE_SIZE_BYTES) {
self->storage_num_bytes_written = 0;
close(self->storage_fd);
self->storage_fd = 0;
}
return file_written;
}
static void gsr_replay_buffer_disk_remove_first_file(gsr_replay_buffer_disk *self) {
gsr_replay_buffer_file_unref(self->files[0], self->replay_directory);
for(size_t i = 1; i < self->num_files; ++i) {
self->files[i - 1] = self->files[i];
}
--self->num_files;
}
static bool gsr_replay_buffer_disk_append(gsr_replay_buffer *replay_buffer, const AVPacket *av_packet, double timestamp) {
gsr_replay_buffer_disk *self = (gsr_replay_buffer_disk*)replay_buffer;
bool success = false;
gsr_replay_buffer_lock(&self->replay_buffer);
if(self->storage_fd <= 0) {
if(!gsr_replay_buffer_disk_create_next_file(self, timestamp))
goto done;
}
const bool data_written = gsr_replay_buffer_disk_append_to_current_file(self, av_packet, timestamp);
if(self->num_files > 1) {
const double buffer_time_accumulated = timestamp - self->files[1]->start_timestamp;
if(buffer_time_accumulated >= self->replay_buffer_time)
gsr_replay_buffer_disk_remove_first_file(self);
}
success = data_written;
done:
gsr_replay_buffer_unlock(&self->replay_buffer);
return success;
}
static AVPacket* gsr_replay_buffer_disk_iterator_get_packet(gsr_replay_buffer *replay_buffer, gsr_replay_buffer_iterator iterator) {
gsr_replay_buffer_disk *self = (gsr_replay_buffer_disk*)replay_buffer;
assert(iterator.file_index < self->num_files);
assert(iterator.packet_index < self->files[iterator.file_index]->num_packets);
return &self->files[iterator.file_index]->packets[iterator.packet_index].packet;
}
static uint8_t* gsr_replay_buffer_disk_iterator_get_packet_data(gsr_replay_buffer *replay_buffer, gsr_replay_buffer_iterator iterator) {
gsr_replay_buffer_disk *self = (gsr_replay_buffer_disk*)replay_buffer;
assert(iterator.file_index < self->num_files);
gsr_replay_buffer_file *file = self->files[iterator.file_index];
assert(iterator.packet_index < file->num_packets);
if(file->fd <= 0) {
char filename[PATH_MAX];
snprintf(filename, sizeof(filename), "%s/%s_%d.mp4", self->replay_directory, FILE_PREFIX, (int)file->id);
file->fd = open(filename, O_RDONLY);
if(file->fd <= 0) {
fprintf(stderr, "gsr error: gsr_replay_buffer_disk_iterator_get_packet_data: failed to open file\n");
return NULL;
}
}
const gsr_av_packet_disk *packet = &self->files[iterator.file_index]->packets[iterator.packet_index];
if(lseek(file->fd, packet->data_index, SEEK_SET) == -1) {
fprintf(stderr, "gsr error: gsr_replay_buffer_disk_iterator_get_packet_data: failed to seek\n");
return NULL;
}
uint8_t *packet_data = malloc(packet->packet.size);
if(read(file->fd, packet_data, packet->packet.size) != packet->packet.size) {
fprintf(stderr, "gsr error: gsr_replay_buffer_disk_iterator_get_packet_data: failed to read data from file\n");
free(packet_data);
return NULL;
}
return packet_data;
}
static gsr_replay_buffer* gsr_replay_buffer_disk_clone(gsr_replay_buffer *replay_buffer) {
gsr_replay_buffer_disk *self = (gsr_replay_buffer_disk*)replay_buffer;
gsr_replay_buffer_disk *destination = calloc(1, sizeof(gsr_replay_buffer_disk));
if(!destination)
return NULL;
gsr_replay_buffer_disk_set_impl_funcs(destination);
gsr_replay_buffer_lock(&self->replay_buffer);
destination->replay_buffer.original_replay_buffer = replay_buffer;
destination->replay_buffer.mutex = self->replay_buffer.mutex;
destination->replay_buffer.mutex_initialized = self->replay_buffer.mutex_initialized;
destination->replay_buffer_time = self->replay_buffer_time;
destination->storage_counter = self->storage_counter;
destination->storage_num_bytes_written = self->storage_num_bytes_written;
destination->storage_fd = 0; // We only want to read from the clone. If there is a need to write to it in the future then TODO change this
for(size_t i = 0; i < self->num_files; ++i) {
destination->files[i] = gsr_replay_buffer_file_ref(self->files[i]);
}
destination->num_files = self->num_files;
snprintf(destination->replay_directory, sizeof(destination->replay_directory), "%s", self->replay_directory);
destination->owns_directory = false;
gsr_replay_buffer_unlock(&self->replay_buffer);
return (gsr_replay_buffer*)destination;
}
/* Binary search */
static size_t gsr_replay_buffer_file_find_packet_index_by_time_passed(const gsr_replay_buffer_file *self, int seconds) {
const double now = clock_get_monotonic_seconds();
if(self->num_packets == 0) {
return 0;
}
size_t lower_bound = 0;
size_t upper_bound = self->num_packets;
size_t index = 0;
for(;;) {
index = lower_bound + (upper_bound - lower_bound) / 2;
const gsr_av_packet_disk *packet = &self->packets[index];
const double time_passed_since_packet = now - packet->timestamp;
if(time_passed_since_packet >= seconds) {
if(lower_bound == index)
break;
lower_bound = index;
} else {
if(upper_bound == index)
break;
upper_bound = index;
}
}
return index;
}
/* Binary search */
static gsr_replay_buffer_iterator gsr_replay_buffer_disk_find_file_index_by_time_passed(gsr_replay_buffer *replay_buffer, int seconds) {
gsr_replay_buffer_disk *self = (gsr_replay_buffer_disk*)replay_buffer;
gsr_replay_buffer_lock(&self->replay_buffer);
const double now = clock_get_monotonic_seconds();
if(self->num_files == 0) {
gsr_replay_buffer_unlock(&self->replay_buffer);
return (gsr_replay_buffer_iterator){0, 0};
}
size_t lower_bound = 0;
size_t upper_bound = self->num_files;
size_t file_index = 0;
for(;;) {
file_index = lower_bound + (upper_bound - lower_bound) / 2;
const gsr_replay_buffer_file *file = self->files[file_index];
const double time_passed_since_file_start = now - file->start_timestamp;
const double time_passed_since_file_end = now - file->end_timestamp;
if(time_passed_since_file_start >= seconds && time_passed_since_file_end <= seconds) {
break;
} else if(time_passed_since_file_start >= seconds) {
if(lower_bound == file_index)
break;
lower_bound = file_index;
} else {
if(upper_bound == file_index)
break;
upper_bound = file_index;
}
}
const gsr_replay_buffer_file *file = self->files[file_index];
const size_t packet_index = gsr_replay_buffer_file_find_packet_index_by_time_passed(file, seconds);
gsr_replay_buffer_unlock(&self->replay_buffer);
return (gsr_replay_buffer_iterator){packet_index, file_index};
}
static gsr_replay_buffer_iterator gsr_replay_buffer_disk_find_keyframe(gsr_replay_buffer *replay_buffer, gsr_replay_buffer_iterator start_iterator, int stream_index, bool invert_stream_index) {
gsr_replay_buffer_disk *self = (gsr_replay_buffer_disk*)replay_buffer;
gsr_replay_buffer_iterator keyframe_iterator = {(size_t)-1, 0};
gsr_replay_buffer_lock(&self->replay_buffer);
for(size_t file_index = start_iterator.file_index; file_index < self->num_files; ++file_index) {
const gsr_replay_buffer_file *file = self->files[file_index];
for(size_t packet_index = start_iterator.packet_index; packet_index < file->num_packets; ++packet_index) {
const gsr_av_packet_disk *packet = &file->packets[packet_index];
if((packet->packet.flags & AV_PKT_FLAG_KEY) && (invert_stream_index ? packet->packet.stream_index != stream_index : packet->packet.stream_index == stream_index)) {
keyframe_iterator.packet_index = packet_index;
keyframe_iterator.file_index = file_index;
break;
}
}
}
gsr_replay_buffer_unlock(&self->replay_buffer);
return keyframe_iterator;
}
static bool gsr_replay_buffer_disk_iterator_next(gsr_replay_buffer *replay_buffer, gsr_replay_buffer_iterator *iterator) {
gsr_replay_buffer_disk *self = (gsr_replay_buffer_disk*)replay_buffer;
if(iterator->file_index >= self->num_files)
return false;
if(iterator->packet_index + 1 >= self->files[iterator->file_index]->num_packets) {
if(iterator->file_index + 1 >= self->num_files)
return false;
if(self->files[iterator->file_index + 1]->num_packets == 0)
return false;
++iterator->file_index;
iterator->packet_index = 0;
return true;
} else {
++iterator->packet_index;
return true;
}
}
static void get_current_time(char *time_str, size_t time_str_size) {
time_t now = time(NULL);
struct tm *t = localtime(&now);
strftime(time_str, time_str_size - 1, "%Y-%m-%d_%H-%M-%S", t);
}
static void gsr_replay_buffer_disk_set_impl_funcs(gsr_replay_buffer_disk *self) {
self->replay_buffer.destroy = gsr_replay_buffer_disk_destroy;
self->replay_buffer.append = gsr_replay_buffer_disk_append;
self->replay_buffer.clear = gsr_replay_buffer_disk_clear;
self->replay_buffer.iterator_get_packet = gsr_replay_buffer_disk_iterator_get_packet;
self->replay_buffer.iterator_get_packet_data = gsr_replay_buffer_disk_iterator_get_packet_data;
self->replay_buffer.clone = gsr_replay_buffer_disk_clone;
self->replay_buffer.find_packet_index_by_time_passed = gsr_replay_buffer_disk_find_file_index_by_time_passed;
self->replay_buffer.find_keyframe = gsr_replay_buffer_disk_find_keyframe;
self->replay_buffer.iterator_next = gsr_replay_buffer_disk_iterator_next;
}
gsr_replay_buffer* gsr_replay_buffer_disk_create(const char *replay_directory, double replay_buffer_time) {
assert(replay_buffer_time > 0);
gsr_replay_buffer_disk *replay_buffer = calloc(1, sizeof(gsr_replay_buffer_disk));
if(!replay_buffer)
return NULL;
char time_str[128];
get_current_time(time_str, sizeof(time_str));
replay_buffer->num_files = 0;
replay_buffer->storage_counter = 0;
replay_buffer->replay_buffer_time = replay_buffer_time;
snprintf(replay_buffer->replay_directory, sizeof(replay_buffer->replay_directory), "%s/gsr-replay-%s.gsr", replay_directory, time_str);
replay_buffer->owns_directory = true;
gsr_replay_buffer_disk_set_impl_funcs(replay_buffer);
return (gsr_replay_buffer*)replay_buffer;
}

256
src/replay_buffer/replay_buffer_ram.c Normal file
View File

@@ -0,0 +1,256 @@
#include "../../include/replay_buffer/replay_buffer_ram.h"
#include "../../include/utils.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <libavutil/mem.h>
static void gsr_replay_buffer_ram_set_impl_funcs(gsr_replay_buffer_ram *self);
static gsr_av_packet_ram* gsr_av_packet_ram_create(const AVPacket *av_packet, double timestamp) {
gsr_av_packet_ram *self = malloc(sizeof(gsr_av_packet_ram));
if(!self)
return NULL;
self->ref_counter = 1;
self->packet = *av_packet;
self->timestamp = timestamp;
// Why are we doing this you ask? there is a ffmpeg bug that causes cpu usage to increase over time when you have
// packets that are not being free'd until later. So we copy the packet data, free the packet and then reconstruct
// the packet later on when we need it, to keep packets alive only for a short period.
self->packet.data = av_memdup(av_packet->data, av_packet->size);
if(!self->packet.data) {
free(self);
return NULL;
}
return self;
}
static gsr_av_packet_ram* gsr_av_packet_ram_ref(gsr_av_packet_ram *self) {
if(self->ref_counter >= 1)
++self->ref_counter;
return self;
}
static void gsr_av_packet_ram_free(gsr_av_packet_ram *self) {
self->ref_counter = 0;
if(self->packet.data) {
av_free(self->packet.data);
self->packet.data = NULL;
}
free(self);
}
static void gsr_av_packet_ram_unref(gsr_av_packet_ram *self) {
if(self->ref_counter >= 1)
--self->ref_counter;
if(self->ref_counter <= 0)
gsr_av_packet_ram_free(self);
}
static void gsr_replay_buffer_ram_destroy(gsr_replay_buffer *replay_buffer) {
gsr_replay_buffer_ram *self = (gsr_replay_buffer_ram*)replay_buffer;
gsr_replay_buffer_lock(&self->replay_buffer);
for(size_t i = 0; i < self->num_packets; ++i) {
if(self->packets[i]) {
gsr_av_packet_ram_unref(self->packets[i]);
self->packets[i] = NULL;
}
}
self->num_packets = 0;
gsr_replay_buffer_unlock(&self->replay_buffer);
if(self->packets) {
free(self->packets);
self->packets = NULL;
}
self->capacity_num_packets = 0;
self->index = 0;
}
static bool gsr_replay_buffer_ram_append(gsr_replay_buffer *replay_buffer, const AVPacket *av_packet, double timestamp) {
gsr_replay_buffer_ram *self = (gsr_replay_buffer_ram*)replay_buffer;
gsr_replay_buffer_lock(&self->replay_buffer);
gsr_av_packet_ram *packet = gsr_av_packet_ram_create(av_packet, timestamp);
if(!packet) {
gsr_replay_buffer_unlock(&self->replay_buffer);
return false;
}
if(self->packets[self->index]) {
gsr_av_packet_ram_unref(self->packets[self->index]);
self->packets[self->index] = NULL;
}
self->packets[self->index] = packet;
self->index = (self->index + 1) % self->capacity_num_packets;
++self->num_packets;
if(self->num_packets > self->capacity_num_packets)
self->num_packets = self->capacity_num_packets;
gsr_replay_buffer_unlock(&self->replay_buffer);
return true;
}
static void gsr_replay_buffer_ram_clear(gsr_replay_buffer *replay_buffer) {
gsr_replay_buffer_ram *self = (gsr_replay_buffer_ram*)replay_buffer;
gsr_replay_buffer_lock(&self->replay_buffer);
for(size_t i = 0; i < self->num_packets; ++i) {
if(self->packets[i]) {
gsr_av_packet_ram_unref(self->packets[i]);
self->packets[i] = NULL;
}
}
self->num_packets = 0;
self->index = 0;
gsr_replay_buffer_unlock(&self->replay_buffer);
}
static gsr_av_packet_ram* gsr_replay_buffer_ram_get_packet_at_index(gsr_replay_buffer *replay_buffer, size_t index) {
gsr_replay_buffer_ram *self = (gsr_replay_buffer_ram*)replay_buffer;
assert(index < self->num_packets);
size_t start_index = 0;
if(self->num_packets < self->capacity_num_packets)
start_index = self->num_packets - self->index;
else
start_index = self->index;
const size_t offset = (start_index + index) % self->capacity_num_packets;
return self->packets[offset];
}
static AVPacket* gsr_replay_buffer_ram_iterator_get_packet(gsr_replay_buffer *replay_buffer, gsr_replay_buffer_iterator iterator) {
return &gsr_replay_buffer_ram_get_packet_at_index(replay_buffer, iterator.packet_index)->packet;
}
static uint8_t* gsr_replay_buffer_ram_iterator_get_packet_data(gsr_replay_buffer *replay_buffer, gsr_replay_buffer_iterator iterator) {
(void)replay_buffer;
(void)iterator;
return NULL;
}
static gsr_replay_buffer* gsr_replay_buffer_ram_clone(gsr_replay_buffer *replay_buffer) {
gsr_replay_buffer_ram *self = (gsr_replay_buffer_ram*)replay_buffer;
gsr_replay_buffer_ram *destination = calloc(1, sizeof(gsr_replay_buffer_ram));
if(!destination)
return NULL;
gsr_replay_buffer_ram_set_impl_funcs(destination);
gsr_replay_buffer_lock(&self->replay_buffer);
destination->replay_buffer.original_replay_buffer = replay_buffer;
destination->replay_buffer.mutex = self->replay_buffer.mutex;
destination->replay_buffer.mutex_initialized = self->replay_buffer.mutex_initialized;
destination->capacity_num_packets = self->capacity_num_packets;
destination->index = self->index;
destination->packets = calloc(destination->capacity_num_packets, sizeof(gsr_av_packet_ram*));
if(!destination->packets) {
free(destination);
gsr_replay_buffer_unlock(&self->replay_buffer);
return NULL;
}
destination->num_packets = self->num_packets;
for(size_t i = 0; i < destination->num_packets; ++i) {
destination->packets[i] = gsr_av_packet_ram_ref(self->packets[i]);
}
gsr_replay_buffer_unlock(&self->replay_buffer);
return (gsr_replay_buffer*)destination;
}
/* Binary search */
static gsr_replay_buffer_iterator gsr_replay_buffer_ram_find_packet_index_by_time_passed(gsr_replay_buffer *replay_buffer, int seconds) {
gsr_replay_buffer_ram *self = (gsr_replay_buffer_ram*)replay_buffer;
gsr_replay_buffer_lock(&self->replay_buffer);
const double now = clock_get_monotonic_seconds();
if(self->num_packets == 0) {
gsr_replay_buffer_unlock(&self->replay_buffer);
return (gsr_replay_buffer_iterator){0, 0};
}
size_t lower_bound = 0;
size_t upper_bound = self->num_packets;
size_t index = 0;
for(;;) {
index = lower_bound + (upper_bound - lower_bound) / 2;
const gsr_av_packet_ram *packet = gsr_replay_buffer_ram_get_packet_at_index(replay_buffer, index);
const double time_passed_since_packet = now - packet->timestamp;
if(time_passed_since_packet >= seconds) {
if(lower_bound == index)
break;
lower_bound = index;
} else {
if(upper_bound == index)
break;
upper_bound = index;
}
}
gsr_replay_buffer_unlock(&self->replay_buffer);
return (gsr_replay_buffer_iterator){index, 0};
}
static gsr_replay_buffer_iterator gsr_replay_buffer_ram_find_keyframe(gsr_replay_buffer *replay_buffer, gsr_replay_buffer_iterator start_iterator, int stream_index, bool invert_stream_index) {
gsr_replay_buffer_ram *self = (gsr_replay_buffer_ram*)replay_buffer;
size_t keyframe_index = (size_t)-1;
gsr_replay_buffer_lock(&self->replay_buffer);
for(size_t i = start_iterator.packet_index; i < self->num_packets; ++i) {
const gsr_av_packet_ram *packet = gsr_replay_buffer_ram_get_packet_at_index(replay_buffer, i);
if((packet->packet.flags & AV_PKT_FLAG_KEY) && (invert_stream_index ? packet->packet.stream_index != stream_index : packet->packet.stream_index == stream_index)) {
keyframe_index = i;
break;
}
}
gsr_replay_buffer_unlock(&self->replay_buffer);
return (gsr_replay_buffer_iterator){keyframe_index, 0};
}
static bool gsr_replay_buffer_ram_iterator_next(gsr_replay_buffer *replay_buffer, gsr_replay_buffer_iterator *iterator) {
gsr_replay_buffer_ram *self = (gsr_replay_buffer_ram*)replay_buffer;
if(iterator->packet_index + 1 < self->num_packets) {
++iterator->packet_index;
return true;
} else {
return false;
}
}
static void gsr_replay_buffer_ram_set_impl_funcs(gsr_replay_buffer_ram *self) {
self->replay_buffer.destroy = gsr_replay_buffer_ram_destroy;
self->replay_buffer.append = gsr_replay_buffer_ram_append;
self->replay_buffer.clear = gsr_replay_buffer_ram_clear;
self->replay_buffer.iterator_get_packet = gsr_replay_buffer_ram_iterator_get_packet;
self->replay_buffer.iterator_get_packet_data = gsr_replay_buffer_ram_iterator_get_packet_data;
self->replay_buffer.clone = gsr_replay_buffer_ram_clone;
self->replay_buffer.find_packet_index_by_time_passed = gsr_replay_buffer_ram_find_packet_index_by_time_passed;
self->replay_buffer.find_keyframe = gsr_replay_buffer_ram_find_keyframe;
self->replay_buffer.iterator_next = gsr_replay_buffer_ram_iterator_next;
}
gsr_replay_buffer* gsr_replay_buffer_ram_create(size_t replay_buffer_num_packets) {
assert(replay_buffer_num_packets > 0);
gsr_replay_buffer_ram *replay_buffer = calloc(1, sizeof(gsr_replay_buffer_ram));
if(!replay_buffer)
return NULL;
replay_buffer->capacity_num_packets = replay_buffer_num_packets;
replay_buffer->num_packets = 0;
replay_buffer->index = 0;
replay_buffer->packets = calloc(replay_buffer->capacity_num_packets, sizeof(gsr_av_packet_ram*));
if(!replay_buffer->packets) {
gsr_replay_buffer_ram_destroy(&replay_buffer->replay_buffer);
free(replay_buffer);
return NULL;
}
gsr_replay_buffer_ram_set_impl_funcs(replay_buffer);
return (gsr_replay_buffer*)replay_buffer;
}