that is part of ass_renderer.
#include "ass_cache.h"
-typedef struct hashmap_item_s {
- void* key;
- void* value;
- struct hashmap_item_s* next;
-} hashmap_item_t;
-typedef hashmap_item_t* hashmap_item_p;
-
-struct hashmap_s {
- int nbuckets;
- size_t key_size, value_size;
- hashmap_item_p* root;
- hashmap_item_dtor_t item_dtor; // a destructor for hashmap key/value pairs
- hashmap_key_compare_t key_compare;
- hashmap_hash_t hash;
- // stats
- int hit_count;
- int miss_count;
- int count;
-};
-
#define FNV1_32A_INIT (unsigned)0x811c9dc5
static inline unsigned fnv_32a_buf(void* buf, size_t len, unsigned hval)
//---------------------------------
// font cache
-hashmap_t* font_cache;
-
static unsigned font_desc_hash(void* buf, size_t len)
{
ass_font_desc_t* desc = buf;
free(key);
}
-ass_font_t* ass_font_cache_find(ass_font_desc_t* desc)
+ass_font_t* ass_font_cache_find(hashmap_t* font_cache, ass_font_desc_t* desc)
{
return hashmap_find(font_cache, desc);
}
* \brief Add a face struct to cache.
* \param font font struct
*/
-void* ass_font_cache_add(ass_font_t* font)
+void* ass_font_cache_add(hashmap_t* font_cache, ass_font_t* font)
{
return hashmap_insert(font_cache, &(font->desc), font);
}
-void ass_font_cache_init(void)
+hashmap_t* ass_font_cache_init(void)
{
+ hashmap_t* font_cache;
font_cache = hashmap_init(sizeof(ass_font_desc_t),
sizeof(ass_font_t),
1000,
font_hash_dtor, font_compare, font_desc_hash);
+ return font_cache;
}
-void ass_font_cache_done(void)
+void ass_font_cache_done(hashmap_t* font_cache)
{
hashmap_done(font_cache);
}
//---------------------------------
// bitmap cache
-hashmap_t* bitmap_cache;
-
static void bitmap_hash_dtor(void* key, size_t key_size, void* value, size_t value_size)
{
bitmap_hash_val_t* v = value;
free(value);
}
-void* cache_add_bitmap(bitmap_hash_key_t* key, bitmap_hash_val_t* val)
+void* cache_add_bitmap(hashmap_t* bitmap_cache, bitmap_hash_key_t* key, bitmap_hash_val_t* val)
{
return hashmap_insert(bitmap_cache, key, val);
}
* \param key hash key
* \return requested hash val or 0 if not found
*/
-bitmap_hash_val_t* cache_find_bitmap(bitmap_hash_key_t* key)
+bitmap_hash_val_t* cache_find_bitmap(hashmap_t* bitmap_cache, bitmap_hash_key_t* key)
{
return hashmap_find(bitmap_cache, key);
}
-void ass_bitmap_cache_init(void)
+hashmap_t* ass_bitmap_cache_init(void)
{
+ hashmap_t* bitmap_cache;
bitmap_cache = hashmap_init(sizeof(bitmap_hash_key_t),
sizeof(bitmap_hash_val_t),
0xFFFF + 13,
bitmap_hash_dtor, bitmap_compare,
bitmap_hash);
+ return bitmap_cache;
}
-void ass_bitmap_cache_done(void)
+void ass_bitmap_cache_done(hashmap_t* bitmap_cache)
{
hashmap_done(bitmap_cache);
}
-void ass_bitmap_cache_reset(void)
+hashmap_t* ass_bitmap_cache_reset(hashmap_t* bitmap_cache)
{
- ass_bitmap_cache_done();
- ass_bitmap_cache_init();
+ ass_bitmap_cache_done(bitmap_cache);
+ return ass_bitmap_cache_init();
}
//---------------------------------
// glyph cache
-hashmap_t* glyph_cache;
-
static void glyph_hash_dtor(void* key, size_t key_size, void* value, size_t value_size)
{
glyph_hash_val_t* v = value;
free(value);
}
-void* cache_add_glyph(glyph_hash_key_t* key, glyph_hash_val_t* val)
+void* cache_add_glyph(hashmap_t* glyph_cache, glyph_hash_key_t* key, glyph_hash_val_t* val)
{
return hashmap_insert(glyph_cache, key, val);
}
* \param key hash key
* \return requested hash val or 0 if not found
*/
-glyph_hash_val_t* cache_find_glyph(glyph_hash_key_t* key)
+glyph_hash_val_t* cache_find_glyph(hashmap_t* glyph_cache, glyph_hash_key_t* key)
{
return hashmap_find(glyph_cache, key);
}
-void ass_glyph_cache_init(void)
+hashmap_t* ass_glyph_cache_init(void)
{
+ hashmap_t* glyph_cache;
glyph_cache = hashmap_init(sizeof(glyph_hash_key_t),
sizeof(glyph_hash_val_t),
0xFFFF + 13,
glyph_hash_dtor, glyph_compare, glyph_hash);
+ return glyph_cache;
}
-void ass_glyph_cache_done(void)
+void ass_glyph_cache_done(hashmap_t* glyph_cache)
{
hashmap_done(glyph_cache);
}
-void ass_glyph_cache_reset(void)
+hashmap_t* ass_glyph_cache_reset(hashmap_t* glyph_cache)
{
- ass_glyph_cache_done();
- ass_glyph_cache_init();
+ ass_glyph_cache_done(glyph_cache);
+ return ass_glyph_cache_init();
}
//---------------------------------
// composite cache
-hashmap_t* composite_cache;
-
static void composite_hash_dtor(void* key, size_t key_size, void* value, size_t value_size)
{
composite_hash_val_t* v = value;
free(value);
}
-void* cache_add_composite(composite_hash_key_t* key, composite_hash_val_t* val)
+void* cache_add_composite(hashmap_t* composite_cache, composite_hash_key_t* key, composite_hash_val_t* val)
{
return hashmap_insert(composite_cache, key, val);
}
* \param key hash key
* \return requested hash val or 0 if not found
*/
-composite_hash_val_t* cache_find_composite(composite_hash_key_t* key)
+composite_hash_val_t* cache_find_composite(hashmap_t* composite_cache, composite_hash_key_t* key)
{
return hashmap_find(composite_cache, key);
}
-void ass_composite_cache_init(void)
+hashmap_t* ass_composite_cache_init(void)
{
+ hashmap_t* composite_cache;
composite_cache = hashmap_init(sizeof(composite_hash_key_t),
sizeof(composite_hash_val_t),
0xFFFF + 13,
composite_hash_dtor, NULL, NULL);
+ return composite_cache;
}
-void ass_composite_cache_done(void)
+void ass_composite_cache_done(hashmap_t* composite_cache)
{
hashmap_done(composite_cache);
}
-void ass_composite_cache_reset(void)
+hashmap_t* ass_composite_cache_reset(hashmap_t* composite_cache)
{
- ass_composite_cache_done();
- ass_composite_cache_init();
+ ass_composite_cache_done(composite_cache);
+ return ass_composite_cache_init();
}
#include "ass_font.h"
#include "ass_bitmap.h"
-void ass_font_cache_init(void);
-ass_font_t* ass_font_cache_find(ass_font_desc_t* desc);
-void* ass_font_cache_add(ass_font_t* font);
-void ass_font_cache_done(void);
+typedef void (*hashmap_item_dtor_t)(void* key, size_t key_size, void* value, size_t value_size);
+typedef int (*hashmap_key_compare_t)(void* key1, void* key2, size_t key_size);
+typedef unsigned (*hashmap_hash_t)(void* key, size_t key_size);
+
+typedef struct hashmap_item_s {
+ void* key;
+ void* value;
+ struct hashmap_item_s* next;
+} hashmap_item_t;
+typedef hashmap_item_t* hashmap_item_p;
+
+typedef struct hashmap_s {
+ int nbuckets;
+ size_t key_size, value_size;
+ hashmap_item_p* root;
+ hashmap_item_dtor_t item_dtor; // a destructor for hashmap key/value pairs
+ hashmap_key_compare_t key_compare;
+ hashmap_hash_t hash;
+ // stats
+ int hit_count;
+ int miss_count;
+ int count;
+} hashmap_t;
+
+hashmap_t* hashmap_init(size_t key_size, size_t value_size, int nbuckets,
+ hashmap_item_dtor_t item_dtor, hashmap_key_compare_t key_compare,
+ hashmap_hash_t hash);
+void hashmap_done(hashmap_t* map);
+void* hashmap_insert(hashmap_t* map, void* key, void* value);
+void* hashmap_find(hashmap_t* map, void* key);
+
+hashmap_t* ass_font_cache_init(void);
+ass_font_t* ass_font_cache_find(hashmap_t*, ass_font_desc_t* desc);
+void* ass_font_cache_add(hashmap_t*, ass_font_t* font);
+void ass_font_cache_done(hashmap_t*);
// Create definitions for bitmap_hash_key and glyph_hash_key
#define CREATE_STRUCT_DEFINITIONS
bitmap_t* bm_s;
} bitmap_hash_val_t;
-void ass_bitmap_cache_init(void);
-void* cache_add_bitmap(bitmap_hash_key_t* key, bitmap_hash_val_t* val);
-bitmap_hash_val_t* cache_find_bitmap(bitmap_hash_key_t* key);
-void ass_bitmap_cache_reset(void);
-void ass_bitmap_cache_done(void);
+hashmap_t* ass_bitmap_cache_init(void);
+void* cache_add_bitmap(hashmap_t*, bitmap_hash_key_t* key, bitmap_hash_val_t* val);
+bitmap_hash_val_t* cache_find_bitmap(hashmap_t* bitmap_cache, bitmap_hash_key_t* key);
+hashmap_t* ass_bitmap_cache_reset(hashmap_t* bitmap_cache);
+void ass_bitmap_cache_done(hashmap_t* bitmap_cache);
// Cache for composited bitmaps
unsigned char* b;
} composite_hash_val_t;
-void ass_composite_cache_init(void);
-void* cache_add_composite(composite_hash_key_t* key, composite_hash_val_t* val);
-composite_hash_val_t* cache_find_composite(composite_hash_key_t* key);
-void ass_composite_cache_reset(void);
-void ass_composite_cache_done(void);
+hashmap_t* ass_composite_cache_init(void);
+void* cache_add_composite(hashmap_t*, composite_hash_key_t* key, composite_hash_val_t* val);
+composite_hash_val_t* cache_find_composite(hashmap_t* composite_cache, composite_hash_key_t* key);
+hashmap_t* ass_composite_cache_reset(hashmap_t* composite_cache);
+void ass_composite_cache_done(hashmap_t* composite_cache);
typedef struct glyph_hash_val_s {
FT_Vector advance; // 26.6, advance distance to the next bitmap in line
} glyph_hash_val_t;
-void ass_glyph_cache_init(void);
-void* cache_add_glyph(glyph_hash_key_t* key, glyph_hash_val_t* val);
-glyph_hash_val_t* cache_find_glyph(glyph_hash_key_t* key);
-void ass_glyph_cache_reset(void);
-void ass_glyph_cache_done(void);
-
-typedef struct hashmap_s hashmap_t;
-typedef void (*hashmap_item_dtor_t)(void* key, size_t key_size, void* value, size_t value_size);
-typedef int (*hashmap_key_compare_t)(void* key1, void* key2, size_t key_size);
-typedef unsigned (*hashmap_hash_t)(void* key, size_t key_size);
-
-hashmap_t* hashmap_init(size_t key_size, size_t value_size, int nbuckets,
- hashmap_item_dtor_t item_dtor, hashmap_key_compare_t key_compare,
- hashmap_hash_t hash);
-void hashmap_done(hashmap_t* map);
-void* hashmap_insert(hashmap_t* map, void* key, void* value);
-void* hashmap_find(hashmap_t* map, void* key);
+hashmap_t* ass_glyph_cache_init(void);
+void* cache_add_glyph(hashmap_t*, glyph_hash_key_t* key, glyph_hash_val_t* val);
+glyph_hash_val_t* cache_find_glyph(hashmap_t* glyph_cache, glyph_hash_key_t* key);
+hashmap_t* ass_glyph_cache_reset(hashmap_t* glyph_cache);
+void ass_glyph_cache_done(hashmap_t* glyph_cache);
#endif /* LIBASS_CACHE_H */
/**
* \brief Create a new ass_font_t according to "desc" argument
*/
-ass_font_t* ass_font_new(ass_library_t* library, FT_Library ftlibrary, void* fc_priv, ass_font_desc_t* desc)
+ass_font_t* ass_font_new(void* font_cache, ass_library_t* library, FT_Library ftlibrary, void* fc_priv, ass_font_desc_t* desc)
{
int error;
ass_font_t* fontp;
ass_font_t font;
- fontp = ass_font_cache_find(desc);
+ fontp = ass_font_cache_find((hashmap_t*)font_cache, desc);
if (fontp)
return fontp;
free(font.desc.family);
return 0;
} else
- return ass_font_cache_add(&font);
+ return ass_font_cache_add((hashmap_t*)font_cache, &font);
}
/**
double size;
} ass_font_t;
-ass_font_t* ass_font_new(ass_library_t* library, FT_Library ftlibrary, void* fc_priv, ass_font_desc_t* desc);
+// FIXME: passing the hashmap via a void pointer is very ugly.
+ass_font_t* ass_font_new(void* font_cache, ass_library_t* library, FT_Library ftlibrary, void* fc_priv, ass_font_desc_t* desc);
void ass_font_set_transform(ass_font_t* font, double scale_x, double scale_y, FT_Vector* v);
void ass_font_set_size(ass_font_t* font, double size);
void ass_font_get_asc_desc(ass_font_t* font, uint32_t ch, int* asc, int* desc);
} render_context_t;
+typedef struct cache_store_s {
+ hashmap_t* font_cache;
+ hashmap_t* glyph_cache;
+ hashmap_t* bitmap_cache;
+ hashmap_t* composite_cache;
+} cache_store_t;
+
struct ass_renderer_s {
ass_library_t* library;
FT_Library ftlibrary;
render_context_t state;
text_info_t text_info;
+ cache_store_t cache;
};
struct render_priv_s {
priv->ftlibrary = ft;
// images_root and related stuff is zero-filled in calloc
- ass_font_cache_init();
- ass_bitmap_cache_init();
- ass_composite_cache_init();
- ass_glyph_cache_init();
+ priv->cache.font_cache = ass_font_cache_init();
+ priv->cache.bitmap_cache = ass_bitmap_cache_init();
+ priv->cache.composite_cache = ass_composite_cache_init();
+ priv->cache.glyph_cache = ass_glyph_cache_init();
priv->text_info.glyphs = calloc(MAX_GLYPHS, sizeof(glyph_info_t));
void ass_renderer_done(ass_renderer_t* render_priv)
{
- ass_font_cache_done();
- ass_bitmap_cache_done();
- ass_composite_cache_done();
- ass_glyph_cache_done();
+ ass_font_cache_done(render_priv->cache.font_cache);
+ ass_bitmap_cache_done(render_priv->cache.bitmap_cache);
+ ass_composite_cache_done(render_priv->cache.composite_cache);
+ ass_glyph_cache_done(render_priv->cache.glyph_cache);
if (render_priv->state.stroker) {
FT_Stroker_Done(render_priv->state.stroker);
render_priv->state.stroker = 0;
* Mainly useful for translucent glyphs and especially borders, to avoid the
* luminance adding up where they overlap (which looks ugly)
*/
-static void render_overlap(ass_image_t** last_tail, ass_image_t** tail, bitmap_hash_key_t *last_hash, bitmap_hash_key_t* hash) {
+static void render_overlap(ass_renderer_t* render_priv, ass_image_t** last_tail, ass_image_t** tail, bitmap_hash_key_t *last_hash, bitmap_hash_key_t* hash) {
int left, top, bottom, right;
int old_left, old_top, w, h, cur_left, cur_top;
int x, y, opos, cpos;
hk.ay = ay;
hk.bx = bx;
hk.by = by;
- hv = cache_find_composite(&hk);
+ hv = cache_find_composite(render_priv->cache.composite_cache, &hk);
if (hv) {
(*last_tail)->bitmap = hv->a;
(*tail)->bitmap = hv->b;
hv = calloc(1, sizeof(*hv));
hv->a = (*last_tail)->bitmap;
hv->b = (*tail)->bitmap;
- cache_add_composite(nhk, hv);
+ cache_add_composite(render_priv->cache.composite_cache, nhk, hv);
}
/**
here_tail = tail;
tail = render_glyph(render_priv, bm, pen_x, pen_y, info->c[3], 0, 1000000, tail);
if (last_tail && tail != here_tail && ((info->c[3] & 0xff) > 0))
- render_overlap(last_tail, here_tail, last_hash, &info->hash_key);
+ render_overlap(render_priv, last_tail, here_tail, last_hash, &info->hash_key);
last_tail = here_tail;
last_hash = &info->hash_key;
}
here_tail = tail;
tail = render_glyph(render_priv, bm, pen_x, pen_y, info->c[2], 0, 1000000, tail);
if (last_tail && tail != here_tail && ((info->c[2] & 0xff) > 0))
- render_overlap(last_tail, here_tail, last_hash, &info->hash_key);
+ render_overlap(render_priv, last_tail, here_tail, last_hash, &info->hash_key);
last_tail = here_tail;
last_hash = &info->hash_key;
}
else if (val == 1) val = 110; //italic
desc.italic = val;
- render_priv->state.font = ass_font_new(render_priv->library, render_priv->ftlibrary, render_priv->fontconfig_priv, &desc);
+ render_priv->state.font = ass_font_new(render_priv->cache.font_cache, render_priv->library, render_priv->ftlibrary, render_priv->fontconfig_priv, &desc);
free(desc.family);
if (render_priv->state.font)
memset(info, 0, sizeof(glyph_info_t));
- val = cache_find_glyph(&key);
+ val = cache_find_glyph(render_priv->cache.glyph_cache, &key);
if (val) {
FT_Glyph_Copy(val->glyph, &info->glyph);
if (val->outline_glyph)
FT_Glyph_Copy(info->outline_glyph, &v.outline_glyph);
v.advance = info->advance;
v.bbox_scaled = info->bbox;
- cache_add_glyph(&key, &v);
+ cache_add_glyph(render_priv->cache.glyph_cache, &key, &v);
}
}
bitmap_hash_val_t* val;
bitmap_hash_key_t* key = &info->hash_key;
- val = cache_find_bitmap(key);
+ val = cache_find_bitmap(render_priv->cache.bitmap_cache, key);
/* val = 0; */
if (val) {
hash_val.bm_o = info->bm_o;
hash_val.bm = info->bm;
hash_val.bm_s = info->bm_s;
- cache_add_bitmap(&(info->hash_key), &hash_val);
+ cache_add_bitmap(render_priv->cache.bitmap_cache, &(info->hash_key), &hash_val);
}
}
// deallocate glyphs
static void ass_reconfigure(ass_renderer_t* priv)
{
priv->render_id = ++last_render_id;
- ass_glyph_cache_reset();
- ass_bitmap_cache_reset();
- ass_composite_cache_reset();
+ priv->cache.glyph_cache = ass_glyph_cache_reset(priv->cache.glyph_cache);
+ priv->cache.bitmap_cache = ass_bitmap_cache_reset(priv->cache.bitmap_cache);
+ priv->cache.composite_cache = ass_composite_cache_reset(priv->cache.composite_cache);
ass_free_images(priv->prev_images_root);
priv->prev_images_root = 0;
}
projects / libass / commitdiff