/*

 * Copyright (c) 2007 Intel Corporation. All Rights Reserved.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the

 * "Software"), to deal in the Software without restriction, including

 * without limitation the rights to use, copy, modify, merge, publish,

 * distribute, sub license, and/or sell copies of the Software, and to

 * permit persons to whom the Software is furnished to do so, subject to

 * the following conditions:

 * 

 * The above copyright notice and this permission notice (including the

 * next paragraph) shall be included in all copies or substantial portions

 * of the Software.

 * 

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.

 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR

 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 */

#define _GNU_SOURCE 1

#include "sysdeps.h"

#include "va.h"

#include "va_backend.h"

#include "va_backend_vpp.h"

#include "va_internal.h"

#include "va_trace.h"

#include "va_fool.h"

#include <assert.h>

#include <stdarg.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <dlfcn.h>

#include <unistd.h>

#ifdef ANDROID

#include <log/log.h>

/* support versions < JellyBean */

#ifndef ALOGE

#define ALOGE LOGE

#endif

#ifndef ALOGI

#define ALOGI LOGI

#endif

#endif

#define DRIVER_EXTENSION	"_drv_video.so"

#define ASSERT		assert

#define CHECK_VTABLE(s, ctx, func) if (!va_checkVtable(dpy, ctx->vtable->va##func, #func)) s = VA_STATUS_ERROR_UNKNOWN;

#define CHECK_MAXIMUM(s, ctx, var) if (!va_checkMaximum(dpy, ctx->max_##var, #var)) s = VA_STATUS_ERROR_UNKNOWN;

#define CHECK_STRING(s, ctx, var) if (!va_checkString(dpy, ctx->str_##var, #var)) s = VA_STATUS_ERROR_UNKNOWN;

/*

 * read a config "env" for libva.conf or from environment setting

 * libva.conf has higher priority

 * return 0: the "env" is set, and the value is copied into env_value

 *        1: the env is not set

 */

int va_parseConfig(char *env, char *env_value)

{

    char *token, *value, *saveptr;

    char oneline[1024];

    FILE *fp=NULL;

    if (env == NULL)

        return 1;

    fp = fopen("/etc/libva.conf", "r");

    while (fp && (fgets(oneline, 1024, fp) != NULL)) {

        if (strlen(oneline) == 1)

            continue;

        token = strtok_r(oneline, "=\n", &saveptr);

        value = strtok_r(NULL, "=\n", &saveptr);

        if (NULL == token || NULL == value)

            continue;

        if (strcmp(token, env) == 0) {

            if (env_value) {

                strncpy(env_value,value, 1024);

                env_value[1023] = '\0';

            }

            fclose(fp);

            return 0;

        }

    }

    if (fp)

        fclose(fp);

    /* no setting in config file, use env setting */

    value = getenv(env);

    if (value) {

        if (env_value) {

            strncpy(env_value, value, 1024);

            env_value[1023] = '\0';

        }

        return 0;

    }

    return 1;

}

int vaDisplayIsValid(VADisplay dpy)

{

    VADisplayContextP pDisplayContext = (VADisplayContextP)dpy;

    return pDisplayContext && (pDisplayContext->vadpy_magic == VA_DISPLAY_MAGIC) && pDisplayContext->vaIsValid(pDisplayContext);

}

/*

 * Global log level configured from the config file or environment, which sets

 * whether default logging appears or not (always overridden by explicitly

 * user-configured logging).

 */

static int default_log_level = 2;

static void default_log_error(void *user_context, const char *buffer)

{

    if (default_log_level < 1)

        return;

# ifdef ANDROID

    ALOGE("%s", buffer);

# else

    fprintf(stderr, "libva error: %s", buffer);

# endif

}

static void default_log_info(void *user_context, const char *buffer)

{

    if (default_log_level < 2)

        return;

# ifdef ANDROID

    ALOGI("%s", buffer);

# else

    fprintf(stderr, "libva info: %s", buffer);

# endif

}

/**

 * Set the callback for error messages, or NULL for no logging.

 * Returns the previous one, or NULL if it was disabled.

 */

VAMessageCallback vaSetErrorCallback(VADisplay dpy, VAMessageCallback callback, void *user_context)

{

    VADisplayContextP dctx;

    VAMessageCallback old_callback;

    if (!vaDisplayIsValid(dpy))

        return NULL;

    dctx = (VADisplayContextP)dpy;

    old_callback = dctx->error_callback;

    dctx->error_callback = callback;

    dctx->error_callback_user_context = user_context;

    return old_callback;

}

/**

 * Set the callback for info messages, or NULL for no logging.

 * Returns the previous one, or NULL if it was disabled.

 */

VAMessageCallback vaSetInfoCallback(VADisplay dpy, VAMessageCallback callback, void *user_context)

{

    VADisplayContextP dctx;

    VAMessageCallback old_callback;

    if (!vaDisplayIsValid(dpy))

        return NULL;

    dctx = (VADisplayContextP)dpy;

    old_callback = dctx->info_callback;

    dctx->info_callback = callback;

    dctx->info_callback_user_context = user_context;

    return old_callback;

}

static void va_MessagingInit()

{

#if ENABLE_VA_MESSAGING

    char env_value[1024];

    int ret;

    if (va_parseConfig("LIBVA_MESSAGING_LEVEL", &env_value[0]) == 0) {

        ret = sscanf(env_value, "%d", &default_log_level);

        if (ret < 1 || default_log_level < 0 || default_log_level > 2)

            default_log_level = 2;

    }

#endif

}

void va_errorMessage(VADisplay dpy, const char *msg, ...)

{

#if ENABLE_VA_MESSAGING

    VADisplayContextP dctx = (VADisplayContextP)dpy;

    char buf[512], *dynbuf;

    va_list args;

    int n, len;

    if (dctx->error_callback == NULL)

        return;

    va_start(args, msg);

    len = vsnprintf(buf, sizeof(buf), msg, args);

    va_end(args);

    if (len >= (int)sizeof(buf)) {

        dynbuf = malloc(len + 1);

        if (!dynbuf)

            return;

        va_start(args, msg);

        n = vsnprintf(dynbuf, len + 1, msg, args);

        va_end(args);

        if (n == len)

            dctx->error_callback(dctx->error_callback_user_context, dynbuf);

        free(dynbuf);

    }

    else if (len > 0)

        dctx->error_callback(dctx->error_callback_user_context, buf);

#endif

}

void va_infoMessage(VADisplay dpy, const char *msg, ...)

{

#if ENABLE_VA_MESSAGING

    VADisplayContextP dctx = (VADisplayContextP)dpy;

    char buf[512], *dynbuf;

    va_list args;

    int n, len;

    if (dctx->info_callback == NULL)

        return;

    va_start(args, msg);

    len = vsnprintf(buf, sizeof(buf), msg, args);

    va_end(args);

    if (len >= (int)sizeof(buf)) {

        dynbuf = malloc(len + 1);

        if (!dynbuf)

            return;

        va_start(args, msg);

        n = vsnprintf(dynbuf, len + 1, msg, args);

        va_end(args);

        if (n == len)

            dctx->info_callback(dctx->info_callback_user_context, dynbuf);

        free(dynbuf);

    }

    else if (len > 0)

        dctx->info_callback(dctx->info_callback_user_context, buf);

#endif

}

static void va_driverErrorCallback(VADriverContextP ctx,

                                   const char *message)

{

    VADisplayContextP dctx = ctx->pDisplayContext;

    if (!dctx)

        return;

    dctx->error_callback(dctx->error_callback_user_context, message);

}

static void va_driverInfoCallback(VADriverContextP ctx,

                                  const char *message)

{

    VADisplayContextP dctx = ctx->pDisplayContext;

    if (!dctx)

        return;

    dctx->info_callback(dctx->info_callback_user_context, message);

}

VADisplayContextP va_newDisplayContext(void)

{

    VADisplayContextP dctx = calloc(1, sizeof(*dctx));

    if (!dctx)

        return NULL;

    dctx->vadpy_magic = VA_DISPLAY_MAGIC;

    dctx->error_callback = default_log_error;

    dctx->info_callback  = default_log_info;

    return dctx;

}

VADriverContextP va_newDriverContext(VADisplayContextP dctx)

{

    VADriverContextP ctx = calloc(1, sizeof(*ctx));

    if (!ctx)

        return NULL;

    dctx->pDriverContext = ctx;

    ctx->pDisplayContext = dctx;

    ctx->error_callback = va_driverErrorCallback;

    ctx->info_callback  = va_driverInfoCallback;

    return ctx;

}

static bool va_checkVtable(VADisplay dpy, void *ptr, char *function)

{

    if (!ptr) {

        va_errorMessage(dpy, "No valid vtable entry for va%s\n", function);

        return false;

    }

    return true;

}

static bool va_checkMaximum(VADisplay dpy, int value, char *variable)

{

    if (!value) {

        va_errorMessage(dpy, "Failed to define max_%s in init\n", variable);

        return false;

    }

    return true;

}

static bool va_checkString(VADisplay dpy, const char* value, char *variable)

{

    if (!value) {

        va_errorMessage(dpy, "Failed to define str_%s in init\n", variable);

        return false;

    }

    return true;

}

static inline int

va_getDriverInitName(char *name, int namelen, int major, int minor)

{

    int ret = snprintf(name, namelen, "__vaDriverInit_%d_%d", major, minor);

    return ret > 0 && ret < namelen;

}

static VAStatus va_getDriverName(VADisplay dpy, char **driver_name)

{

    VADisplayContextP pDisplayContext = (VADisplayContextP)dpy;

    return pDisplayContext->vaGetDriverName(pDisplayContext, driver_name);

}

static char *va_getDriverPath(const char *driver_dir, const char *driver_name)

{

  int n = snprintf(0, 0, "%s/%s%s", driver_dir, driver_name, DRIVER_EXTENSION);

  if (n < 0)

      return NULL;

  char *driver_path = (char *) malloc(n + 1);

  if (!driver_path)

      return NULL;

  n = snprintf(driver_path, n + 1, "%s/%s%s",

               driver_dir, driver_name, DRIVER_EXTENSION);

  if (n < 0) {

    free(driver_path);

    return NULL;

  }

  return driver_path;

}

static VAStatus va_openDriver(VADisplay dpy, char *driver_name)

{

    VADriverContextP ctx = CTX(dpy);

    VAStatus vaStatus = VA_STATUS_ERROR_UNKNOWN;

    char *search_path = NULL;

    char *saveptr;

    char *driver_dir;

    if (geteuid() == getuid())

        /* don't allow setuid apps to use LIBVA_DRIVERS_PATH */

        search_path = getenv("LIBVA_DRIVERS_PATH");

    if (!search_path)

        search_path = VA_DRIVERS_PATH;

    search_path = strdup((const char *)search_path);

    if (!search_path) {

         va_errorMessage(dpy, "%s L%d Out of memory\n",

                            __FUNCTION__, __LINE__);

         return VA_STATUS_ERROR_ALLOCATION_FAILED;

    }

    driver_dir = strtok_r(search_path, ":", &saveptr);

    while (driver_dir) {

        void *handle = NULL;

        char *driver_path = va_getDriverPath(driver_dir, driver_name);

        if (!driver_path) {

            va_errorMessage(dpy, "%s L%d Out of memory\n",

                            __FUNCTION__, __LINE__);

            free(search_path);

            return VA_STATUS_ERROR_ALLOCATION_FAILED;

        }

        va_infoMessage(dpy, "Trying to open %s\n", driver_path);

#ifndef ANDROID

        handle = dlopen( driver_path, RTLD_NOW | RTLD_GLOBAL | RTLD_NODELETE );

#else

        handle = dlopen( driver_path, RTLD_NOW| RTLD_GLOBAL);

#endif

        if (!handle) {

            /* Don't give errors for non-existing files */

            if (0 == access( driver_path, F_OK))

                va_errorMessage(dpy, "dlopen of %s failed: %s\n", driver_path, dlerror());

        } else {

            VADriverInit init_func = NULL;

            char init_func_s[256];

            int i;

            static const struct {

                int major;

                int minor;

            } compatible_versions[] = {

                { VA_MAJOR_VERSION, VA_MINOR_VERSION },

                { VA_MAJOR_VERSION, 4 },

                { VA_MAJOR_VERSION, 3 },

                { VA_MAJOR_VERSION, 2 },

                { VA_MAJOR_VERSION, 1 },

                { VA_MAJOR_VERSION, 0 },

                { -1, -1}

            };

            for (i = 0; compatible_versions[i].major >= 0; i++) {

                if (va_getDriverInitName(init_func_s, sizeof(init_func_s),

                                         compatible_versions[i].major,

                                         compatible_versions[i].minor)) {

                    init_func = (VADriverInit)dlsym(handle, init_func_s);

                    if (init_func) {

                        va_infoMessage(dpy, "Found init function %s\n", init_func_s);

                        break;

                    }

                }

            }

            if (compatible_versions[i].major < 0) {

                va_errorMessage(dpy, "%s has no function %s\n",

                                driver_path, init_func_s);

                dlclose(handle);

            } else {

                struct VADriverVTable *vtable = ctx->vtable;

                struct VADriverVTableVPP *vtable_vpp = ctx->vtable_vpp;

                vaStatus = VA_STATUS_SUCCESS;

                if (!vtable) {

                    vtable = calloc(1, sizeof(*vtable));

                    if (!vtable)

                        vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;

                }

                ctx->vtable = vtable;

                if (!vtable_vpp) {

                    vtable_vpp = calloc(1, sizeof(*vtable_vpp));

                    if (vtable_vpp)

                        vtable_vpp->version = VA_DRIVER_VTABLE_VPP_VERSION;

                    else

                        vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;

                }

                ctx->vtable_vpp = vtable_vpp;

                if (init_func && VA_STATUS_SUCCESS == vaStatus)

                    vaStatus = (*init_func)(ctx);

                if (VA_STATUS_SUCCESS == vaStatus) {

                    CHECK_MAXIMUM(vaStatus, ctx, profiles);

                    CHECK_MAXIMUM(vaStatus, ctx, entrypoints);

                    CHECK_MAXIMUM(vaStatus, ctx, attributes);

                    CHECK_MAXIMUM(vaStatus, ctx, image_formats);

                    CHECK_MAXIMUM(vaStatus, ctx, subpic_formats);

                    CHECK_STRING(vaStatus, ctx, vendor);

                    CHECK_VTABLE(vaStatus, ctx, Terminate);

                    CHECK_VTABLE(vaStatus, ctx, QueryConfigProfiles);

                    CHECK_VTABLE(vaStatus, ctx, QueryConfigEntrypoints);

                    CHECK_VTABLE(vaStatus, ctx, QueryConfigAttributes);

                    CHECK_VTABLE(vaStatus, ctx, CreateConfig);

                    CHECK_VTABLE(vaStatus, ctx, DestroyConfig);

                    CHECK_VTABLE(vaStatus, ctx, GetConfigAttributes);

                    CHECK_VTABLE(vaStatus, ctx, CreateSurfaces);

                    CHECK_VTABLE(vaStatus, ctx, DestroySurfaces);

                    CHECK_VTABLE(vaStatus, ctx, CreateContext);

                    CHECK_VTABLE(vaStatus, ctx, DestroyContext);

                    CHECK_VTABLE(vaStatus, ctx, CreateBuffer);

                    CHECK_VTABLE(vaStatus, ctx, BufferSetNumElements);

                    CHECK_VTABLE(vaStatus, ctx, MapBuffer);

                    CHECK_VTABLE(vaStatus, ctx, UnmapBuffer);

                    CHECK_VTABLE(vaStatus, ctx, DestroyBuffer);

                    CHECK_VTABLE(vaStatus, ctx, BeginPicture);

                    CHECK_VTABLE(vaStatus, ctx, RenderPicture);

                    CHECK_VTABLE(vaStatus, ctx, EndPicture);

                    CHECK_VTABLE(vaStatus, ctx, SyncSurface);

                    CHECK_VTABLE(vaStatus, ctx, QuerySurfaceStatus);

                    CHECK_VTABLE(vaStatus, ctx, PutSurface);

                    CHECK_VTABLE(vaStatus, ctx, QueryImageFormats);

                    CHECK_VTABLE(vaStatus, ctx, CreateImage);

                    CHECK_VTABLE(vaStatus, ctx, DeriveImage);

                    CHECK_VTABLE(vaStatus, ctx, DestroyImage);

                    CHECK_VTABLE(vaStatus, ctx, SetImagePalette);

                    CHECK_VTABLE(vaStatus, ctx, GetImage);

                    CHECK_VTABLE(vaStatus, ctx, PutImage);

                    CHECK_VTABLE(vaStatus, ctx, QuerySubpictureFormats);

                    CHECK_VTABLE(vaStatus, ctx, CreateSubpicture);

                    CHECK_VTABLE(vaStatus, ctx, DestroySubpicture);

                    CHECK_VTABLE(vaStatus, ctx, SetSubpictureImage);

                    CHECK_VTABLE(vaStatus, ctx, SetSubpictureChromakey);

                    CHECK_VTABLE(vaStatus, ctx, SetSubpictureGlobalAlpha);

                    CHECK_VTABLE(vaStatus, ctx, AssociateSubpicture);

                    CHECK_VTABLE(vaStatus, ctx, DeassociateSubpicture);

                    CHECK_VTABLE(vaStatus, ctx, QueryDisplayAttributes);

                    CHECK_VTABLE(vaStatus, ctx, GetDisplayAttributes);

                    CHECK_VTABLE(vaStatus, ctx, SetDisplayAttributes);

                }

                if (VA_STATUS_SUCCESS != vaStatus) {

                    va_errorMessage(dpy, "%s init failed\n", driver_path);

                    dlclose(handle);

                }

                if (VA_STATUS_SUCCESS == vaStatus)

                    ctx->handle = handle;

                free(driver_path);

                break;

            }

        }

        free(driver_path);

        driver_dir = strtok_r(NULL, ":", &saveptr);

    }

    free(search_path);    

    return vaStatus;

}

VAPrivFunc vaGetLibFunc(VADisplay dpy, const char *func)

{

    VADriverContextP ctx;

    if (!vaDisplayIsValid(dpy))

        return NULL;

    ctx = CTX(dpy);

    if (NULL == ctx->handle)

        return NULL;

    return (VAPrivFunc) dlsym(ctx->handle, func);

}

/*

 * Returns a short english description of error_status

 */

const char *vaErrorStr(VAStatus error_status)

{

    switch(error_status) {

        case VA_STATUS_SUCCESS:

            return "success (no error)";

        case VA_STATUS_ERROR_OPERATION_FAILED:

            return "operation failed";

        case VA_STATUS_ERROR_ALLOCATION_FAILED:

            return "resource allocation failed";

        case VA_STATUS_ERROR_INVALID_DISPLAY:

            return "invalid VADisplay";

        case VA_STATUS_ERROR_INVALID_CONFIG:

            return "invalid VAConfigID";

        case VA_STATUS_ERROR_INVALID_CONTEXT:

            return "invalid VAContextID";

        case VA_STATUS_ERROR_INVALID_SURFACE:

            return "invalid VASurfaceID";

        case VA_STATUS_ERROR_INVALID_BUFFER:

            return "invalid VABufferID";

        case VA_STATUS_ERROR_INVALID_IMAGE:

            return "invalid VAImageID";

        case VA_STATUS_ERROR_INVALID_SUBPICTURE:

            return "invalid VASubpictureID";

        case VA_STATUS_ERROR_ATTR_NOT_SUPPORTED:

            return "attribute not supported";

        case VA_STATUS_ERROR_MAX_NUM_EXCEEDED:

            return "list argument exceeds maximum number";

        case VA_STATUS_ERROR_UNSUPPORTED_PROFILE:

            return "the requested VAProfile is not supported";

        case VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT:

            return "the requested VAEntryPoint is not supported";

        case VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT:

            return "the requested RT Format is not supported";

        case VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE:

            return "the requested VABufferType is not supported";

        case VA_STATUS_ERROR_SURFACE_BUSY:

            return "surface is in use";

        case VA_STATUS_ERROR_FLAG_NOT_SUPPORTED:

            return "flag not supported";

        case VA_STATUS_ERROR_INVALID_PARAMETER:

            return "invalid parameter";

        case VA_STATUS_ERROR_RESOLUTION_NOT_SUPPORTED:

            return "resolution not supported";

        case VA_STATUS_ERROR_UNIMPLEMENTED:

            return "the requested function is not implemented";

        case VA_STATUS_ERROR_SURFACE_IN_DISPLAYING:

            return "surface is in displaying (may by overlay)" ;

        case VA_STATUS_ERROR_INVALID_IMAGE_FORMAT:

            return "invalid VAImageFormat";

        case VA_STATUS_ERROR_DECODING_ERROR:

            return "internal decoding error";

        case VA_STATUS_ERROR_ENCODING_ERROR:

            return "internal encoding error";

        case VA_STATUS_ERROR_INVALID_VALUE:

            return "an invalid/unsupported value was supplied";

        case VA_STATUS_ERROR_UNSUPPORTED_FILTER:

            return "the requested filter is not supported";

        case VA_STATUS_ERROR_INVALID_FILTER_CHAIN:

            return "an invalid filter chain was supplied";

        case VA_STATUS_ERROR_HW_BUSY:

            return "HW busy now";

        case VA_STATUS_ERROR_UNSUPPORTED_MEMORY_TYPE:

            return "an unsupported memory type was supplied";

        case VA_STATUS_ERROR_NOT_ENOUGH_BUFFER:

            return "allocated memory size is not enough for input or output";

        case VA_STATUS_ERROR_UNKNOWN:

            return "unknown libva error";

    }

    return "unknown libva error / description missing";

}

VAStatus vaSetDriverName(

    VADisplay dpy,

    char *driver_name

)

{

    VADriverContextP ctx;

    VAStatus vaStatus = VA_STATUS_SUCCESS;

    char *override_driver_name = NULL;

    ctx = CTX(dpy);

    if (strlen(driver_name) == 0 || strlen(driver_name) >=256) {

        vaStatus = VA_STATUS_ERROR_INVALID_PARAMETER;

        va_errorMessage(dpy, "vaSetDriverName returns %s\n",

                         vaErrorStr(vaStatus));

        return vaStatus;

    }

    override_driver_name = strdup(driver_name);

    if (!override_driver_name) {

        vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;

        va_errorMessage(dpy, "vaSetDriverName returns %s. Out of Memory\n",

                         vaErrorStr(vaStatus));

        return vaStatus;

    }

    ctx->override_driver_name = override_driver_name;

    return VA_STATUS_SUCCESS;

}

VAStatus vaInitialize (

    VADisplay dpy,

    int *major_version,	 /* out */

    int *minor_version 	 /* out */

)

{

    const char *driver_name_env = NULL;

    char *driver_name = NULL;

    VAStatus vaStatus;

    VADriverContextP ctx;

    CHECK_DISPLAY(dpy);

    ctx = CTX(dpy);

    va_TraceInit(dpy);

    va_FoolInit(dpy);

    va_MessagingInit();

    va_infoMessage(dpy, "VA-API version %s\n", VA_VERSION_S);

    vaStatus = va_getDriverName(dpy, &driver_name);

    if (!ctx->override_driver_name) {

        va_infoMessage(dpy, "va_getDriverName() returns %d\n", vaStatus);

        driver_name_env = getenv("LIBVA_DRIVER_NAME");

    } else if (vaStatus == VA_STATUS_SUCCESS) {

        if (driver_name)

            free(driver_name);

        driver_name = strdup(ctx->override_driver_name);

        if (!driver_name) {

            vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;

            va_errorMessage(dpy, "vaInitialize() failed with %s, out of memory\n",

                        vaErrorStr(vaStatus));

            return vaStatus;

        }

        va_infoMessage(dpy, "User requested driver '%s'\n", driver_name);

    }

    if (driver_name_env && (geteuid() == getuid())) {

        /* Don't allow setuid apps to use LIBVA_DRIVER_NAME */

        if (driver_name) /* memory is allocated in va_getDriverName */

            free(driver_name);

        driver_name = strdup(driver_name_env);

        vaStatus = VA_STATUS_SUCCESS;

        va_infoMessage(dpy, "User requested driver '%s'\n", driver_name);

    }

    if ((VA_STATUS_SUCCESS == vaStatus) && (driver_name != NULL)) {

        vaStatus = va_openDriver(dpy, driver_name);

        va_infoMessage(dpy, "va_openDriver() returns %d\n", vaStatus);

        *major_version = VA_MAJOR_VERSION;

        *minor_version = VA_MINOR_VERSION;

    } else

        va_errorMessage(dpy, "va_getDriverName() failed with %s,driver_name=%s\n",

                        vaErrorStr(vaStatus), driver_name);

    if (driver_name)

        free(driver_name);

    VA_TRACE_LOG(va_TraceInitialize, dpy, major_version, minor_version);

    VA_TRACE_RET(dpy, vaStatus);

    return vaStatus;

}

/*

 * After this call, all library internal resources will be cleaned up

 */ 

VAStatus vaTerminate (

    VADisplay dpy

)

{

  VAStatus vaStatus = VA_STATUS_SUCCESS;

  VADisplayContextP pDisplayContext = (VADisplayContextP)dpy;

  VADriverContextP old_ctx;

  CHECK_DISPLAY(dpy);

  old_ctx = CTX(dpy);

  if (old_ctx->handle) {

      vaStatus = old_ctx->vtable->vaTerminate(old_ctx);

      dlclose(old_ctx->handle);

      old_ctx->handle = NULL;

  }

  free(old_ctx->vtable);

  old_ctx->vtable = NULL;

  free(old_ctx->vtable_vpp);

  old_ctx->vtable_vpp = NULL;

  if (old_ctx->override_driver_name) {

      free(old_ctx->override_driver_name);

      old_ctx->override_driver_name = NULL;

  }

  VA_TRACE_LOG(va_TraceTerminate, dpy);

  VA_TRACE_RET(dpy, vaStatus);

  va_TraceEnd(dpy);

  va_FoolEnd(dpy);

  if (VA_STATUS_SUCCESS == vaStatus)

      pDisplayContext->vaDestroy(pDisplayContext);

  return vaStatus;

}

/*

 * vaQueryVendorString returns a pointer to a zero-terminated string

 * describing some aspects of the VA implemenation on a specific

 * hardware accelerator. The format of the returned string is:

 * <vendorname>-<major_version>-<minor_version>-<addtional_info>

 * e.g. for the Intel GMA500 implementation, an example would be:

 * "IntelGMA500-1.0-0.2-patch3

 */

const char *vaQueryVendorString (

    VADisplay dpy

)

{

  if (!vaDisplayIsValid(dpy))

      return NULL;

  return CTX(dpy)->str_vendor;

}

/* Get maximum number of profiles supported by the implementation */

int vaMaxNumProfiles (

    VADisplay dpy

)

{

  if (!vaDisplayIsValid(dpy))

      return 0;

  return CTX(dpy)->max_profiles;

}

/* Get maximum number of entrypoints supported by the implementation */

int vaMaxNumEntrypoints (

    VADisplay dpy

)

{

  if (!vaDisplayIsValid(dpy))

      return 0;

  return CTX(dpy)->max_entrypoints;

}

/* Get maximum number of attributs supported by the implementation */

int vaMaxNumConfigAttributes (

    VADisplay dpy

)

{

  if (!vaDisplayIsValid(dpy))

      return 0;

  return CTX(dpy)->max_attributes;

}

VAStatus vaQueryConfigEntrypoints (

    VADisplay dpy,

    VAProfile profile,

    VAEntrypoint *entrypoints,	/* out */

    int *num_entrypoints	/* out */

)

{

  VADriverContextP ctx;

  VAStatus vaStatus = VA_STATUS_SUCCESS;

  CHECK_DISPLAY(dpy);

  ctx = CTX(dpy);

  vaStatus = ctx->vtable->vaQueryConfigEntrypoints ( ctx, profile, entrypoints, num_entrypoints);

  VA_TRACE_RET(dpy, vaStatus);

  return vaStatus;

}

VAStatus vaGetConfigAttributes (

    VADisplay dpy,

    VAProfile profile,

    VAEntrypoint entrypoint,

    VAConfigAttrib *attrib_list, /* in/out */

    int num_attribs

)

{

  VADriverContextP ctx;

  VAStatus vaStatus = VA_STATUS_SUCCESS;

  CHECK_DISPLAY(dpy);

  ctx = CTX(dpy);

  vaStatus = ctx->vtable->vaGetConfigAttributes ( ctx, profile, entrypoint, attrib_list, num_attribs );

  VA_TRACE_RET(dpy, vaStatus);

  return vaStatus;

}

VAStatus vaQueryConfigProfiles (

    VADisplay dpy,

    VAProfile *profile_list,	/* out */

    int *num_profiles		/* out */

)

{

  VADriverContextP ctx;

  VAStatus vaStatus = VA_STATUS_SUCCESS;

  CHECK_DISPLAY(dpy);

  ctx = CTX(dpy);

  vaStatus =  ctx->vtable->vaQueryConfigProfiles ( ctx, profile_list, num_profiles );

  VA_TRACE_RET(dpy, vaStatus);

  return vaStatus;

}

VAStatus vaCreateConfig (

    VADisplay dpy,

    VAProfile profile, 

    VAEntrypoint entrypoint, 

    VAConfigAttrib *attrib_list,

    int num_attribs,

    VAConfigID *config_id /* out */

)

{

  VADriverContextP ctx;