/*
|
* 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_base"
|
|
#include <math.h>
|
#include <memory.h>
|
|
#include "mpp_env.h"
|
#include "mpp_mem.h"
|
#include "mpp_common.h"
|
|
#include "rc_base.h"
|
|
#define MPP_RC_DBG_FUNCTION (0x00000001)
|
#define MPP_RC_DBG_BPS (0x00000010)
|
#define MPP_RC_DBG_RC (0x00000020)
|
#define MPP_RC_DBG_CFG (0x00000100)
|
#define MPP_RC_DBG_RECORD (0x00001000)
|
#define MPP_RC_DBG_VBV (0x00002000)
|
|
#define mpp_rc_dbg(flag, fmt, ...) _mpp_dbg(mpp_rc_debug, flag, fmt, ## __VA_ARGS__)
|
#define mpp_rc_dbg_f(flag, fmt, ...) _mpp_dbg_f(mpp_rc_debug, flag, fmt, ## __VA_ARGS__)
|
|
#define mpp_rc_dbg_func(fmt, ...) mpp_rc_dbg_f(MPP_RC_DBG_FUNCTION, fmt, ## __VA_ARGS__)
|
#define mpp_rc_dbg_bps(fmt, ...) mpp_rc_dbg(MPP_RC_DBG_BPS, fmt, ## __VA_ARGS__)
|
#define mpp_rc_dbg_rc(fmt, ...) mpp_rc_dbg(MPP_RC_DBG_RC, fmt, ## __VA_ARGS__)
|
#define mpp_rc_dbg_cfg(fmt, ...) mpp_rc_dbg(MPP_RC_DBG_CFG, fmt, ## __VA_ARGS__)
|
#define mpp_rc_dbg_vbv(fmt, ...) mpp_rc_dbg(MPP_RC_DBG_VBV, fmt, ## __VA_ARGS__)
|
|
#define SIGN(a) ((a) < (0) ? (-1) : (1))
|
#define DIV(a, b) (((a) + (SIGN(a) * (b)) / 2) / (b))
|
|
MPP_RET mpp_data_init_v2(MppDataV2 **data, RK_S32 size, RK_S32 value)
|
{
|
if (NULL == data || size <= 0) {
|
mpp_err_f("invalid data %p size %d\n", data, size);
|
return MPP_ERR_NULL_PTR;
|
}
|
|
*data = NULL;
|
MppDataV2 *p = mpp_malloc_size(MppDataV2, sizeof(MppDataV2) + sizeof(RK_S32) * size);
|
if (NULL == p) {
|
mpp_err_f("malloc size %d failed\n", size);
|
return MPP_ERR_MALLOC;
|
}
|
p->size = size;
|
p->pos_r = 0;
|
p->pos_pw = 0;
|
p->pos_w = 0;
|
p->pos_ahead = 0;
|
p->sum = 0;
|
*data = p;
|
|
mpp_data_reset_v2(p, value);
|
return MPP_OK;
|
}
|
|
void mpp_data_deinit_v2(MppDataV2 *p)
|
{
|
MPP_FREE(p);
|
}
|
|
void mpp_data_reset_v2(MppDataV2 *p, RK_S32 val)
|
{
|
RK_S32 i;
|
RK_S32 *data = p->val;
|
|
p->pos_pw = 0;
|
p->pos_w = 0;
|
p->pos_r = p->size;
|
p->sum = val * p->size;
|
|
for (i = 0; i < p->size; i++)
|
*data++ = val;
|
}
|
|
void mpp_data_preset_v2(MppDataV2 *p, RK_S32 val)
|
{
|
mpp_assert(p);
|
if (p->pos_r == p->size) {
|
p->pos_r--;
|
p->sum -= p->val[p->pos_pw];
|
}
|
mpp_assert(p->pos_r < p->size);
|
p->val[p->pos_pw] = val;
|
p->sum += p->val[p->pos_pw];
|
p->pos_pw++;
|
p->pos_r++;
|
if (p->pos_pw >= p->size) {
|
p->pos_pw = 0;
|
}
|
p->pos_ahead++;
|
}
|
|
void mpp_data_update_v2(MppDataV2 *p, RK_S32 val)
|
{
|
mpp_assert(p->pos_ahead >= 0 && p->pos_ahead <= 2);
|
if (p->pos_ahead) {
|
p->sum += val - p->val[p->pos_w];
|
p->val[p->pos_w] = val;
|
p->pos_w++;
|
if (p->pos_w >= p->size)
|
p->pos_w = 0;
|
|
p->pos_ahead--;
|
|
return;
|
}
|
|
mpp_assert(p);
|
if (p->pos_r == p->size) {
|
p->pos_r--;
|
p->sum -= p->val[p->pos_w];
|
}
|
mpp_assert(p->pos_r < p->size);
|
p->val[p->pos_w] = val;
|
p->sum += p->val[p->pos_w];
|
p->pos_w++;
|
p->pos_r++;
|
if (p->pos_w >= p->size)
|
p->pos_w = 0;
|
}
|
|
RK_S32 mpp_data_get_pre_val_v2(MppDataV2 *p, RK_S32 idx)
|
{
|
if (idx < 0) {
|
idx = p->size + idx;
|
}
|
mpp_assert(p->pos_w < p->size);
|
mpp_assert(idx < p->size);
|
RK_S32 pos = 0;
|
|
pos = p->pos_w - 1;
|
if (pos - idx < 0) {
|
mpp_assert(p->pos_r == p->size);
|
RK_S32 pos1 = idx - pos;
|
pos = p->size - pos1;
|
} else {
|
pos = pos - idx;
|
}
|
mpp_assert(pos < p->size);
|
return p->val[pos];
|
}
|
|
RK_S32 mpp_data_sum_v2(MppDataV2 *p)
|
{
|
return (RK_S32)p->sum;
|
}
|
RK_S32 mpp_data_mean_v2(MppDataV2 *p)
|
{
|
RK_S32 mean = (RK_S32)p->sum / p->size;
|
return mean;
|
}
|
|
RK_S32 mpp_data_sum_with_ratio_v2(MppDataV2 *p, RK_S32 len, RK_S32 num, RK_S32 denorm)
|
{
|
mpp_assert(p);
|
|
RK_S32 i;
|
RK_S64 sum = 0;
|
RK_S32 *data = p->val;
|
|
mpp_assert(len <= p->size);
|
|
if (num == denorm) {
|
for (i = 0; i < len; i++)
|
sum += *data++;
|
} else {
|
// NOTE: use 64bit to avoid 0 in 32bit
|
RK_S64 acc_num = 1;
|
RK_S64 acc_denorm = 1;
|
|
for (i = 0; i < len; i++) {
|
sum += p->val[i] * acc_num / acc_denorm;
|
acc_num *= num;
|
acc_denorm *= denorm;
|
}
|
}
|
|
return DIV(sum, len);
|
}
|
