/******************************************************************************
 *
 * Copyright 2007, Silicon Image, Inc.  All rights reserved.
 * No part of this work may be reproduced, modified, distributed, transmitted,
 * transcribed, or translated into any language or computer format, in any form
 * or by any means without written permission of: Silicon Image, Inc., 1060
 * East Arques Avenue, Sunnyvale, California 94085
 *
 *****************************************************************************/
/**
 * @file media_buffer_pool.c
 *
 * @brief
 *          Buffer Pool implementation
 *
 * <pre>
 *
 *   Principal Author: Joerg Detert
 *   Creation date:    Feb 28, 2008
 *
 * </pre>
 *
 *****************************************************************************/

#include <string.h>

#include "media_buffer_pool.h"



#define MEDIA_BUF_ALIGN(buf, align) (((buf)+((align)-1U)) & ~((align)-1U))


/******************************************************************************
 * MediaBufPoolGetSize
 *****************************************************************************/
RESULT MediaBufPoolGetSize(MediaBufPoolConfig_t* pPoolConfig)
{
    RESULT  ret = RET_SUCCESS;

    if(pPoolConfig == NULL)
    {
        return RET_WRONG_HANDLE;
    }

    if(pPoolConfig->bufNum > pPoolConfig->maxBufNum)
    {
        return RET_WRONG_CONFIG;
    }

    /* size of extra metadata */
    pPoolConfig->metaDataMemSize = pPoolConfig->maxBufNum * pPoolConfig->metaDataSizeMediaBuf;

    /* size of media buffer array */
    pPoolConfig->metaDataMemSize += (uint32_t)(pPoolConfig->maxBufNum * sizeof(MediaBuffer_t));

    /* calculate size of buffer array*/
    if(pPoolConfig->flags & (uint32_t)BUFPOOL_RINGBUFFER)
    {
        /* results in no gaps between buffers but an offset depending on the alignment */
        pPoolConfig->bufMemSize = (pPoolConfig->maxBufNum * pPoolConfig->bufSize) +
                                   pPoolConfig->bufAlign;

        /* the buffer size must be correct to the alignment otherwise we would have
         * unaligned buffers after the first which is always aligned */
        if((pPoolConfig->bufSize & ((uint32_t)pPoolConfig->bufAlign - 1U)) != 0U)
        {
            return RET_WRONG_CONFIG;
        }
    }
    else
    {
        /* this leads to gaps between the buffers dependend on the alignment */
        pPoolConfig->bufMemSize = pPoolConfig->maxBufNum * (pPoolConfig->bufSize +
                                  pPoolConfig->bufAlign);
    }

    return ret;
}


/******************************************************************************
 * MediaBufPoolCreate
 *****************************************************************************/
RESULT MediaBufPoolCreate(MediaBufPool_t*       pBufPool,
                          MediaBufPoolConfig_t* pPoolConfig,
                          MediaBufPoolMemory_t  poolMemory)
{
    uint32_t        i;
    uint32_t        offset;
    void*           pBuf;
    RESULT  ret = RET_SUCCESS;
    if(pBufPool == NULL)
    {
        return RET_WRONG_HANDLE;
    }

    if((poolMemory.pMetaDataMemory  == NULL) ||
       (poolMemory.pBufferMemory    == NULL))
    {
        return RET_INVALID_PARM;
    }

    if((pPoolConfig->bufNum == 0U) || (pPoolConfig->bufSize == 0U) ||
       (pPoolConfig->maxBufNum < pPoolConfig->bufNum))
    {
        return RET_WRONG_CONFIG;
    }

    /* If buffer pool is switched to ringbuffer mode, there must not be any gap*/
    /* between individual buffers inside static buffer pool, introduced by data*/
    /* alignement issues (e.g. rouding up of internal buffer sizes).*/
    /* That is, the buffer size must be a multiple of the data alignement.*/
    if((pPoolConfig->flags & BUFPOOL_RINGBUFFER) &&
       (pPoolConfig->bufSize % pPoolConfig->bufAlign))
    {
        return RET_WRONG_CONFIG;
    }

    /* initialize buffer pool object*/
    (void) memset(pBufPool, 0, sizeof(MediaBufPool_t));

    pBufPool->bufSize              = pPoolConfig->bufSize;
    pBufPool->metaDataSizeMediaBuf = pPoolConfig->metaDataSizeMediaBuf;
    pBufPool->bufNum               = pPoolConfig->bufNum;
    pBufPool->freeBufNum           = pPoolConfig->bufNum;
    pBufPool->maxBufNum            = pPoolConfig->maxBufNum;
    pBufPool->poolSize             = pPoolConfig->bufNum * pPoolConfig->bufSize;
    pBufPool->flags                = pPoolConfig->flags;

    /* The memory given by the caller is assigned to the buffer pool */
    pBufPool->pBaseAddress = poolMemory.pMetaDataMemory;

    /* Make sure that sizes in pPoolConfig are written */
    (void) MediaBufPoolGetSize(pPoolConfig);
    /* initialize buffer memory to zero */
    (void) memset(poolMemory.pMetaDataMemory, 0, (size_t) pPoolConfig->metaDataMemSize);

    /* We use the first partition of memory for the media buffer array */
    pBufPool->pBufArray = (MediaBuffer_t*) pBufPool->pBaseAddress;

    /* The second partition of memory is used for the buffer meta data array for Media Buffers */
    offset = (pPoolConfig->maxBufNum * sizeof(MediaBuffer_t));
    pBufPool->pMetaDataMediaBufBase = (void*) (((ulong_t) pBufPool->pBaseAddress) + offset);

    /* The memory pointed to by pBufferMemory is used for
     * the real buffer memory. This memory is assigned to the pointers stored in the corresponding
     * MediaBuffer_t[]. Due to the alignment restrictions given by the user it must be kept in mind
     * that the alignment is added. */
    pBuf = poolMemory.pBufferMemory;
    for(i = 0U; i < pBufPool->maxBufNum; i++)
    {
        /* set base address of buffer
           (will be changed in case that buffer pool is resized) */
        pBufPool->pBufArray[i].pBaseAddress = (uint8_t*) MEDIA_BUF_ALIGN((ulong_t)pBuf +
                        (i * pPoolConfig->bufSize), (uint32_t)pPoolConfig->bufAlign);
        /* set base size of buffer
           (will be changed in case that buffer pool is resized) */
        pBufPool->pBufArray[i].baseSize = pBufPool->bufSize;

        if ( pPoolConfig->metaDataSizeMediaBuf != 0 )
        {
            /* set Media Buffer meta data structure address for
               (stays the same during lifetime of buffer pool) */
            pBufPool->pBufArray[i].pMetaData = (void *)((ulong_t) pBufPool->pMetaDataMediaBufBase +
                                               (i * pPoolConfig->metaDataSizeMediaBuf));
        }
        else
        {
            pBufPool->pBufArray[i].pMetaData = NULL;
        }

        MediaBufInit(&pBufPool->pBufArray[i]);
    }

    AtomicMutexInit();

    return ret;
}


/******************************************************************************
 * MediaBufPoolDestroy
 *****************************************************************************/
RESULT MediaBufPoolDestroy(MediaBufPool_t *pBufPool)
{
    DCT_ASSERT(pBufPool != NULL);

    (void) memset(pBufPool, 0, sizeof(MediaBufPool_t));
    AtomicMutexDestory();
    return RET_SUCCESS;
}


/******************************************************************************
 * MediaBufPoolReset
 *****************************************************************************/
RESULT MediaBufPoolReset(MediaBufPool_t* pBufPool)
{
    uint32_t i;

    DCT_ASSERT(pBufPool != NULL);

    /* reset state variables */
    pBufPool->freeBufNum = pBufPool->bufNum;
    pBufPool->fillLevel  = 0;
    pBufPool->index      = 0;

    /* re-init media buffers */
    for(i = 0U; i < pBufPool->maxBufNum; i++)
    {
        MediaBufInit(&pBufPool->pBufArray[i]);
    }

    return RET_SUCCESS;
}


/******************************************************************************
 * MediaBufPoolRegisterCb
 *****************************************************************************/
RESULT MediaBufPoolRegisterCb(MediaBufPool_t*         pBufPool,
                              MediaBufPoolCbNotify_t  fpCallback,
                              void*                   pUserContext)
{
    RESULT ret = RET_NOTAVAILABLE;
    int32_t i;

    if(pBufPool == NULL)
    {
        return RET_WRONG_HANDLE;
    }

    if(fpCallback == NULL)
    {
        return RET_INVALID_PARM;
    }

    if(pBufPool->notify.fpCallback == NULL)
    {
        pBufPool->notify.fpCallback    = fpCallback;
        pBufPool->notify.pUserContext  = pUserContext;
        ret = RET_SUCCESS;
    }

    return ret;
}


/******************************************************************************
 * MediaBufPoolDeregisterCb
 *****************************************************************************/
RESULT MediaBufPoolDeregisterCb(MediaBufPool_t*         pBufPool,
                                MediaBufPoolCbNotify_t  fpCallback)
{
    RESULT ret = RET_NOTAVAILABLE;
    int32_t i;

    if(pBufPool == NULL)
    {
        return RET_WRONG_HANDLE;
    }

    if(fpCallback == NULL)
    {
        return RET_INVALID_PARM;
    }

    if(pBufPool->notify.fpCallback == fpCallback)
    {
        pBufPool->notify.fpCallback   = NULL;
        pBufPool->notify.pUserContext = NULL;
        ret = RET_SUCCESS;
    }

    return ret;
}



/******************************************************************************
 * MediaBufPoolGetBuffer
 *****************************************************************************/
MediaBuffer_t* MediaBufPoolGetBuffer(MediaBufPool_t* pBufPool)
{
    MediaBuffer_t *pMediaBuffer;

    DCT_ASSERT(pBufPool != NULL);

    for(;;)
    {
        /* if the requested number of buffers is greater than the maximum then wait*/
        while( pBufPool->freeBufNum == 0U )
        {
            return  NULL;
        }

        /* at least one buffer is free*/
        for(;;)
        {
            if(!pBufPool->pBufArray[pBufPool->index].lockCount)
            {
                /* adjust the resources count*/
                pBufPool->freeBufNum--;
                pBufPool->pBufArray[pBufPool->index].lockCount = 1;
                pBufPool->pBufArray[pBufPool->index].pOwner = pBufPool;
                pMediaBuffer = &pBufPool->pBufArray[pBufPool->index];

                if(++(pBufPool->index) >= pBufPool->bufNum)
                {
                    pBufPool->index = 0U;
                }

                return pMediaBuffer;
            }
            else
            {
                /* pBufPool->uiIndex points to the next buffer to be checked for a get empty request.*/
                /* If that buffer is locked, no media buffer is returned, because random access is*/
                /* not allowed in ringbuffer mode.*/
                if(pBufPool->flags & BUFPOOL_RINGBUFFER)
                {
                    return  NULL;
                }
            }
            if(++(pBufPool->index) >= pBufPool->bufNum)
            {
                pBufPool->index = 0U;
            }
        }
    } /* for( ;;)*/
}


/******************************************************************************
 * MediaBufPoolFreeBuffer
 *****************************************************************************/
void MediaBufPoolFreeBuffer(MediaBufPool_t* pBufPool, MediaBuffer_t *pBuf)
{
    int32_t i;

    DCT_ASSERT(pBufPool != NULL);
    DCT_ASSERT(pBuf != NULL);

    pBuf->lockCount = 0;
    pBufPool->freeBufNum++;

    if(pBufPool->notify.fpCallback != NULL)
    {
        (pBufPool->notify.fpCallback)(pBufPool->notify.pUserContext, pBuf);
    }
}