static boolean
is_any_register_declared(
struct sanity_check_ctx *ctx,
uint file )
{
struct cso_hash_iter iter =
cso_hash_first_node(ctx->regs_decl);
while (!cso_hash_iter_is_null(iter)) {
scan_register *reg = (scan_register *)cso_hash_iter_data(iter);
if (reg->file == file)
return TRUE;
iter = cso_hash_iter_next(iter);
}
return FALSE;
}
static void
cache_destroy(struct cso_context *cso,
struct cso_hash *hash, unsigned processor)
{
struct cso_hash_iter iter = cso_hash_first_node(hash);
while (!cso_hash_iter_is_null(iter)) {
void *shader = (void *)cso_hash_iter_data(iter);
if (processor == PIPE_SHADER_FRAGMENT) {
cso_delete_fragment_shader(cso, shader);
} else if (processor == PIPE_SHADER_VERTEX) {
cso_delete_vertex_shader(cso, shader);
}
iter = cso_hash_erase(hash, iter);
}
cso_hash_delete(hash);
}
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 font_destroy(struct vg_font *font)
{
struct vg_context *ctx = vg_current_context();
struct cso_hash_iter iter;
vg_context_remove_object(ctx, &font->base);
iter = cso_hash_first_node(font->glyphs);
while (!cso_hash_iter_is_null(iter)) {
struct vg_glyph *glyph = (struct vg_glyph *) cso_hash_iter_data(iter);
FREE(glyph);
iter = cso_hash_iter_next(iter);
}
cso_hash_delete(font->glyphs);
vg_free_object(&font->base);
FREE(font);
}
/**
* Remove all entries from the map, calling the delete callback for each.
* \param user passed to the delete callback as the last param.
*/
void
util_keymap_remove_all(struct keymap *map, void *user)
{
struct cso_hash_iter iter;
struct keymap_item *item;
assert(map);
if (!map)
return;
iter = cso_hash_first_node(map->cso);
while (!cso_hash_iter_is_null(iter)) {
item = (struct keymap_item *)
cso_hash_take(map->cso, cso_hash_iter_key(iter));
map->delete_func(map, item->key, item->value, user);
FREE(item->key);
FREE(item);
iter = cso_hash_first_node(map->cso);
}
}
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;
}
/* u_vbuf uses its own caching for vertex elements, because it needs to keep
* its own preprocessed state per vertex element CSO. */
static struct u_vbuf_elements *
u_vbuf_set_vertex_elements_internal(struct u_vbuf *mgr, unsigned count,
const struct pipe_vertex_element *states)
{
struct pipe_context *pipe = mgr->pipe;
unsigned key_size, hash_key;
struct cso_hash_iter iter;
struct u_vbuf_elements *ve;
struct cso_velems_state velems_state;
/* need to include the count into the stored state data too. */
key_size = sizeof(struct pipe_vertex_element) * count + sizeof(unsigned);
velems_state.count = count;
memcpy(velems_state.velems, states,
sizeof(struct pipe_vertex_element) * count);
hash_key = cso_construct_key((void*)&velems_state, key_size);
iter = cso_find_state_template(mgr->cso_cache, hash_key, CSO_VELEMENTS,
(void*)&velems_state, key_size);
if (cso_hash_iter_is_null(iter)) {
struct cso_velements *cso = MALLOC_STRUCT(cso_velements);
memcpy(&cso->state, &velems_state, key_size);
cso->data = u_vbuf_create_vertex_elements(mgr, count, states);
cso->delete_state = (cso_state_callback)u_vbuf_delete_vertex_elements;
cso->context = (void*)mgr;
iter = cso_insert_state(mgr->cso_cache, hash_key, CSO_VELEMENTS, cso);
ve = cso->data;
} else {
ve = ((struct cso_velements *)cso_hash_iter_data(iter))->data;
}
assert(ve);
if (ve != mgr->ve)
pipe->bind_vertex_elements_state(pipe, ve->driver_cso);
return ve;
}
void cso_for_each_state(struct cso_cache *sc, enum cso_cache_type type,
cso_state_callback func, void *user_data)
{
struct cso_hash *hash = 0;
struct cso_hash_iter iter;
switch (type) {
case CSO_BLEND:
hash = sc->blend_hash;
break;
case CSO_SAMPLER:
hash = sc->sampler_hash;
break;
case CSO_DEPTH_STENCIL_ALPHA:
hash = sc->depth_stencil_hash;
break;
case CSO_RASTERIZER:
hash = sc->rasterizer_hash;
break;
case CSO_FRAGMENT_SHADER:
hash = sc->fs_hash;
break;
case CSO_VERTEX_SHADER:
hash = sc->vs_hash;
break;
case CSO_VELEMENTS:
hash = sc->velements_hash;
break;
}
iter = cso_hash_first_node(hash);
while (!cso_hash_iter_is_null(iter)) {
void *state = cso_hash_iter_data(iter);
iter = cso_hash_iter_next(iter);
if (state) {
func(state, user_data);
}
}
}
/**
* Insert a new key + data pointer into the table.
* Note: we create a copy of the key, but not the data!
* If the key is already present in the table, replace the existing
* entry (calling the delete callback on the previous entry).
* If the maximum capacity of the map is reached an old entry
* will be deleted (the delete callback will be called).
*/
boolean
util_keymap_insert(struct keymap *map, const void *key,
const void *data, void *user)
{
unsigned key_hash;
struct keymap_item *item;
struct cso_hash_iter iter;
assert(map);
if (!map)
return FALSE;
key_hash = hash(key, map->key_size);
item = hash_table_find_item(map, key, key_hash);
if (item) {
/* call delete callback for old entry/item */
map->delete_func(map, item->key, item->value, user);
item->value = (void *) data;
return TRUE;
}
item = MALLOC_STRUCT(keymap_item);
if (!item)
return FALSE;
item->key = mem_dup(key, map->key_size);
item->value = (void *) data;
iter = cso_hash_insert(map->cso, key_hash, item);
if (cso_hash_iter_is_null(iter)) {
FREE(item);
return FALSE;
}
map->num_entries++;
return TRUE;
}