// 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 <assert.h>
|
|
#include "encoder.h"
|
#include "flow.h"
|
|
#include "buffer.h"
|
#include "media_type.h"
|
|
#ifdef RK_MOVE_DETECTION
|
#include "move_detection_flow.h"
|
#endif
|
|
// When the resolution is 2688x1520,
|
// the average encoding takes 12ms.
|
//
|
// TO DO: Dynamic calculate time cost.
|
#define ENC_CONST_MAX_TIME 12000 // us
|
|
namespace easymedia
|
{
|
|
static bool encode(Flow* f, MediaBufferVector& input_vector);
|
|
class VideoEncoderFlow : public Flow
|
{
|
public:
|
VideoEncoderFlow(const char* param);
|
virtual ~VideoEncoderFlow()
|
{
|
AutoPrintLine apl(__func__);
|
StopAllThread();
|
}
|
static const char* GetFlowName()
|
{
|
return "video_enc";
|
}
|
int Control(unsigned long int request, ...);
|
void Dump(std::string& dump_info) override;
|
|
MediaConfig GetConfig()
|
{
|
MediaConfig cfg;
|
memset(&cfg, 0, sizeof(cfg));
|
if (enc) {
|
cfg = enc->GetConfig();
|
}
|
return cfg;
|
}
|
|
private:
|
std::shared_ptr<VideoEncoder> enc;
|
bool extra_output;
|
bool extra_merge;
|
std::list<std::shared_ptr<MediaBuffer>> extra_buffer_list;
|
#ifdef RK_MOVE_DETECTION
|
MoveDetectionFlow* md_flow;
|
#endif // RK_MOVE_DETECTION
|
friend bool encode(Flow* f, MediaBufferVector& input_vector);
|
};
|
|
bool encode(Flow* f, MediaBufferVector& input_vector)
|
{
|
VideoEncoderFlow* vf = (VideoEncoderFlow*)f;
|
std::shared_ptr<VideoEncoder> enc = vf->enc;
|
std::shared_ptr<MediaBuffer>& src = input_vector[0];
|
std::shared_ptr<MediaBuffer> dst, extra_dst;
|
|
if (!src) {
|
return false;
|
}
|
|
dst = std::make_shared<MediaBuffer>(); // TODO: buffer pool
|
if (!dst) {
|
LOG_NO_MEMORY();
|
return false;
|
}
|
if (vf->extra_output) {
|
extra_dst = std::make_shared<MediaBuffer>();
|
if (!extra_dst) {
|
LOG_NO_MEMORY();
|
return false;
|
}
|
}
|
|
#ifdef RK_MOVE_DETECTION
|
std::shared_ptr<MediaBuffer> md_info;
|
if (vf->md_flow) {
|
int smartp_enable = 0;
|
enc->QueryChange(VideoEncoder::kMoveDetectionFlow, &smartp_enable, sizeof(int));
|
if (!smartp_enable) {
|
LOG("INFO: VEnc Flow: Wait for smartp configuration to take effect\n");
|
} else {
|
LOGD("VEnc Flow: LookForMdResult start!\n");
|
|
MediaConfig mcfg = vf->GetConfig();
|
int fps = mcfg.vid_cfg.frame_rate;
|
if (fps <= 0) {
|
LOG("ERROR: VEnc Flow: smartp must config fps correctly!");
|
fps = 30;
|
} else if (fps > 60) {
|
LOG("WARN: VEnc Flow: smartp may error in high fps:%d!", fps);
|
}
|
|
int maximum_timeout = 1000000 / fps - ENC_CONST_MAX_TIME;
|
md_info = vf->md_flow->LookForMdResult(src->GetAtomicClock(), maximum_timeout);
|
if (md_info) {
|
#ifndef NDEBUG
|
LOGD("VEnc Flow: get md info(cnt=%d): %p, %zuBytes\n", md_info->GetValidSize() / sizeof(INFO_LIST),
|
md_info.get(), md_info->GetValidSize());
|
#endif
|
if (md_info->GetSize() >= sizeof(INFO_LIST)) {
|
#ifndef NDEBUG
|
INFO_LIST* info = (INFO_LIST*)md_info->GetPtr();
|
while (info->flag) {
|
LOGD("VEnc Flow: mdinfo: flag:%d, upleft:<%d, %d>, downright:<%d, "
|
"%d>\n",
|
info->flag, info->up_left[0], info->up_left[1], info->down_right[0],
|
info->down_right[1]);
|
info += 1;
|
}
|
#endif
|
src->SetRelatedSPtr(md_info);
|
}
|
} else {
|
LOG("ERROR: VEnc Flow: fate error get null md result\n");
|
}
|
|
LOGD("VEnc Flow: LookForMdResult end!\n\n");
|
}
|
}
|
#endif // RK_MOVE_DETECTION
|
|
if (0 != enc->Process(src, dst, extra_dst)) {
|
LOG("encoder failed\n");
|
return false;
|
}
|
|
bool ret = true;
|
// when output fps less len input fps, enc->Proccess() may
|
// return a empty mediabuff.
|
if (dst->GetValidSize() > 0) {
|
ret = vf->SetOutput(dst, 0);
|
if (vf->extra_output) {
|
ret &= vf->SetOutput(extra_dst, 1);
|
}
|
}
|
|
return ret;
|
}
|
|
VideoEncoderFlow::VideoEncoderFlow(const char* param)
|
: extra_output(false), extra_merge(false)
|
#ifdef RK_MOVE_DETECTION
|
,
|
md_flow(nullptr)
|
#endif
|
{
|
std::list<std::string> separate_list;
|
std::map<std::string, std::string> params;
|
|
LOG("VEnc Flow: dump param:%s\n", param);
|
if (!ParseWrapFlowParams(param, params, separate_list)) {
|
SetError(-EINVAL);
|
return;
|
}
|
std::string& codec_name = params[KEY_NAME];
|
if (codec_name.empty()) {
|
LOG("missing codec name\n");
|
SetError(-EINVAL);
|
return;
|
}
|
|
std::string& extra_merge_value = params[KEY_NEED_EXTRA_MERGE];
|
if (!extra_merge_value.empty()) {
|
extra_merge = !!std::stoi(extra_merge_value);
|
}
|
|
const char* ccodec_name = codec_name.c_str();
|
// check input/output type
|
std::string&& rule = gen_datatype_rule(params);
|
if (rule.empty()) {
|
SetError(-EINVAL);
|
return;
|
}
|
if (!REFLECTOR(Encoder)::IsMatch(ccodec_name, rule.c_str())) {
|
LOG("Unsupport for video encoder %s : [%s]\n", ccodec_name, rule.c_str());
|
SetError(-EINVAL);
|
return;
|
}
|
|
std::string& enc_param_str = separate_list.back();
|
std::map<std::string, std::string> enc_params;
|
|
if (!parse_media_param_map(enc_param_str.c_str(), enc_params)) {
|
SetError(-EINVAL);
|
return;
|
}
|
// copy data type to enc params.
|
std::string::size_type idx;
|
idx = enc_param_str.find(KEY_OUTPUTDATATYPE);
|
if (idx == enc_param_str.npos)
|
PARAM_STRING_APPEND(enc_param_str, KEY_OUTPUTDATATYPE, params[KEY_OUTPUTDATATYPE]);
|
if (enc_params[KEY_INPUTDATATYPE].empty()) {
|
enc_params[KEY_INPUTDATATYPE] = params[KEY_INPUTDATATYPE];
|
}
|
if (enc_params[KEY_OUTPUTDATATYPE].empty()) {
|
enc_params[KEY_OUTPUTDATATYPE] = params[KEY_OUTPUTDATATYPE];
|
}
|
|
MediaConfig mc;
|
if (!ParseMediaConfigFromMap(enc_params, mc)) {
|
SetError(-EINVAL);
|
return;
|
}
|
|
auto encoder = REFLECTOR(Encoder)::Create<VideoEncoder>(ccodec_name, enc_param_str.c_str());
|
if (!encoder) {
|
LOG("Fail to create video encoder %s<%s>\n", ccodec_name, enc_param_str.c_str());
|
SetError(-EINVAL);
|
return;
|
}
|
|
if (!encoder->InitConfig(mc)) {
|
LOG("Fail to init config, %s\n", ccodec_name);
|
SetError(-EINVAL);
|
return;
|
}
|
|
std::string roi_region_str = enc_params[KEY_ROI_REGIONS];
|
if (!roi_region_str.empty()) {
|
int roi_regions_cnt = 0;
|
std::vector<EncROIRegion> roi_regions;
|
roi_regions = StringToRoiRegions(roi_region_str);
|
roi_regions_cnt = roi_regions.size();
|
if (roi_regions_cnt) {
|
EncROIRegion* regions = (EncROIRegion*)malloc(roi_regions_cnt * sizeof(EncROIRegion));
|
for (int i = 0; i < roi_regions_cnt; i++) {
|
(regions + i)->x = roi_regions[i].x;
|
(regions + i)->y = roi_regions[i].y;
|
(regions + i)->w = roi_regions[i].w;
|
(regions + i)->h = roi_regions[i].h;
|
(regions + i)->intra = roi_regions[i].intra;
|
(regions + i)->quality = roi_regions[i].quality;
|
(regions + i)->qp_area_idx = roi_regions[i].qp_area_idx;
|
(regions + i)->area_map_en = roi_regions[i].area_map_en;
|
(regions + i)->abs_qp_en = roi_regions[i].abs_qp_en;
|
LOG("VEnc Flow: Roi Regions[%d]: (%d,%d,%d,%d,%d,%d,%d,%d,%d)\n", i, roi_regions[i].x,
|
roi_regions[i].y, roi_regions[i].w, roi_regions[i].h, roi_regions[i].intra,
|
roi_regions[i].quality, roi_regions[i].qp_area_idx, roi_regions[i].area_map_en,
|
roi_regions[i].abs_qp_en);
|
}
|
|
auto pbuff = std::make_shared<ParameterBuffer>(0);
|
pbuff->SetPtr(regions, roi_regions_cnt * sizeof(EncROIRegion));
|
encoder->RequestChange(VideoEncoder::kROICfgChange, pbuff);
|
}
|
}
|
|
void* extra_data = nullptr;
|
size_t extra_data_size = 0;
|
encoder->GetExtraData(&extra_data, &extra_data_size);
|
// TODO: if not h264
|
const std::string& output_dt = enc_params[KEY_OUTPUTDATATYPE];
|
|
enc = encoder;
|
|
SlotMap sm;
|
sm.input_slots.push_back(0);
|
sm.output_slots.push_back(0);
|
if (params[KEY_NEED_EXTRA_OUTPUT] == "y") {
|
extra_output = true;
|
sm.output_slots.push_back(1);
|
}
|
sm.process = encode;
|
sm.thread_model = Model::ASYNCCOMMON;
|
sm.mode_when_full = InputMode::DROPFRONT;
|
sm.input_maxcachenum.push_back(3);
|
if (!InstallSlotMap(sm, "VideoEncoderFlow", 40)) {
|
LOG("Fail to InstallSlotMap, %s\n", ccodec_name);
|
SetError(-EINVAL);
|
return;
|
}
|
SetFlowTag("VideoEncoderFlow");
|
|
if (extra_data && extra_data_size > 0 && (output_dt == VIDEO_H264 || output_dt == VIDEO_H265)) {
|
|
if (extra_merge) {
|
std::shared_ptr<MediaBuffer> extra_buf = std::make_shared<MediaBuffer>();
|
extra_buf->SetPtr(extra_data);
|
extra_buf->SetValidSize(extra_data_size);
|
extra_buf->SetUserFlag(MediaBuffer::kExtraIntra);
|
SetOutput(extra_buf, 0);
|
} else {
|
if (output_dt == VIDEO_H264)
|
extra_buffer_list =
|
split_h264_separate((const uint8_t*)extra_data, extra_data_size, gettimeofday());
|
else
|
extra_buffer_list =
|
split_h265_separate((const uint8_t*)extra_data, extra_data_size, gettimeofday());
|
for (auto& extra_buffer : extra_buffer_list) {
|
assert(extra_buffer->GetUserFlag() & MediaBuffer::kExtraIntra);
|
SetOutput(extra_buffer, 0);
|
}
|
}
|
|
if (extra_output) {
|
std::shared_ptr<MediaBuffer> nullbuffer;
|
SetOutput(nullbuffer, 1);
|
}
|
}
|
}
|
|
int VideoEncoderFlow::Control(unsigned long int request, ...)
|
{
|
va_list ap;
|
va_start(ap, request);
|
auto value = va_arg(ap, std::shared_ptr<ParameterBuffer>);
|
va_end(ap);
|
assert(value);
|
|
#ifdef RK_MOVE_DETECTION
|
if (request == VideoEncoder::kMoveDetectionFlow) {
|
if (value->GetSize() != sizeof(void**)) {
|
LOG("ERROR: VEnc Flow: move detect config falied!\n");
|
return -1;
|
}
|
md_flow = *((MoveDetectionFlow**)value->GetPtr());
|
LOGD("VEnc Flow: md_flow:%p\n", md_flow);
|
}
|
#endif // RK_MOVE_DETECTION
|
|
enc->RequestChange(request, value);
|
return 0;
|
}
|
|
void VideoEncoderFlow::Dump(std::string& dump_info)
|
{
|
const MediaConfig mc = GetConfig();
|
char str_line[1024] = {0};
|
|
DumpBase(dump_info);
|
sprintf(str_line, "#Dump Flow(%s) advanced info:\r\n", GetFlowTag());
|
dump_info.append(str_line);
|
memset(str_line, 0, sizeof(str_line));
|
sprintf(str_line, " Name:%s\r\n", GetFlowName());
|
dump_info.append(str_line);
|
|
memset(str_line, 0, sizeof(str_line));
|
if (mc.type == Type::Image) {
|
dump_info.append(" CodecType: JPEG\r\n");
|
sprintf(str_line, " Input: %d(%d)x%d(%d) fmt:%s\r\n", mc.img_cfg.image_info.width,
|
mc.img_cfg.image_info.vir_width, mc.img_cfg.image_info.height, mc.img_cfg.image_info.vir_height,
|
PixFmtToString(mc.img_cfg.image_info.pix_fmt));
|
dump_info.append(str_line);
|
memset(str_line, 0, sizeof(str_line));
|
sprintf(str_line, " Qfactor:%d\n", mc.img_cfg.qfactor);
|
dump_info.append(str_line);
|
} else if (mc.type == Type::Video) {
|
const VideoConfig& vcfg = mc.vid_cfg;
|
const ImageConfig& imgcfg = vcfg.image_cfg;
|
|
if (imgcfg.codec_type == CODEC_TYPE_H264) {
|
dump_info.append(" CodecType: H264\r\n");
|
} else if (imgcfg.codec_type == CODEC_TYPE_H265) {
|
dump_info.append(" CodecType: H265\r\n");
|
} else {
|
LOG("ERROR: VEnc Flow: config fatal error!\n");
|
return;
|
}
|
sprintf(str_line, " Input: %d(%d)x%d(%d) fmt:%s\r\n", imgcfg.image_info.width, imgcfg.image_info.vir_width,
|
imgcfg.image_info.height, imgcfg.image_info.vir_height, PixFmtToString(imgcfg.image_info.pix_fmt));
|
dump_info.append(str_line);
|
memset(str_line, 0, sizeof(str_line));
|
sprintf(str_line, " QpArray: init:%d min:%d, max:%d, step:%d, min_i:%d, max_i:%d\r\n", vcfg.qp_init,
|
vcfg.qp_min, vcfg.qp_max, vcfg.qp_step, vcfg.qp_min_i, vcfg.qp_max_i);
|
dump_info.append(str_line);
|
memset(str_line, 0, sizeof(str_line));
|
sprintf(str_line, " BitRate: target:%d, min:%d, max:%d\r\n", vcfg.bit_rate, vcfg.bit_rate_min,
|
vcfg.bit_rate_max);
|
dump_info.append(str_line);
|
memset(str_line, 0, sizeof(str_line));
|
sprintf(str_line, " FrameRate: in:%d/%d, out:%d/%d\r\n", vcfg.frame_in_rate, vcfg.frame_in_rate_den,
|
vcfg.frame_rate, vcfg.frame_rate_den);
|
dump_info.append(str_line);
|
memset(str_line, 0, sizeof(str_line));
|
sprintf(str_line, " GopSize: %d\r\n", vcfg.gop_size);
|
dump_info.append(str_line);
|
memset(str_line, 0, sizeof(str_line));
|
sprintf(str_line, " RcQuality: %s\r\n", vcfg.rc_quality);
|
dump_info.append(str_line);
|
memset(str_line, 0, sizeof(str_line));
|
sprintf(str_line, " RcMode: %s\r\n", vcfg.rc_mode);
|
dump_info.append(str_line);
|
memset(str_line, 0, sizeof(str_line));
|
sprintf(str_line, " FullRange: %s\r\n", vcfg.full_range ? "Enable" : "Disable");
|
dump_info.append(str_line);
|
|
if (imgcfg.codec_type == CODEC_TYPE_H264) {
|
memset(str_line, 0, sizeof(str_line));
|
sprintf(str_line, " Trans8x8: %s\r\n", vcfg.trans_8x8 ? "Enable" : "Disable");
|
dump_info.append(str_line);
|
memset(str_line, 0, sizeof(str_line));
|
sprintf(str_line, " H264Level: %d\r\n", vcfg.level);
|
dump_info.append(str_line);
|
memset(str_line, 0, sizeof(str_line));
|
sprintf(str_line, " H264Profile: %d\r\n", vcfg.profile);
|
dump_info.append(str_line);
|
}
|
} else {
|
LOG("ERROR: VEnc Flow: Dump: to do...!\n");
|
return;
|
}
|
|
return;
|
}
|
|
DEFINE_FLOW_FACTORY(VideoEncoderFlow, Flow)
|
// type depends on encoder
|
const char* FACTORY(VideoEncoderFlow)::ExpectedInputDataType()
|
{
|
return "";
|
}
|
const char* FACTORY(VideoEncoderFlow)::OutPutDataType()
|
{
|
return "";
|
}
|
|
} // namespace easymedia
|
