/*****************************************************************************
*
*****************************************************************************/
-struct picture_release_sys_t {
- /* Saved release */
- void (*release)(picture_t *);
- picture_release_sys_t *release_sys;
-
- /* */
- int (*lock)(picture_t *);
- void (*unlock)(picture_t *);
-
- /* */
- int64_t tick;
+struct picture_gc_sys_t {
+ picture_pool_t *pool;
+ picture_t *picture;
+ bool in_use;
+ uint64_t tick;
};
struct picture_pool_t {
+ uint64_t tick;
/* */
- picture_pool_t *master;
- int64_t tick;
- /* */
- int picture_count;
+ unsigned picture_count;
picture_t **picture;
- bool *picture_reserved;
+
+ int (*pic_lock)(picture_t *);
+ void (*pic_unlock)(picture_t *);
+ unsigned refs;
+ vlc_mutex_t lock;
};
-static void Release(picture_t *);
-static int Lock(picture_t *);
-static void Unlock(picture_t *);
+void picture_pool_Release(picture_pool_t *pool)
+{
+ bool destroy;
+
+ vlc_mutex_lock(&pool->lock);
+ assert(pool->refs > 0);
+ destroy = --pool->refs == 0;
+ vlc_mutex_unlock(&pool->lock);
+
+ if (likely(!destroy))
+ return;
+
+ for (unsigned i = 0; i < pool->picture_count; i++) {
+ picture_t *picture = pool->picture[i];
+ picture_gc_sys_t *sys = picture->gc.p_sys;
+
+ picture_Release(sys->picture);
+ free(sys);
+ free(picture);
+ }
+
+ vlc_mutex_destroy(&pool->lock);
+ free(pool->picture);
+ free(pool);
+}
+
+static void picture_pool_ReleasePicture(picture_t *picture)
+{
+ picture_gc_sys_t *sys = picture->gc.p_sys;
+ picture_pool_t *pool = sys->pool;
+
+ if (pool->pic_unlock != NULL)
+ pool->pic_unlock(picture);
+
+ vlc_mutex_lock(&pool->lock);
+ assert(sys->in_use);
+ sys->in_use = false;
+ vlc_mutex_unlock(&pool->lock);
+
+ picture_pool_Release(pool);
+}
+
+static picture_t *picture_pool_ClonePicture(picture_pool_t *pool,
+ picture_t *picture)
+{
+ picture_gc_sys_t *sys = malloc(sizeof(*sys));
+ if (unlikely(sys == NULL))
+ return NULL;
+
+ sys->pool = pool;
+ sys->picture = picture;
+ sys->in_use = false;
+ sys->tick = 0;
+
+ picture_resource_t res = {
+ .p_sys = picture->p_sys,
+ .pf_destroy = picture_pool_ReleasePicture,
+ };
-static picture_pool_t *Create(picture_pool_t *master, int picture_count)
+ for (int i = 0; i < picture->i_planes; i++) {
+ res.p[i].p_pixels = picture->p[i].p_pixels;
+ res.p[i].i_lines = picture->p[i].i_lines;
+ res.p[i].i_pitch = picture->p[i].i_pitch;
+ }
+
+ picture_t *clone = picture_NewFromResource(&picture->format, &res);
+ if (likely(clone != NULL))
+ clone->gc.p_sys = sys;
+ else
+ free(sys);
+
+ return clone;
+}
+
+static picture_pool_t *Create(int picture_count)
{
picture_pool_t *pool = calloc(1, sizeof(*pool));
if (!pool)
return NULL;
- pool->master = master;
- pool->tick = master ? master->tick : 1;
+ pool->tick = 1;
pool->picture_count = picture_count;
pool->picture = calloc(pool->picture_count, sizeof(*pool->picture));
- pool->picture_reserved = calloc(pool->picture_count, sizeof(*pool->picture_reserved));
- if (!pool->picture || !pool->picture_reserved) {
+ if (!pool->picture) {
free(pool->picture);
- free(pool->picture_reserved);
free(pool);
return NULL;
}
+ pool->refs = 1;
+ vlc_mutex_init(&pool->lock);
return pool;
}
picture_pool_t *picture_pool_NewExtended(const picture_pool_configuration_t *cfg)
{
- picture_pool_t *pool = Create(NULL, cfg->picture_count);
+ picture_pool_t *pool = Create(cfg->picture_count);
if (!pool)
return NULL;
- for (int i = 0; i < cfg->picture_count; i++) {
- picture_t *picture = cfg->picture[i];
-
- /* The pool must be the only owner of the picture */
- assert(picture->i_refcount == 1);
+ pool->pic_lock = cfg->lock;
+ pool->pic_unlock = cfg->unlock;
- /* Install the new release callback */
- picture_release_sys_t *release_sys = malloc(sizeof(*release_sys));
- if (!release_sys)
+ for (unsigned i = 0; i < cfg->picture_count; i++) {
+ picture_t *picture = picture_pool_ClonePicture(pool, cfg->picture[i]);
+ if (unlikely(picture == NULL))
abort();
- release_sys->release = picture->pf_release;
- release_sys->release_sys = picture->p_release_sys;
- release_sys->lock = cfg->lock;
- release_sys->unlock = cfg->unlock;
- release_sys->tick = 0;
-
- /* */
- picture->i_refcount = 0;
- picture->pf_release = Release;
- picture->p_release_sys = release_sys;
-
- /* */
+
+ atomic_init(&picture->gc.refcount, 0);
+
pool->picture[i] = picture;
- pool->picture_reserved[i] = false;
}
return pool;
}
-picture_pool_t *picture_pool_New(int picture_count, picture_t *picture[])
+picture_pool_t *picture_pool_New(unsigned count, picture_t *const *tab)
{
picture_pool_configuration_t cfg;
memset(&cfg, 0, sizeof(cfg));
- cfg.picture_count = picture_count;
- cfg.picture = picture;
+ cfg.picture_count = count;
+ cfg.picture = tab;
return picture_pool_NewExtended(&cfg);
}
-picture_pool_t *picture_pool_NewFromFormat(const video_format_t *fmt, int picture_count)
+picture_pool_t *picture_pool_NewFromFormat(const video_format_t *fmt,
+ unsigned count)
{
- picture_t *picture[picture_count];
+ picture_t *picture[count ? count : 1];
+ unsigned i;
- for (int i = 0; i < picture_count; i++) {
+ for (i = 0; i < count; i++) {
picture[i] = picture_NewFromFormat(fmt);
- if (!picture[i])
+ if (picture[i] == NULL)
goto error;
}
- picture_pool_t *pool = picture_pool_New(picture_count, picture);
+
+ picture_pool_t *pool = picture_pool_New(count, picture);
if (!pool)
goto error;
return pool;
error:
- for (int i = 0; i < picture_count; i++) {
- if (!picture[i])
- break;
- picture_Release(picture[i]);
- }
+ while (i > 0)
+ picture_Release(picture[--i]);
return NULL;
}
-picture_pool_t *picture_pool_Reserve(picture_pool_t *master, int count)
+picture_pool_t *picture_pool_Reserve(picture_pool_t *master, unsigned count)
{
- picture_pool_t *pool = Create(master, count);
- if (!pool)
- return NULL;
+ picture_t *picture[count ? count : 1];
+ unsigned i;
- int found = 0;
- for (int i = 0; i < master->picture_count && found < count; i++) {
- if (master->picture_reserved[i])
- continue;
-
- assert(master->picture[i]->i_refcount == 0);
- master->picture_reserved[i] = true;
-
- pool->picture[found] = master->picture[i];
- pool->picture_reserved[found] = false;
- found++;
- }
- if (found < count) {
- picture_pool_Delete(pool);
- return NULL;
+ for (i = 0; i < count; i++) {
+ picture[i] = picture_pool_Get(master);
+ if (picture[i] == NULL)
+ goto error;
}
- return pool;
-}
-void picture_pool_Delete(picture_pool_t *pool)
-{
- for (int i = 0; i < pool->picture_count; i++) {
- picture_t *picture = pool->picture[i];
- if (pool->master) {
- for (int j = 0; j < pool->master->picture_count; j++) {
- if (pool->master->picture[j] == picture)
- pool->master->picture_reserved[j] = false;
- }
- } else {
- picture_release_sys_t *release_sys = picture->p_release_sys;
-
- assert(picture->i_refcount == 0);
- assert(!pool->picture_reserved[i]);
-
- /* Restore old release callback */
- picture->i_refcount = 1;
- picture->pf_release = release_sys->release;
- picture->p_release_sys = release_sys->release_sys;
+ picture_pool_t *pool = picture_pool_New(count, picture);
+ if (!pool)
+ goto error;
- picture_Release(picture);
+ pool->pic_lock = master->pic_lock;
+ pool->pic_unlock = master->pic_unlock;
+ return pool;
- free(release_sys);
- }
- }
- free(pool->picture_reserved);
- free(pool->picture);
- free(pool);
+error:
+ while (i > 0)
+ picture_Release(picture[--i]);
+ return NULL;
}
picture_t *picture_pool_Get(picture_pool_t *pool)
{
- for (int i = 0; i < pool->picture_count; i++) {
- if (pool->picture_reserved[i])
- continue;
+ vlc_mutex_lock(&pool->lock);
+ assert(pool->refs > 0);
+ for (unsigned i = 0; i < pool->picture_count; i++) {
picture_t *picture = pool->picture[i];
- if (picture->i_refcount > 0)
+ picture_gc_sys_t *sys = picture->gc.p_sys;
+ uint64_t tick;
+
+ if (sys->in_use)
continue;
- if (Lock(picture))
+ pool->refs++;
+ tick = ++pool->tick;
+ sys->in_use = true;
+ vlc_mutex_unlock(&pool->lock);
+
+ if (pool->pic_lock != NULL && pool->pic_lock(picture) != 0) {
+ vlc_mutex_lock(&pool->lock);
+ sys->in_use = false;
+ pool->refs--;
+ vlc_mutex_unlock(&pool->lock);
continue;
+ }
+
+ sys->tick = tick;
- /* */
+ assert(atomic_load(&picture->gc.refcount) == 0);
+ atomic_init(&picture->gc.refcount, 1);
picture->p_next = NULL;
- picture->p_release_sys->tick = pool->tick++;
- picture_Hold(picture);
return picture;
}
+
+ vlc_mutex_unlock(&pool->lock);
return NULL;
}
-void picture_pool_NonEmpty(picture_pool_t *pool, bool reset)
+unsigned picture_pool_Reset(picture_pool_t *pool)
{
- picture_t *old = NULL;
-
- for (int i = 0; i < pool->picture_count; i++) {
- if (pool->picture_reserved[i])
- continue;
+ unsigned ret = 0;
+retry:
+ vlc_mutex_lock(&pool->lock);
+ assert(pool->refs > 0);
+ for (unsigned i = 0; i < pool->picture_count; i++) {
picture_t *picture = pool->picture[i];
- if (reset) {
- if (picture->i_refcount > 0)
- Unlock(picture);
- picture->i_refcount = 0;
- } else if (picture->i_refcount == 0) {
- return;
- } else if (!old || picture->p_release_sys->tick < old->p_release_sys->tick) {
- old = picture;
+ picture_gc_sys_t *sys = picture->gc.p_sys;
+
+ if (sys->in_use) {
+ vlc_mutex_unlock(&pool->lock);
+ picture_Release(picture);
+ ret++;
+ goto retry;
}
}
- if (!reset && old) {
- if (old->i_refcount > 0)
- Unlock(old);
- old->i_refcount = 0;
- }
-}
-int picture_pool_GetSize(picture_pool_t *pool)
-{
- return pool->picture_count;
+ vlc_mutex_unlock(&pool->lock);
+
+ return ret;
}
-static void Release(picture_t *picture)
+void picture_pool_NonEmpty(picture_pool_t *pool)
{
- assert(picture->i_refcount > 0);
+ picture_t *oldest = NULL;
+ uint64_t tick = 0;
- if (--picture->i_refcount > 0)
- return;
- Unlock(picture);
-}
+ vlc_mutex_lock(&pool->lock);
+ assert(pool->refs > 0);
-static int Lock(picture_t *picture)
-{
- picture_release_sys_t *release_sys = picture->p_release_sys;
- if (release_sys->lock)
- return release_sys->lock(picture);
- return VLC_SUCCESS;
+ for (unsigned i = 0; i < pool->picture_count; i++) {
+ picture_t *picture = pool->picture[i];
+ picture_gc_sys_t *sys = picture->gc.p_sys;
+
+ if (!sys->in_use) {
+ vlc_mutex_unlock(&pool->lock);
+ return; /* Nothing to do */
+ }
+
+ if (picture->gc.p_sys->tick < tick) {
+ oldest = picture;
+ tick = picture->gc.p_sys->tick;
+ }
+ }
+
+ if (oldest != NULL) {
+ while (oldest->gc.p_sys->in_use) {
+ vlc_mutex_unlock(&pool->lock);
+ picture_Release(oldest);
+ vlc_mutex_lock(&pool->lock);
+ }
+ }
+
+ vlc_mutex_unlock(&pool->lock);
}
-static void Unlock(picture_t *picture)
+
+unsigned picture_pool_GetSize(const picture_pool_t *pool)
{
- picture_release_sys_t *release_sys = picture->p_release_sys;
- if (release_sys->unlock)
- release_sys->unlock(picture);
+ return pool->picture_count;
}
-
projects / vlc / blobdiff