static bool
dest_is_invariant(nir_dest *dest, struct set *invariants)
{
if (dest->is_ssa) {
return _mesa_set_search(invariants, &dest->ssa);
} else {
return _mesa_set_search(invariants, dest->reg.reg);
}
}
void GLAPIENTRY
_mesa_VDPAUSurfaceAccessNV(GLintptr surface, GLenum access)
{
struct vdp_surface *surf = (struct vdp_surface *)surface;
GET_CURRENT_CONTEXT(ctx);
if (!ctx->vdpDevice || !ctx->vdpGetProcAddress || !ctx->vdpSurfaces) {
_mesa_error(ctx, GL_INVALID_OPERATION, "VDPAUSurfaceAccessNV");
return;
}
if (!_mesa_set_search(ctx->vdpSurfaces, surf)) {
_mesa_error(ctx, GL_INVALID_VALUE, "VDPAUSurfaceAccessNV");
return;
}
if (access != GL_READ_ONLY && access != GL_WRITE_ONLY &&
access != GL_READ_WRITE) {
_mesa_error(ctx, GL_INVALID_VALUE, "VDPAUSurfaceAccessNV");
return;
}
if (surf->state == GL_SURFACE_MAPPED_NV) {
_mesa_error(ctx, GL_INVALID_OPERATION, "VDPAUSurfaceAccessNV");
return;
}
surf->access = access;
}
void GLAPIENTRY
_mesa_VDPAUGetSurfaceivNV(GLintptr surface, GLenum pname, GLsizei bufSize,
GLsizei *length, GLint *values)
{
struct vdp_surface *surf = (struct vdp_surface *)surface;
GET_CURRENT_CONTEXT(ctx);
if (!ctx->vdpDevice || !ctx->vdpGetProcAddress || !ctx->vdpSurfaces) {
_mesa_error(ctx, GL_INVALID_OPERATION, "VDPAUGetSurfaceivNV");
return;
}
if (!_mesa_set_search(ctx->vdpSurfaces, surf)) {
_mesa_error(ctx, GL_INVALID_VALUE, "VDPAUGetSurfaceivNV");
return;
}
if (pname != GL_SURFACE_STATE_NV) {
_mesa_error(ctx, GL_INVALID_ENUM, "VDPAUGetSurfaceivNV");
return;
}
if (bufSize < 1) {
_mesa_error(ctx, GL_INVALID_VALUE, "VDPAUGetSurfaceivNV");
return;
}
values[0] = surf->state;
if (length != NULL)
*length = 1;
}
void GLAPIENTRY
_mesa_VDPAUUnregisterSurfaceNV(GLintptr surface)
{
struct vdp_surface *surf = (struct vdp_surface *)surface;
struct set_entry *entry;
int i;
GET_CURRENT_CONTEXT(ctx);
if (!ctx->vdpDevice || !ctx->vdpGetProcAddress || !ctx->vdpSurfaces) {
_mesa_error(ctx, GL_INVALID_OPERATION, "VDPAUUnregisterSurfaceNV");
return;
}
/* according to the spec it's ok when this is zero */
if (surface == 0)
return;
entry = _mesa_set_search(ctx->vdpSurfaces, surf);
if (!entry) {
_mesa_error(ctx, GL_INVALID_VALUE, "VDPAUUnregisterSurfaceNV");
return;
}
for (i = 0; i < MAX_TEXTURES; i++) {
if (surf->textures[i]) {
surf->textures[i]->Immutable = GL_FALSE;
_mesa_reference_texobj(&surf->textures[i], NULL);
}
}
_mesa_set_remove(ctx->vdpSurfaces, entry);
free(surf);
}
/* Identical to nir_assign_var_locations_packed except that it assigns
* locations to the variables that are used 100% directly first and then
* assigns locations to variables that are used indirectly.
*/
void
nir_assign_var_locations_scalar_direct_first(nir_shader *shader,
struct exec_list *var_list,
unsigned *direct_size,
unsigned *size)
{
struct set *indirect_set = _mesa_set_create(NULL, _mesa_hash_pointer,
_mesa_key_pointer_equal);
nir_foreach_overload(shader, overload) {
if (overload->impl)
nir_foreach_block(overload->impl, mark_indirect_uses_block,
indirect_set);
}
unsigned location = 0;
foreach_list_typed(nir_variable, var, node, var_list) {
if (var->data.mode == nir_var_uniform && var->interface_type != NULL)
continue;
if (_mesa_set_search(indirect_set, var))
continue;
var->data.driver_location = location;
location += type_size(var->type);
}
*direct_size = location;
foreach_list_typed(nir_variable, var, node, var_list) {
if (var->data.mode == nir_var_uniform && var->interface_type != NULL)
continue;
if (!_mesa_set_search(indirect_set, var))
continue;
var->data.driver_location = location;
location += type_size(var->type);
}
*size = location;
_mesa_set_destroy(indirect_set, NULL);
}
/**
* Check if the given sync object is:
* - non-null
* - not in sync objects hash table
* - type is GL_SYNC_FENCE
* - not marked as deleted
*/
bool
_mesa_validate_sync(struct gl_context *ctx,
const struct gl_sync_object *syncObj)
{
return (syncObj != NULL)
&& _mesa_set_search(ctx->Shared->SyncObjects, syncObj) != NULL
&& (syncObj->Type == GL_SYNC_FENCE)
&& !syncObj->DeletePending;
}
static int
_mesa_validate_sync(struct gl_context *ctx, struct gl_sync_object *syncObj)
{
return (syncObj != NULL)
&& _mesa_set_search(ctx->Shared->SyncObjects,
_mesa_hash_pointer(syncObj),
syncObj) != NULL
&& (syncObj->Type == GL_SYNC_FENCE)
&& !syncObj->DeletePending;
}
void GLAPIENTRY
_mesa_VDPAUMapSurfacesNV(GLsizei numSurfaces, const GLintptr *surfaces)
{
GET_CURRENT_CONTEXT(ctx);
int i;
if (!ctx->vdpDevice || !ctx->vdpGetProcAddress || !ctx->vdpSurfaces) {
_mesa_error(ctx, GL_INVALID_OPERATION, "VDPAUUnmapSurfacesNV");
return;
}
for (i = 0; i < numSurfaces; ++i) {
struct vdp_surface *surf = (struct vdp_surface *)surfaces[i];
if (!_mesa_set_search(ctx->vdpSurfaces, surf)) {
_mesa_error(ctx, GL_INVALID_VALUE, "VDPAUSurfaceAccessNV");
return;
}
if (surf->state == GL_SURFACE_MAPPED_NV) {
_mesa_error(ctx, GL_INVALID_OPERATION, "VDPAUSurfaceAccessNV");
return;
}
}
for (i = 0; i < numSurfaces; ++i) {
struct vdp_surface *surf = (struct vdp_surface *)surfaces[i];
unsigned numTextureNames = surf->output ? 1 : 4;
unsigned j;
for (j = 0; j < numTextureNames; ++j) {
struct gl_texture_object *tex = surf->textures[j];
struct gl_texture_image *image;
_mesa_lock_texture(ctx, tex);
image = _mesa_get_tex_image(ctx, tex, surf->target, 0);
if (!image) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "VDPAUMapSurfacesNV");
_mesa_unlock_texture(ctx, tex);
return;
}
ctx->Driver.FreeTextureImageBuffer(ctx, image);
ctx->Driver.VDPAUMapSurface(ctx, surf->target, surf->access,
surf->output, tex, image,
surf->vdpSurface, j);
_mesa_unlock_texture(ctx, tex);
}
surf->state = GL_SURFACE_MAPPED_NV;
}
}
virtual ir_visitor_status visit(ir_dereference_variable *ir)
{
struct set_entry *entry = _mesa_set_search(variables, ir->var);
/* If a variable is dereferenced at all, remove it from the set of
* variables that are candidates for removal.
*/
if (entry != NULL)
_mesa_set_remove(variables, entry);
return visit_continue;
}
GLboolean GLAPIENTRY
_mesa_VDPAUIsSurfaceNV(GLintptr surface)
{
struct vdp_surface *surf = (struct vdp_surface *)surface;
GET_CURRENT_CONTEXT(ctx);
if (!ctx->vdpDevice || !ctx->vdpGetProcAddress || !ctx->vdpSurfaces) {
_mesa_error(ctx, GL_INVALID_OPERATION, "VDPAUIsSurfaceNV");
return false;
}
if (!_mesa_set_search(ctx->vdpSurfaces, surf)) {
return false;
}
return true;
}
/**
* Check if the given sync object is:
* - non-null
* - not in sync objects hash table
* - not marked as deleted
*
* Returns the internal gl_sync_object pointer if the sync object is valid
* or NULL if it isn't.
*
* If "incRefCount" is true, the reference count is incremented, which is
* normally what you want; otherwise, a glDeleteSync from another thread
* could delete the sync object while you are still working on it.
*/
struct gl_sync_object *
_mesa_get_and_ref_sync(struct gl_context *ctx, GLsync sync, bool incRefCount)
{
struct gl_sync_object *syncObj = (struct gl_sync_object *) sync;
simple_mtx_lock(&ctx->Shared->Mutex);
if (syncObj != NULL
&& _mesa_set_search(ctx->Shared->SyncObjects, syncObj) != NULL
&& !syncObj->DeletePending) {
if (incRefCount) {
syncObj->RefCount++;
}
} else {
syncObj = NULL;
}
simple_mtx_unlock(&ctx->Shared->Mutex);
return syncObj;
}
void
_mesa_unref_sync_object(struct gl_context *ctx, struct gl_sync_object *syncObj)
{
struct set_entry *entry;
mtx_lock(&ctx->Shared->Mutex);
syncObj->RefCount--;
if (syncObj->RefCount == 0) {
entry = _mesa_set_search(ctx->Shared->SyncObjects, syncObj);
assert (entry != NULL);
_mesa_set_remove(ctx->Shared->SyncObjects, entry);
mtx_unlock(&ctx->Shared->Mutex);
ctx->Driver.DeleteSyncObject(ctx, syncObj);
} else {
mtx_unlock(&ctx->Shared->Mutex);
}
}
void
_mesa_unref_sync_object(struct gl_context *ctx, struct gl_sync_object *syncObj)
{
struct set_entry *entry;
_glthread_LOCK_MUTEX(ctx->Shared->Mutex);
syncObj->RefCount--;
if (syncObj->RefCount == 0) {
entry = _mesa_set_search(ctx->Shared->SyncObjects,
_mesa_hash_pointer(syncObj),
syncObj);
assert (entry != NULL);
_mesa_set_remove(ctx->Shared->SyncObjects, entry);
_glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
ctx->Driver.DeleteSyncObject(ctx, syncObj);
} else {
_glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
}
}
static bool
var_is_invariant(nir_variable *var, struct set * invariants)
{
return var->data.invariant || _mesa_set_search(invariants, var);
}
