/*
|
* Copyright 2016 Rockchip Electronics Co. LTD
|
*
|
* 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.
|
*/
|
|
#define MODULE_TAG "rc_data_impl"
|
|
#include <string.h>
|
|
#include "mpp_env.h"
|
#include "mpp_mem.h"
|
#include "mpp_list.h"
|
#include "mpp_debug.h"
|
#include "mpp_common.h"
|
|
#include "rc_data.h"
|
#include "rc_data_impl.h"
|
|
#define RC_LIST_HEAD 1
|
#define RC_LIST_TAIL 0
|
|
#define RC_FRM_TYPE_I 0
|
#define RC_FRM_TYPE_P 1
|
|
#define RC_FRM_STATUS_VALID (0x00000001)
|
#define RC_HAL_SET_VALID (0x00000002)
|
#define RC_HAL_RET_VALID (0x00000004)
|
|
static void rc_data_indexes_init(RcDataIndexes *sort)
|
{
|
RK_S32 i;
|
|
memset(sort, 0, sizeof(*sort));
|
|
INIT_LIST_HEAD(&sort->seq);
|
|
for (i = 0; i < (RK_S32)MPP_ARRAY_ELEMS(sort->type); i++)
|
INIT_LIST_HEAD(&sort->type[i]);
|
|
for (i = 0; i < (RK_S32)MPP_ARRAY_ELEMS(sort->tid); i++)
|
INIT_LIST_HEAD(&sort->tid[i]);
|
|
for (i = 0; i < (RK_S32)MPP_ARRAY_ELEMS(sort->status); i++)
|
INIT_LIST_HEAD(&sort->status[i]);
|
}
|
|
static void rc_data_node_init(DataGroupImpl *p, RcDataNode *node, RK_S32 slot_idx)
|
{
|
RcDataIndexes *indexes = &p->indexes;
|
RcDataStatus status = RC_DATA_ST_UNUSED;
|
RcDataHead *head = &node->head;
|
RcDataBase *base = &node->base;
|
|
memset(node, 0, sizeof(*node));
|
|
head->node = node;
|
head->slot_id = slot_idx;
|
|
INIT_LIST_HEAD(&head->seq);
|
INIT_LIST_HEAD(&head->type);
|
INIT_LIST_HEAD(&head->tid);
|
INIT_LIST_HEAD(&head->status);
|
list_add_tail(&head->status, &indexes->status[status]);
|
indexes->status_cnt[status]++;
|
|
base->head = head;
|
|
node->extra = NULL;
|
}
|
|
MPP_RET rc_data_group_init(DataGroupImpl *p, RK_S32 base_cnt, RK_S32 extra_cnt)
|
{
|
p->lock = new Mutex();
|
|
node_group_init(&p->node, sizeof(RcDataNode), base_cnt);
|
node_group_init(&p->extra, sizeof(RcDataExtra), extra_cnt);
|
|
mpp_assert(p->lock);
|
mpp_assert(p->node);
|
mpp_assert(p->extra);
|
|
p->base_cnt = base_cnt;
|
p->extra_cnt = extra_cnt;
|
|
rc_data_group_reset(p);
|
|
return MPP_OK;
|
}
|
|
MPP_RET rc_data_group_deinit(DataGroupImpl *p)
|
{
|
mpp_assert(p->lock);
|
mpp_assert(p->node);
|
mpp_assert(p->extra);
|
|
node_group_deinit(p->node);
|
node_group_deinit(p->extra);
|
|
delete p->lock;
|
|
return MPP_OK;
|
}
|
|
MPP_RET rc_data_group_reset(DataGroupImpl *p)
|
{
|
RK_S32 i;
|
|
rc_data_indexes_init(&p->indexes);
|
|
for (i = 0; i < p->base_cnt; i++) {
|
RcDataNode *node = (RcDataNode *)node_group_get(p->node, i);
|
|
rc_data_node_init(p, node, i);
|
}
|
|
for (i = 0; i < p->extra_cnt; i++) {
|
RcDataExtra *extra = (RcDataExtra *)node_group_get(p->extra, i);
|
|
/* NOTE: node in head is NULL */
|
memset(extra, 0, sizeof(*extra));
|
}
|
|
return MPP_OK;
|
}
|
|
RcDataNode *rc_data_group_get_node_by_seq_id(DataGroupImpl *p, RK_S32 seq_id)
|
{
|
RcDataIndexes *indexes = &p->indexes;
|
|
if (list_empty(&indexes->seq))
|
return NULL;
|
|
RcDataNode *node = NULL;
|
RcDataHead *pos;
|
|
if (MPP_ABS(seq_id - indexes->seq_new) < MPP_ABS(seq_id - indexes->seq_old)) {
|
list_for_each_entry(pos, &indexes->seq, RcDataHead, seq) {
|
if (pos->seq_id == seq_id) {
|
node = pos->node;
|
break;
|
}
|
}
|
} else {
|
list_for_each_entry_reverse(pos, &indexes->seq, RcDataHead, seq) {
|
if (pos->seq_id == seq_id) {
|
node = pos->node;
|
break;
|
}
|
}
|
}
|
|
return node;
|
}
|
|
RcDataNode *rc_data_group_get_node_by_status(DataGroupImpl *p, RcDataStatus status, RK_S32 whence)
|
{
|
RcDataIndexes *indexes = &p->indexes;
|
|
mpp_assert(status >= RC_DATA_ST_UNUSED && status <= RC_DATA_ST_DONE);
|
|
struct list_head *list = &indexes->status[status];
|
|
if (list_empty(list))
|
return NULL;
|
|
list = (whence == RC_LIST_HEAD) ? (list->next) : (list->prev);
|
RcDataHead *head = list_entry(list, RcDataHead, status);
|
mpp_assert(head->data_status == status);
|
mpp_assert(head->node);
|
return head->node;
|
}
|
|
void rc_data_group_put_node(DataGroupImpl *p, RcDataNode *node)
|
{
|
RcDataIndexes *indexes = &p->indexes;
|
RcDataHead *head = &node->head;
|
|
AutoMutex auto_lock(p->lock);
|
RcDataStatus data_status = head->data_status;
|
|
list_del_init(&head->status);
|
indexes->status_cnt[data_status]--;
|
|
if (data_status == RC_DATA_ST_FILLING) {
|
// ready on filling add to indexing list by property
|
EncFrmStatus frm_status = head->frm_status;
|
RK_S32 type_id = frm_status.is_intra ? RC_FRM_TYPE_I : RC_FRM_TYPE_P;
|
RK_S32 tid = frm_status.temporal_id;
|
|
mpp_assert(list_empty(&head->seq));
|
list_add_tail(&head->seq, &indexes->seq);
|
indexes->seq_cnt++;
|
indexes->seq_new = head->seq_id;
|
|
mpp_assert(list_empty(&head->type));
|
list_add_tail(&head->type, &indexes->type[type_id]);
|
indexes->type_cnt[type_id]++;
|
|
mpp_assert(tid < 4);
|
mpp_assert(list_empty(&head->tid));
|
list_add_tail(&head->tid, &indexes->tid[type_id]);
|
indexes->tid_cnt[type_id]++;
|
}
|
|
// goto next status
|
switch (data_status) {
|
case RC_DATA_ST_UNUSED : {
|
data_status = RC_DATA_ST_FILLING;
|
} break;
|
case RC_DATA_ST_FILLING : {
|
data_status = RC_DATA_ST_DONE;
|
} break;
|
case RC_DATA_ST_DONE : {
|
data_status = RC_DATA_ST_UNUSED;
|
} break;
|
default : {
|
data_status = RC_DATA_ST_BUTT;
|
mpp_assert(data_status != RC_DATA_ST_BUTT);
|
} break;
|
}
|
|
if (data_status == RC_DATA_ST_UNUSED) {
|
// removed from indexing list
|
EncFrmStatus frm_status = head->frm_status;
|
|
if (!list_empty(&head->seq)) {
|
list_del_init(&head->seq);
|
indexes->seq_cnt--;
|
indexes->seq_old = head->seq_id;
|
}
|
|
if (!list_empty(&head->type)) {
|
RK_S32 type_id = frm_status.is_intra ? RC_FRM_TYPE_I : RC_FRM_TYPE_P;
|
|
list_del_init(&head->type);
|
indexes->type_cnt[type_id]--;
|
}
|
|
if (!list_empty(&head->tid)) {
|
RK_S32 tid = frm_status.temporal_id;
|
|
mpp_assert(tid < 4);
|
list_del_init(&head->tid);
|
indexes->tid_cnt[tid]--;
|
}
|
}
|
|
list_add_tail(&head->status, &indexes->status[data_status]);
|
indexes->status_cnt[data_status]++;
|
head->data_status = data_status;
|
}
|
|
RcData rc_data_get_next(DataGroup grp)
|
{
|
DataGroupImpl *p = (DataGroupImpl *)grp;
|
RcDataNode *node = rc_data_group_get_node_by_status(
|
p, RC_DATA_ST_UNUSED, RC_LIST_HEAD);
|
|
return (RcData)node;
|
}
|
|
RcData rc_data_get_curr_latest(DataGroup grp)
|
{
|
DataGroupImpl *p = (DataGroupImpl *)grp;
|
RcDataNode *node = rc_data_group_get_node_by_status(
|
p, RC_DATA_ST_FILLING, RC_LIST_TAIL);
|
|
return (RcData)node;
|
}
|
|
RcData rc_data_get_curr_oldest(DataGroup grp)
|
{
|
DataGroupImpl *p = (DataGroupImpl *)grp;
|
RcDataNode *node = rc_data_group_get_node_by_status(
|
p, RC_DATA_ST_FILLING, RC_LIST_HEAD);
|
|
return (RcData)node;
|
}
|
|
RcData rc_data_get_last_latest(DataGroup grp)
|
{
|
DataGroupImpl *p = (DataGroupImpl *)grp;
|
RcDataNode *node = rc_data_group_get_node_by_status(
|
p, RC_DATA_ST_DONE, RC_LIST_TAIL);
|
|
return (RcData)node;
|
}
|
|
RcData rc_data_get_last_oldest(DataGroup grp)
|
{
|
DataGroupImpl *p = (DataGroupImpl *)grp;
|
RcDataNode *node = rc_data_group_get_node_by_status(
|
p, RC_DATA_ST_DONE, RC_LIST_HEAD);
|
|
return (RcData)node;
|
}
|
