encoder/ihevce_buffer_que.c

/******************************************************************************
 *
 * Copyright (C) 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *****************************************************************************
 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
*/

/**
******************************************************************************
* @file
*  ihevce_buffer_que.c
*
* @brief
*  This file contains all the functions related to Buffer Queue manager
*
* @author
*  ittiam
*
* @par List of Functions:
*  ihevce_buff_que_get_mem_recs
*  ihevce_buff_que_get_num_mem_recs
*  ihevce_buff_que_init
*  ihevce_buff_que_get_free_buf
*  ihevce_buff_que_get_next_buf
*  ihevce_buff_que_get_next_reorder_buf
*  ihevce_buff_que_set_buf_prod
*  ihevce_buff_que_rel_buf
*  ihevce_buff_que_get_active_bufs
*  ihevce_buff_que_set_reorder_buf
*
******************************************************************************
*/

/*****************************************************************************/
/* File Includes                                                             */
/*****************************************************************************/

/* System Include Files */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <assert.h>

/* User Include Files */
#include "ihevc_typedefs.h"
#include "itt_video_api.h"
#include "ihevce_buffer_que_interface.h"
#include "ihevce_buffer_que_private.h"

/*****************************************************************************/
/* Function Definitions                                                      */
/*****************************************************************************/

/*!
************************************************************************
* \brief
*    return number of records used by Buffer Que manager.
************************************************************************
*/
WORD32 ihevce_buff_que_get_num_mem_recs(void)
{
    return (NUM_BUFFER_QUE_MEM_RECS);
}

/*!
************************************************************************
* \brief
*    return each record attributes of Buffer Que manager
************************************************************************
*/
WORD32 ihevce_buff_que_get_mem_recs(
    iv_mem_rec_t *ps_mem_tab, WORD32 max_num_bufs_in_que, WORD32 i4_mem_space)
{
    /* Que manager state structure */
    ps_mem_tab[BUFFER_QUE_CTXT].i4_mem_size = sizeof(buf_que_t);
    ps_mem_tab[BUFFER_QUE_CTXT].e_mem_type = (IV_MEM_TYPE_T)i4_mem_space;
    ps_mem_tab[BUFFER_QUE_CTXT].i4_mem_alignment = 8;

    /* number of users memory */
    ps_mem_tab[BUFFER_QUE_NUM_USER_MEM].i4_mem_size = (sizeof(WORD32) * max_num_bufs_in_que);
    ps_mem_tab[BUFFER_QUE_NUM_USER_MEM].e_mem_type = (IV_MEM_TYPE_T)i4_mem_space;
    ps_mem_tab[BUFFER_QUE_NUM_USER_MEM].i4_mem_alignment = 8;

    /* Produced status memory */
    ps_mem_tab[BUFFER_QUE_PROD_STS_MEM].i4_mem_size = (sizeof(WORD32) * max_num_bufs_in_que);
    ps_mem_tab[BUFFER_QUE_PROD_STS_MEM].e_mem_type = (IV_MEM_TYPE_T)i4_mem_space;
    ps_mem_tab[BUFFER_QUE_PROD_STS_MEM].i4_mem_alignment = 8;

    /* Encode sequence memory */
    ps_mem_tab[BUFFER_QUE_ENC_SEQ_MEM].i4_mem_size = (sizeof(UWORD32) * max_num_bufs_in_que);
    ps_mem_tab[BUFFER_QUE_ENC_SEQ_MEM].e_mem_type = (IV_MEM_TYPE_T)i4_mem_space;
    ps_mem_tab[BUFFER_QUE_ENC_SEQ_MEM].i4_mem_alignment = 8;

    /* Queued sequence memory */
    ps_mem_tab[BUFFER_QUE_QUED_SEQ_MEM].i4_mem_size = (sizeof(UWORD32) * max_num_bufs_in_que);
    ps_mem_tab[BUFFER_QUE_QUED_SEQ_MEM].e_mem_type = (IV_MEM_TYPE_T)i4_mem_space;
    ps_mem_tab[BUFFER_QUE_QUED_SEQ_MEM].i4_mem_alignment = 8;

    return (NUM_BUFFER_QUE_MEM_RECS);
}

/*!
************************************************************************
* \brief
*    Intialization for Buffer Que manager state structure
************************************************************************
*/
void *ihevce_buff_que_init(iv_mem_rec_t *ps_mem_tab, WORD32 num_bufs_in_que, void **ppv_buff_ptrs)
{
    buf_que_t *ps_buf_que;
    WORD32 i;

    /* que manager state structure */
    ps_buf_que = (buf_que_t *)ps_mem_tab[BUFFER_QUE_CTXT].pv_base;

    /* buffer status memory init */
    ps_buf_que->pi4_num_users = (WORD32 *)ps_mem_tab[BUFFER_QUE_NUM_USER_MEM].pv_base;

    ps_buf_que->pi4_produced_sts = (WORD32 *)ps_mem_tab[BUFFER_QUE_PROD_STS_MEM].pv_base;

    ps_buf_que->pu4_enc_seq = (UWORD32 *)ps_mem_tab[BUFFER_QUE_ENC_SEQ_MEM].pv_base;

    ps_buf_que->pu4_que_seq = (UWORD32 *)ps_mem_tab[BUFFER_QUE_QUED_SEQ_MEM].pv_base;

    /* reset the state structure variables */
    ps_buf_que->i4_num_bufs = num_bufs_in_que;
    ps_buf_que->i4_num_active_bufs = 0;
    ps_buf_que->u4_last_prod = 0;
    ps_buf_que->u4_last_cons = 0;
    ps_buf_que->u4_next_disp_seq = 0;
    ps_buf_que->u4_last_disp_seq = 0;
    ps_buf_que->ppv_buff_ptrs = ppv_buff_ptrs;

    /* init all the buffer status to default values */
    for(i = 0; i < ps_buf_que->i4_num_bufs; i++)
    {
        ps_buf_que->pi4_num_users[i] = 0;
        ps_buf_que->pi4_produced_sts[i] = 0;
        ps_buf_que->pu4_enc_seq[i] = UINT32_MAX;
        ps_buf_que->pu4_que_seq[i] = UINT32_MAX;
    }

    return ((void *)ps_buf_que);
}

/*!
**************************************************************************
* \brief
*    This function gets the next free buffer. This function is called by the
*    Producer to get a free buffer
**************************************************************************
*/
void *ihevce_buff_que_get_free_buf(void *pv_buf_que, WORD32 *pi4_id)
{
    buf_que_t *ps_buf_que;
    WORD32 i;
    WORD32 num_bufs;

    ps_buf_que = (buf_que_t *)pv_buf_que;
    num_bufs = ps_buf_que->i4_num_bufs;

    /* loop unitl a free buffer is found */
    for(i = 0; i < num_bufs; i++)
    {
        if((ps_buf_que->pi4_num_users[i] == 0) && (ps_buf_que->pi4_produced_sts[i] == 0))
        {
            *(pi4_id) = i;
            ps_buf_que->pi4_num_users[i] = 1;
            ps_buf_que->pu4_que_seq[i] = ps_buf_que->u4_last_prod;
            ps_buf_que->u4_last_prod += 1;

            return (ps_buf_que->ppv_buff_ptrs[i]);
        }
    }
    return (NULL);
}

/*!
**************************************************************************
* \brief
*    This function gets the next buffer in Que . This function will be called by
*    consumer to get the next buffer in Queued order.
**************************************************************************
*/
void *ihevce_buff_que_get_next_buf(void *pv_buf_que, WORD32 *pi4_id)
{
    buf_que_t *ps_buf_que;
    WORD32 i;
    UWORD32 next_qued_seq;

    ps_buf_que = (buf_que_t *)pv_buf_que;

    /* get the next queued buffer to be sent */
    next_qued_seq = ps_buf_que->u4_last_cons;

    /* check for matching index */
    for(i = 0; i < ps_buf_que->i4_num_bufs; i++)
    {
        if(next_qued_seq == ps_buf_que->pu4_que_seq[i])
        {
            if(1 == ps_buf_que->pi4_produced_sts[i])
            {
                *(pi4_id) = i;
                ps_buf_que->u4_last_cons += 1;

                return (ps_buf_que->ppv_buff_ptrs[i]);
            }
            else
            {
                break;
            }
        }
    }

    /* Buffer not ready for Consumption */
    return (NULL);
}

/*!
**************************************************************************
* \brief
*    This function gives the buffer curresponding to the id passed
**************************************************************************
*/
void *ihevce_buff_que_get_buf(void *pv_buf_que, WORD32 i4_id)
{
    buf_que_t *ps_buf_que;

    ps_buf_que = (buf_que_t *)pv_buf_que;

    if(i4_id >= ps_buf_que->i4_num_bufs)
        return (NULL);

    return (ps_buf_que->ppv_buff_ptrs[i4_id]);
}

/*!
**************************************************************************
* \brief
*    This function gets the next buffer for in reordered order. This function
*    will be called by consumer to get the next buffer in reordered order
**************************************************************************
*/
void *ihevce_buff_que_get_next_reorder_buf(void *pv_buf_que, WORD32 *pi4_id)
{
    buf_que_t *ps_buf_que;
    WORD32 i;
    UWORD32 next_disp_seq;

    ps_buf_que = (buf_que_t *)pv_buf_que;

    /* get the next reordered buffer to be sent */
    next_disp_seq = ps_buf_que->u4_last_disp_seq;

    /* check for matching index */
    for(i = 0; i < ps_buf_que->i4_num_bufs; i++)
    {
        if(next_disp_seq == ps_buf_que->pu4_enc_seq[i])
        {
            *(pi4_id) = i;
            ps_buf_que->u4_last_disp_seq += 1;

            return (ps_buf_que->ppv_buff_ptrs[i]);
        }
    }

    /* Buffer not ready for Consumption */
    return (NULL);
}

/*!
**************************************************************************
* \brief
*    This function sets the buffer as produced. This function will be called
*    by Producer to say that buffer is ready for consumption.
**************************************************************************
*/
WORD32 ihevce_buff_que_set_buf_prod(void *pv_buf_que, WORD32 buf_id, WORD32 num_users)
{
    buf_que_t *ps_buf_que;

    ps_buf_que = (buf_que_t *)pv_buf_que;

    if(buf_id < ps_buf_que->i4_num_bufs)
    {
        if(ps_buf_que->pi4_produced_sts[buf_id] == 0)
        {
            ps_buf_que->pi4_num_users[buf_id] += num_users;
            ps_buf_que->i4_num_active_bufs += 1;
            ps_buf_que->pi4_produced_sts[buf_id] = 1;

            return 0;
        }
        else
        {
            /* Buffer is already marked as Produced */
            return (-1);
        }
    }
    else
    {
        /* Unable to recognize the Buffer ID */
        return (-1);
    }

    return (-1);
}

/*!
**************************************************************************
* \brief
*    This function decrements number of users. If Number of users are Zero,
*    then active Buffers in list gets decremented and this buffer is marked
*    unused.
**************************************************************************
*/
WORD32 ihevce_buff_que_rel_buf(void *pv_buf_que, WORD32 buf_id)
{
    buf_que_t *ps_buf_que;
    WORD32 i;

    ps_buf_que = (buf_que_t *)pv_buf_que;
    i = buf_id;

    /* check if the buf id is less than max num buffers */
    if(i < ps_buf_que->i4_num_bufs)
    {
        if(ps_buf_que->pi4_produced_sts[i] > 0)
        {
            /* decrease the number of users */
            ps_buf_que->pi4_num_users[i] -= 1;

            if(ps_buf_que->pi4_num_users[i] == 0)
            {
                if(0 == ps_buf_que->i4_num_active_bufs)
                {
                    return (-1);
                }

                ps_buf_que->i4_num_active_bufs -= 1;
                ps_buf_que->pi4_produced_sts[i] = 0;
            }
            return 0;
        }
        else
        {
            /* Illeagal release of Buffer, No one is using it */
            return (-1);
        }
    }

    /* Unable to recognize the Buffer ID */
    return (-1);
}

/*!
**************************************************************************
* \brief
*    This function gets number of active buffers.
**************************************************************************
*/
WORD32 ihevce_buff_que_get_active_bufs(void *pv_buf_que)
{
    buf_que_t *ps_buf_que;

    ps_buf_que = (buf_que_t *)pv_buf_que;
    return (ps_buf_que->i4_num_active_bufs);
}

/*!
**************************************************************************
* \brief
*    This function sets the reorder number for given buffer.
*    this will set the order for the consumer who is consuming in reorder order
**************************************************************************
*/
WORD32 ihevce_buff_que_set_reorder_buf(void *pv_buf_que, WORD32 buf_id)
{
    buf_que_t *ps_buf_que;

    ps_buf_que = (buf_que_t *)pv_buf_que;

    if(buf_id < ps_buf_que->i4_num_bufs)
    {
        WORD32 next_disp_seq = ps_buf_que->u4_next_disp_seq;

        /* increment the seq number */
        ps_buf_que->u4_next_disp_seq++;

        /* set the reorder number to the corresponding id */
        ps_buf_que->pu4_enc_seq[buf_id] = next_disp_seq;

        return 0;
    }
    else
    {
        /* invalid buffer id */
        return (-1);
    }

    return (-1);
}