// 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_inc.h"
|
|
#include <assert.h>
|
|
#include "media_config.h"
|
#include "media_type.h"
|
#include "utils.h"
|
|
namespace easymedia
|
{
|
MppFrameFormat ConvertToMppPixFmt(const PixelFormat& fmt)
|
{
|
// static const MppFrameFormat invalid_mpp_fmt =
|
// static_cast<MppFrameFormat>(-1);
|
static_assert(PIX_FMT_YUV420P == 0, "The index should greater than 0\n");
|
static MppFrameFormat mpp_fmts[PIX_FMT_NB] = {
|
[PIX_FMT_YUV420P] = MPP_FMT_YUV420P,
|
[PIX_FMT_NV12] = MPP_FMT_YUV420SP,
|
[PIX_FMT_NV21] = MPP_FMT_YUV420SP_VU,
|
[PIX_FMT_YUV422P] = MPP_FMT_YUV422P,
|
[PIX_FMT_NV16] = MPP_FMT_YUV422SP,
|
[PIX_FMT_NV61] = MPP_FMT_YUV422SP_VU,
|
[PIX_FMT_YUYV422] = MPP_FMT_YUV422_YUYV,
|
[PIX_FMT_UYVY422] = MPP_FMT_YUV422_UYVY,
|
[PIX_FMT_RGB332] = (MppFrameFormat)-1,
|
[PIX_FMT_RGB565] = MPP_FMT_RGB565,
|
[PIX_FMT_BGR565] = MPP_FMT_BGR565,
|
[PIX_FMT_RGB888] = MPP_FMT_RGB888,
|
[PIX_FMT_BGR888] = MPP_FMT_BGR888,
|
[PIX_FMT_ARGB8888] = MPP_FMT_ARGB8888,
|
[PIX_FMT_ABGR8888] = MPP_FMT_ABGR8888,
|
[PIX_FMT_FBC0] = (MppFrameFormat)(MPP_FMT_YUV420SP | MPP_FRAME_FBC_AFBC_V1),
|
[PIX_FMT_FBC2] = (MppFrameFormat)(MPP_FMT_YUV422SP | MPP_FRAME_FBC_AFBC_V1)};
|
if (fmt >= 0 && fmt < PIX_FMT_NB) {
|
return mpp_fmts[fmt];
|
}
|
return (MppFrameFormat)-1;
|
}
|
|
PixelFormat ConvertToPixFmt(const MppFrameFormat& mfmt)
|
{
|
switch (mfmt) {
|
case MPP_FMT_YUV420P:
|
return PIX_FMT_YUV420P;
|
case MPP_FMT_YUV420SP:
|
return PIX_FMT_NV12;
|
case MPP_FMT_YUV420SP_VU:
|
return PIX_FMT_NV21;
|
case MPP_FMT_YUV422P:
|
return PIX_FMT_YUV422P;
|
case MPP_FMT_YUV422SP:
|
return PIX_FMT_NV16;
|
case MPP_FMT_YUV422SP_VU:
|
return PIX_FMT_NV61;
|
case MPP_FMT_YUV422_YUYV:
|
return PIX_FMT_YUYV422;
|
case MPP_FMT_YUV422_UYVY:
|
return PIX_FMT_UYVY422;
|
case MPP_FMT_RGB565:
|
return PIX_FMT_RGB565;
|
case MPP_FMT_BGR565:
|
return PIX_FMT_BGR565;
|
case MPP_FMT_RGB888:
|
return PIX_FMT_RGB888;
|
case MPP_FMT_BGR888:
|
return PIX_FMT_BGR888;
|
case MPP_FMT_ARGB8888:
|
return PIX_FMT_ARGB8888;
|
case MPP_FMT_ABGR8888:
|
return PIX_FMT_ABGR8888;
|
default:
|
LOG("unsupport for mpp pixel fmt: %d\n", mfmt);
|
return PIX_FMT_NONE;
|
}
|
}
|
|
class _MPP_SUPPORT_TYPES : public SupportMediaTypes
|
{
|
public:
|
_MPP_SUPPORT_TYPES()
|
{
|
types.append(TYPENEAR(IMAGE_YUV420P));
|
types.append(TYPENEAR(IMAGE_NV12));
|
types.append(TYPENEAR(IMAGE_NV21));
|
types.append(TYPENEAR(IMAGE_YUV422P));
|
types.append(TYPENEAR(IMAGE_NV16));
|
types.append(TYPENEAR(IMAGE_NV61));
|
types.append(TYPENEAR(IMAGE_YUYV422));
|
types.append(TYPENEAR(IMAGE_UYVY422));
|
types.append(TYPENEAR(IMAGE_RGB565));
|
types.append(TYPENEAR(IMAGE_BGR565));
|
types.append(TYPENEAR(IMAGE_RGB888));
|
types.append(TYPENEAR(IMAGE_BGR888));
|
types.append(TYPENEAR(IMAGE_ARGB8888));
|
types.append(TYPENEAR(IMAGE_ABGR8888));
|
types.append(TYPENEAR(IMAGE_FBC0));
|
types.append(TYPENEAR(IMAGE_FBC2));
|
}
|
};
|
static _MPP_SUPPORT_TYPES priv_types;
|
|
const char* MppAcceptImageFmts()
|
{
|
return priv_types.types.c_str();
|
}
|
|
MppCodingType GetMPPCodingType(const std::string& data_type)
|
{
|
if (data_type == VIDEO_H264) {
|
return MPP_VIDEO_CodingAVC;
|
} else if (data_type == VIDEO_H265) {
|
return MPP_VIDEO_CodingHEVC;
|
} else if (data_type == VIDEO_MJPEG) {
|
return MPP_VIDEO_CodingMJPEG;
|
} else if (data_type == IMAGE_JPEG) {
|
return MPP_VIDEO_CodingMJPEG;
|
}
|
LOG("mpp decoder TODO for %s\n", data_type.c_str());
|
return MPP_VIDEO_CodingUnused;
|
}
|
|
static MppEncRcQuality mpp_rc_qualitys[] = {
|
MPP_ENC_RC_QUALITY_WORST, MPP_ENC_RC_QUALITY_WORSE, MPP_ENC_RC_QUALITY_MEDIUM, MPP_ENC_RC_QUALITY_BETTER,
|
MPP_ENC_RC_QUALITY_BEST, MPP_ENC_RC_QUALITY_CQP, MPP_ENC_RC_QUALITY_AQ_ONLY};
|
|
MppEncRcQuality GetMPPRCQuality(const char* quality)
|
{
|
static_assert(ARRAY_ELEMS(rc_quality_strings) == ARRAY_ELEMS(mpp_rc_qualitys),
|
"rc quality strings miss match mpp rc quality enum");
|
if (!quality) {
|
return MPP_ENC_RC_QUALITY_BUTT;
|
}
|
for (size_t i = 0; i < ARRAY_ELEMS(rc_quality_strings); i++)
|
if (!strcasecmp(quality, rc_quality_strings[i])) {
|
return mpp_rc_qualitys[i];
|
}
|
|
return MPP_ENC_RC_QUALITY_BUTT;
|
}
|
|
static const MppEncRcMode mpp_rc_modes[] = {MPP_ENC_RC_MODE_VBR, MPP_ENC_RC_MODE_CBR, MPP_ENC_RC_MODE_FIXQP};
|
|
MppEncRcMode GetMPPRCMode(const char* rc_mode)
|
{
|
static_assert(ARRAY_ELEMS(rc_mode_strings) == ARRAY_ELEMS(mpp_rc_modes),
|
"rc mode strings miss match mpp rc mode enum");
|
if (!rc_mode) {
|
return MPP_ENC_RC_MODE_BUTT;
|
}
|
for (size_t i = 0; i < ARRAY_ELEMS(rc_mode_strings); i++)
|
if (!strcasecmp(rc_mode, rc_mode_strings[i])) {
|
return mpp_rc_modes[i];
|
}
|
|
return MPP_ENC_RC_MODE_BUTT;
|
}
|
|
MPPContext::MPPContext() : ctx(NULL), mpi(NULL), frame_group(NULL)
|
{
|
}
|
MPPContext::~MPPContext()
|
{
|
if (mpi) {
|
mpi->reset(ctx);
|
mpp_destroy(ctx);
|
ctx = NULL;
|
LOG("mpp destroy ctx done\n");
|
}
|
if (frame_group) {
|
mpp_buffer_group_put(frame_group);
|
frame_group = NULL;
|
LOG("mpp buffer group free done\n");
|
}
|
}
|
|
MPP_RET init_mpp_buffer(MppBuffer& buffer, const std::shared_ptr<MediaBuffer>& mb, size_t frame_size)
|
{
|
MPP_RET ret;
|
int fd = mb->GetFD();
|
void* ptr = mb->GetPtr();
|
size_t size = mb->GetValidSize();
|
|
if (fd >= 0) {
|
MppBufferInfo info;
|
|
memset(&info, 0, sizeof(info));
|
info.type = MPP_BUFFER_TYPE_ION;
|
info.size = size;
|
info.fd = fd;
|
info.ptr = ptr;
|
|
ret = mpp_buffer_import(&buffer, &info);
|
if (ret) {
|
LOG("import input picture buffer failed\n");
|
goto fail;
|
}
|
} else {
|
if (frame_size == 0) {
|
return MPP_OK;
|
}
|
if (size == 0) {
|
size = frame_size;
|
assert(frame_size > 0);
|
}
|
ret = mpp_buffer_get(NULL, &buffer, size);
|
if (ret) {
|
LOG("allocate output stream buffer failed\n");
|
goto fail;
|
}
|
}
|
|
return MPP_OK;
|
|
fail:
|
if (buffer) {
|
mpp_buffer_put(buffer);
|
buffer = nullptr;
|
}
|
return ret;
|
}
|
|
MPP_RET init_mpp_buffer_with_content(MppBuffer& buffer, const std::shared_ptr<MediaBuffer>& mb)
|
{
|
size_t size = mb->GetValidSize();
|
MPP_RET ret = init_mpp_buffer(buffer, mb, size);
|
if (ret) {
|
return ret;
|
}
|
int fd = mb->GetFD();
|
void* ptr = mb->GetPtr();
|
// As init_mpp_buffer is a no time-consuming function and do not memcpy
|
// content to a virtual buffer, do memcpy here.
|
if (fd < 0 && ptr) {
|
// !!time-consuming operation
|
// LOGD("extra time-consuming memcpy to mpp, size=%d!\n", size);
|
memcpy(mpp_buffer_get_ptr(buffer), ptr, size);
|
// sync between cpu and device if cached?
|
}
|
return MPP_OK;
|
}
|
|
// vi_len: virtual Intra frame gap.
|
// gop_len: should equal gop_size.
|
MPP_RET mpi_enc_gen_ref_cfg(MppEncRefCfg ref, RK_S32 gop_mode, RK_S32 gop_len, RK_S32 vi_len)
|
{
|
MppEncRefLtFrmCfg lt_ref[4];
|
MppEncRefStFrmCfg st_ref[16];
|
RK_S32 lt_cnt = 0;
|
RK_S32 st_cnt = 0;
|
MPP_RET ret = MPP_OK;
|
|
memset(<_ref, 0, sizeof(lt_ref));
|
memset(&st_ref, 0, sizeof(st_ref));
|
|
switch (gop_mode) {
|
case GOP_MODE_TSVC4: {
|
// tsvc4
|
// /-> P1 /-> P3 /-> P5 /-> P7
|
// / / / /
|
// //--------> P2 //--------> P6
|
// // //
|
// ///---------------------> P4
|
// ///
|
// P0 ------------------------------------------------> P8
|
lt_cnt = 1;
|
|
/* set 8 frame lt-ref gap */
|
lt_ref[0].lt_idx = 0;
|
lt_ref[0].temporal_id = 0;
|
lt_ref[0].ref_mode = REF_TO_PREV_LT_REF;
|
lt_ref[0].lt_gap = 8;
|
lt_ref[0].lt_delay = 0;
|
|
st_cnt = 9;
|
/* set tsvc4 st-ref struct */
|
/* st 0 layer 0 - ref */
|
st_ref[0].is_non_ref = 0;
|
st_ref[0].temporal_id = 0;
|
st_ref[0].ref_mode = REF_TO_TEMPORAL_LAYER;
|
st_ref[0].ref_arg = 0;
|
st_ref[0].repeat = 0;
|
/* st 1 layer 3 - non-ref */
|
st_ref[1].is_non_ref = 1;
|
st_ref[1].temporal_id = 3;
|
st_ref[1].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[1].ref_arg = 0;
|
st_ref[1].repeat = 0;
|
/* st 2 layer 2 - ref */
|
st_ref[2].is_non_ref = 0;
|
st_ref[2].temporal_id = 2;
|
st_ref[2].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[2].ref_arg = 0;
|
st_ref[2].repeat = 0;
|
/* st 3 layer 3 - non-ref */
|
st_ref[3].is_non_ref = 1;
|
st_ref[3].temporal_id = 3;
|
st_ref[3].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[3].ref_arg = 0;
|
st_ref[3].repeat = 0;
|
/* st 4 layer 1 - ref */
|
st_ref[4].is_non_ref = 0;
|
st_ref[4].temporal_id = 1;
|
st_ref[4].ref_mode = REF_TO_PREV_LT_REF;
|
st_ref[4].ref_arg = 0;
|
st_ref[4].repeat = 0;
|
/* st 5 layer 3 - non-ref */
|
st_ref[5].is_non_ref = 1;
|
st_ref[5].temporal_id = 3;
|
st_ref[5].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[5].ref_arg = 0;
|
st_ref[5].repeat = 0;
|
/* st 6 layer 2 - ref */
|
st_ref[6].is_non_ref = 0;
|
st_ref[6].temporal_id = 2;
|
st_ref[6].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[6].ref_arg = 0;
|
st_ref[6].repeat = 0;
|
/* st 7 layer 3 - non-ref */
|
st_ref[7].is_non_ref = 1;
|
st_ref[7].temporal_id = 3;
|
st_ref[7].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[7].ref_arg = 0;
|
st_ref[7].repeat = 0;
|
/* st 8 layer 0 - ref */
|
st_ref[8].is_non_ref = 0;
|
st_ref[8].temporal_id = 0;
|
st_ref[8].ref_mode = REF_TO_TEMPORAL_LAYER;
|
st_ref[8].ref_arg = 0;
|
st_ref[8].repeat = 0;
|
} break;
|
case GOP_MODE_TSVC3: {
|
// tsvc3
|
// /-> P1 /-> P3
|
// / /
|
// //--------> P2
|
// //
|
// P0/---------------------> P4
|
lt_cnt = 0;
|
|
st_cnt = 5;
|
/* set tsvc4 st-ref struct */
|
/* st 0 layer 0 - ref */
|
st_ref[0].is_non_ref = 0;
|
st_ref[0].temporal_id = 0;
|
st_ref[0].ref_mode = REF_TO_TEMPORAL_LAYER;
|
st_ref[0].ref_arg = 0;
|
st_ref[0].repeat = 0;
|
/* st 1 layer 2 - non-ref */
|
st_ref[1].is_non_ref = 1;
|
st_ref[1].temporal_id = 2;
|
st_ref[1].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[1].ref_arg = 0;
|
st_ref[1].repeat = 0;
|
/* st 2 layer 1 - ref */
|
st_ref[2].is_non_ref = 0;
|
st_ref[2].temporal_id = 1;
|
st_ref[2].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[2].ref_arg = 0;
|
st_ref[2].repeat = 0;
|
/* st 3 layer 2 - non-ref */
|
st_ref[3].is_non_ref = 1;
|
st_ref[3].temporal_id = 2;
|
st_ref[3].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[3].ref_arg = 0;
|
st_ref[3].repeat = 0;
|
/* st 4 layer 0 - ref */
|
st_ref[4].is_non_ref = 0;
|
st_ref[4].temporal_id = 0;
|
st_ref[4].ref_mode = REF_TO_TEMPORAL_LAYER;
|
st_ref[4].ref_arg = 0;
|
st_ref[4].repeat = 0;
|
} break;
|
case GOP_MODE_TSVC2: {
|
// tsvc2
|
// /-> P1
|
// /
|
// P0--------> P2
|
lt_cnt = 0;
|
|
st_cnt = 3;
|
/* set tsvc4 st-ref struct */
|
/* st 0 layer 0 - ref */
|
st_ref[0].is_non_ref = 0;
|
st_ref[0].temporal_id = 0;
|
st_ref[0].ref_mode = REF_TO_TEMPORAL_LAYER;
|
st_ref[0].ref_arg = 0;
|
st_ref[0].repeat = 0;
|
/* st 1 layer 2 - non-ref */
|
st_ref[1].is_non_ref = 1;
|
st_ref[1].temporal_id = 1;
|
st_ref[1].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[1].ref_arg = 0;
|
st_ref[1].repeat = 0;
|
/* st 2 layer 1 - ref */
|
st_ref[2].is_non_ref = 0;
|
st_ref[2].temporal_id = 0;
|
st_ref[2].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[2].ref_arg = 0;
|
st_ref[2].repeat = 0;
|
} break;
|
case GOP_MODE_SMARTP: {
|
// smartp: M = vi_len - 2; N = gop_size.
|
// /-> E0 -> E1...-> EM /-> E0 -> E1...-> EM /-> E0 -> E1...-> EM
|
// / / /
|
// P0-------------------> P1 /
|
// |---------------------------------------------> P2
|
// |------------------------------------------------------------------------>
|
// PN
|
|
lt_cnt = 1;
|
st_cnt = 3;
|
/* set gop_len frame lt-ref gap */
|
lt_ref[0].lt_idx = 0;
|
lt_ref[0].temporal_id = 0;
|
lt_ref[0].ref_mode = REF_TO_PREV_LT_REF;
|
lt_ref[0].lt_gap = gop_len;
|
lt_ref[0].lt_delay = 0;
|
|
/* set smartp st-ref struct */
|
/* st 0 layer 0 - ref */
|
st_ref[0].is_non_ref = 0;
|
st_ref[0].temporal_id = 0;
|
st_ref[0].ref_mode = REF_TO_PREV_INTRA;
|
st_ref[0].ref_arg = 0;
|
st_ref[0].repeat = 0;
|
|
/* st 1 layer 1 - non-ref */
|
st_ref[1].is_non_ref = 0;
|
st_ref[1].temporal_id = 1;
|
st_ref[1].ref_mode = REF_TO_PREV_REF_FRM;
|
st_ref[1].ref_arg = 0;
|
st_ref[1].repeat = vi_len - 2;
|
/* st 2 layer 0 - ref */
|
st_ref[2].is_non_ref = 0;
|
st_ref[2].temporal_id = 0;
|
st_ref[2].ref_mode = REF_TO_PREV_INTRA;
|
st_ref[2].ref_arg = 0;
|
st_ref[2].repeat = 0;
|
} break;
|
default: {
|
LOG("ERROR: MPP: unsupport gop mode %d\n", gop_mode);
|
} break;
|
}
|
|
#if 0
|
for(int i = 0; i < lt_cnt; i++) {
|
printf("\nLT ref[%d].lt_idx = %d\n", i, lt_ref[i].lt_idx);
|
printf("LT ref[%d].temporal_id = %d\n", i, lt_ref[i].temporal_id);
|
printf("LT ref[%d].ref_mode = %d\n", i, lt_ref[i].ref_mode);
|
printf("LT ref[%d].lt_gap = %d\n", i, lt_ref[i].lt_gap);
|
printf("LT ref[%d].lt_delay = %d\n", i, lt_ref[i].lt_delay);
|
}
|
|
for(int i = 0; i < st_cnt; i++) {
|
printf("\nST ref[%d].is_non_ref = %d\n", i, st_ref[i].is_non_ref);
|
printf("ST ref[%d].temporal_id = %d\n", i, st_ref[i].temporal_id);
|
printf("ST ref[%d].ref_mode = %d\n", i, st_ref[i].ref_mode);
|
printf("ST ref[%d].ref_arg = %d\n", i, st_ref[i].ref_arg);
|
printf("ST ref[%d].repeat = %d\n", i, st_ref[i].repeat);
|
}
|
#endif
|
|
if (lt_cnt || st_cnt) {
|
ret = mpp_enc_ref_cfg_set_cfg_cnt(ref, lt_cnt, st_cnt);
|
|
if (lt_cnt) {
|
ret = mpp_enc_ref_cfg_add_lt_cfg(ref, lt_cnt, lt_ref);
|
}
|
|
if (st_cnt) {
|
ret = mpp_enc_ref_cfg_add_st_cfg(ref, st_cnt, st_ref);
|
}
|
|
/* check and get dpb size */
|
ret = mpp_enc_ref_cfg_check(ref);
|
}
|
|
return ret;
|
}
|
|
} // namespace easymedia
|
