static struct vg_glyph *get_glyph(struct vg_font *font,
VGuint glyphIndex)
{
struct cso_hash_iter iter;
iter = cso_hash_find(font->glyphs, (unsigned) glyphIndex);
return (struct vg_glyph *) cso_hash_iter_data(iter);
}
struct cso_hash_iter
cso_find_state(struct cso_cache *sc,
unsigned hash_key, enum cso_cache_type type)
{
struct cso_hash *hash = _cso_hash_for_type(sc, type);
return cso_hash_find(hash, hash_key);
}
void
util_surfaces_do_detach(struct util_surfaces *us, struct pipe_surface *ps)
{
struct pipe_resource *pt = ps->texture;
if(pt->target == PIPE_TEXTURE_3D || pt->target == PIPE_TEXTURE_CUBE)
{ /* or 2D array */
cso_hash_erase(us->u.hash, cso_hash_find(us->u.hash, (ps->u.tex.first_layer << 8) | ps->u.tex.level));
}
else
us->u.array[ps->u.tex.level] = 0;
}
void *cso_hash_find_data_from_template( struct cso_hash *hash,
unsigned hash_key,
void *templ,
int size )
{
struct cso_hash_iter iter = cso_hash_find(hash, hash_key);
while (!cso_hash_iter_is_null(iter)) {
void *iter_data = cso_hash_iter_data(iter);
if (!memcmp(iter_data, templ, size)) {
/* We found a match
*/
return iter_data;
}
iter = cso_hash_iter_next(iter);
}
return NULL;
}
boolean
util_surfaces_do_get(struct util_surfaces *us, unsigned surface_struct_size,
struct pipe_context *ctx, struct pipe_resource *pt,
unsigned level, unsigned layer,
struct pipe_surface **res)
{
struct pipe_surface *ps;
if(pt->target == PIPE_TEXTURE_3D || pt->target == PIPE_TEXTURE_CUBE)
{ /* or 2D array */
if(!us->u.hash)
us->u.hash = cso_hash_create();
ps = cso_hash_iter_data(cso_hash_find(us->u.hash, (layer << 8) | level));
}
else
{
if(!us->u.array)
us->u.array = CALLOC(pt->last_level + 1, sizeof(struct pipe_surface *));
ps = us->u.array[level];
}
if(ps && ps->context == ctx)
{
p_atomic_inc(&ps->reference.count);
*res = ps;
return FALSE;
}
ps = (struct pipe_surface *)CALLOC(1, surface_struct_size);
if(!ps)
{
*res = NULL;
return FALSE;
}
pipe_surface_init(ctx, ps, pt, level, layer);
if(pt->target == PIPE_TEXTURE_3D || pt->target == PIPE_TEXTURE_CUBE)
cso_hash_insert(us->u.hash, (layer << 8) | level, ps);
else
us->u.array[level] = ps;
*res = ps;
return TRUE;
}
static INLINE struct cso_hash_iter
hash_table_find_iter(const struct keymap *map, const void *key,
unsigned key_hash)
{
struct cso_hash_iter iter;
struct keymap_item *item;
iter = cso_hash_find(map->cso, key_hash);
while (!cso_hash_iter_is_null(iter)) {
item = (struct keymap_item *) cso_hash_iter_data(iter);
if (!memcmp(item->key, key, map->key_size))
break;
iter = cso_hash_iter_next(iter);
}
return iter;
}
static INLINE void *
shader_from_cache(struct pipe_context *pipe,
unsigned type, struct cso_hash *hash, unsigned key)
{
void *shader = 0;
struct cso_hash_iter iter = cso_hash_find(hash, key);
if (cso_hash_iter_is_null(iter)) {
if (type == PIPE_SHADER_VERTEX)
shader = create_vs(pipe, key);
else
shader = create_fs(pipe, key);
cso_hash_insert(hash, key, shader);
} else
shader = (void *)cso_hash_iter_data(iter);
return shader;
}
void * shaders_cache_fill(struct shaders_cache *sc,
int shader_key)
{
VGint key = shader_key;
struct cached_shader *cached;
struct cso_hash_iter iter = cso_hash_find(sc->hash, key);
if (cso_hash_iter_is_null(iter)) {
cached = CALLOC_STRUCT(cached_shader);
cached->driver_shader = create_shader(sc->pipe->pipe, key, &cached->state);
cso_hash_insert(sc->hash, key, cached);
return cached->driver_shader;
}
cached = (struct cached_shader *)cso_hash_iter_data(iter);
assert(cached->driver_shader);
return cached->driver_shader;
}
struct pipe_surface *
util_surfaces_do_get(struct util_surfaces *us, unsigned surface_struct_size, struct pipe_screen *pscreen, struct pipe_resource *pt, unsigned face, unsigned level, unsigned zslice, unsigned flags)
{
struct pipe_surface *ps;
if(pt->target == PIPE_TEXTURE_3D || pt->target == PIPE_TEXTURE_CUBE)
{ /* or 2D array */
if(!us->u.hash)
us->u.hash = cso_hash_create();
ps = cso_hash_iter_data(cso_hash_find(us->u.hash, ((zslice + face) << 8) | level));
}
else
{
if(!us->u.array)
us->u.array = CALLOC(pt->last_level + 1, sizeof(struct pipe_surface *));
ps = us->u.array[level];
}
if(ps)
{
p_atomic_inc(&ps->reference.count);
return ps;
}
ps = (struct pipe_surface *)CALLOC(1, surface_struct_size);
if(!ps)
return NULL;
pipe_surface_init(ps, pt, face, level, zslice, flags);
ps->offset = ~0;
if(pt->target == PIPE_TEXTURE_3D || pt->target == PIPE_TEXTURE_CUBE)
cso_hash_insert(us->u.hash, ((zslice + face) << 8) | level, ps);
else
us->u.array[level] = ps;
return ps;
}