#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <stdarg.h>
#include <va/va.h>
#include <va/va_vpp.h>
#include <va/va_x11.h>
#include <X11/Xlib.h>

static void
error(const char *format, ...)
{
    va_list args;

    va_start(args, format);
    fprintf(stderr, "error: ");
    vfprintf(stderr, format, args);
    fprintf(stderr, "\n");
    va_end(args);
}

static bool
va_check_status(VAStatus status, const char *msg)
{
    if (status != VA_STATUS_SUCCESS) {
        error("%s: %s", msg, vaErrorStr(status));
        return false;
    }
    return true;
}

struct map_entry {
    int         value;
    const char *str;
};

static const struct map_entry *
map_lookup(const struct map_entry *map, int value)
{
    const struct map_entry *m;

    for (m = map; m->str != NULL; m++) {
        if (m->value == value)
            return m;
    }
    return NULL;
}

static const struct map_entry map_filters[] = {
    { VAProcFilterNoiseReduction,       "noise-reduction"       },
    { VAProcFilterDeinterlacing,        "deinterlacing"         },
    { VAProcFilterSharpening,           "sharpening"            },
    { VAProcFilterColorBalance,         "color-balance"         },
    { 0, NULL }
};

int
main(void)
{
    Display *dpy = NULL;
    VADisplay va_dpy = NULL;
    VAConfigID va_config = VA_INVALID_ID;
    VAContextID va_context = VA_INVALID_ID;
    VAStatus va_status;
    VAProcFilterType *filters = NULL;
    unsigned int i, num_filters = 0;
    int va_major_version, va_minor_version;
    bool va_initialized = false, success = false;

    dpy = XOpenDisplay(NULL);
    if (!dpy) {
        error("failed to create X11 display");
        goto end;
    }

    va_dpy = vaGetDisplay(dpy);
    if (!va_dpy) {
        error("failed to create VA display");
        goto end;
    }

    va_status = vaInitialize(va_dpy, &va_major_version, &va_minor_version);
    if (!va_check_status(va_status, "vaInitialize()"))
        goto end;
    va_initialized = true;

    va_status = vaCreateConfig(va_dpy, VAProfileNone,
        VAEntrypointVideoProc, NULL, 0, &va_config);
    if (!va_check_status(va_status, "vaCreateConfig()"))
        goto end;

    va_status = vaCreateContext(va_dpy, va_config, 0, 0, 0, NULL, 0,
        &va_context);
    if (!va_check_status(va_status, "vaCreateContext()"))
        goto end;

    num_filters = 1; //VAProcFilterCount;
    filters = malloc(num_filters * sizeof(*filters));
    if (!filters) {
        error("failed to allocate VA filters memory");
        goto end;
    }

    va_status = vaQueryVideoProcFilters(va_dpy, va_context,
        filters, &num_filters);

    // Try to reallocate to the expected number of filters
    if (va_status == VA_STATUS_ERROR_MAX_NUM_EXCEEDED) {
        VAProcFilterType * const new_filters =
            realloc(filters, num_filters * sizeof(*new_filters));
        if (!new_filters) {
            error("failed to reallocate VA filters memory");
            goto end;
        }
        filters = new_filters;

        va_status = vaQueryVideoProcFilters(va_dpy, va_context,
            filters, &num_filters);
    }
    if (!va_check_status(va_status, "vaQueryVideoProcFilters()"))
        goto end;

    printf("%u filters\n", num_filters);
    for (i = 0; i < num_filters; i++) {
        const struct map_entry * const m = map_lookup(map_filters, filters[i]);
        if (m && m->str)
            printf("  %s\n", m->str);
        else
            printf("  unknown filter %d\n", filters[i]);
    }
    success = true;

end:
    free(filters);
    if (va_initialized) {
        if (va_context != VA_INVALID_ID)
            vaDestroyContext(va_dpy, va_context);
        if (va_config != VA_INVALID_ID)
            vaDestroyConfig(va_dpy, va_config);
        vaTerminate(va_dpy);
    }
    XCloseDisplay(dpy);
    return success ? 0 : EXIT_FAILURE;
}