init

include/capture/capture.h

@@ -0,0 +1,64 @@
+#ifndef GSR_CAPTURE_CAPTURE_H
+#define GSR_CAPTURE_CAPTURE_H
+
+#include "../color_conversion.h"
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+typedef struct AVCodecContext AVCodecContext;
+typedef struct AVStream AVStream;
+typedef struct AVFrame AVFrame;
+typedef struct AVMasteringDisplayMetadata AVMasteringDisplayMetadata;
+typedef struct AVContentLightMetadata AVContentLightMetadata;
+typedef struct gsr_capture gsr_capture;
+typedef struct gsr_capture_metadata gsr_capture_metadata;
+
+typedef enum {
+    GSR_CAPTURE_ALIGN_START,
+    GSR_CAPTURE_ALIGN_CENTER,
+    GSR_CAPTURE_ALIGN_END
+} gsr_capture_alignment;
+
+struct gsr_capture_metadata {
+    // Size of the video
+    vec2i video_size;
+    // The captured output gets scaled to this size. By default this will be the same size as the captured target
+    vec2i recording_size;
+    vec2i position;
+    int fps;
+    gsr_capture_alignment halign;
+    gsr_capture_alignment valign;
+    gsr_flip flip;
+};
+
+struct gsr_capture {
+    /* These methods should not be called manually. Call gsr_capture_* instead. |capture_metadata->video_size| should be set by this function */
+    int (*start)(gsr_capture *cap, gsr_capture_metadata *capture_metadata);
+    void (*on_event)(gsr_capture *cap, gsr_egl *egl); /* can be NULL */
+    void (*tick)(gsr_capture *cap); /* can be NULL. If there is an event then |on_event| is called before this */
+    bool (*should_stop)(gsr_capture *cap, bool *err); /* can be NULL. If NULL, return false */
+    bool (*capture_has_synchronous_task)(gsr_capture *cap); /* can be NULL. If this returns true then the time spent in |capture| is ignored for video/audio (capture is paused while the synchronous task happens) */
+    void (*pre_capture)(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion); /* can be NULL */
+    int (*capture)(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion); /* Return 0 if the frame was captured */
+    bool (*uses_external_image)(gsr_capture *cap); /* can be NULL. If NULL, return false */
+    bool (*set_hdr_metadata)(gsr_capture *cap, AVMasteringDisplayMetadata *mastering_display_metadata, AVContentLightMetadata *light_metadata); /* can be NULL. If NULL, return false */
+    uint64_t (*get_window_id)(gsr_capture *cap); /* can be NULL. Returns 0 if unknown */
+    bool (*is_damaged)(gsr_capture *cap); /* can be NULL */
+    void (*clear_damage)(gsr_capture *cap); /* can be NULL */
+    void (*destroy)(gsr_capture *cap);
+
+    void *priv; /* can be NULL */
+    bool started;
+};
+
+int gsr_capture_start(gsr_capture *cap, gsr_capture_metadata *capture_metadata);
+void gsr_capture_on_event(gsr_capture *cap, gsr_egl *egl);
+void gsr_capture_tick(gsr_capture *cap);
+bool gsr_capture_should_stop(gsr_capture *cap, bool *err);
+int gsr_capture_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion);
+bool gsr_capture_uses_external_image(gsr_capture *cap);
+bool gsr_capture_set_hdr_metadata(gsr_capture *cap, AVMasteringDisplayMetadata *mastering_display_metadata, AVContentLightMetadata *light_metadata);
+void gsr_capture_destroy(gsr_capture *cap);
+
+#endif /* GSR_CAPTURE_CAPTURE_H */

include/capture/kms.h

@@ -0,0 +1,23 @@
+#ifndef GSR_CAPTURE_KMS_H
+#define GSR_CAPTURE_KMS_H
+
+#include "capture.h"
+#include "../cursor.h"
+#include "../../kms/kms_shared.h"
+
+typedef struct {
+    gsr_egl *egl;
+    gsr_cursor *x11_cursor;
+    gsr_kms_response *kms_response;
+    const char *display_to_capture; /* A copy is made of this */
+    bool hdr;
+    bool record_cursor;
+    int fps;
+    vec2i output_resolution;
+    vec2i region_size;
+    vec2i region_position;
+} gsr_capture_kms_params;
+
+gsr_capture* gsr_capture_kms_create(const gsr_capture_kms_params *params);
+
+#endif /* GSR_CAPTURE_KMS_H */

include/capture/nvfbc.h

@@ -0,0 +1,20 @@
+#ifndef GSR_CAPTURE_NVFBC_H
+#define GSR_CAPTURE_NVFBC_H
+
+#include "capture.h"
+#include "../vec2.h"
+
+typedef struct {
+    gsr_egl *egl;
+    const char *display_to_capture; /* if this is "screen", then the entire x11 screen is captured (all displays). A copy is made of this */
+    int fps;
+    bool direct_capture;
+    bool record_cursor;
+    vec2i output_resolution;
+    vec2i region_size;
+    vec2i region_position;
+} gsr_capture_nvfbc_params;
+
+gsr_capture* gsr_capture_nvfbc_create(const gsr_capture_nvfbc_params *params);
+
+#endif /* GSR_CAPTURE_NVFBC_H */

include/capture/portal.h

@@ -0,0 +1,17 @@
+#ifndef GSR_CAPTURE_PORTAL_H
+#define GSR_CAPTURE_PORTAL_H
+
+#include "capture.h"
+
+typedef struct {
+    gsr_egl *egl;
+    bool record_cursor;
+    bool restore_portal_session;
+    /* If this is set to NULL then this defaults to $XDG_CONFIG_HOME/gpu-screen-recorder/restore_token ($XDG_CONFIG_HOME defaults to $HOME/.config) */
+    const char *portal_session_token_filepath;
+    vec2i output_resolution;
+} gsr_capture_portal_params;
+
+gsr_capture* gsr_capture_portal_create(const gsr_capture_portal_params *params);
+
+#endif /* GSR_CAPTURE_PORTAL_H */

include/capture/v4l2.h

@@ -0,0 +1,30 @@
+#ifndef GSR_CAPTURE_V4L2_H
+#define GSR_CAPTURE_V4L2_H
+
+#include "capture.h"
+
+typedef enum {
+    GSR_CAPTURE_V4L2_PIXFMT_AUTO,
+    GSR_CAPTURE_V4L2_PIXFMT_YUYV,
+    GSR_CAPTURE_V4L2_PIXFMT_MJPEG
+} gsr_capture_v4l2_pixfmt;
+
+typedef struct {
+    bool yuyv;
+    bool mjpeg;
+} gsr_capture_v4l2_supported_pixfmts;
+
+typedef struct {
+    gsr_egl *egl;
+    vec2i output_resolution;
+    const char *device_path;
+    gsr_capture_v4l2_pixfmt pixfmt;
+    int fps;
+} gsr_capture_v4l2_params;
+
+gsr_capture* gsr_capture_v4l2_create(const gsr_capture_v4l2_params *params);
+
+typedef void (*v4l2_devices_query_callback)(const char *path, gsr_capture_v4l2_supported_pixfmts supported_pixfmts, vec2i size, void *userdata);
+void gsr_capture_v4l2_list_devices(v4l2_devices_query_callback callback, void *userdata);
+
+#endif /* GSR_CAPTURE_V4L2_H */

include/capture/xcomposite.h

@@ -0,0 +1,19 @@
+#ifndef GSR_CAPTURE_XCOMPOSITE_H
+#define GSR_CAPTURE_XCOMPOSITE_H
+
+#include "capture.h"
+#include "../vec2.h"
+#include "../cursor.h"
+
+typedef struct {
+    gsr_egl *egl;
+    gsr_cursor *cursor;
+    unsigned long window;
+    bool follow_focused; /* If this is set then |window| is ignored */
+    bool record_cursor;
+    vec2i output_resolution;
+} gsr_capture_xcomposite_params;
+
+gsr_capture* gsr_capture_xcomposite_create(const gsr_capture_xcomposite_params *params);
+
+#endif /* GSR_CAPTURE_XCOMPOSITE_H */

include/capture/ximage.h

@@ -0,0 +1,20 @@
+#ifndef GSR_CAPTURE_XIMAGE_H
+#define GSR_CAPTURE_XIMAGE_H
+
+#include "capture.h"
+#include "../vec2.h"
+#include "../cursor.h"
+
+typedef struct {
+    gsr_egl *egl;
+    gsr_cursor *cursor;
+    const char *display_to_capture; /* A copy is made of this */
+    bool record_cursor;
+    vec2i output_resolution;
+    vec2i region_size;
+    vec2i region_position;
+} gsr_capture_ximage_params;
+
+gsr_capture* gsr_capture_ximage_create(const gsr_capture_ximage_params *params);
+
+#endif /* GSR_CAPTURE_XIMAGE_H */