/******************************************************************************
*
* 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);
}