/*****************************************************************************

 * picture_pool.c : picture pool functions

 *****************************************************************************

 * Copyright (C) 2009 VLC authors and VideoLAN

 * Copyright (C) 2009 Laurent Aimar <fenrir _AT_ videolan _DOT_ org>

 * Copyright (C) 2013-2015 Rémi Denis-Courmont

 *

 * Authors: Laurent Aimar <fenrir _AT_ videolan _DOT_ org>

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms of the GNU Lesser General Public License as published by

 * the Free Software Foundation; either version 2.1 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * GNU Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with this program; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.

 *****************************************************************************/

#ifdef HAVE_CONFIG_H

# include "config.h"

#endif

#include <assert.h>

#include <limits.h>

#include <stdatomic.h>

#include <stdbit.h>

#include <stdlib.h>

#include <vlc_common.h>

#include <vlc_threads.h>

#include <vlc_picture_pool.h>

#include <vlc_atomic.h>

#include <vlc_list.h>

#include "picture.h"

#define POOL_MAX 256

struct picture_pool_t {

    vlc_mutex_t lock;

    vlc_cond_t  wait;

    vlc_atomic_rc_t    refs;

    bool released;

    struct vlc_list inuse_list;

    struct vlc_list available_list;

};

static void picture_pool_Destroy(picture_pool_t *pool)

{

    if (!vlc_atomic_rc_dec(&pool->refs))

        return;

    assert(vlc_list_is_empty(&pool->inuse_list));

    assert(vlc_list_is_empty(&pool->available_list));

    free(pool);

}

void picture_pool_Release(picture_pool_t *pool)

{

    vlc_mutex_lock(&pool->lock);

    /* Release pictures from both available and in-use lists */

    for (size_t i = 0; i < 2; ++i)

    {

        struct vlc_list *list = i == 0 ? &pool->available_list : &pool->inuse_list;

        picture_priv_t *priv;

        vlc_list_foreach(priv, list, pool_node)

        {

            assert(priv->pool == pool);

            vlc_list_remove(&priv->pool_node);

            picture_Release(&priv->picture);

        }

    }

    /* Prevent in-use cloned pictures to be added back to lists */

    pool->released = true;

    vlc_mutex_unlock(&pool->lock);

    picture_pool_Destroy(pool);

}

static void picture_pool_ReleaseClone(picture_t *clone)

{

    picture_priv_t *priv = container_of(clone, picture_priv_t, picture);

    /* Retrieve the original pic that was cloned */

    picture_t *original = priv->gc.opaque;

    picture_priv_t *original_priv = container_of(original, picture_priv_t, picture);

    picture_pool_t *pool = original_priv->pool;

    assert(pool != NULL);

    vlc_mutex_lock(&pool->lock);

    if (!pool->released)

    {

        vlc_list_remove(&original_priv->pool_node);

        vlc_list_append(&original_priv->pool_node, &pool->available_list);

        vlc_cond_signal(&pool->wait);

    }

    vlc_mutex_unlock(&pool->lock);

    picture_Release(original);

    picture_pool_Destroy(pool);

}

static picture_t *picture_pool_ClonePicture(picture_pool_t *pool,

                                            picture_t *picture)

{

    picture_t *clone = picture_InternalClone(picture, picture_pool_ReleaseClone,

                                             picture);

    if (clone != NULL) {

        assert(!picture_HasChainedPics(clone));

        vlc_atomic_rc_inc(&pool->refs);

    }

    return clone;

}

static void picture_pool_AppendPic(picture_pool_t *pool, picture_t *pic)

{

    picture_priv_t *priv = container_of(pic, picture_priv_t, picture);

    assert(priv->pool == NULL);

    vlc_list_append(&priv->pool_node, &pool->available_list);

    priv->pool = pool;

}

static picture_pool_t *

picture_pool_NewCommon(void)

{

    picture_pool_t *pool = malloc(sizeof(*pool));

    if (unlikely(pool == NULL))

        return NULL;

    vlc_list_init(&pool->inuse_list);

    vlc_list_init(&pool->available_list);

    vlc_mutex_init(&pool->lock);

    vlc_cond_init(&pool->wait);

    vlc_atomic_rc_init(&pool->refs);

    pool->released = false;

    return pool;

}

picture_pool_t *picture_pool_New(unsigned count, picture_t *const *tab)

{

    if (unlikely(count > POOL_MAX))

        return NULL;

    picture_pool_t *pool = picture_pool_NewCommon();

    if (unlikely(pool == NULL))

        return NULL;

    for (unsigned i = 0; i < count; ++i)

        picture_pool_AppendPic(pool, tab[i]);

    return pool;

}

picture_pool_t *picture_pool_NewFromFormat(const video_format_t *fmt,

                                           unsigned count)

{

    if (count == 0)

        vlc_assert_unreachable();

    if (unlikely(count > POOL_MAX))

        return NULL;

    picture_pool_t *pool = picture_pool_NewCommon();

    if (unlikely(pool == NULL))

        return NULL;

    for (unsigned i = 0; i < count; ++i)

    {

        picture_t *pic = picture_NewFromFormat(fmt);

        if (pic == NULL)

        {

            picture_pool_Release(pool);

            return NULL;

        }

        picture_pool_AppendPic(pool, pic);

    }

    return pool;

}

static picture_t *picture_pool_GetAvailableLocked(picture_pool_t *pool)

{

    picture_priv_t *priv = vlc_list_first_entry_or_null(&pool->available_list,

                                                        picture_priv_t,

                                                        pool_node);

    assert(priv != NULL);

    assert(priv->pool == pool);

    vlc_list_remove(&priv->pool_node);

    vlc_list_append(&priv->pool_node, &pool->inuse_list);

    return &priv->picture;

}

picture_t *picture_pool_Get(picture_pool_t *pool)

{

    vlc_mutex_lock(&pool->lock);

    assert(vlc_atomic_rc_get(&pool->refs) > 0);

    if (vlc_list_is_empty(&pool->available_list))

    {

        vlc_mutex_unlock(&pool->lock);

        return NULL;

    }

    picture_t *pic = picture_pool_GetAvailableLocked(pool);

    vlc_mutex_unlock(&pool->lock);

    return picture_pool_ClonePicture(pool, pic);

}

picture_t *picture_pool_Wait(picture_pool_t *pool)

{

    vlc_mutex_lock(&pool->lock);

    assert(vlc_atomic_rc_get(&pool->refs) > 0);

    while (vlc_list_is_empty(&pool->available_list))

        vlc_cond_wait(&pool->wait, &pool->lock);

    picture_t *pic = picture_pool_GetAvailableLocked(pool);

    vlc_mutex_unlock(&pool->lock);

    return picture_pool_ClonePicture(pool, pic);

}