void va_FoolInit(VADisplay dpy)
{
char env_value[1024];
struct fool_context *fool_ctx = calloc(sizeof(struct fool_context), 1);
if (fool_ctx == NULL)
return;
if (va_parseConfig("LIBVA_FOOL_POSTP", NULL) == 0) {
va_fool_postp = 1;
va_infoMessage(dpy, "LIBVA_FOOL_POSTP is on, dummy vaPutSurface\n");
}
if (va_parseConfig("LIBVA_FOOL_DECODE", NULL) == 0) {
va_fool_codec |= VA_FOOL_FLAG_DECODE;
va_infoMessage(dpy, "LIBVA_FOOL_DECODE is on, dummy decode\n");
}
if (va_parseConfig("LIBVA_FOOL_ENCODE", &env_value[0]) == 0) {
va_fool_codec |= VA_FOOL_FLAG_ENCODE;
fool_ctx->fn_enc = strdup(env_value);
va_infoMessage(dpy, "LIBVA_FOOL_ENCODE is on, load encode data from file with patten %s\n",
fool_ctx->fn_enc);
}
if (va_parseConfig("LIBVA_FOOL_JPEG", &env_value[0]) == 0) {
va_fool_codec |= VA_FOOL_FLAG_JPEG;
fool_ctx->fn_jpg = strdup(env_value);
va_infoMessage(dpy, "LIBVA_FOOL_JPEG is on, load encode data from file with patten %s\n",
fool_ctx->fn_jpg);
}
((VADisplayContextP)dpy)->vafool = fool_ctx;
}
VAStatus vaInitialize (
VADisplay dpy,
int *major_version, /* out */
int *minor_version /* out */
)
{
const char *driver_name_env = NULL;
char *driver_name = NULL;
VAStatus vaStatus;
CHECK_DISPLAY(dpy);
va_TraceInit(dpy);
va_FoolInit(dpy);
va_infoMessage("VA-API version %s\n", VA_VERSION_S);
vaStatus = va_getDriverName(dpy, &driver_name);
va_infoMessage("va_getDriverName() returns %d\n", vaStatus);
driver_name_env = getenv("LIBVA_DRIVER_NAME");
if ((VA_STATUS_SUCCESS == vaStatus) &&
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("User requested driver '%s'\n", driver_name);
}
if ((VA_STATUS_SUCCESS == vaStatus) && (driver_name != NULL)) {
vaStatus = va_openDriver(dpy, driver_name);
va_infoMessage("va_openDriver() returns %d\n", vaStatus);
*major_version = VA_MAJOR_VERSION;
*minor_version = VA_MINOR_VERSION;
} else
va_errorMessage("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);
return vaStatus;
}
int va_FoolCreateConfig(
VADisplay dpy,
VAProfile profile,
VAEntrypoint entrypoint,
VAConfigAttrib *attrib_list,
int num_attribs,
VAConfigID *config_id /* out */
)
{
DPY2FOOLCTX(dpy);
fool_ctx->entrypoint = entrypoint;
/*
* check fool_codec to align with current context
* e.g. fool_codec = decode then for encode, the
* vaBegin/vaRender/vaEnd also run into fool path
* which is not desired
*/
if (((fool_codec & VA_FOOL_FLAG_DECODE) && (entrypoint == VAEntrypointVLD)) ||
((fool_codec & VA_FOOL_FLAG_JPEG) && (entrypoint == VAEntrypointEncPicture)))
fool_ctx->enabled = 1;
else if ((fool_codec & VA_FOOL_FLAG_ENCODE) && (entrypoint == VAEntrypointEncSlice)) {
/* H264 is desired */
if (((profile == VAProfileH264Baseline ||
profile == VAProfileH264Main ||
profile == VAProfileH264High ||
profile == VAProfileH264ConstrainedBaseline)) &&
strstr(fool_ctx->fn_enc, "h264"))
fool_ctx->enabled = 1;
/* vp8 is desired */
if ((profile == VAProfileVP8Version0_3) &&
strstr(fool_ctx->fn_enc, "vp8"))
fool_ctx->enabled = 1;
}
if (fool_ctx->enabled)
va_infoMessage("FOOL is enabled for this context\n");
else
va_infoMessage("FOOL is not enabled for this context\n");
return 0; /* continue */
}
void va_FoolInit(VADisplay dpy)
{
char env_value[1024];
int fool_index = 0;
for (fool_index = 0; fool_index < FOOL_CONTEXT_MAX; fool_index++)
if (fool_context[fool_index].dpy == 0)
break;
if (fool_index == FOOL_CONTEXT_MAX)
return;
memset(&fool_context[fool_index], 0, sizeof(struct _fool_context));
if (va_parseConfig("LIBVA_FOOL_POSTP", NULL) == 0) {
fool_postp = 1;
va_infoMessage("LIBVA_FOOL_POSTP is on, dummy vaPutSurface\n");
}
if (va_parseConfig("LIBVA_FOOL_DECODE", NULL) == 0) {
fool_codec |= VA_FOOL_FLAG_DECODE;
va_infoMessage("LIBVA_FOOL_DECODE is on, dummy decode\n");
}
if (va_parseConfig("LIBVA_FOOL_ENCODE", &env_value[0]) == 0) {
fool_codec |= VA_FOOL_FLAG_ENCODE;
fool_context[fool_index].fn_enc = strdup(env_value);
va_infoMessage("LIBVA_FOOL_ENCODE is on, load encode data from file with patten %s\n",
fool_context[fool_index].fn_enc);
}
if (va_parseConfig("LIBVA_FOOL_JPEG", &env_value[0]) == 0) {
fool_codec |= VA_FOOL_FLAG_JPEG;
fool_context[fool_index].fn_jpg = strdup(env_value);
va_infoMessage("LIBVA_FOOL_JPEG is on, load encode data from file with patten %s\n",
fool_context[fool_index].fn_jpg);
}
if (fool_codec)
fool_context[fool_index].dpy = dpy;
}
VAStatus vaInitialize (
VADisplay dpy,
int *major_version, /* out */
int *minor_version /* out */
)
{
char *driver_name = NULL;
VAStatus vaStatus;
CHECK_DISPLAY(dpy);
va_TraceInit(dpy);
va_FoolInit(dpy);
va_infoMessage("VA-API version %s\n", VA_VERSION_S);
vaStatus = va_getDriverName(dpy, &driver_name);
va_infoMessage("va_getDriverName() returns %d\n", vaStatus);
if ((VA_STATUS_SUCCESS == vaStatus) && (driver_name != NULL)) {
vaStatus = va_openDriver(dpy, driver_name);
va_infoMessage("va_openDriver() returns %d\n", vaStatus);
*major_version = VA_MAJOR_VERSION;
*minor_version = VA_MINOR_VERSION;
} else
va_errorMessage("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);
return vaStatus;
}
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 (!search_path)
search_path = VA_DRIVERS_PATH;
search_path = strdup((const char *)search_path);
driver_dir = strtok_r(search_path, ":", &saveptr);
while (driver_dir) {
void *handle = NULL;
char *driver_path = (char *) malloc( strlen(driver_dir) +
strlen(driver_name) +
strlen(DRIVER_EXTENSION) + 2 );
if (!driver_path) {
va_errorMessage("%s L%d Out of memory!n",
__FUNCTION__, __LINE__);
free(search_path);
return VA_STATUS_ERROR_ALLOCATION_FAILED;
}
strncpy( driver_path, driver_dir, strlen(driver_dir) + 1);
strncat( driver_path, "/", strlen("/") );
strncat( driver_path, driver_name, strlen(driver_name) );
strncat( driver_path, DRIVER_EXTENSION, strlen(DRIVER_EXTENSION) );
va_infoMessage("Trying to open %s\n", driver_path);
handle = load_library( driver_path);
if (!handle) {
/* Don't give errors for non-existing files */
if (0 == access( driver_path, F_OK))
va_errorMessage("load_library of %s failed\n", driver_path);
} 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 },
{ 0, 35 },
{ 0, 34 },
{ 0, 33 },
{ 0, 32 },
{ -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)get_proc_address(handle, init_func_s);
if (init_func) {
va_infoMessage("Found init function %s\n", init_func_s);
break;
}
}
}
if (compatible_versions[i].major < 0) {
va_errorMessage("%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_MAXIMUM(vaStatus, ctx, display_attributes);
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("%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;
}
