// Copyright 2019 Fuzhou Rockchip Electronics Co., Ltd. All rights reserved.
|
// Use of this source code is governed by a BSD-style license that can be
|
// found in the LICENSE file.
|
|
#include "mpp_encoder.h"
|
|
#include <assert.h>
|
#include <fcntl.h>
|
#include <time.h>
|
#include <unistd.h>
|
|
#include <memory>
|
|
#include "buffer.h"
|
#include "utils.h"
|
|
namespace easymedia
|
{
|
|
MPPEncoder::MPPEncoder()
|
: coding_type(MPP_VIDEO_CodingAutoDetect), output_mb_flags(0), encoder_sta_en(false), stream_size_1s(0),
|
frame_cnt_1s(0), last_ts(0), cur_ts(0), userdata_len(0), userdata_frame_id(0), userdata_all_frame_en(0)
|
{
|
#ifdef MPP_SUPPORT_HW_OSD
|
// reset osd data.
|
memset(&osd_data, 0, sizeof(osd_data));
|
#endif
|
memset(&roi_cfg, 0, sizeof(roi_cfg));
|
rc_api_brief_name = "default";
|
}
|
|
MPPEncoder::~MPPEncoder()
|
{
|
#ifdef MPP_SUPPORT_HW_OSD
|
if (osd_data.buf) {
|
LOGD("MPP Encoder: free osd buff\n");
|
mpp_buffer_put(osd_data.buf);
|
osd_data.buf = NULL;
|
}
|
#endif
|
if (roi_cfg.regions) {
|
LOGD("MPP Encoder: free enc roi region buff\n");
|
free(roi_cfg.regions);
|
roi_cfg.regions = NULL;
|
}
|
}
|
|
void MPPEncoder::SetMppCodeingType(MppCodingType type)
|
{
|
coding_type = type;
|
if (type == MPP_VIDEO_CodingMJPEG) {
|
codec_type = CODEC_TYPE_JPEG;
|
} else if (type == MPP_VIDEO_CodingAVC) {
|
codec_type = CODEC_TYPE_H264;
|
} else if (type == MPP_VIDEO_CodingHEVC) {
|
codec_type = CODEC_TYPE_H265;
|
}
|
// mpp always return a single nal
|
if (type == MPP_VIDEO_CodingAVC || type == MPP_VIDEO_CodingHEVC) {
|
output_mb_flags |= MediaBuffer::kSingleNalUnit;
|
}
|
}
|
|
bool MPPEncoder::Init()
|
{
|
if (coding_type == MPP_VIDEO_CodingUnused) {
|
return false;
|
}
|
mpp_ctx = std::make_shared<MPPContext>();
|
if (!mpp_ctx) {
|
return false;
|
}
|
MppCtx ctx = NULL;
|
MppApi* mpi = NULL;
|
int ret = mpp_create(&ctx, &mpi);
|
if (ret) {
|
LOG("mpp_create failed\n");
|
return false;
|
}
|
mpp_ctx->ctx = ctx;
|
mpp_ctx->mpi = mpi;
|
ret = mpp_init(ctx, MPP_CTX_ENC, coding_type);
|
if (ret != MPP_OK) {
|
LOG("mpp_init failed with type %d\n", coding_type);
|
mpp_destroy(ctx);
|
ctx = NULL;
|
mpi = NULL;
|
return false;
|
}
|
return true;
|
}
|
|
int MPPEncoder::PrepareMppFrame(const std::shared_ptr<MediaBuffer>& input, std::shared_ptr<MediaBuffer>& mdinfo,
|
MppFrame& frame)
|
{
|
MppBuffer pic_buf = nullptr;
|
if (input->GetType() != Type::Image) {
|
LOG("mpp encoder input source only support image buffer\n");
|
return -EINVAL;
|
}
|
PixelFormat fmt = input->GetPixelFormat();
|
if (fmt == PIX_FMT_NONE) {
|
LOG("mpp encoder input source invalid pixel format\n");
|
return -EINVAL;
|
}
|
ImageBuffer* hw_buffer = static_cast<ImageBuffer*>(input.get());
|
|
assert(input->GetValidSize() > 0);
|
mpp_frame_set_pts(frame, hw_buffer->GetUSTimeStamp());
|
mpp_frame_set_dts(frame, hw_buffer->GetUSTimeStamp());
|
mpp_frame_set_width(frame, hw_buffer->GetWidth());
|
mpp_frame_set_height(frame, hw_buffer->GetHeight());
|
mpp_frame_set_fmt(frame, ConvertToMppPixFmt(fmt));
|
|
if (fmt == PIX_FMT_YUYV422 || fmt == PIX_FMT_UYVY422) {
|
mpp_frame_set_hor_stride(frame, hw_buffer->GetVirWidth() * 2);
|
} else {
|
mpp_frame_set_hor_stride(frame, hw_buffer->GetVirWidth());
|
}
|
mpp_frame_set_ver_stride(frame, hw_buffer->GetVirHeight());
|
|
MppMeta meta = mpp_frame_get_meta(frame);
|
auto& related_vec = input->GetRelatedSPtrs();
|
if (!related_vec.empty()) {
|
mdinfo = std::static_pointer_cast<MediaBuffer>(related_vec[0]);
|
LOGD("MPP Encoder: set mdinfo(%p, %zuBytes) to frame\n", mdinfo->GetPtr(), mdinfo->GetValidSize());
|
mpp_meta_set_ptr(meta, KEY_MV_LIST, mdinfo->GetPtr());
|
}
|
|
if (roi_cfg.number && roi_cfg.regions) {
|
LOGD("MPP Encoder: set roi cfg(cnt:%d,%p) to frame\n", roi_cfg.number, roi_cfg.regions);
|
mpp_meta_set_ptr(meta, KEY_ROI_DATA, &roi_cfg);
|
}
|
|
#ifdef MPP_SUPPORT_HW_OSD
|
if (osd_data.num_region && osd_data.buf) {
|
LOGD("MPP Encoder: set osd data(%d regions) to frame\n", osd_data.num_region);
|
mpp_meta_set_ptr(meta, KEY_OSD_DATA, (void*)&osd_data);
|
}
|
#endif // MPP_SUPPORT_HW_OSD
|
|
if (userdata_len) {
|
LOGD("MPP Encoder: set userdata(%dBytes) to frame\n", userdata_len);
|
bool skip_frame = false;
|
if (!userdata_all_frame_en) {
|
MediaConfig& cfg = GetConfig();
|
// userdata_frame_id = 0 : first gop frame.
|
if (userdata_frame_id) {
|
skip_frame = true;
|
}
|
|
userdata_frame_id++;
|
if (userdata_frame_id == cfg.vid_cfg.gop_size) {
|
userdata_frame_id = 0;
|
}
|
}
|
|
if (!skip_frame) {
|
mpp_ud.pdata = userdata;
|
mpp_ud.len = userdata_len;
|
mpp_meta_set_ptr(meta, KEY_USER_DATA, &mpp_ud);
|
}
|
}
|
|
MPP_RET ret = init_mpp_buffer_with_content(pic_buf, input);
|
if (ret) {
|
LOG("prepare picture buffer failed\n");
|
return ret;
|
}
|
|
mpp_frame_set_buffer(frame, pic_buf);
|
if (input->IsEOF()) {
|
mpp_frame_set_eos(frame, 1);
|
}
|
|
mpp_buffer_put(pic_buf);
|
|
return 0;
|
}
|
|
int MPPEncoder::PrepareMppPacket(std::shared_ptr<MediaBuffer>& output, MppPacket& packet)
|
{
|
MppBuffer mpp_buf = nullptr;
|
|
if (!output->IsHwBuffer()) {
|
return 0;
|
}
|
|
MPP_RET ret = init_mpp_buffer(mpp_buf, output, 0);
|
if (ret) {
|
LOG("import output stream buffer failed\n");
|
return ret;
|
}
|
|
if (mpp_buf) {
|
mpp_packet_init_with_buffer(&packet, mpp_buf);
|
mpp_buffer_put(mpp_buf);
|
}
|
|
return 0;
|
}
|
|
int MPPEncoder::PrepareMppExtraBuffer(std::shared_ptr<MediaBuffer> extra_output, MppBuffer& buffer)
|
{
|
MppBuffer mpp_buf = nullptr;
|
if (!extra_output || !extra_output->IsValid()) {
|
return 0;
|
}
|
MPP_RET ret = init_mpp_buffer(mpp_buf, extra_output, extra_output->GetValidSize());
|
if (ret) {
|
LOG("import extra stream buffer failed\n");
|
return ret;
|
}
|
buffer = mpp_buf;
|
return 0;
|
}
|
|
class MPPPacketContext
|
{
|
public:
|
MPPPacketContext(std::shared_ptr<MPPContext> ctx, MppPacket p) : mctx(ctx), packet(p)
|
{
|
}
|
~MPPPacketContext()
|
{
|
if (packet) {
|
mpp_packet_deinit(&packet);
|
}
|
}
|
|
private:
|
std::shared_ptr<MPPContext> mctx;
|
MppPacket packet;
|
};
|
|
static int __free_mpppacketcontext(void* p)
|
{
|
assert(p);
|
delete (MPPPacketContext*)p;
|
return 0;
|
}
|
|
int MPPEncoder::Process(const std::shared_ptr<MediaBuffer>& input, std::shared_ptr<MediaBuffer>& output,
|
std::shared_ptr<MediaBuffer> extra_output)
|
{
|
MppFrame frame = nullptr;
|
MppPacket packet = nullptr;
|
MppPacket import_packet = nullptr;
|
MppBuffer mv_buf = nullptr;
|
size_t packet_len = 0;
|
RK_U32 packet_flag = 0;
|
RK_U32 out_eof = 0;
|
RK_S64 pts = 0;
|
std::shared_ptr<MediaBuffer> mdinfo;
|
RK_S32 temporal_id = -1;
|
Type out_type;
|
|
if (!input) {
|
return 0;
|
}
|
if (!output) {
|
return -EINVAL;
|
}
|
|
// all changes must set before encode and among the same thread
|
while (HasChangeReq()) {
|
auto change = PeekChange();
|
if (change.first && !CheckConfigChange(change)) {
|
return -1;
|
}
|
}
|
|
int ret = mpp_frame_init(&frame);
|
if (MPP_OK != ret) {
|
LOG("mpp_frame_init failed\n");
|
goto ENCODE_OUT;
|
}
|
|
ret = PrepareMppFrame(input, mdinfo, frame);
|
if (ret) {
|
LOG("PrepareMppFrame failed\n");
|
goto ENCODE_OUT;
|
}
|
|
if (output->IsValid()) {
|
ret = PrepareMppPacket(output, packet);
|
if (ret) {
|
LOG("PrepareMppPacket failed\n");
|
goto ENCODE_OUT;
|
}
|
import_packet = packet;
|
}
|
|
ret = PrepareMppExtraBuffer(extra_output, mv_buf);
|
if (ret) {
|
LOG("PrepareMppExtraBuffer failed\n");
|
goto ENCODE_OUT;
|
}
|
|
ret = Process(frame, packet, mv_buf);
|
if (ret) {
|
goto ENCODE_OUT;
|
}
|
|
if (!packet) {
|
LOG("ERROR: MPP Encoder: input frame:%p, %zuBytes; output null packet!\n", frame,
|
mpp_buffer_get_size(mpp_frame_get_buffer(frame)));
|
goto ENCODE_OUT;
|
}
|
|
packet_len = mpp_packet_get_length(packet);
|
{
|
MppMeta packet_meta = mpp_packet_get_meta(packet);
|
RK_S32 is_intra = 0;
|
mpp_meta_get_s32(packet_meta, KEY_OUTPUT_INTRA, &is_intra);
|
packet_flag = (is_intra) ? MediaBuffer::kIntra : MediaBuffer::kPredicted;
|
mpp_meta_get_s32(packet_meta, KEY_TEMPORAL_ID, &temporal_id);
|
}
|
out_eof = mpp_packet_get_eos(packet);
|
pts = mpp_packet_get_pts(packet);
|
if (pts <= 0) {
|
pts = mpp_packet_get_dts(packet);
|
}
|
|
// out fps < in fps ?
|
if (packet_len == 0) {
|
output->SetValidSize(0);
|
if (extra_output) {
|
extra_output->SetValidSize(0);
|
}
|
goto ENCODE_OUT;
|
}
|
|
// Calculate bit rate statistics.
|
if (encoder_sta_en) {
|
MediaConfig& cfg = GetConfig();
|
int target_fps = cfg.vid_cfg.frame_rate;
|
int target_bpsmax = cfg.vid_cfg.bit_rate_max;
|
int enable_bps = 1;
|
frame_cnt_1s += 1;
|
stream_size_1s += packet_len;
|
if (target_fps <= 0) {
|
target_fps = 30;
|
enable_bps = 0;
|
}
|
// Refresh every second
|
if ((frame_cnt_1s % target_fps) == 0) {
|
// Calculate the frame rate based on the system time.
|
cur_ts = gettimeofday();
|
if (last_ts) {
|
encoded_fps = ((float)target_fps / (cur_ts - last_ts)) * 1000000;
|
} else {
|
encoded_fps = 0;
|
}
|
|
last_ts = cur_ts;
|
if (enable_bps) {
|
// convert bytes to bits
|
encoded_bps = stream_size_1s * 8;
|
LOG("MPP ENCODER: bps:%d, actual_bps:%d, fps:%d, actual_fps:%f\n", target_bpsmax, encoded_bps,
|
target_fps, encoded_fps);
|
} else {
|
LOG("MPP ENCODER: fps statistical period:%d, actual_fps:%f\n", target_fps, encoded_fps);
|
}
|
|
// reset 1s variable
|
stream_size_1s = 0;
|
frame_cnt_1s = 0;
|
}
|
} else if (cur_ts) {
|
// clear tmp statistics variable.
|
stream_size_1s = 0;
|
frame_cnt_1s = 0;
|
cur_ts = 0;
|
last_ts = 0;
|
}
|
|
if (output->IsValid()) {
|
if (!import_packet) {
|
// !!time-consuming operation
|
void* ptr = output->GetPtr();
|
assert(ptr);
|
LOGD("extra time-consuming memcpy to cpu!\n");
|
memcpy(ptr, mpp_packet_get_data(packet), packet_len);
|
// sync to cpu?
|
}
|
} else {
|
MPPPacketContext* ctx = new MPPPacketContext(mpp_ctx, packet);
|
if (!ctx) {
|
LOG_NO_MEMORY();
|
ret = -ENOMEM;
|
goto ENCODE_OUT;
|
}
|
output->SetFD(mpp_buffer_get_fd(mpp_packet_get_buffer(packet)));
|
output->SetPtr(mpp_packet_get_data(packet));
|
output->SetSize(mpp_packet_get_size(packet));
|
output->SetUserData(ctx, __free_mpppacketcontext);
|
packet = nullptr;
|
}
|
output->SetValidSize(packet_len);
|
output->SetUserFlag(packet_flag | output_mb_flags);
|
output->SetTsvcLevel(temporal_id);
|
output->SetUSTimeStamp(pts);
|
output->SetEOF(out_eof ? true : false);
|
out_type = output->GetType();
|
if (out_type == Type::Image) {
|
auto out_img = std::static_pointer_cast<ImageBuffer>(output);
|
auto& info = out_img->GetImageInfo();
|
const auto& in_cfg = GetConfig();
|
info = (coding_type == MPP_VIDEO_CodingMJPEG) ? in_cfg.img_cfg.image_info
|
: in_cfg.vid_cfg.image_cfg.image_info;
|
// info.pix_fmt = codec_type;
|
} else {
|
output->SetType(Type::Video);
|
}
|
|
if (mv_buf) {
|
if (extra_output->GetFD() < 0) {
|
void* ptr = extra_output->GetPtr();
|
assert(ptr);
|
memcpy(ptr, mpp_buffer_get_ptr(mv_buf), mpp_buffer_get_size(mv_buf));
|
}
|
extra_output->SetValidSize(mpp_buffer_get_size(mv_buf));
|
extra_output->SetUserFlag(packet_flag);
|
extra_output->SetUSTimeStamp(pts);
|
}
|
|
ENCODE_OUT:
|
if (frame) {
|
mpp_frame_deinit(&frame);
|
}
|
if (packet) {
|
mpp_packet_deinit(&packet);
|
}
|
if (mv_buf) {
|
mpp_buffer_put(mv_buf);
|
}
|
|
return ret;
|
}
|
|
int MPPEncoder::Process(MppFrame frame, MppPacket& packet, MppBuffer& mv_buf)
|
{
|
MppCtx ctx = mpp_ctx->ctx;
|
MppApi* mpi = mpp_ctx->mpi;
|
|
if (mv_buf) {
|
LOG("TODO move detection frome mpp encoder...\n");
|
}
|
|
int ret = mpi->encode_put_frame(ctx, frame);
|
if (ret) {
|
LOG("mpp encode put frame failed\n");
|
return -1;
|
}
|
|
ret = mpi->encode_get_packet(ctx, &packet);
|
if (ret) {
|
LOG("mpp encode get packet failed\n");
|
return -1;
|
}
|
|
return 0;
|
}
|
|
int MPPEncoder::SendInput(const std::shared_ptr<MediaBuffer>&)
|
{
|
errno = ENOSYS;
|
return -1;
|
}
|
std::shared_ptr<MediaBuffer> MPPEncoder::FetchOutput()
|
{
|
errno = ENOSYS;
|
return nullptr;
|
}
|
|
int MPPEncoder::EncodeControl(int cmd, void* param)
|
{
|
MpiCmd mpi_cmd = (MpiCmd)cmd;
|
int ret = mpp_ctx->mpi->control(mpp_ctx->ctx, mpi_cmd, (MppParam)param);
|
|
if (ret) {
|
LOG("mpp control cmd 0x%08x param %p failed\n", cmd, param);
|
return ret;
|
}
|
|
return 0;
|
}
|
|
void MPPEncoder::QueryChange(uint32_t change, void* value, int32_t size)
|
{
|
if (!value || !size) {
|
LOG("ERROR: MPP ENCODER: %s invalid argument!\n", __func__);
|
return;
|
}
|
switch (change) {
|
case VideoEncoder::kMoveDetectionFlow:
|
if (size < (int)sizeof(int32_t)) {
|
LOG("ERROR: MPP ENCODER: %s change:[%d], size invalid!\n", __func__,
|
VideoEncoder::kMoveDetectionFlow);
|
return;
|
}
|
if (rc_api_brief_name == "smart") {
|
*((int32_t*)value) = 1;
|
} else {
|
*((int32_t*)value) = 0;
|
}
|
break;
|
default:
|
LOG("WARN: MPP ENCODER: %s change:[%d] not support!\n", __func__, change);
|
}
|
}
|
|
void MPPEncoder::set_statistics_switch(bool value)
|
{
|
LOG("[INFO] MPP ENCODER %s statistics\n", value ? "enable" : "disable");
|
encoder_sta_en = value;
|
}
|
|
int MPPEncoder::get_statistics_bps()
|
{
|
if (!encoder_sta_en) {
|
LOG("[WARN] MPP ENCODER statistics should enable first!\n");
|
}
|
return encoded_bps;
|
}
|
|
int MPPEncoder::get_statistics_fps()
|
{
|
if (!encoder_sta_en) {
|
LOG("[WARN] MPP ENCODER statistics should enable first!\n");
|
}
|
return encoded_fps;
|
}
|
|
#ifdef MPP_SUPPORT_HW_OSD
|
|
#define OSD_PTL_SIZE 1024 // Bytes.
|
|
#ifndef NDEBUG
|
static void OsdDummpRegions(OsdRegionData* rdata)
|
{
|
if (!rdata) {
|
return;
|
}
|
|
LOGD("#RegionData:%p:\n", rdata->buffer);
|
LOG("\t enable:%u\n", rdata->enable);
|
LOG("\t region_id:%u\n", rdata->region_id);
|
LOG("\t inverse:%u\n", rdata->inverse);
|
LOG("\t pos_x:%u\n", rdata->pos_x);
|
LOG("\t pos_y:%u\n", rdata->pos_y);
|
LOG("\t width:%u\n", rdata->width);
|
LOG("\t height:%u\n", rdata->height);
|
}
|
|
static void OsdDummpMppOsd(MppEncOSDData* osd)
|
{
|
LOGD("#MPP OsdData: cnt:%d buff:%p, bufSize:%zu\n", osd->num_region, osd->buf, mpp_buffer_get_size(osd->buf));
|
for (int i = 0; i < OSD_REGIONS_CNT; i++) {
|
LOGD("#MPP OsdData[%d]:\n", i);
|
LOG("\t enable:%u\n", osd->region[i].enable);
|
LOG("\t inverse:%u\n", osd->region[i].inverse);
|
LOG("\t pos_x:%u\n", osd->region[i].start_mb_x * 16);
|
LOG("\t pos_y:%u\n", osd->region[i].start_mb_y * 16);
|
LOG("\t width:%u\n", osd->region[i].num_mb_x * 16);
|
LOG("\t height:%u\n", osd->region[i].num_mb_y * 16);
|
LOG("\t buf_offset:%u\n", osd->region[i].buf_offset);
|
}
|
}
|
|
static void SaveOsdImg(MppEncOSDData* _data, int index)
|
{
|
if (!_data->buf) {
|
return;
|
}
|
|
char _path[64] = {0};
|
sprintf(_path, "/tmp/osd_img%d", index);
|
LOGD("MPP Encoder: save osd img to %s\n", _path);
|
int fd = open(_path, O_WRONLY | O_CREAT);
|
if (fd <= 0) {
|
return;
|
}
|
|
int size = _data->region[index].num_mb_x * 16;
|
size *= _data->region[index].num_mb_y * 16;
|
uint8_t* ptr = (uint8_t*)mpp_buffer_get_ptr(_data->buf);
|
ptr += _data->region[index].buf_offset;
|
if (ptr && size) {
|
write(fd, ptr, size);
|
}
|
close(fd);
|
}
|
#endif // NDEBUG
|
|
int MPPEncoder::OsdPaletteSet(uint32_t* ptl_data)
|
{
|
if (!ptl_data) {
|
return -1;
|
}
|
|
LOGD("MPP Encoder: setting yuva palette...\n");
|
MppCtx ctx = mpp_ctx->ctx;
|
MppApi* mpi = mpp_ctx->mpi;
|
MppEncOSDPltCfg osd_plt_cfg;
|
MppEncOSDPlt osd_plt;
|
|
// TODO rgba plt to yuva plt.
|
for (int k = 0; k < 256; k++) {
|
osd_plt.data[k].val = *(ptl_data + k);
|
}
|
|
osd_plt_cfg.change = MPP_ENC_OSD_PLT_CFG_CHANGE_ALL;
|
osd_plt_cfg.type = MPP_ENC_OSD_PLT_TYPE_USERDEF;
|
osd_plt_cfg.plt = &osd_plt;
|
|
int ret = mpi->control(ctx, MPP_ENC_SET_OSD_PLT_CFG, &osd_plt_cfg);
|
if (ret) {
|
LOG("ERROR: MPP Encoder: set osd plt failed ret %d\n", ret);
|
}
|
|
return ret;
|
}
|
|
static int OsdUpdateRegionInfo(MppEncOSDData* osd, OsdRegionData* region_data)
|
{
|
uint32_t new_size = 0;
|
uint32_t old_size = 0;
|
uint8_t rid = region_data->region_id;
|
uint8_t* region_src = NULL;
|
uint8_t* region_dst = NULL;
|
|
if (!region_data->enable) {
|
osd->region[rid].enable = 0;
|
osd->num_region = 0;
|
for (int i = 0; i < OSD_REGIONS_CNT; i++) {
|
if (osd->region[i].enable) {
|
osd->num_region = i + 1;
|
}
|
}
|
assert(osd->num_region <= 8);
|
return 0;
|
}
|
|
// get buffer size to compare.
|
new_size = region_data->width * region_data->height;
|
// If there is enough space, reuse the previous buffer.
|
// However, the current area must be active, so as to
|
// avoid opening up too large a buffer at the beginning,
|
// and it will not be reduced later.
|
if (osd->region[rid].enable) {
|
old_size = osd->region[rid].num_mb_x * osd->region[rid].num_mb_y * 256;
|
}
|
|
// update region info.
|
osd->region[rid].enable = 1;
|
osd->region[rid].inverse = region_data->inverse;
|
osd->region[rid].start_mb_x = region_data->pos_x / 16;
|
osd->region[rid].start_mb_y = region_data->pos_y / 16;
|
osd->region[rid].num_mb_x = region_data->width / 16;
|
osd->region[rid].num_mb_y = region_data->height / 16;
|
|
// 256 * 16 => 4096 is enough for osd.
|
assert(osd->region[rid].start_mb_x <= 256);
|
assert(osd->region[rid].start_mb_y <= 256);
|
assert(osd->region[rid].num_mb_x <= 256);
|
assert(osd->region[rid].num_mb_y <= 256);
|
|
// region[rid] buffer size is enough, copy data directly.
|
if (old_size >= new_size) {
|
LOGD("MPP Encoder: Region[%d] reuse old buff:%u, new_size:%u\n", rid, old_size, new_size);
|
region_src = region_data->buffer;
|
region_dst = (uint8_t*)mpp_buffer_get_ptr(osd->buf);
|
region_dst += osd->region[rid].buf_offset;
|
memcpy(region_dst, region_src, new_size);
|
#ifndef NDEBUG
|
SaveOsdImg(osd, rid);
|
#endif
|
return 0;
|
}
|
|
// region[rid] buffer size too small, resize buffer.
|
MppBuffer new_buff = NULL;
|
MppBuffer old_buff = NULL;
|
uint32_t old_offset[OSD_REGIONS_CNT] = {0};
|
uint32_t total_size = 0;
|
uint32_t current_size = 0;
|
|
osd->num_region = 0;
|
for (int i = 0; i < OSD_REGIONS_CNT; i++) {
|
if (osd->region[i].enable) {
|
old_offset[i] = osd->region[i].buf_offset;
|
osd->region[i].buf_offset = total_size;
|
total_size += osd->region[i].num_mb_x * osd->region[i].num_mb_y * 256;
|
osd->num_region = i + 1;
|
} else {
|
osd->region[i].start_mb_x = 0;
|
osd->region[i].start_mb_y = 0;
|
osd->region[i].buf_offset = 0;
|
osd->region[i].num_mb_x = 0;
|
osd->region[i].num_mb_y = 0;
|
}
|
}
|
|
old_buff = osd->buf;
|
int ret = mpp_buffer_get(NULL, &new_buff, total_size);
|
if (ret) {
|
LOG("ERROR: MPP Encoder: get osd %dBytes buffer failed(%d)\n", total_size, ret);
|
// reset target region.
|
osd->region[rid].enable = 0;
|
osd->region[rid].start_mb_x = 0;
|
osd->region[rid].start_mb_y = 0;
|
osd->region[rid].buf_offset = 0;
|
return -1;
|
}
|
|
for (int i = 0; i < OSD_REGIONS_CNT; i++) {
|
if (!osd->region[i].enable) {
|
continue;
|
}
|
|
if (i != rid) {
|
// copy other region data to new buffer.
|
region_src = (uint8_t*)mpp_buffer_get_ptr(old_buff);
|
region_src += old_offset[i];
|
region_dst = (uint8_t*)mpp_buffer_get_ptr(new_buff);
|
region_dst += osd->region[i].buf_offset;
|
current_size = osd->region[i].num_mb_x * osd->region[i].num_mb_y * 256;
|
} else {
|
// copy current region data to new buffer.
|
region_src = region_data->buffer;
|
region_dst = (uint8_t*)mpp_buffer_get_ptr(new_buff);
|
region_dst += osd->region[i].buf_offset;
|
current_size = new_size;
|
}
|
|
assert(region_src);
|
assert(region_dst);
|
memcpy(region_dst, region_src, current_size);
|
#ifndef NDEBUG
|
SaveOsdImg(osd, i);
|
#endif
|
}
|
|
// replace old buff with new buff.
|
osd->buf = new_buff;
|
if (old_buff) {
|
mpp_buffer_put(old_buff);
|
}
|
|
return 0;
|
}
|
|
int MPPEncoder::OsdRegionSet(OsdRegionData* rdata)
|
{
|
if (!rdata) {
|
return -EINVAL;
|
}
|
|
LOGD("MPP Encoder: setting osd regions...\n");
|
if ((rdata->region_id >= OSD_REGIONS_CNT)) {
|
LOG("ERROR: MPP Encoder: invalid region id(%d), should be [0, %d).\n", rdata->region_id, OSD_REGIONS_CNT);
|
return -EINVAL;
|
}
|
|
if (rdata->enable && !rdata->buffer) {
|
LOG("ERROR: MPP Encoder: invalid region data");
|
return -EINVAL;
|
}
|
|
if ((rdata->width % 16) || (rdata->height % 16) || (rdata->pos_x % 16) || (rdata->pos_y % 16)) {
|
LOG("WARN: MPP Encoder: osd size must be 16 aligned\n");
|
rdata->width = UPALIGNTO16(rdata->width);
|
rdata->height = UPALIGNTO16(rdata->height);
|
rdata->pos_x = UPALIGNTO16(rdata->pos_x);
|
rdata->pos_y = UPALIGNTO16(rdata->pos_y);
|
}
|
|
#ifndef NDEBUG
|
OsdDummpRegions(rdata);
|
#endif
|
int ret = OsdUpdateRegionInfo(&osd_data, rdata);
|
#ifndef NDEBUG
|
OsdDummpMppOsd(&osd_data);
|
#endif
|
|
return ret;
|
}
|
|
int MPPEncoder::OsdRegionGet(OsdRegionData* rdata)
|
{
|
LOG("ToDo...%p\n", rdata);
|
return 0;
|
}
|
#endif // MPP_SUPPORT_HW_OSD
|
|
int MPPEncoder::RoiUpdateRegions(EncROIRegion* regions, int region_cnt)
|
{
|
if (!regions || region_cnt == 0) {
|
roi_cfg.number = 0;
|
if (roi_cfg.regions) {
|
free(roi_cfg.regions);
|
roi_cfg.regions = NULL;
|
}
|
LOG("MPP Encoder: disable roi function.");
|
return 0;
|
}
|
|
int msize = region_cnt * sizeof(MppEncROIRegion);
|
MppEncROIRegion* region = (MppEncROIRegion*)malloc(msize);
|
if (!region) {
|
LOG_NO_MEMORY();
|
return -ENOMEM;
|
}
|
|
for (int i = 0; i < region_cnt; i++) {
|
if ((regions[i].x % 16) || (regions[i].y % 16) || (regions[i].w % 16) || (regions[i].h % 16)) {
|
LOG("WARN: MPP Encoder: region parameter should be an integer multiple "
|
"of 16\n");
|
LOG("WARN: MPP Encoder: reset region[%d] frome <%d,%d,%d,%d> to "
|
"<%d,%d,%d,%d>\n",
|
i, regions[i].x, regions[i].y, regions[i].w, regions[i].h, UPALIGNTO16(regions[i].x),
|
UPALIGNTO16(regions[i].y), UPALIGNTO16(regions[i].w), UPALIGNTO16(regions[i].h));
|
regions[i].x = UPALIGNTO16(regions[i].x);
|
regions[i].y = UPALIGNTO16(regions[i].y);
|
regions[i].w = UPALIGNTO16(regions[i].w);
|
regions[i].h = UPALIGNTO16(regions[i].h);
|
}
|
LOGD("MPP Encoder: roi region[%d]:<%d,%d,%d,%d>\n", i, regions[i].x, regions[i].y, regions[i].w,
|
regions[i].h);
|
LOGD("MPP Encoder: roi region[%d].intra=%d,\n", i, regions[i].intra);
|
LOGD("MPP Encoder: roi region[%d].quality=%d,\n", i, regions[i].quality);
|
LOGD("MPP Encoder: roi region[%d].abs_qp_en=%d,\n", i, regions[i].abs_qp_en);
|
LOGD("MPP Encoder: roi region[%d].qp_area_idx=%d,\n", i, regions[i].qp_area_idx);
|
LOGD("MPP Encoder: roi region[%d].area_map_en=%d,\n", i, regions[i].area_map_en);
|
assert(regions[i].x < 8192);
|
assert(regions[i].y < 8192);
|
assert(regions[i].w < 8192);
|
assert(regions[i].h < 8192);
|
assert(regions[i].x < 8192);
|
assert(regions[i].intra <= 1);
|
assert(regions[i].abs_qp_en <= 1);
|
assert(regions[i].qp_area_idx <= 7);
|
assert(regions[i].area_map_en <= 1);
|
VALUE_SCOPE_CHECK(regions[i].quality, -48, 51);
|
|
region[i].x = regions[i].x;
|
region[i].y = regions[i].y;
|
region[i].w = regions[i].w;
|
region[i].h = regions[i].h;
|
region[i].intra = regions[i].intra;
|
region[i].quality = regions[i].quality;
|
region[i].abs_qp_en = regions[i].abs_qp_en;
|
region[i].qp_area_idx = regions[i].qp_area_idx;
|
region[i].area_map_en = regions[i].area_map_en;
|
}
|
roi_cfg.number = region_cnt;
|
if (roi_cfg.regions) {
|
free(roi_cfg.regions);
|
}
|
roi_cfg.regions = region;
|
return 0;
|
}
|
|
int MPPEncoder::SetUserData(const char* data, uint16_t len)
|
{
|
uint16_t valid_size = len;
|
|
if (!data && len) {
|
LOG("ERROR: Mpp Encoder: invalid userdata!\n");
|
return -1;
|
}
|
|
if (valid_size > MPP_ENCODER_USERDATA_MAX_SIZE) {
|
valid_size = MPP_ENCODER_USERDATA_MAX_SIZE;
|
LOG("WARN: Mpp Encoder: UserData exceeds maximum length(%d),"
|
"Reset to %d\n",
|
valid_size, valid_size);
|
}
|
|
if (valid_size) {
|
memcpy(userdata, data, valid_size);
|
}
|
|
userdata_len = valid_size;
|
return 0;
|
}
|
|
void MPPEncoder::ClearUserData()
|
{
|
userdata_len = 0;
|
}
|
|
void MPPEncoder::RestartUserData()
|
{
|
userdata_frame_id = 0;
|
}
|
|
void MPPEncoder::EnableUserDataAllFrame(bool value)
|
{
|
userdata_all_frame_en = value ? 1 : 0;
|
}
|
|
} // namespace easymedia
|
