Move codec query from encoder to separate file

7 files changed, 455 insertions, 441 deletions

diff --git a/src/codec_query/cuda.c b/src/codec_query/cuda.c
new file mode 100644
index 0000000..690e7d4
--- /dev/null
+++ b/src/codec_query/cuda.c
@@ -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;
+}
diff --git a/src/codec_query/vaapi.c b/src/codec_query/vaapi.c
new file mode 100644
index 0000000..d9f3497
--- /dev/null
+++ b/src/codec_query/vaapi.c
@@ -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;
+}
diff --git a/src/encoder/video/cuda.c b/src/encoder/video/cuda.c
index c878dc8..f3cc9a4 100644
--- a/src/encoder/video/cuda.c
+++ b/src/encoder/video/cuda.c
@@ -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,
diff --git a/src/encoder/video/software.c b/src/encoder/video/software.c
index fe23156..cedcc1b 100644
--- a/src/encoder/video/software.c
+++ b/src/encoder/video/software.c
@@ -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,
diff --git a/src/encoder/video/vaapi.c b/src/encoder/video/vaapi.c
index 9f3a807..b5ccce9 100644
--- a/src/encoder/video/vaapi.c
+++ b/src/encoder/video/vaapi.c
@@ -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,
diff --git a/src/encoder/video/video.c b/src/encoder/video/video.c
index daaf537..9b0def0 100644
--- a/src/encoder/video/video.c
+++ b/src/encoder/video/video.c
@@ -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);
diff --git a/src/main.cpp b/src/main.cpp
index 7c66bd1..79f5be8 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -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)