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

Move codec query from encoder to separate file

Browse Source
This commit is contained in:
dec05eba
2024-09-26 16:08:26 +02:00
parent 0b20a46e58
commit 1aaa26d87e
12 changed files with 491 additions and 455 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
include/codec_query/codec_query.h Normal file
View File

@@ -0,0 +1,18 @@
#ifndef GSR_CODEC_QUERY_H
#define GSR_CODEC_QUERY_H
#include <stdbool.h>
typedef struct {
bool h264;
bool hevc;
bool hevc_hdr;
bool hevc_10bit;
bool av1;
bool av1_hdr;
bool av1_10bit;
bool vp8;
bool vp9;
} gsr_supported_video_codecs;
#endif /* GSR_CODEC_QUERY_H */

8
include/codec_query/cuda.h Normal file
View File

@@ -0,0 +1,8 @@
#ifndef GSR_CODEC_QUERY_CUDA_H
#define GSR_CODEC_QUERY_CUDA_H
#include "codec_query.h"
bool gsr_get_supported_video_codecs_nvenc(gsr_supported_video_codecs *video_codecs, bool cleanup);
#endif /* GSR_CODEC_QUERY_CUDA_H */

8
include/codec_query/vaapi.h Normal file
View File

@@ -0,0 +1,8 @@
#ifndef GSR_CODEC_QUERY_VAAPI_H
#define GSR_CODEC_QUERY_VAAPI_H
#include "codec_query.h"
bool gsr_get_supported_video_codecs_vaapi(gsr_supported_video_codecs *video_codecs, const char *card_path, bool cleanup);
#endif /* GSR_CODEC_QUERY_VAAPI_H */

14
include/encoder/video/video.h
View File

@@ -8,20 +8,7 @@ typedef struct gsr_video_encoder gsr_video_encoder;
typedef struct AVCodecContext AVCodecContext;
typedef struct AVFrame AVFrame;
typedef struct {
bool h264;
bool hevc;
bool hevc_hdr;
bool hevc_10bit;
bool av1;
bool av1_hdr;
bool av1_10bit;
bool vp8;
bool vp9;
} gsr_supported_video_codecs;
struct gsr_video_encoder {
gsr_supported_video_codecs (*get_supported_codecs)(gsr_video_encoder *encoder, bool cleanup);
bool (*start)(gsr_video_encoder *encoder, AVCodecContext *video_codec_context, AVFrame *frame);
void (*copy_textures_to_frame)(gsr_video_encoder *encoder, AVFrame *frame); /* Can be NULL */
/* |textures| should be able to fit 2 elements */
@@ -32,7 +19,6 @@ struct gsr_video_encoder {
bool started;
};
gsr_supported_video_codecs gsr_video_encoder_get_supported_codecs(gsr_video_encoder *encoder, bool cleanup);
bool gsr_video_encoder_start(gsr_video_encoder *encoder, AVCodecContext *video_codec_context, AVFrame *frame);
void gsr_video_encoder_copy_textures_to_frame(gsr_video_encoder *encoder, AVFrame *frame);
void gsr_video_encoder_get_textures(gsr_video_encoder *encoder, unsigned int *textures, int *num_textures, gsr_destination_color *destination_color);

2
meson.build
View File

@@ -18,6 +18,8 @@ src = [
'src/encoder/video/vaapi.c',
'src/encoder/video/vulkan.c',
'src/encoder/video/software.c',
'src/codec_query/cuda.c',
'src/codec_query/vaapi.c',
'src/egl.c',
'src/cuda.c',
'src/xnvctrl.c',

235
src/codec_query/cuda.c Normal file
View File

@@ -0,0 +1,235 @@
#include "../../include/codec_query/cuda.h"
#include "../../include/cuda.h"
#include "../../external/nvEncodeAPI.h"
#include <dlfcn.h>
#include <stdio.h>
#include <string.h>
static void* open_nvenc_library(void) {
dlerror(); /* clear */
void *lib = dlopen("libnvidia-encode.so.1", RTLD_LAZY);
if(!lib) {
lib = dlopen("libnvidia-encode.so", RTLD_LAZY);
if(!lib) {
fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc failed: failed to load libnvidia-encode.so/libnvidia-encode.so.1, error: %s\n", dlerror());
return NULL;
}
}
return lib;
}
static bool profile_is_h264(const GUID *profile_guid) {
const GUID *h264_guids[] = {
&NV_ENC_H264_PROFILE_BASELINE_GUID,
&NV_ENC_H264_PROFILE_MAIN_GUID,
&NV_ENC_H264_PROFILE_HIGH_GUID,
&NV_ENC_H264_PROFILE_PROGRESSIVE_HIGH_GUID,
&NV_ENC_H264_PROFILE_CONSTRAINED_HIGH_GUID
};
for(int i = 0; i < 5; ++i) {
if(memcmp(profile_guid, h264_guids[i], sizeof(GUID)) == 0)
return true;
}
return false;
}
static bool profile_is_hevc(const GUID *profile_guid) {
const GUID *h264_guids[] = {
&NV_ENC_HEVC_PROFILE_MAIN_GUID,
};
for(int i = 0; i < 1; ++i) {
if(memcmp(profile_guid, h264_guids[i], sizeof(GUID)) == 0)
return true;
}
return false;
}
static bool profile_is_hevc_10bit(const GUID *profile_guid) {
const GUID *h264_guids[] = {
&NV_ENC_HEVC_PROFILE_MAIN10_GUID,
};
for(int i = 0; i < 1; ++i) {
if(memcmp(profile_guid, h264_guids[i], sizeof(GUID)) == 0)
return true;
}
return false;
}
static bool profile_is_av1(const GUID *profile_guid) {
const GUID *h264_guids[] = {
&NV_ENC_AV1_PROFILE_MAIN_GUID,
};
for(int i = 0; i < 1; ++i) {
if(memcmp(profile_guid, h264_guids[i], sizeof(GUID)) == 0)
return true;
}
return false;
}
static bool encoder_get_supported_profiles(const NV_ENCODE_API_FUNCTION_LIST *function_list, void *nvenc_encoder, const GUID *encoder_guid, gsr_supported_video_codecs *supported_video_codecs) {
bool success = false;
GUID *profile_guids = NULL;
uint32_t profile_guid_count = 0;
if(function_list->nvEncGetEncodeProfileGUIDCount(nvenc_encoder, *encoder_guid, &profile_guid_count) != NV_ENC_SUCCESS) {
fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: nvEncGetEncodeProfileGUIDCount failed, error: %s\n", function_list->nvEncGetLastErrorString(nvenc_encoder));
goto fail;
}
if(profile_guid_count == 0)
goto fail;
profile_guids = calloc(profile_guid_count, sizeof(GUID));
if(!profile_guids) {
fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: failed to allocate %d guids\n", (int)profile_guid_count);
goto fail;
}
if(function_list->nvEncGetEncodeProfileGUIDs(nvenc_encoder, *encoder_guid, profile_guids, profile_guid_count, &profile_guid_count) != NV_ENC_SUCCESS) {
fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: nvEncGetEncodeProfileGUIDs failed, error: %s\n", function_list->nvEncGetLastErrorString(nvenc_encoder));
goto fail;
}
for(uint32_t i = 0; i < profile_guid_count; ++i) {
if(profile_is_h264(&profile_guids[i])) {
supported_video_codecs->h264 = true;
} else if(profile_is_hevc(&profile_guids[i])) {
supported_video_codecs->hevc = true;
} else if(profile_is_hevc_10bit(&profile_guids[i])) {
supported_video_codecs->hevc_hdr = true;
supported_video_codecs->hevc_10bit = true;
} else if(profile_is_av1(&profile_guids[i])) {
supported_video_codecs->av1 = true;
supported_video_codecs->av1_hdr = true;
supported_video_codecs->av1_10bit = true;
}
}
success = true;
fail:
if(profile_guids)
free(profile_guids);
return success;
}
static bool get_supported_video_codecs(const NV_ENCODE_API_FUNCTION_LIST *function_list, void *nvenc_encoder, gsr_supported_video_codecs *supported_video_codecs) {
bool success = false;
GUID *encoder_guids = NULL;
*supported_video_codecs = (gsr_supported_video_codecs){0};
uint32_t encode_guid_count = 0;
if(function_list->nvEncGetEncodeGUIDCount(nvenc_encoder, &encode_guid_count) != NV_ENC_SUCCESS) {
fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: nvEncGetEncodeGUIDCount failed, error: %s\n", function_list->nvEncGetLastErrorString(nvenc_encoder));
goto fail;
}
if(encode_guid_count == 0)
goto fail;
encoder_guids = calloc(encode_guid_count, sizeof(GUID));
if(!encoder_guids) {
fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: failed to allocate %d guids\n", (int)encode_guid_count);
goto fail;
}
if(function_list->nvEncGetEncodeGUIDs(nvenc_encoder, encoder_guids, encode_guid_count, &encode_guid_count) != NV_ENC_SUCCESS) {
fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: nvEncGetEncodeGUIDs failed, error: %s\n", function_list->nvEncGetLastErrorString(nvenc_encoder));
goto fail;
}
for(uint32_t i = 0; i < encode_guid_count; ++i) {
encoder_get_supported_profiles(function_list, nvenc_encoder, &encoder_guids[i], supported_video_codecs);
}
success = true;
fail:
if(encoder_guids)
free(encoder_guids);
return success;
}
#define NVENCAPI_VERSION_470 (11 | (1 << 24))
#define NVENCAPI_STRUCT_VERSION_470(ver) ((uint32_t)NVENCAPI_VERSION_470 | ((ver)<<16) | (0x7 << 28))
bool gsr_get_supported_video_codecs_nvenc(gsr_supported_video_codecs *video_codecs, bool cleanup) {
memset(video_codecs, 0, sizeof(*video_codecs));
bool success = false;
void *nvenc_lib = NULL;
void *nvenc_encoder = NULL;
gsr_cuda cuda;
memset(&cuda, 0, sizeof(cuda));
if(!gsr_cuda_load(&cuda, NULL, false)) {
fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: failed to load cuda\n");
goto done;
}
nvenc_lib = open_nvenc_library();
if(!nvenc_lib)
goto done;
typedef NVENCSTATUS NVENCAPI (*FUNC_NvEncodeAPICreateInstance)(NV_ENCODE_API_FUNCTION_LIST *functionList);
FUNC_NvEncodeAPICreateInstance nvEncodeAPICreateInstance = (FUNC_NvEncodeAPICreateInstance)dlsym(nvenc_lib, "NvEncodeAPICreateInstance");
if(!nvEncodeAPICreateInstance) {
fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: failed to find NvEncodeAPICreateInstance in libnvidia-encode.so\n");
goto done;
}
NV_ENCODE_API_FUNCTION_LIST function_list;
memset(&function_list, 0, sizeof(function_list));
function_list.version = NVENCAPI_STRUCT_VERSION(2);
if(nvEncodeAPICreateInstance(&function_list) != NV_ENC_SUCCESS) {
fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: nvEncodeAPICreateInstance failed\n");
goto done;
}
NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS params;
memset(&params, 0, sizeof(params));
params.version = NVENCAPI_STRUCT_VERSION(1);
params.deviceType = NV_ENC_DEVICE_TYPE_CUDA;
params.device = cuda.cu_ctx;
params.apiVersion = NVENCAPI_VERSION;
if(function_list.nvEncOpenEncodeSessionEx(&params, &nvenc_encoder) != NV_ENC_SUCCESS) {
// Old nvidia gpus dont support the new nvenc api (which is required for av1).
// In such cases fallback to old api version if possible and try again.
function_list.version = NVENCAPI_STRUCT_VERSION_470(2);
if(nvEncodeAPICreateInstance(&function_list) != NV_ENC_SUCCESS) {
fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: nvEncodeAPICreateInstance (retry) failed\n");
goto done;
}
params.version = NVENCAPI_STRUCT_VERSION_470(1);
params.apiVersion = NVENCAPI_VERSION_470;
if(function_list.nvEncOpenEncodeSessionEx(&params, &nvenc_encoder) != NV_ENC_SUCCESS) {
fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: nvEncOpenEncodeSessionEx (retry) failed\n");
goto done;
}
}
success = get_supported_video_codecs(&function_list, nvenc_encoder, video_codecs);
done:
if(cleanup) {
if(nvenc_encoder)
function_list.nvEncDestroyEncoder(nvenc_encoder);
if(nvenc_lib)
dlclose(nvenc_lib);
gsr_cuda_unload(&cuda);
}
return success;
}

193
src/codec_query/vaapi.c Normal file
View File

@@ -0,0 +1,193 @@
#include "../../include/codec_query/vaapi.h"
#include "../../include/utils.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <va/va.h>
#include <va/va_drm.h>
static bool profile_is_h264(VAProfile profile) {
switch(profile) {
case 5: // VAProfileH264Baseline
case VAProfileH264Main:
case VAProfileH264High:
case VAProfileH264ConstrainedBaseline:
return true;
default:
return false;
}
}
static bool profile_is_hevc_8bit(VAProfile profile) {
switch(profile) {
case VAProfileHEVCMain:
return true;
default:
return false;
}
}
static bool profile_is_hevc_10bit(VAProfile profile) {
switch(profile) {
case VAProfileHEVCMain10:
//case VAProfileHEVCMain12:
//case VAProfileHEVCMain422_10:
//case VAProfileHEVCMain422_12:
//case VAProfileHEVCMain444:
//case VAProfileHEVCMain444_10:
//case VAProfileHEVCMain444_12:
return true;
default:
return false;
}
}
static bool profile_is_av1(VAProfile profile) {
switch(profile) {
case VAProfileAV1Profile0:
case VAProfileAV1Profile1:
return true;
default:
return false;
}
}
static bool profile_is_vp8(VAProfile profile) {
switch(profile) {
case VAProfileVP8Version0_3:
return true;
default:
return false;
}
}
static bool profile_is_vp9(VAProfile profile) {
switch(profile) {
case VAProfileVP9Profile0:
case VAProfileVP9Profile1:
case VAProfileVP9Profile2:
case VAProfileVP9Profile3:
return true;
default:
return false;
}
}
static bool profile_supports_video_encoding(VADisplay va_dpy, VAProfile profile) {
int num_entrypoints = vaMaxNumEntrypoints(va_dpy);
if(num_entrypoints <= 0)
return false;
VAEntrypoint *entrypoint_list = calloc(num_entrypoints, sizeof(VAEntrypoint));
if(!entrypoint_list)
return false;
bool supported = false;
if(vaQueryConfigEntrypoints(va_dpy, profile, entrypoint_list, &num_entrypoints) == VA_STATUS_SUCCESS) {
for(int i = 0; i < num_entrypoints; ++i) {
if(entrypoint_list[i] == VAEntrypointEncSlice) {
supported = true;
break;
}
}
}
free(entrypoint_list);
return supported;
}
static bool get_supported_video_codecs(VADisplay va_dpy, gsr_supported_video_codecs *video_codecs, bool cleanup) {
*video_codecs = (gsr_supported_video_codecs){0};
bool success = false;
VAProfile *profile_list = NULL;
vaSetInfoCallback(va_dpy, NULL, NULL);
int va_major = 0;
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;
}
int num_profiles = vaMaxNumProfiles(va_dpy);
if(num_profiles <= 0)
goto fail;
profile_list = calloc(num_profiles, sizeof(VAProfile));
if(!profile_list || vaQueryConfigProfiles(va_dpy, profile_list, &num_profiles) != VA_STATUS_SUCCESS)
goto fail;
for(int i = 0; i < num_profiles; ++i) {
if(profile_is_h264(profile_list[i])) {
if(profile_supports_video_encoding(va_dpy, profile_list[i]))
video_codecs->h264 = true;
} else if(profile_is_hevc_8bit(profile_list[i])) {
if(profile_supports_video_encoding(va_dpy, profile_list[i]))
video_codecs->hevc = true;
} else if(profile_is_hevc_10bit(profile_list[i])) {
if(profile_supports_video_encoding(va_dpy, profile_list[i])) {
video_codecs->hevc_hdr = true;
video_codecs->hevc_10bit = true;
}
} else if(profile_is_av1(profile_list[i])) {
if(profile_supports_video_encoding(va_dpy, profile_list[i])) {
video_codecs->av1 = true;
video_codecs->av1_hdr = true;
video_codecs->av1_10bit = true;
}
} else if(profile_is_vp8(profile_list[i])) {
if(profile_supports_video_encoding(va_dpy, profile_list[i]))
video_codecs->vp8 = true;
} else if(profile_is_vp9(profile_list[i])) {
if(profile_supports_video_encoding(va_dpy, profile_list[i]))
video_codecs->vp9 = true;
}
}
success = true;
fail:
if(profile_list)
free(profile_list);
if(cleanup)
vaTerminate(va_dpy);
return success;
}
bool gsr_get_supported_video_codecs_vaapi(gsr_supported_video_codecs *video_codecs, const char *card_path, bool cleanup) {
memset(video_codecs, 0, sizeof(*video_codecs));
bool success = false;
char render_path[128];
if(!gsr_card_path_get_render_path(card_path, render_path)) {
fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vaapi: failed to get /dev/dri/renderDXXX file from %s\n", card_path);
goto done;
}
const int drm_fd = open(render_path, O_RDWR);
if(drm_fd == -1) {
fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vaapi: failed to open device %s\n", render_path);
goto done;
}
VADisplay va_dpy = vaGetDisplayDRM(drm_fd);
if(va_dpy) {
if(!get_supported_video_codecs(va_dpy, video_codecs, cleanup)) {
fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vaapi: failed to query supported video codecs for device %s\n", render_path);
goto done;
}
success = true;
}
done:
if(cleanup)
close(drm_fd);
return success;
}

231
src/encoder/video/cuda.c
View File

@@ -1,13 +1,11 @@
#include "../../../include/encoder/video/cuda.h"
#include "../../../include/egl.h"
#include "../../../include/cuda.h"
#include "../../../external/nvEncodeAPI.h"
#include <libavcodec/avcodec.h>
#include <libavutil/hwcontext_cuda.h>
#include <stdlib.h>
#include <dlfcn.h>
typedef struct {
gsr_video_encoder_cuda_params params;
@@ -125,234 +123,6 @@ static bool gsr_video_encoder_cuda_setup_textures(gsr_video_encoder_cuda *self,
return true;
}
static void* open_nvenc_library(void) {
dlerror(); /* clear */
void *lib = dlopen("libnvidia-encode.so.1", RTLD_LAZY);
if(!lib) {
lib = dlopen("libnvidia-encode.so", RTLD_LAZY);
if(!lib) {
fprintf(stderr, "gsr error: gsr_video_encoder_cuda_get_supported_codecs failed: failed to load libnvidia-encode.so/libnvidia-encode.so.1, error: %s\n", dlerror());
return NULL;
}
}
return lib;
}
static bool profile_is_h264(const GUID *profile_guid) {
const GUID *h264_guids[] = {
&NV_ENC_H264_PROFILE_BASELINE_GUID,
&NV_ENC_H264_PROFILE_MAIN_GUID,
&NV_ENC_H264_PROFILE_HIGH_GUID,
&NV_ENC_H264_PROFILE_PROGRESSIVE_HIGH_GUID,
&NV_ENC_H264_PROFILE_CONSTRAINED_HIGH_GUID
};
for(int i = 0; i < 5; ++i) {
if(memcmp(profile_guid, h264_guids[i], sizeof(GUID)) == 0)
return true;
}
return false;
}
static bool profile_is_hevc(const GUID *profile_guid) {
const GUID *h264_guids[] = {
&NV_ENC_HEVC_PROFILE_MAIN_GUID,
};
for(int i = 0; i < 1; ++i) {
if(memcmp(profile_guid, h264_guids[i], sizeof(GUID)) == 0)
return true;
}
return false;
}
static bool profile_is_hevc_10bit(const GUID *profile_guid) {
const GUID *h264_guids[] = {
&NV_ENC_HEVC_PROFILE_MAIN10_GUID,
};
for(int i = 0; i < 1; ++i) {
if(memcmp(profile_guid, h264_guids[i], sizeof(GUID)) == 0)
return true;
}
return false;
}
static bool profile_is_av1(const GUID *profile_guid) {
const GUID *h264_guids[] = {
&NV_ENC_AV1_PROFILE_MAIN_GUID,
};
for(int i = 0; i < 1; ++i) {
if(memcmp(profile_guid, h264_guids[i], sizeof(GUID)) == 0)
return true;
}
return false;
}
static bool encoder_get_supported_profiles(const NV_ENCODE_API_FUNCTION_LIST *function_list, void *nvenc_encoder, const GUID *encoder_guid, gsr_supported_video_codecs *supported_video_codecs) {
bool success = false;
GUID *profile_guids = NULL;
uint32_t profile_guid_count = 0;
if(function_list->nvEncGetEncodeProfileGUIDCount(nvenc_encoder, *encoder_guid, &profile_guid_count) != NV_ENC_SUCCESS) {
fprintf(stderr, "gsr error: gsr_video_encoder_cuda_get_supported_codecs: nvEncGetEncodeProfileGUIDCount failed, error: %s\n", function_list->nvEncGetLastErrorString(nvenc_encoder));
goto fail;
}
if(profile_guid_count == 0)
goto fail;
profile_guids = calloc(profile_guid_count, sizeof(GUID));
if(!profile_guids) {
fprintf(stderr, "gsr error: gsr_video_encoder_cuda_get_supported_codecs: failed to allocate %d guids\n", (int)profile_guid_count);
goto fail;
}
if(function_list->nvEncGetEncodeProfileGUIDs(nvenc_encoder, *encoder_guid, profile_guids, profile_guid_count, &profile_guid_count) != NV_ENC_SUCCESS) {
fprintf(stderr, "gsr error: gsr_video_encoder_cuda_get_supported_codecs: nvEncGetEncodeProfileGUIDs failed, error: %s\n", function_list->nvEncGetLastErrorString(nvenc_encoder));
goto fail;
}
for(uint32_t i = 0; i < profile_guid_count; ++i) {
if(profile_is_h264(&profile_guids[i])) {
supported_video_codecs->h264 = true;
} else if(profile_is_hevc(&profile_guids[i])) {
supported_video_codecs->hevc = true;
} else if(profile_is_hevc_10bit(&profile_guids[i])) {
supported_video_codecs->hevc_hdr = true;
supported_video_codecs->hevc_10bit = true;
} else if(profile_is_av1(&profile_guids[i])) {
supported_video_codecs->av1 = true;
supported_video_codecs->av1_hdr = true;
supported_video_codecs->av1_10bit = true;
}
}
success = true;
fail:
if(profile_guids)
free(profile_guids);
return success;
}
static bool get_supported_video_codecs(const NV_ENCODE_API_FUNCTION_LIST *function_list, void *nvenc_encoder, gsr_supported_video_codecs *supported_video_codecs) {
bool success = false;
GUID *encoder_guids = NULL;
*supported_video_codecs = (gsr_supported_video_codecs){0};
uint32_t encode_guid_count = 0;
if(function_list->nvEncGetEncodeGUIDCount(nvenc_encoder, &encode_guid_count) != NV_ENC_SUCCESS) {
fprintf(stderr, "gsr error: gsr_video_encoder_cuda_get_supported_codecs: nvEncGetEncodeGUIDCount failed, error: %s\n", function_list->nvEncGetLastErrorString(nvenc_encoder));
goto fail;
}
if(encode_guid_count == 0)
goto fail;
encoder_guids = calloc(encode_guid_count, sizeof(GUID));
if(!encoder_guids) {
fprintf(stderr, "gsr error: gsr_video_encoder_cuda_get_supported_codecs: failed to allocate %d guids\n", (int)encode_guid_count);
goto fail;
}
if(function_list->nvEncGetEncodeGUIDs(nvenc_encoder, encoder_guids, encode_guid_count, &encode_guid_count) != NV_ENC_SUCCESS) {
fprintf(stderr, "gsr error: gsr_video_encoder_cuda_get_supported_codecs: nvEncGetEncodeGUIDs failed, error: %s\n", function_list->nvEncGetLastErrorString(nvenc_encoder));
goto fail;
}
for(uint32_t i = 0; i < encode_guid_count; ++i) {
encoder_get_supported_profiles(function_list, nvenc_encoder, &encoder_guids[i], supported_video_codecs);
}
success = true;
fail:
if(encoder_guids)
free(encoder_guids);
return success;
}
#define NVENCAPI_VERSION_470 (11 | (1 << 24))
#define NVENCAPI_STRUCT_VERSION_470(ver) ((uint32_t)NVENCAPI_VERSION_470 | ((ver)<<16) | (0x7 << 28))
static gsr_supported_video_codecs gsr_video_encoder_cuda_get_supported_codecs(gsr_video_encoder *encoder, bool cleanup) {
(void)encoder;
void *nvenc_lib = NULL;
void *nvenc_encoder = NULL;
gsr_cuda cuda;
memset(&cuda, 0, sizeof(cuda));
gsr_supported_video_codecs supported_video_codecs = {0};
if(!gsr_cuda_load(&cuda, NULL, false)) {
fprintf(stderr, "gsr error: gsr_video_encoder_cuda_get_supported_codecs: failed to load cuda\n");
goto done;
}
nvenc_lib = open_nvenc_library();
if(!nvenc_lib)
goto done;
typedef NVENCSTATUS NVENCAPI (*FUNC_NvEncodeAPICreateInstance)(NV_ENCODE_API_FUNCTION_LIST *functionList);
FUNC_NvEncodeAPICreateInstance nvEncodeAPICreateInstance = (FUNC_NvEncodeAPICreateInstance)dlsym(nvenc_lib, "NvEncodeAPICreateInstance");
if(!nvEncodeAPICreateInstance) {
fprintf(stderr, "gsr error: gsr_video_encoder_cuda_get_supported_codecs: failed to find NvEncodeAPICreateInstance in libnvidia-encode.so\n");
goto done;
}
NV_ENCODE_API_FUNCTION_LIST function_list;
memset(&function_list, 0, sizeof(function_list));
function_list.version = NVENCAPI_STRUCT_VERSION(2);
if(nvEncodeAPICreateInstance(&function_list) != NV_ENC_SUCCESS) {
fprintf(stderr, "gsr error: gsr_video_encoder_cuda_get_supported_codecs: nvEncodeAPICreateInstance failed\n");
goto done;
}
NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS params;
memset(&params, 0, sizeof(params));
params.version = NVENCAPI_STRUCT_VERSION(1);
params.deviceType = NV_ENC_DEVICE_TYPE_CUDA;
params.device = cuda.cu_ctx;
params.apiVersion = NVENCAPI_VERSION;
if(function_list.nvEncOpenEncodeSessionEx(&params, &nvenc_encoder) != NV_ENC_SUCCESS) {
// Old nvidia gpus dont support the new nvenc api (which is required for av1).
// In such cases fallback to old api version if possible and try again.
function_list.version = NVENCAPI_STRUCT_VERSION_470(2);
if(nvEncodeAPICreateInstance(&function_list) != NV_ENC_SUCCESS) {
fprintf(stderr, "gsr error: gsr_video_encoder_cuda_get_supported_codecs: nvEncodeAPICreateInstance (retry) failed\n");
goto done;
}
params.version = NVENCAPI_STRUCT_VERSION_470(1);
params.apiVersion = NVENCAPI_VERSION_470;
if(function_list.nvEncOpenEncodeSessionEx(&params, &nvenc_encoder) != NV_ENC_SUCCESS) {
fprintf(stderr, "gsr error: gsr_video_encoder_cuda_get_supported_codecs: nvEncOpenEncodeSessionEx (retry) failed\n");
goto done;
}
}
get_supported_video_codecs(&function_list, nvenc_encoder, &supported_video_codecs);
done:
if(cleanup) {
if(nvenc_encoder)
function_list.nvEncDestroyEncoder(nvenc_encoder);
if(nvenc_lib)
dlclose(nvenc_lib);
gsr_cuda_unload(&cuda);
}
return supported_video_codecs;
}
static void gsr_video_encoder_cuda_stop(gsr_video_encoder_cuda *self, AVCodecContext *video_codec_context);
static bool gsr_video_encoder_cuda_start(gsr_video_encoder *encoder, AVCodecContext *video_codec_context, AVFrame *frame) {
@@ -456,7 +226,6 @@ gsr_video_encoder* gsr_video_encoder_cuda_create(const gsr_video_encoder_cuda_pa
encoder_cuda->params = *params;
*encoder = (gsr_video_encoder) {
.get_supported_codecs = gsr_video_encoder_cuda_get_supported_codecs,
.start = gsr_video_encoder_cuda_start,
.copy_textures_to_frame = gsr_video_encoder_cuda_copy_textures_to_frame,
.get_textures = gsr_video_encoder_cuda_get_textures,

17
src/encoder/video/software.c
View File

@@ -58,22 +58,6 @@ static bool gsr_video_encoder_software_setup_textures(gsr_video_encoder_software
return true;
}
static gsr_supported_video_codecs gsr_video_encoder_software_get_supported_codecs(gsr_video_encoder *encoder, bool cleanup) {
(void)encoder;
(void)cleanup;
return (gsr_supported_video_codecs) {
.h264 = true,
.hevc = false,
.hevc_hdr = false,
.hevc_10bit = false,
.av1 = false,
.av1_hdr = false,
.av1_10bit = false,
.vp8 = false,
.vp9 = false
};
}
static void gsr_video_encoder_software_stop(gsr_video_encoder_software *self, AVCodecContext *video_codec_context);
static bool gsr_video_encoder_software_start(gsr_video_encoder *encoder, AVCodecContext *video_codec_context, AVFrame *frame) {
@@ -145,7 +129,6 @@ gsr_video_encoder* gsr_video_encoder_software_create(const gsr_video_encoder_sof
encoder_software->params = *params;
*encoder = (gsr_video_encoder) {
.get_supported_codecs = gsr_video_encoder_software_get_supported_codecs,
.start = gsr_video_encoder_software_start,
.copy_textures_to_frame = gsr_video_encoder_software_copy_textures_to_frame,
.get_textures = gsr_video_encoder_software_get_textures,

180
src/encoder/video/vaapi.c
View File

@@ -6,7 +6,6 @@
#include <libavutil/hwcontext_vaapi.h>
#include <va/va_drmcommon.h>
#include <va/va_drm.h>
#include <stdlib.h>
#include <unistd.h>
@@ -148,184 +147,6 @@ static bool gsr_video_encoder_vaapi_setup_textures(gsr_video_encoder_vaapi *self
}
}
static bool profile_is_h264(VAProfile profile) {
switch(profile) {
case 5: // VAProfileH264Baseline
case VAProfileH264Main:
case VAProfileH264High:
case VAProfileH264ConstrainedBaseline:
return true;
default:
return false;
}
}
static bool profile_is_hevc_8bit(VAProfile profile) {
switch(profile) {
case VAProfileHEVCMain:
return true;
default:
return false;
}
}
static bool profile_is_hevc_10bit(VAProfile profile) {
switch(profile) {
case VAProfileHEVCMain10:
//case VAProfileHEVCMain12:
//case VAProfileHEVCMain422_10:
//case VAProfileHEVCMain422_12:
//case VAProfileHEVCMain444:
//case VAProfileHEVCMain444_10:
//case VAProfileHEVCMain444_12:
return true;
default:
return false;
}
}
static bool profile_is_av1(VAProfile profile) {
switch(profile) {
case VAProfileAV1Profile0:
case VAProfileAV1Profile1:
return true;
default:
return false;
}
}
static bool profile_is_vp8(VAProfile profile) {
switch(profile) {
case VAProfileVP8Version0_3:
return true;
default:
return false;
}
}
static bool profile_is_vp9(VAProfile profile) {
switch(profile) {
case VAProfileVP9Profile0:
case VAProfileVP9Profile1:
case VAProfileVP9Profile2:
case VAProfileVP9Profile3:
return true;
default:
return false;
}
}
static bool profile_supports_video_encoding(VADisplay va_dpy, VAProfile profile) {
int num_entrypoints = vaMaxNumEntrypoints(va_dpy);
if(num_entrypoints <= 0)
return false;
VAEntrypoint *entrypoint_list = calloc(num_entrypoints, sizeof(VAEntrypoint));
if(!entrypoint_list)
return false;
bool supported = false;
if(vaQueryConfigEntrypoints(va_dpy, profile, entrypoint_list, &num_entrypoints) == VA_STATUS_SUCCESS) {
for(int i = 0; i < num_entrypoints; ++i) {
if(entrypoint_list[i] == VAEntrypointEncSlice) {
supported = true;
break;
}
}
}
free(entrypoint_list);
return supported;
}
static bool get_supported_video_codecs(VADisplay va_dpy, gsr_supported_video_codecs *video_codecs, bool cleanup) {
*video_codecs = (gsr_supported_video_codecs){0};
bool success = false;
VAProfile *profile_list = NULL;
vaSetInfoCallback(va_dpy, NULL, NULL);
int va_major = 0;
int va_minor = 0;
if(vaInitialize(va_dpy, &va_major, &va_minor) != VA_STATUS_SUCCESS) {
fprintf(stderr, "gsr error: gsr_video_encoder_vaapi_get_supported_codecs: vaInitialize failed\n");
goto fail;
}
int num_profiles = vaMaxNumProfiles(va_dpy);
if(num_profiles <= 0)
goto fail;
profile_list = calloc(num_profiles, sizeof(VAProfile));
if(!profile_list || vaQueryConfigProfiles(va_dpy, profile_list, &num_profiles) != VA_STATUS_SUCCESS)
goto fail;
for(int i = 0; i < num_profiles; ++i) {
if(profile_is_h264(profile_list[i])) {
if(profile_supports_video_encoding(va_dpy, profile_list[i]))
video_codecs->h264 = true;
} else if(profile_is_hevc_8bit(profile_list[i])) {
if(profile_supports_video_encoding(va_dpy, profile_list[i]))
video_codecs->hevc = true;
} else if(profile_is_hevc_10bit(profile_list[i])) {
if(profile_supports_video_encoding(va_dpy, profile_list[i])) {
video_codecs->hevc_hdr = true;
video_codecs->hevc_10bit = true;
}
} else if(profile_is_av1(profile_list[i])) {
if(profile_supports_video_encoding(va_dpy, profile_list[i])) {
video_codecs->av1 = true;
video_codecs->av1_hdr = true;
video_codecs->av1_10bit = true;
}
} else if(profile_is_vp8(profile_list[i])) {
if(profile_supports_video_encoding(va_dpy, profile_list[i]))
video_codecs->vp8 = true;
} else if(profile_is_vp9(profile_list[i])) {
if(profile_supports_video_encoding(va_dpy, profile_list[i]))
video_codecs->vp9 = true;
}
}
success = true;
fail:
if(profile_list)
free(profile_list);
if(cleanup)
vaTerminate(va_dpy);
return success;
}
static gsr_supported_video_codecs gsr_video_encoder_vaapi_get_supported_codecs(gsr_video_encoder *encoder, bool cleanup) {
gsr_video_encoder_vaapi *self = encoder->priv;
gsr_supported_video_codecs supported_video_codecs = {0};
char render_path[128];
if(!gsr_card_path_get_render_path(self->params.egl->card_path, render_path)) {
fprintf(stderr, "gsr error: gsr_video_encoder_vaapi_get_supported_codecs: failed to get /dev/dri/renderDXXX file from %s\n", self->params.egl->card_path);
return supported_video_codecs;
}
const int drm_fd = open(render_path, O_RDWR);
if(drm_fd == -1) {
fprintf(stderr, "gsr error: gsr_video_encoder_vaapi_get_supported_codecs: failed to open device %s\n", render_path);
return supported_video_codecs;
}
VADisplay va_dpy = vaGetDisplayDRM(drm_fd);
if(va_dpy) {
if(!get_supported_video_codecs(va_dpy, &supported_video_codecs, cleanup))
fprintf(stderr, "gsr error: gsr_video_encoder_vaapi_get_supported_codecs: failed to query supported video codecs for device %s\n", render_path);
}
if(cleanup)
close(drm_fd);
return supported_video_codecs;
}
static void gsr_video_encoder_vaapi_stop(gsr_video_encoder_vaapi *self, AVCodecContext *video_codec_context);
static bool gsr_video_encoder_vaapi_start(gsr_video_encoder *encoder, AVCodecContext *video_codec_context, AVFrame *frame) {
@@ -413,7 +234,6 @@ gsr_video_encoder* gsr_video_encoder_vaapi_create(const gsr_video_encoder_vaapi_
encoder_vaapi->params = *params;
*encoder = (gsr_video_encoder) {
.get_supported_codecs = gsr_video_encoder_vaapi_get_supported_codecs,
.start = gsr_video_encoder_vaapi_start,
.copy_textures_to_frame = NULL,
.get_textures = gsr_video_encoder_vaapi_get_textures,

4
src/encoder/video/video.c
View File

@@ -1,10 +1,6 @@
#include "../../../include/encoder/video/video.h"
#include <assert.h>
gsr_supported_video_codecs gsr_video_encoder_get_supported_codecs(gsr_video_encoder *encoder, bool cleanup) {
return encoder->get_supported_codecs(encoder, cleanup);
}
bool gsr_video_encoder_start(gsr_video_encoder *encoder, AVCodecContext *video_codec_context, AVFrame *frame) {
assert(!encoder->started);
bool res = encoder->start(encoder, video_codec_context, frame);

36
src/main.cpp
View File

@@ -9,6 +9,8 @@ extern "C" {
#include "../include/encoder/video/cuda.h"
#include "../include/encoder/video/vaapi.h"
#include "../include/encoder/video/software.h"
#include "../include/codec_query/cuda.h"
#include "../include/codec_query/vaapi.h"
#include "../include/egl.h"
#include "../include/utils.h"
#include "../include/damage.h"
@@ -1656,6 +1658,25 @@ static gsr_video_encoder* create_video_encoder(gsr_egl *egl, bool overclock, gsr
return video_encoder;
}
static bool get_supported_video_codecs(gsr_egl *egl, bool use_software_video_encoder, bool cleanup, gsr_supported_video_codecs *video_codecs) {
memset(video_codecs, 0, sizeof(*video_codecs));
if(use_software_video_encoder) {
video_codecs->h264 = true;
return true;
}
switch(egl->gpu_info.vendor) {
case GSR_GPU_VENDOR_AMD:
case GSR_GPU_VENDOR_INTEL:
return gsr_get_supported_video_codecs_vaapi(video_codecs, egl->card_path, cleanup);
case GSR_GPU_VENDOR_NVIDIA:
return gsr_get_supported_video_codecs_nvenc(video_codecs, cleanup);
}
return false;
}
static void xwayland_check_callback(const gsr_monitor *monitor, void *userdata) {
bool *xwayland_found = (bool*)userdata;
if(monitor->name_len >= 8 && strncmp(monitor->name, "XWAYLAND", 8) == 0)
@@ -1756,7 +1777,8 @@ static void list_supported_video_codecs(gsr_egl *egl, bool wayland) {
if(!video_encoder)
return;
gsr_supported_video_codecs supported_video_codecs = gsr_video_encoder_get_supported_codecs(video_encoder, false);
gsr_supported_video_codecs supported_video_codecs;
get_supported_video_codecs(egl, false, false, &supported_video_codecs);
set_supported_video_codecs_ffmpeg(&supported_video_codecs, egl->gpu_info.vendor);
if(supported_video_codecs.h264)
@@ -2223,18 +2245,14 @@ static const char* video_codec_to_string(VideoCodec video_codec) {
static const AVCodec* pick_video_codec(VideoCodec *video_codec, gsr_egl *egl, bool use_software_video_encoder, bool video_codec_auto, const char *video_codec_to_use, bool is_flv) {
// TODO: software encoder for hevc, av1, vp8 and vp9
gsr_video_encoder *video_encoder = create_video_encoder(egl, false, GSR_COLOR_DEPTH_8_BITS, use_software_video_encoder);
if(!video_encoder) {
fprintf(stderr, "Error: failed to create video encoder\n");
_exit(1);
gsr_supported_video_codecs supported_video_codecs;
if(!get_supported_video_codecs(egl, use_software_video_encoder, true, &supported_video_codecs)) {
fprintf(stderr, "Error: failed to query for supported video codecs\n");
_exit(11);
}
const gsr_supported_video_codecs supported_video_codecs = gsr_video_encoder_get_supported_codecs(video_encoder, true);
const AVCodec *video_codec_f = nullptr;
// TODO: Cleanup
// gsr_video_encoder_destroy
switch(*video_codec) {
case VideoCodec::H264: {
if(use_software_video_encoder)