mirror of
https://repo.dec05eba.com/gpu-screen-recorder
synced 2026-03-31 17:17:16 +09:00
Move codec query from encoder to separate file
This commit is contained in:
dec05eba
235
src/codec_query/cuda.c
Normal file
235
src/codec_query/cuda.c
Normal 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(¶ms, 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(¶ms, &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(¶ms, &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
193
src/codec_query/vaapi.c
Normal 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;
|
||||
}
|
||||
Reference in New Issue
Block a user