diff --git a/project/3rdparty/include/media/drm_media_api.h b/project/3rdparty/include/media/drm_media_api.h index 4b973fed0..61b2c39dc 100644 --- a/project/3rdparty/include/media/drm_media_api.h +++ b/project/3rdparty/include/media/drm_media_api.h @@ -101,6 +101,9 @@ int drm_mpi_vdec_create_channel(int channel, const drm_vdec_chn_attr_t *pstAttr) int drm_mpi_venc_destroy_channel(int channel); int drm_mpi_venc_create_channel(int channel, drm_venc_chn_attr_t *stVencChnAttr); +int drm_mpi_venc_create_jpeg_light_channel(int channel, drm_venc_chn_attr_t *stVencChnAttr); + +int drm_mpi_venc_set_gop(int channel, uint32_t u32Gop); int drm_mpi_venc_set_gop_mode(int channel, drm_venc_gop_attr_t *pstGopModeAttr); int drm_mpi_venc_set_fps(int channel, uint8_t u8OutNum, uint8_t u8OutDen, uint8_t u8InNum, uint8_t u8InDen); int drm_mpi_venc_set_bitrate(int channel, uint32_t u32BitRate, uint32_t u32MinBitRate, uint32_t u32MaxBitRate); @@ -108,10 +111,41 @@ int drm_mpi_venc_set_avc_profile(int channel, uint32_t u32Profile, uint32_t u32L int drm_mpi_venc_set_resolution(int channel, drm_venc_resolution_param_t stResolutionParam); int drm_mpi_venc_set_rotation(int channel, drm_venc_rotation_e rotation_rate); int drm_mpi_venc_set_rc_mode(int channel, drm_venc_rc_mode_e RcMode); +int drm_mpi_venc_set_rc_quality(int channel, drm_venc_rc_quality_e RcQuality); + +int drm_mpi_venc_request_idr(int channel, bool bInstant); int drm_mpi_venc_get_channel_attribute(int channel, drm_venc_chn_attr_t *stVencChnAttr); int drm_mpi_venc_set_channel_attribute(int channel, drm_venc_chn_attr_t *stVencChnAttr); +int drm_mpi_venc_get_channel_parameter(int channel, drm_venc_chn_param_t *stVencChnParam); +int drm_mpi_venc_set_channel_parameter(int channel, drm_venc_chn_param_t *stVencChnParam); + +int drm_mpi_venc_get_rc_parameter(int channel, drm_venc_rc_param_t *pstRcParam); +int drm_mpi_venc_set_rc_parameter(int channel, drm_venc_rc_param_t *pstRcParam); + +int drm_mpi_venc_set_jpeg_parameter(int channel, drm_venc_jpeg_param_t *pstJpegParam); + +int drm_mpi_venc_insert_userdata(int channel, uint8_t *pu8Data, uint32_t u32Len); + +int drm_mpi_venc_get_roi_attribute(int channel, drm_venc_roi_attr_t *pstRoiAttr, int roi_index07); +int drm_mpi_venc_set_roi_attribute(int channel, const drm_venc_roi_attr_t *pstRoiAttr, int region_cnt); + +int drm_mpi_venc_get_fd(int channel); +int drm_mpi_venc_query_status(int channel, drm_venc_chn_status_t *pstStatus); + +int drm_mpi_venc_get_super_frame_strategy(int channel, drm_venc_superframe_cfg_t *pstSuperFrmParam); +int drm_mpi_venc_set_super_frame_strategy(int channel, const drm_venc_superframe_cfg_t *pstSuperFrmParam); + +int drm_mpi_venc_start_recv_frame(int channel, const drm_recv_pic_param_t *pstRecvParam); + +int drm_mpi_venc_region_init(int channel, drm_venc_color_tbl_t *stColorTbl); + +int drm_mpi_venc_region_set_bitmap(int channel, const drm_osd_region_info_t *pstRgnInfo, const drm_bitmap_t *pstBitmap); +int drm_mpi_venc_region_set_cover(int channel, const drm_osd_region_info_t *pstRgnInfo, const drm_cover_info_t *pstCoverInfo); +int drm_mpi_venc_region_set_coverEx(int channel, const drm_osd_region_info_t *pstRgnInfo, const drm_cover_info_t *pstCoverInfo); +int drm_mpi_venc_region_set_palette_id(int channel, const drm_osd_region_info_t *pstRgnInfo, const drm_osd_color_palette_buf_t *pstColPalBuf); + #ifdef __cplusplus } #endif diff --git a/project/3rdparty/include/media/drm_media_common.h b/project/3rdparty/include/media/drm_media_common.h index a294ec305..76efe242f 100644 --- a/project/3rdparty/include/media/drm_media_common.h +++ b/project/3rdparty/include/media/drm_media_common.h @@ -80,12 +80,12 @@ typedef enum { DRM_SAMPLE_FMT_NB } DrmSampleFormat, drm_sample_format_e; -typedef struct rkSIZE_S { +typedef struct SIZE_S { uint32_t u32Width; uint32_t u32Height; } drm_size_t; -typedef struct rkRECT_S { +typedef struct RECT_S { int32_t s32X; int32_t s32Y; uint32_t u32Width; diff --git a/project/3rdparty/include/media/drm_media_vdec.h b/project/3rdparty/include/media/drm_media_vdec.h index 395e93407..9318df4ab 100644 --- a/project/3rdparty/include/media/drm_media_vdec.h +++ b/project/3rdparty/include/media/drm_media_vdec.h @@ -42,7 +42,7 @@ typedef struct VDEC_ATTR_VIDEO_S { } drm_video_vdec_attr_t; -typedef struct rkVDEC_CHN_ATTR_S { +typedef struct VDEC_CHN_ATTR_S { drm_codec_type_e enCodecType; drm_video_mode_e enMode; drm_video_decodec_mode_e enDecodecMode; diff --git a/project/3rdparty/source/media/media/drm_media_api.cpp b/project/3rdparty/source/media/media/drm_media_api.cpp index 35e236f44..726731cec 100644 --- a/project/3rdparty/source/media/media/drm_media_api.cpp +++ b/project/3rdparty/source/media/media/drm_media_api.cpp @@ -105,7 +105,7 @@ typedef struct drm_media_channel { std::condition_variable luma_buf_cond; bool luma_buf_quit; bool luma_buf_start; - std::shared_ptr luma_rkmedia_buf; + std::shared_ptr luma_media_buf; } drm_media_channel_t; typedef struct video_mix_device { @@ -432,7 +432,7 @@ static void flow_output_callback(void *handle, std::shared_ptrmode_id == MOD_ID_VI) { std::unique_lock lck(target_chn->luma_buf_mtx); if (!target_chn->luma_buf_quit && target_chn->luma_buf_start) { - target_chn->luma_rkmedia_buf = media_mb; + target_chn->luma_media_buf = media_mb; } target_chn->luma_buf_cond.notify_all(); @@ -466,12 +466,12 @@ static void flow_output_callback(void *handle, std::shared_ptr(media_mb.get()); - mb->stImageInfo.u32Width = rkmedia_ib->GetWidth(); - mb->stImageInfo.u32Height = rkmedia_ib->GetHeight(); - mb->stImageInfo.u32HorStride = rkmedia_ib->GetVirWidth(); - mb->stImageInfo.u32VerStride = rkmedia_ib->GetVirHeight(); - std::string strPixFmt = PixFmtToString(rkmedia_ib->GetPixelFormat()); + libdrm::ImageBuffer *media_ib = static_cast(media_mb.get()); + mb->stImageInfo.u32Width = media_ib->GetWidth(); + mb->stImageInfo.u32Height = media_ib->GetHeight(); + mb->stImageInfo.u32HorStride = media_ib->GetVirWidth(); + mb->stImageInfo.u32VerStride = media_ib->GetVirHeight(); + std::string strPixFmt = PixFmtToString(media_ib->GetPixelFormat()); mb->stImageInfo.enImgType = StringToImageType(strPixFmt); } @@ -641,7 +641,7 @@ int drm_mpi_system_bind(const drm_chn_t *pstSrcChn, const drm_chn_t *pstDstChn) } if ((src_chn->media_out_cb_status == CHN_OUT_CB_INIT) || (src_chn->media_out_cb_status == CHN_OUT_CB_CLOSE)) { - DRM_MEDIA_LOGD("disable rkmedia flow output callback"); + DRM_MEDIA_LOGD("disable media flow output callback"); src_chn->media_out_cb_status = CHN_OUT_CB_CLOSE; src->SetOutputCallBack(NULL, NULL); @@ -1190,7 +1190,7 @@ int drm_mpi_system_stop_get_media_buffer(mod_id_e enModID, int s32ChnId) target_mutex->lock(); target_chn->media_out_cb_status = CHN_OUT_CB_CLOSE; target_chn->media_flow->SetOutputCallBack(NULL, NULL); - DRM_MEDIA_LOGD("disable rkmedia output callback"); + DRM_MEDIA_LOGD("disable media output callback"); target_mutex->unlock(); return 0; @@ -1264,7 +1264,7 @@ int drm_mpi_system_start_get_media_buffer(mod_id_e enModID, int s32ChnId) target_mutex->unlock(); return 0; } else if (target_chn->media_out_cb_status == CHN_OUT_CB_CLOSE) { - DRM_MEDIA_LOGD("enable rkmedia output callback"); + DRM_MEDIA_LOGD("enable media output callback"); target_chn->media_flow->SetOutputCallBack(target_chn, flow_output_callback); } target_chn->media_out_cb_status = CHN_OUT_CB_USER; @@ -1586,7 +1586,7 @@ int drm_mpi_vi_disable_channel(int channel) clear_media_channel_buffer(&g_vi_chns[channel]); g_vi_chns[channel].status = CHN_STATUS_CLOSED; g_vi_chns[channel].luma_buf_mtx.lock(); - g_vi_chns[channel].luma_rkmedia_buf.reset(); + g_vi_chns[channel].luma_media_buf.reset(); g_vi_chns[channel].luma_buf_cond.notify_all(); g_vi_chns[channel].luma_buf_quit = true; g_vi_chns[channel].luma_buf_mtx.unlock(); @@ -1823,12 +1823,12 @@ int drm_mpi_vi_stop_region_luma(int channel) g_vi_chns[channel].luma_buf_mtx.lock(); g_vi_chns[channel].luma_buf_start = false; - g_vi_chns[channel].luma_rkmedia_buf.reset(); + g_vi_chns[channel].luma_media_buf.reset(); g_vi_chns[channel].luma_buf_mtx.unlock(); g_vi_mtx.lock(); if (g_vi_chns[channel].media_out_cb_status == CHN_OUT_CB_LUMA) { - DRM_MEDIA_LOGD("luma mode: disable rkmedia out callback"); + DRM_MEDIA_LOGD("luma mode: disable media out callback"); g_vi_chns[channel].media_out_cb_status = CHN_OUT_CB_CLOSE; g_vi_chns[channel].media_flow->SetOutputCallBack(&g_vi_chns[channel], flow_output_callback); } @@ -1912,7 +1912,7 @@ int drm_mpi_vi_get_channel_region_luma(int channel, const drm_video_region_info_ { std::unique_lock lck(target_chn->luma_buf_mtx); - if (!target_chn->luma_rkmedia_buf) { + if (!target_chn->luma_media_buf) { if ((s32MilliSec < 0) && !target_chn->luma_buf_quit) { target_chn->luma_buf_cond.wait(lck); } else if (s32MilliSec > 0) { @@ -1924,11 +1924,11 @@ int drm_mpi_vi_get_channel_region_luma(int channel, const drm_video_region_info_ } } - if (target_chn->luma_rkmedia_buf) { - media_mb = std::static_pointer_cast(target_chn->luma_rkmedia_buf); + if (target_chn->luma_media_buf) { + media_mb = std::static_pointer_cast(target_chn->luma_media_buf); } - target_chn->luma_rkmedia_buf.reset(); + target_chn->luma_media_buf.reset(); } if (!media_mb) { @@ -2371,7 +2371,7 @@ int drm_mpi_rga_create_channel(int channel, drm_rga_attr_t *pstRgaAttr) PARAM_STRING_APPEND_TO(filter_param, DRM_KEY_BUFFER_FLIP, enFlip); flow_param = libdrm::JoinFlowParam(flow_param, 1, filter_param); - DRM_MEDIA_LOGD("Rkrga Filter flow param:[%s]", flow_param.c_str()); + DRM_MEDIA_LOGD("rkrga filter flow param:[%s]", flow_param.c_str()); g_rga_chns[channel].media_flow = libdrm::REFLECTOR(Flow)::Create(flow_name.c_str(), flow_param.c_str()); if (!g_rga_chns[channel].media_flow) { @@ -3169,11 +3169,11 @@ static int create_media_jpeg_snap_pipeline(drm_media_channel_t *VenChn) uint32_t u32InFpsDen = 1; uint32_t u32OutFpsNum = 1; uint32_t u32OutFpsDen = 1; - const char *pcRkmediaRcMode = nullptr; - const char *pcRkmediaCodecType = nullptr; + const char *pcMediaRcMode = nullptr; + const char *pcMediaCodecType = nullptr; VENC_CHN_ATTR_S *stVencChnAttr = &VenChn->venc_attr.attr; VENC_CHN_PARAM_S *stVencChnParam = &VenChn->venc_attr.param; - VENC_ROTATION_E enRotation = stVencChnAttr->stVencAttr.enRotation; + drm_venc_rotation_e enRotation = stVencChnAttr->stVencAttr.enRotation; int mjpeg_bps = 0; int pre_enc_bps = 2000000; @@ -3191,14 +3191,14 @@ static int create_media_jpeg_snap_pipeline(drm_media_channel_t *VenChn) u32InFpsDen = stVencChnAttr->stRcAttr.stMjpegCbr.u32SrcFrameRateDen; u32OutFpsNum = stVencChnAttr->stRcAttr.stMjpegCbr.fr32DstFrameRateNum; u32OutFpsDen = stVencChnAttr->stRcAttr.stMjpegCbr.fr32DstFrameRateDen; - pcRkmediaRcMode = DRM_KEY_CBR; + pcMediaRcMode = DRM_KEY_CBR; } else if (stVencChnAttr->stRcAttr.enRcMode == VENC_RC_MODE_MJPEGVBR) { mjpeg_bps = stVencChnAttr->stRcAttr.stMjpegVbr.u32BitRate; u32InFpsNum = stVencChnAttr->stRcAttr.stMjpegVbr.u32SrcFrameRateNum; u32InFpsDen = stVencChnAttr->stRcAttr.stMjpegVbr.u32SrcFrameRateDen; u32OutFpsNum = stVencChnAttr->stRcAttr.stMjpegVbr.fr32DstFrameRateNum; u32OutFpsDen = stVencChnAttr->stRcAttr.stMjpegVbr.fr32DstFrameRateDen; - pcRkmediaRcMode = DRM_KEY_VBR; + pcMediaRcMode = DRM_KEY_VBR; } else { DRM_MEDIA_LOGE("Invalid RcMode:[%d]", stVencChnAttr->stRcAttr.enRcMode); return -1; @@ -3219,13 +3219,13 @@ static int create_media_jpeg_snap_pipeline(drm_media_channel_t *VenChn) return -4; } - pcRkmediaCodecType = DRM_VIDEO_MJPEG; + pcMediaCodecType = DRM_VIDEO_MJPEG; s32ZoomWidth = stVencChnAttr->stVencAttr.stAttrMjpege.u32ZoomWidth; s32ZoomHeight = stVencChnAttr->stVencAttr.stAttrMjpege.u32ZoomHeight; s32ZoomVirWidth = stVencChnAttr->stVencAttr.stAttrMjpege.u32ZoomVirWidth; s32ZoomVirHeight = stVencChnAttr->stVencAttr.stAttrMjpege.u32ZoomVirHeight; } else { - pcRkmediaCodecType = DRM_IMAGE_JPEG; + pcMediaCodecType = DRM_IMAGE_JPEG; s32ZoomWidth = stVencChnAttr->stVencAttr.stAttrJpege.u32ZoomWidth; s32ZoomHeight = stVencChnAttr->stVencAttr.stAttrJpege.u32ZoomHeight; s32ZoomVirWidth = stVencChnAttr->stVencAttr.stAttrJpege.u32ZoomVirWidth; @@ -3377,7 +3377,7 @@ static int create_media_jpeg_snap_pipeline(drm_media_channel_t *VenChn) flow_param = ""; PARAM_STRING_APPEND(flow_param, DRM_KEY_NAME, "rkmpp"); PARAM_STRING_APPEND(flow_param, DRM_KEY_INPUTDATATYPE, DRM_IMAGE_NV12); - PARAM_STRING_APPEND(flow_param, DRM_KEY_OUTPUTDATATYPE, pcRkmediaCodecType); + PARAM_STRING_APPEND(flow_param, DRM_KEY_OUTPUTDATATYPE, pcMediaCodecType); enc_param = ""; PARAM_STRING_APPEND_TO(enc_param, DRM_KEY_BUFFER_WIDTH, jpeg_width); @@ -3406,7 +3406,7 @@ static int create_media_jpeg_snap_pipeline(drm_media_channel_t *VenChn) PARAM_STRING_APPEND(enc_param, DRM_KEY_FPS, str_fps_out); PARAM_STRING_APPEND(enc_param, DRM_KEY_FPS_IN, str_fps_out); - PARAM_STRING_APPEND(enc_param, DRM_KEY_COMPRESS_RC_MODE, pcRkmediaRcMode); + PARAM_STRING_APPEND(enc_param, DRM_KEY_COMPRESS_RC_MODE, pcMediaRcMode); } else { PARAM_STRING_APPEND_TO(enc_param, DRM_KEY_JPEG_QFACTOR, 50); @@ -3424,7 +3424,7 @@ static int create_media_jpeg_snap_pipeline(drm_media_channel_t *VenChn) } flow_param = libdrm::JoinFlowParam(flow_param, 1, enc_param); - DRM_MEDIA_LOGD("JPEG: Type:[%s] encoder flow param:[%s]", pcRkmediaCodecType, flow_param.c_str()); + DRM_MEDIA_LOGD("JPEG: Type:[%s] encoder flow param:[%s]", pcMediaCodecType, flow_param.c_str()); video_jpeg_flow = libdrm::REFLECTOR(Flow)::Create(flow_name.c_str(), flow_param.c_str()); if (!video_jpeg_flow) { @@ -3497,15 +3497,15 @@ static int create_media_jpeg_light(drm_media_channel_t *VenChn) uint32_t u32OutFpsNum = 1; uint32_t u32OutFpsDen = 1; bool bSupprtDcf = false; - const char *pcRkmediaRcMode = nullptr; - const char *pcRkmediaCodecType = nullptr; + const char *pcMediaRcMode = nullptr; + const char *pcMediaCodecType = nullptr; std::shared_ptr video_jpeg_flow; int video_width = stVencChnAttr->stVencAttr.u32PicWidth; int video_height = stVencChnAttr->stVencAttr.u32PicHeight; int vir_width = stVencChnAttr->stVencAttr.u32VirWidth; int vir_height = stVencChnAttr->stVencAttr.u32VirHeight; std::string pixel_format = ImageTypeToString(stVencChnAttr->stVencAttr.imageType); - VENC_ROTATION_E enRotation = stVencChnAttr->stVencAttr.enRotation; + drm_venc_rotation_e enRotation = stVencChnAttr->stVencAttr.enRotation; if (stVencChnAttr->stVencAttr.enType == DRM_CODEC_TYPE_MJPEG) { if (stVencChnAttr->stRcAttr.enRcMode == VENC_RC_MODE_MJPEGCBR) { @@ -3514,14 +3514,14 @@ static int create_media_jpeg_light(drm_media_channel_t *VenChn) u32InFpsDen = stVencChnAttr->stRcAttr.stMjpegCbr.u32SrcFrameRateDen; u32OutFpsNum = stVencChnAttr->stRcAttr.stMjpegCbr.fr32DstFrameRateNum; u32OutFpsDen = stVencChnAttr->stRcAttr.stMjpegCbr.fr32DstFrameRateDen; - pcRkmediaRcMode = DRM_KEY_CBR; + pcMediaRcMode = DRM_KEY_CBR; } else if (stVencChnAttr->stRcAttr.enRcMode == VENC_RC_MODE_MJPEGVBR) { mjpeg_bps = stVencChnAttr->stRcAttr.stMjpegVbr.u32BitRate; u32InFpsNum = stVencChnAttr->stRcAttr.stMjpegVbr.u32SrcFrameRateNum; u32InFpsDen = stVencChnAttr->stRcAttr.stMjpegVbr.u32SrcFrameRateDen; u32OutFpsNum = stVencChnAttr->stRcAttr.stMjpegVbr.fr32DstFrameRateNum; u32OutFpsDen = stVencChnAttr->stRcAttr.stMjpegVbr.fr32DstFrameRateDen; - pcRkmediaRcMode = DRM_KEY_VBR; + pcMediaRcMode = DRM_KEY_VBR; } else { DRM_MEDIA_LOGE("Invalid RcMode:[%d]", stVencChnAttr->stRcAttr.enRcMode); return -2; @@ -3542,10 +3542,10 @@ static int create_media_jpeg_light(drm_media_channel_t *VenChn) return -5; } - pcRkmediaCodecType = DRM_VIDEO_MJPEG; + pcMediaCodecType = DRM_VIDEO_MJPEG; } else { bSupprtDcf = stVencChnAttr->stVencAttr.stAttrJpege.bSupportDCF; - pcRkmediaCodecType = DRM_IMAGE_JPEG; + pcMediaCodecType = DRM_IMAGE_JPEG; } std::string enc_param = ""; @@ -3554,7 +3554,7 @@ static int create_media_jpeg_light(drm_media_channel_t *VenChn) PARAM_STRING_APPEND(flow_param, DRM_KEY_NAME, "rkmpp"); PARAM_STRING_APPEND(flow_param, DRM_KEY_INPUTDATATYPE, pixel_format); - PARAM_STRING_APPEND(flow_param, DRM_KEY_OUTPUTDATATYPE, pcRkmediaCodecType); + PARAM_STRING_APPEND(flow_param, DRM_KEY_OUTPUTDATATYPE, pcMediaCodecType); PARAM_STRING_APPEND_TO(enc_param, DRM_KEY_BUFFER_WIDTH, video_width); PARAM_STRING_APPEND_TO(enc_param, DRM_KEY_BUFFER_HEIGHT, video_height); PARAM_STRING_APPEND_TO(enc_param, DRM_KEY_BUFFER_VIR_WIDTH, vir_width); @@ -3600,13 +3600,13 @@ static int create_media_jpeg_light(drm_media_channel_t *VenChn) PARAM_STRING_APPEND_TO(enc_param, DRM_KEY_COMPRESS_BITRATE_MAX, mjpeg_bps); } - PARAM_STRING_APPEND(enc_param, DRM_KEY_COMPRESS_RC_MODE, pcRkmediaRcMode); + PARAM_STRING_APPEND(enc_param, DRM_KEY_COMPRESS_RC_MODE, pcMediaRcMode); } else { PARAM_STRING_APPEND_TO(enc_param, DRM_KEY_JPEG_QFACTOR, 50); } flow_param = libdrm::JoinFlowParam(flow_param, 1, enc_param); - DRM_MEDIA_LOGD("JPEG-LT: Type:[%s] encoder flow param:[%s]", pcRkmediaCodecType, flow_param.c_str()); + DRM_MEDIA_LOGD("JPEG-LT: Type:[%s] encoder flow param:[%s]", pcMediaCodecType, flow_param.c_str()); video_jpeg_flow = libdrm::REFLECTOR(Flow)::Create(flow_name.c_str(), flow_param.c_str()); if (!video_jpeg_flow) { @@ -3658,18 +3658,18 @@ int drm_mpi_venc_destroy_channel(int channel) std::shared_ptr ptrFlowHead = NULL; while (!g_venc_chns[channel].media_flow_list.empty()) { - auto ptrRkmediaFlow0 = g_venc_chns[channel].media_flow_list.back(); + auto ptrMediaFlow0 = g_venc_chns[channel].media_flow_list.back(); g_venc_chns[channel].media_flow_list.pop_back(); if (!g_venc_chns[channel].media_flow_list.empty()) { - auto ptrRkmediaFlow1 = g_venc_chns[channel].media_flow_list.back(); - ptrRkmediaFlow1->RemoveDownFlow(ptrRkmediaFlow0); + auto ptrMediaFlow1 = g_venc_chns[channel].media_flow_list.back(); + ptrMediaFlow1->RemoveDownFlow(ptrMediaFlow0); } else { - ptrFlowHead = ptrRkmediaFlow0; + ptrFlowHead = ptrMediaFlow0; break; } - ptrRkmediaFlow0.reset(); + ptrMediaFlow0.reset(); } if (g_venc_chns[channel].media_flow) { @@ -3901,6 +3901,60 @@ int drm_mpi_venc_create_channel(int channel, drm_venc_chn_attr_t *stVencChnAttr) return 0; } +int drm_mpi_venc_set_gop(int channel, uint32_t u32Gop) +{ + if ((channel < DRM_VENC_CHANNEL_00) || (channel >= DRM_VENC_CHANNEL_BUTT)) { + return -1; + } + + if (g_venc_chns[channel].status < CHN_STATUS_OPEN) { + return -2; + } + + g_venc_mtx.lock(); + int ret = video_encoder_set_gop_size(g_venc_chns[channel].media_flow, u32Gop); + if (!ret) { + g_venc_chns[channel].venc_attr.attr.stGopAttr.u32GopSize = u32Gop; + switch (g_venc_chns[channel].venc_attr.attr.stRcAttr.enRcMode) { + case VENC_RC_MODE_H264CBR: + g_venc_chns[channel].venc_attr.attr.stRcAttr.stH264Cbr.u32Gop = u32Gop; + break; + + case VENC_RC_MODE_H264VBR: + g_venc_chns[channel].venc_attr.attr.stRcAttr.stH264Vbr.u32Gop = u32Gop; + break; + + case VENC_RC_MODE_H264AVBR: + g_venc_chns[channel].venc_attr.attr.stRcAttr.stH264Vbr.u32Gop = u32Gop; + break; + + case VENC_RC_MODE_MJPEGCBR: + break; + + case VENC_RC_MODE_MJPEGVBR: + break; + + case VENC_RC_MODE_H265CBR: + g_venc_chns[channel].venc_attr.attr.stRcAttr.stH265Cbr.u32Gop = u32Gop; + break; + + case VENC_RC_MODE_H265VBR: + g_venc_chns[channel].venc_attr.attr.stRcAttr.stH265Vbr.u32Gop = u32Gop; + break; + + case VENC_RC_MODE_H265AVBR: + g_venc_chns[channel].venc_attr.attr.stRcAttr.stH265Avbr.u32Gop = u32Gop; + break; + + case VENC_RC_MODE_BUTT: + break; + } + } + g_venc_mtx.unlock(); + + return 0; +} + int drm_mpi_venc_set_gop_mode(int channel, drm_venc_gop_attr_t *pstGopModeAttr) { if (!pstGopModeAttr) { @@ -4235,6 +4289,70 @@ int drm_mpi_venc_set_rc_mode(int channel, drm_venc_rc_mode_e RcMode) return ret; } +int drm_mpi_venc_set_rc_quality(int channel, drm_venc_rc_quality_e RcQuality) +{ + if ((channel < DRM_VENC_CHANNEL_00) || (channel >= DRM_VENC_CHANNEL_BUTT)) { + return -1; + } + + if (g_venc_chns[channel].status < CHN_STATUS_OPEN) + return -2; + + g_venc_mtx.lock(); + switch (RcQuality) { + case VENC_RC_QUALITY_HIGHEST: + video_encoder_set_rc_quality(g_venc_chns[channel].media_flow, DRM_KEY_HIGHEST); + break; + + case VENC_RC_QUALITY_HIGHER: + video_encoder_set_rc_quality(g_venc_chns[channel].media_flow, DRM_KEY_HIGHER); + break; + + case VENC_RC_QUALITY_HIGH: + video_encoder_set_rc_quality(g_venc_chns[channel].media_flow, DRM_KEY_HIGH); + break; + + case VENC_RC_QUALITY_MEDIUM: + video_encoder_set_rc_quality(g_venc_chns[channel].media_flow, DRM_KEY_MEDIUM); + break; + + case VENC_RC_QUALITY_LOW: + video_encoder_set_rc_quality(g_venc_chns[channel].media_flow, DRM_KEY_LOW); + break; + + case VENC_RC_QUALITY_LOWER: + video_encoder_set_rc_quality(g_venc_chns[channel].media_flow, DRM_KEY_LOWER); + break; + + case VENC_RC_QUALITY_LOWEST: + video_encoder_set_rc_quality(g_venc_chns[channel].media_flow, DRM_KEY_LOWEST); + break; + + default: + break; + } + g_venc_mtx.unlock(); + + return 0; +} + +int drm_mpi_venc_request_idr(int channel, bool bInstant) +{ + if ((channel < DRM_VENC_CHANNEL_00) || (channel >= DRM_VENC_CHANNEL_BUTT)) { + return -1; + } + + if (g_venc_chns[channel].status < CHN_STATUS_OPEN) { + return -2; + } + + g_venc_mtx.lock(); + video_encoder_force_idr(g_venc_chns[channel].media_flow); + g_venc_mtx.unlock(); + + return 0; +} + int drm_mpi_venc_get_channel_attribute(int channel, drm_venc_chn_attr_t *stVencChnAttr) { if (!stVencChnAttr) { @@ -4390,7 +4508,7 @@ static int venc_set_bitrate_if_change(int channel, drm_venc_rc_attr_t *stRcAttr) return ret; } -static int RK_MPI_VENC_SetFps_If_Change(int channel, drm_venc_rc_attr_t *stRcAttr) +static int venc_set_fps_if_change(int channel, drm_venc_rc_attr_t *stRcAttr) { int ret = 0; @@ -4565,7 +4683,7 @@ int drm_mpi_venc_set_channel_attribute(int channel, drm_venc_chn_attr_t *stVencC return ret; } - ret = RK_MPI_VENC_SetFps_If_Change(channel, &stVencChnAttr->stRcAttr); + ret = venc_set_fps_if_change(channel, &stVencChnAttr->stRcAttr); if (ret) { return ret; } @@ -4578,6 +4696,1102 @@ int drm_mpi_venc_set_channel_attribute(int channel, drm_venc_chn_attr_t *stVencC return ret; } +int drm_mpi_venc_create_jpeg_light_channel(int channel, drm_venc_chn_attr_t *stVencChnAttr) +{ + if ((channel < DRM_VENC_CHANNEL_00) || (channel >= DRM_VENC_CHANNEL_BUTT)) { + return -1; + } + + if (!stVencChnAttr) { + return -2; + } + + if ((stVencChnAttr->stVencAttr.enType != DRM_CODEC_TYPE_JPEG) && (stVencChnAttr->stVencAttr.enType != DRM_CODEC_TYPE_MJPEG)) { + return -3; + } + + if (g_venc_chns[channel].status != CHN_STATUS_CLOSED) { + return -4; + } + + DRM_MEDIA_LOGI("Enable venc channel:[%d], type:[%d] starting......", channel, stVencChnAttr->stVencAttr.enType); + + uint32_t u32InFpsNum = 1; + uint32_t u32InFpsDen = 1; + uint32_t u32OutFpsNum = 1; + uint32_t u32OutFpsDen = 1; + const char *pcMediaRcMode = nullptr; + const char *pcMediaCodecType = nullptr; + std::shared_ptr video_jpeg_flow; + + int mjpeg_bps = 0; + int video_width = stVencChnAttr->stVencAttr.u32PicWidth; + int video_height = stVencChnAttr->stVencAttr.u32PicHeight; + int vir_width = stVencChnAttr->stVencAttr.u32VirWidth; + int vir_height = stVencChnAttr->stVencAttr.u32VirHeight; + std::string pixel_format = ImageTypeToString(stVencChnAttr->stVencAttr.imageType); + drm_venc_rotation_e enRotation = stVencChnAttr->stVencAttr.enRotation; + + if (stVencChnAttr->stVencAttr.enType == DRM_CODEC_TYPE_MJPEG) { + if (stVencChnAttr->stRcAttr.enRcMode == VENC_RC_MODE_MJPEGCBR) { + mjpeg_bps = stVencChnAttr->stRcAttr.stMjpegCbr.u32BitRate; + u32InFpsNum = stVencChnAttr->stRcAttr.stMjpegCbr.u32SrcFrameRateNum; + u32InFpsDen = stVencChnAttr->stRcAttr.stMjpegCbr.u32SrcFrameRateDen; + u32OutFpsNum = stVencChnAttr->stRcAttr.stMjpegCbr.fr32DstFrameRateNum; + u32OutFpsDen = stVencChnAttr->stRcAttr.stMjpegCbr.fr32DstFrameRateDen; + pcMediaRcMode = DRM_KEY_CBR; + } else if (stVencChnAttr->stRcAttr.enRcMode == VENC_RC_MODE_MJPEGVBR) { + mjpeg_bps = stVencChnAttr->stRcAttr.stMjpegVbr.u32BitRate; + u32InFpsNum = stVencChnAttr->stRcAttr.stMjpegVbr.u32SrcFrameRateNum; + u32InFpsDen = stVencChnAttr->stRcAttr.stMjpegVbr.u32SrcFrameRateDen; + u32OutFpsNum = stVencChnAttr->stRcAttr.stMjpegVbr.fr32DstFrameRateNum; + u32OutFpsDen = stVencChnAttr->stRcAttr.stMjpegVbr.fr32DstFrameRateDen; + pcMediaRcMode = DRM_KEY_VBR; + } else { + DRM_MEDIA_LOGE("Invalid RcMode:[%d]", stVencChnAttr->stRcAttr.enRcMode); + return -5; + } + + if ((mjpeg_bps < 2000) || (mjpeg_bps > 100000000)) { + DRM_MEDIA_LOGE("Invalid BitRate:[%d], should be:[2000, 100000000]", mjpeg_bps); + return -6; + } + + if (!u32InFpsNum) { + DRM_MEDIA_LOGE("Invalid src frame rate:[%d/%d]", u32InFpsNum, u32InFpsDen); + return -7; + } + + if (!u32OutFpsNum) { + DRM_MEDIA_LOGE("Invalid dst frame rate:[%d/%d]", u32OutFpsNum, u32OutFpsDen); + return -8; + } + + pcMediaCodecType = DRM_VIDEO_MJPEG; + } else { + pcMediaCodecType = DRM_IMAGE_JPEG; + } + + g_venc_mtx.lock(); + if (g_venc_chns[channel].status != CHN_STATUS_CLOSED) { + g_venc_mtx.unlock(); + return -9; + } + + memcpy(&g_venc_chns[channel].venc_attr.attr, stVencChnAttr, sizeof(drm_venc_chn_attr_t)); + + std::string enc_param = ""; + std::string flow_param = ""; + std::string flow_name = "video_enc"; + + PARAM_STRING_APPEND(flow_param, DRM_KEY_NAME, "rkmpp"); + PARAM_STRING_APPEND(flow_param, DRM_KEY_INPUTDATATYPE, DRM_IMAGE_NV12); + PARAM_STRING_APPEND(flow_param, DRM_KEY_OUTPUTDATATYPE, pcMediaCodecType); + PARAM_STRING_APPEND_TO(enc_param, DRM_KEY_BUFFER_WIDTH, video_width); + PARAM_STRING_APPEND_TO(enc_param, DRM_KEY_BUFFER_HEIGHT, video_height); + PARAM_STRING_APPEND_TO(enc_param, DRM_KEY_BUFFER_VIR_WIDTH, vir_width); + PARAM_STRING_APPEND_TO(enc_param, DRM_KEY_BUFFER_VIR_HEIGHT, vir_height); + PARAM_STRING_APPEND_TO(enc_param, DRM_KEY_ROTATION, enRotation); + + if (stVencChnAttr->stVencAttr.enType == DRM_CODEC_TYPE_MJPEG) { + std::string str_fps_in; + str_fps_in.append(std::to_string(u32InFpsNum)).append("/").append(std::to_string(u32InFpsDen)); + PARAM_STRING_APPEND(enc_param, DRM_KEY_FPS_IN, str_fps_in); + + std::string str_fps_out; + str_fps_out.append(std::to_string(u32OutFpsNum)).append("/").append(std::to_string(u32OutFpsDen)); + PARAM_STRING_APPEND(enc_param, DRM_KEY_FPS, str_fps_out); + + if (stVencChnAttr->stRcAttr.enRcMode == VENC_RC_MODE_MJPEGCBR) { + PARAM_STRING_APPEND_TO(enc_param, DRM_KEY_COMPRESS_BITRATE, mjpeg_bps); + } else { + PARAM_STRING_APPEND_TO(enc_param, DRM_KEY_COMPRESS_BITRATE_MAX, mjpeg_bps); + } + + PARAM_STRING_APPEND(enc_param, DRM_KEY_COMPRESS_RC_MODE, pcMediaRcMode); + } else { + PARAM_STRING_APPEND_TO(enc_param, DRM_KEY_JPEG_QFACTOR, 50); + } + + flow_param = libdrm::JoinFlowParam(flow_param, 1, enc_param); + DRM_MEDIA_LOGD("JPEG-LT: Type:[%s] encoder flow param:[%s]", pcMediaCodecType, flow_param.c_str()); + + video_jpeg_flow = libdrm::REFLECTOR(Flow)::Create(flow_name.c_str(), flow_param.c_str()); + if (!video_jpeg_flow) { + DRM_MEDIA_LOGE("Create flow:[%s] failed", flow_name.c_str()); + g_venc_mtx.unlock(); + return -10; + } + + video_jpeg_flow->SetFlowTag("JpegLightEncoder"); + + init_media_channel_buffer(&g_venc_chns[channel]); + video_jpeg_flow->SetOutputCallBack(&g_venc_chns[channel], flow_output_callback); + + g_venc_chns[channel].media_flow = video_jpeg_flow; + g_venc_chns[channel].media_flow_list.push_back(video_jpeg_flow); + + if (pipe2(g_venc_chns[channel].wake_fd, O_CLOEXEC) == -1) { + g_venc_chns[channel].wake_fd[0] = 0; + g_venc_chns[channel].wake_fd[1] = 0; + DRM_MEDIA_LOGW("Create pipe failed"); + } + g_venc_chns[channel].status = CHN_STATUS_OPEN; + g_venc_mtx.unlock(); + + g_venc_chns[channel].venc_attr.bFullFunc = false; + return 0; +} + +int drm_mpi_venc_get_channel_parameter(int channel, drm_venc_chn_param_t *stVencChnParam) +{ + if (!stVencChnParam) { + return -1; + } + + if ((channel < DRM_VENC_CHANNEL_00) || (channel >= DRM_VENC_CHANNEL_BUTT)) { + return -2; + } + + g_venc_mtx.lock(); + memcpy(stVencChnParam, &g_venc_chns[channel].venc_attr.param, sizeof(drm_venc_chn_param_t)); + g_venc_mtx.unlock(); + + return 0; +} + +int drm_mpi_venc_set_channel_parameter(int channel, drm_venc_chn_param_t *stVencChnParam) +{ + if (!stVencChnParam) { + return -1; + } + + if ((channel < DRM_VENC_CHANNEL_00) || (channel >= DRM_VENC_CHANNEL_BUTT)) { + return -2; + } + + g_venc_mtx.lock(); + if (g_venc_chns[channel].status == CHN_STATUS_CLOSED) { + g_venc_mtx.unlock(); + return -3; + } + + memcpy(&g_venc_chns[channel].venc_attr.param, stVencChnParam, sizeof(drm_venc_chn_param_t)); + + DrmVideoResolutionCfg vid_cfg; + std::shared_ptr flow; + drm_codec_type_e enCodecType = g_venc_chns[channel].venc_attr.attr.stVencAttr.enType; + + if (((enCodecType == DRM_CODEC_TYPE_MJPEG) || (enCodecType == DRM_CODEC_TYPE_JPEG)) && (g_venc_chns[channel].venc_attr.bFullFunc)) { + vid_cfg.width = g_venc_chns[channel].venc_attr.attr.stVencAttr.stAttrJpege.u32ZoomWidth; + vid_cfg.height = g_venc_chns[channel].venc_attr.attr.stVencAttr.stAttrJpege.u32ZoomHeight; + vid_cfg.vir_width = g_venc_chns[channel].venc_attr.attr.stVencAttr.stAttrJpege.u32ZoomVirWidth; + vid_cfg.vir_height = g_venc_chns[channel] .venc_attr.attr.stVencAttr.stAttrJpege.u32ZoomVirHeight; + flow = g_venc_chns[channel].media_flow_list.back(); + } else { + vid_cfg.width = g_venc_chns[channel].venc_attr.attr.stVencAttr.u32PicWidth; + vid_cfg.height = g_venc_chns[channel].venc_attr.attr.stVencAttr.u32PicHeight; + vid_cfg.vir_width = g_venc_chns[channel].venc_attr.attr.stVencAttr.u32VirWidth; + vid_cfg.vir_height = g_venc_chns[channel].venc_attr.attr.stVencAttr.u32VirHeight; + flow = g_venc_chns[channel].media_flow; + } + + vid_cfg.x = stVencChnParam->stCropCfg.stRect.s32X; + vid_cfg.y = stVencChnParam->stCropCfg.stRect.s32Y; + vid_cfg.w = stVencChnParam->stCropCfg.stRect.u32Width; + vid_cfg.h = stVencChnParam->stCropCfg.stRect.u32Height; + + int ret = video_encoder_set_resolution(flow, &vid_cfg); + if (ret) { + g_venc_mtx.unlock(); + return -4; + } + g_venc_mtx.unlock(); + + return 0; +} + +int drm_mpi_venc_get_rc_parameter(int channel, drm_venc_rc_param_t *pstRcParam) +{ + if (!pstRcParam) { + return -1; + } + + if ((channel < DRM_VENC_CHANNEL_00) || (channel >= DRM_VENC_CHANNEL_BUTT)) { + return -2; + } + + if (g_venc_chns[channel].status < CHN_STATUS_OPEN) { + return -3; + } + + DrmVideoEncoderQp stVencQp; + + g_venc_mtx.lock(); + int ret = video_encoder_get_qp(g_venc_chns[channel].media_flow, stVencQp); + if (!ret) { + memcpy(pstRcParam->u32ThrdI, stVencQp.thrd_i, RC_TEXTURE_THR_SIZE * sizeof(uint32_t)); + memcpy(pstRcParam->u32ThrdP, stVencQp.thrd_p, RC_TEXTURE_THR_SIZE * sizeof(uint32_t)); + pstRcParam->u32RowQpDeltaI = stVencQp.row_qp_delta_i; + pstRcParam->u32RowQpDeltaP = stVencQp.row_qp_delta_p; + + pstRcParam->bEnableHierQp = (bool)stVencQp.hier_qp_en; + memcpy(pstRcParam->s32HierQpDelta, stVencQp.hier_qp_delta, RC_HEIR_SIZE * sizeof(int)); + memcpy(pstRcParam->s32HierFrameNum, stVencQp.hier_frame_num, RC_HEIR_SIZE * sizeof(int)); + + pstRcParam->s32FirstFrameStartQp = stVencQp.qp_init; + switch (g_venc_chns[channel].venc_attr.attr.stVencAttr.enType) { + case DRM_CODEC_TYPE_H264: + pstRcParam->stParamH264.u32MaxQp = stVencQp.qp_max; + pstRcParam->stParamH264.u32MinQp = stVencQp.qp_min; + pstRcParam->stParamH264.u32MaxIQp = stVencQp.qp_max_i; + pstRcParam->stParamH264.u32MinIQp = stVencQp.qp_min_i; + break; + + case DRM_CODEC_TYPE_H265: + pstRcParam->stParamH265.u32MaxQp = stVencQp.qp_max; + pstRcParam->stParamH265.u32MinQp = stVencQp.qp_min; + pstRcParam->stParamH265.u32MaxIQp = stVencQp.qp_max_i; + pstRcParam->stParamH265.u32MinIQp = stVencQp.qp_min_i; + break; + + case DRM_CODEC_TYPE_JPEG: + break; + + default: + break; + } + } else { + memcpy(pstRcParam, &g_venc_chns[channel].venc_attr.stRcPara, sizeof(drm_venc_rc_param_t)); + } + g_venc_mtx.unlock(); + + return 0; +} + +int drm_mpi_venc_set_rc_parameter(int channel, drm_venc_rc_param_t *pstRcParam) +{ + if ((channel < DRM_VENC_CHANNEL_00) || (channel >= DRM_VENC_CHANNEL_BUTT)) { + return -1; + } + + if (g_venc_chns[channel].status < CHN_STATUS_OPEN) { + return -2; + } + + g_venc_mtx.lock(); + DrmVideoEncoderQp stVencQp; + + memcpy(stVencQp.thrd_i, pstRcParam->u32ThrdI, RC_TEXTURE_THR_SIZE * sizeof(uint32_t)); + memcpy(stVencQp.thrd_p, pstRcParam->u32ThrdP, RC_TEXTURE_THR_SIZE * sizeof(uint32_t)); + stVencQp.row_qp_delta_i = pstRcParam->u32RowQpDeltaI; + stVencQp.row_qp_delta_p = pstRcParam->u32RowQpDeltaP; + + stVencQp.hier_qp_en = (bool)pstRcParam->bEnableHierQp; + memcpy(stVencQp.hier_qp_delta, pstRcParam->s32HierQpDelta, RC_HEIR_SIZE * sizeof(int)); + memcpy(stVencQp.hier_frame_num, pstRcParam->s32HierFrameNum, RC_HEIR_SIZE * sizeof(int)); + + stVencQp.qp_init = pstRcParam->s32FirstFrameStartQp; + switch (g_venc_chns[channel].venc_attr.attr.stVencAttr.enType) { + case DRM_CODEC_TYPE_H264: + stVencQp.qp_step = pstRcParam->stParamH264.u32StepQp; + stVencQp.qp_max = pstRcParam->stParamH264.u32MaxQp; + stVencQp.qp_min = pstRcParam->stParamH264.u32MinQp; + stVencQp.qp_max_i = pstRcParam->stParamH264.u32MaxIQp; + stVencQp.qp_min_i = pstRcParam->stParamH264.u32MinIQp; + break; + + case DRM_CODEC_TYPE_H265: + stVencQp.qp_step = pstRcParam->stParamH265.u32StepQp; + stVencQp.qp_max = pstRcParam->stParamH265.u32MaxQp; + stVencQp.qp_min = pstRcParam->stParamH265.u32MinQp; + stVencQp.qp_max_i = pstRcParam->stParamH265.u32MaxIQp; + stVencQp.qp_min_i = pstRcParam->stParamH265.u32MinIQp; + break; + + case DRM_CODEC_TYPE_JPEG: + break; + + default: + break; + } + + int ret = video_encoder_set_qp(g_venc_chns[channel].media_flow, stVencQp); + if (!ret) { + memcpy(&g_venc_chns[channel].venc_attr.stRcPara, pstRcParam, sizeof(drm_venc_rc_param_t)); + } + g_venc_mtx.unlock(); + + return ret; +} + +int drm_mpi_venc_set_jpeg_parameter(int channel, drm_venc_jpeg_param_t *pstJpegParam) +{ + if ((channel < DRM_VENC_CHANNEL_00) || (channel >= DRM_VENC_CHANNEL_BUTT)) { + return -1; + } + + if (!pstJpegParam) { + return -2; + } + + if (pstJpegParam->u32Qfactor > 99 || !pstJpegParam->u32Qfactor) { + DRM_MEDIA_LOGE("u32Qfactor:[%d] is invalid, should be:[1, 99]", pstJpegParam->u32Qfactor); + return -3; + } + + if ((g_venc_chns[channel].status < CHN_STATUS_OPEN) || g_venc_chns[channel].media_flow_list.empty()) { + return -4; + } + + if (g_venc_chns[channel].venc_attr.attr.stVencAttr.enType != DRM_CODEC_TYPE_JPEG) { + return -5; + } + + std::shared_ptr media_flow = g_venc_chns[channel].media_flow_list.back(); + int ret = libdrm::jpeg_encoder_set_qfactor(media_flow, pstJpegParam->u32Qfactor); + + return ret; +} + +int drm_mpi_venc_insert_userdata(int channel, uint8_t *pu8Data, uint32_t u32Len) +{ + if ((channel < DRM_VENC_CHANNEL_00) || (channel >= DRM_VENC_CHANNEL_BUTT)) { + return -1; + } + + if (g_venc_chns[channel].status < CHN_STATUS_OPEN) { + return -2; + } + + g_venc_mtx.lock(); + video_encoder_set_userdata(g_venc_chns[channel].media_flow, pu8Data, u32Len); + g_venc_mtx.unlock(); + + return 0; +} + +int drm_mpi_venc_get_roi_attribute(int channel, drm_venc_roi_attr_t *pstRoiAttr, int roi_index07) +{ + if (!pstRoiAttr) { + return -1; + } + + if ((channel < DRM_VENC_CHANNEL_00) || (channel >= DRM_VENC_CHANNEL_BUTT)) { + return -2; + } + + if (g_venc_chns[channel].status < CHN_STATUS_OPEN) { + return -3; + } + + if ((roi_index07 < 0) || (roi_index07 > 7)) { + return -4; + } + + g_venc_mtx.lock(); + memcpy(pstRoiAttr, &g_venc_chns[channel].venc_attr.astRoiAttr[roi_index07], sizeof(drm_venc_roi_attr_t)); + g_venc_mtx.unlock(); + + return 0; +} + +int drm_mpi_venc_set_roi_attribute(int channel, const drm_venc_roi_attr_t *pstRoiAttr, int region_cnt) +{ + int ret = 0; + + if ((channel < DRM_VENC_CHANNEL_00) || (channel >= DRM_VENC_CHANNEL_BUTT)) { + return -1; + } + + if (g_venc_chns[channel].status < CHN_STATUS_OPEN) { + return -2; + } + + if (((pstRoiAttr == nullptr) && (region_cnt > 0)) || (region_cnt > 8)) { + return -3; + } + + if (g_venc_chns[channel].venc_attr.attr.stVencAttr.enType != DRM_CODEC_TYPE_H264 + && g_venc_chns[channel].venc_attr.attr.stVencAttr.enType != DRM_CODEC_TYPE_H265) + { + return -4; + } + + int img_width; + int img_height; + int x_offset = 0; + int y_offset = 0; + int valid_rgn_cnt = 0; + DrmEncROIRegion regions[region_cnt]; + + if ((g_venc_chns[channel].venc_attr.attr.stVencAttr.enRotation == VENC_ROTATION_90) + || (g_venc_chns[channel].venc_attr.attr.stVencAttr.enRotation == VENC_ROTATION_270)) + { + img_width = g_venc_chns[channel].venc_attr.attr.stVencAttr.u32PicHeight; + img_height = g_venc_chns[channel].venc_attr.attr.stVencAttr.u32PicWidth; + } else { + img_width = g_venc_chns[channel].venc_attr.attr.stVencAttr.u32PicWidth; + img_height = g_venc_chns[channel].venc_attr.attr.stVencAttr.u32PicHeight; + } + + memset(regions, 0x00, sizeof(DrmEncROIRegion) * region_cnt); + for (int i = 0; i < region_cnt; i++) { + if (!pstRoiAttr[i].bEnable) { + continue; + } + + regions[valid_rgn_cnt].x = pstRoiAttr[i].stRect.s32X; + regions[valid_rgn_cnt].y = pstRoiAttr[i].stRect.s32Y; + regions[valid_rgn_cnt].w = pstRoiAttr[i].stRect.u32Width; + regions[valid_rgn_cnt].h = pstRoiAttr[i].stRect.u32Height; + regions[valid_rgn_cnt].intra = pstRoiAttr[i].bIntra; + regions[valid_rgn_cnt].abs_qp_en = pstRoiAttr[i].bAbsQp; + regions[valid_rgn_cnt].qp_area_idx = pstRoiAttr[i].u32Index; + regions[valid_rgn_cnt].quality = pstRoiAttr[i].s32Qp; + regions[valid_rgn_cnt].area_map_en = 1; + + x_offset = pstRoiAttr[i].stRect.s32X + pstRoiAttr[i].stRect.u32Width; + y_offset = pstRoiAttr[i].stRect.s32Y + pstRoiAttr[i].stRect.u32Height; + if ((x_offset > img_width) || (y_offset > img_height)) { + return -5; + } + + valid_rgn_cnt++; + } + + g_venc_mtx.lock(); + ret = video_encoder_set_roi_regions(g_venc_chns[channel].media_flow, regions, valid_rgn_cnt); + if (!ret) { + for (int i = 0; i < region_cnt; i++) { + memcpy(&g_venc_chns[channel].venc_attr.astRoiAttr[i], &pstRoiAttr[i], sizeof(drm_venc_roi_attr_t)); + } + } + g_venc_mtx.unlock(); + + return ret ? -6 : 0; +} + +int drm_mpi_venc_get_fd(int channel) +{ + if ((channel < DRM_VENC_CHANNEL_00) || (channel >= DRM_VENC_CHANNEL_BUTT)) { + return -1; + } + + int rcv_fd = 0; + + g_venc_mtx.lock(); + if (g_venc_chns[channel].status < CHN_STATUS_OPEN) { + g_venc_mtx.unlock(); + return -2; + } + rcv_fd = g_venc_chns[channel].wake_fd[0]; + g_venc_mtx.unlock(); + + return rcv_fd; +} + +int drm_mpi_venc_query_status(int channel, drm_venc_chn_status_t *pstStatus) +{ + if ((channel < DRM_VENC_CHANNEL_00) || (channel >= DRM_VENC_CHANNEL_BUTT)) { + return -1; + } + + if (!pstStatus) { + return -2; + } + + g_venc_mtx.lock(); + if ((g_venc_chns[channel].status < CHN_STATUS_OPEN) || (!g_venc_chns[channel].media_flow)) { + g_venc_mtx.unlock(); + return -3; + } + + uint32_t u32BufferUsedCnt = 0; + uint32_t u32BufferTotalCnt = 0; + + g_venc_chns[channel].media_flow->GetCachedBufferNum(u32BufferTotalCnt, u32BufferUsedCnt); + g_venc_mtx.unlock(); + + pstStatus->u32LeftFrames = u32BufferUsedCnt; + pstStatus->u32TotalFrames = u32BufferTotalCnt; + + g_venc_chns[channel].buffer_list_mtx.lock(); + pstStatus->u32TotalPackets = g_venc_chns[channel].buffer_depth; + pstStatus->u32LeftPackets = g_venc_chns[channel].buffer_list.size(); + g_venc_chns[channel].buffer_list_mtx.unlock(); + + return 0; +} + +int drm_mpi_venc_get_super_frame_strategy(int channel, drm_venc_superframe_cfg_t *pstSuperFrmParam) +{ + if ((channel < DRM_VENC_CHANNEL_00) || (channel >= DRM_VENC_CHANNEL_BUTT)) { + return -1; + } + + if (!pstSuperFrmParam) { + return -2; + } + + if (g_venc_chns[channel].status != CHN_STATUS_OPEN) { + return -3; + } + + if (!g_venc_chns[channel].media_flow) { + return -4; + } + + // TODO: + + return 0; +} + +int drm_mpi_venc_set_super_frame_strategy(int channel, const drm_venc_superframe_cfg_t *pstSuperFrmParam) +{ + if ((channel < DRM_VENC_CHANNEL_00) || (channel >= DRM_VENC_CHANNEL_BUTT)) { + return -1; + } + + if (!pstSuperFrmParam) { + return -2; + } + + if (g_venc_chns[channel].status < CHN_STATUS_OPEN) { + return -3; + } + + if (!g_venc_chns[channel].media_flow) { + return -4; + } + + DrmVencSuperFrmCfg media_super_frm_cfg; + switch (pstSuperFrmParam->enSuperFrmMode) { + case SUPERFRM_NONE: + media_super_frm_cfg.SuperFrmMode = DRM_MEDIA_SUPERFRM_NONE; + break; + + case SUPERFRM_DISCARD: + media_super_frm_cfg.SuperFrmMode = DRM_MEDIA_SUPERFRM_DISCARD; + break; + + case SUPERFRM_REENCODE: + media_super_frm_cfg.SuperFrmMode = DRM_MEDIA_SUPERFRM_REENCODE; + break; + + default: + return -5; + } + + switch (pstSuperFrmParam->enRcPriority) { + case VENC_RC_PRIORITY_BITRATE_FIRST: + media_super_frm_cfg.RcPriority = DRM_MEDIA_VENC_RC_PRIORITY_BITRATE_FIRST; + break; + + case VENC_RC_PRIORITY_FRAMEBITS_FIRST: + media_super_frm_cfg.RcPriority = DRM_MEDIA_VENC_RC_PRIORITY_FRAMEBITS_FIRST; + break; + + default: + return -6; + } + + media_super_frm_cfg.SuperIFrmBitsThr = pstSuperFrmParam->u32SuperIFrmBitsThr; + media_super_frm_cfg.SuperPFrmBitsThr = pstSuperFrmParam->u32SuperPFrmBitsThr; + + int ret = libdrm::video_encoder_set_super_frame(g_venc_chns[channel].media_flow, &media_super_frm_cfg); + if (ret) { + ret = -7; + } + + return 0; +} + +int drm_mpi_venc_start_recv_frame(int channel, const drm_recv_pic_param_t *pstRecvParam) +{ + if ((channel < DRM_VENC_CHANNEL_00) || (channel >= DRM_VENC_CHANNEL_BUTT)) { + return -1; + } + + if (!pstRecvParam) { + return -2; + } + + if (!g_venc_chns[channel].media_flow) { + return -3; + } + + g_venc_chns[channel].media_flow->SetRunTimes(pstRecvParam->s32RecvPicNum); + return 0; +} + +int drm_mpi_venc_region_set_palette_id(int channel, const drm_osd_region_info_t *pstRgnInfo, const drm_osd_color_palette_buf_t *pstColPalBuf) +{ + int ret = 0; + + if ((channel < DRM_VENC_CHANNEL_00) || (channel >= DRM_VENC_CHANNEL_BUTT)) { + return -1; + } + + if ((g_venc_chns[channel].status < CHN_STATUS_OPEN) || (g_venc_chns[channel].bColorTblInit == false)) { + return -2; + } + + drm_codec_type_e enCodecType = g_venc_chns[channel].venc_attr.attr.stVencAttr.enType; + if (((enCodecType == DRM_CODEC_TYPE_MJPEG) || (enCodecType == DRM_CODEC_TYPE_JPEG)) && (!g_venc_chns[channel].venc_attr.bFullFunc)) { + DRM_MEDIA_LOGE("Jpeg lt don't support SetPaletteId"); + return -3; + } + + if (pstRgnInfo && !pstRgnInfo->u8Enable) { + DrmOsdRegionData media_osd_rgn; + + memset(&media_osd_rgn, 0x00, sizeof(media_osd_rgn)); + media_osd_rgn.region_id = pstRgnInfo->enRegionId; + media_osd_rgn.enable = pstRgnInfo->u8Enable; + media_osd_rgn.region_type = REGION_TYPE_OVERLAY; + + ret = libdrm::video_encoder_set_osd_region(g_venc_chns[channel].media_flow, &media_osd_rgn); + if (ret) { + ret = -4; + } + + return ret; + } + + if (!pstColPalBuf || !pstColPalBuf->pIdBuf) { + return -5; + } + + if (!pstRgnInfo || !pstRgnInfo->u32Width || !pstRgnInfo->u32Height) { + return -6; + } + + if ((pstRgnInfo->u32PosX % 16) || (pstRgnInfo->u32PosY % 16) || (pstRgnInfo->u32Width % 16) || (pstRgnInfo->u32Height % 16)) { + DRM_MEDIA_LOGE(" = <%d, %d, %d, %d> must be 16 aligned", pstRgnInfo->u32PosX, pstRgnInfo->u32PosY, pstRgnInfo->u32Width, pstRgnInfo->u32Height); + return -7; + } + + if ((pstRgnInfo->u32Width != pstColPalBuf->u32Width) || (pstRgnInfo->u32Height != pstColPalBuf->u32Height)) { + DRM_MEDIA_LOGE("RgnInfo:[%dx%d] and ColorPaletteBuf:[%dx%d] not equal", pstRgnInfo->u32Width, pstRgnInfo->u32Height, pstColPalBuf->u32Width, pstColPalBuf->u32Height); + return -8; + } + + DrmOsdRegionData media_osd_rgn; + + media_osd_rgn.buffer = (uint8_t *)pstColPalBuf->pIdBuf; + media_osd_rgn.region_id = pstRgnInfo->enRegionId; + media_osd_rgn.pos_x = pstRgnInfo->u32PosX; + media_osd_rgn.pos_y = pstRgnInfo->u32PosY; + media_osd_rgn.width = pstRgnInfo->u32Width; + media_osd_rgn.height = pstRgnInfo->u32Height; + media_osd_rgn.inverse = pstRgnInfo->u8Inverse; + media_osd_rgn.enable = pstRgnInfo->u8Enable; + media_osd_rgn.region_type = REGION_TYPE_OVERLAY; + + ret = libdrm::video_encoder_set_osd_region(g_venc_chns[channel].media_flow, &media_osd_rgn); + if (ret) { + ret = -9; + } + + return ret; +} + +int drm_mpi_venc_region_init(int channel, drm_venc_color_tbl_t *stColorTbl) +{ + if ((channel < DRM_VENC_CHANNEL_00) || (channel >= DRM_VENC_CHANNEL_BUTT)) { + return -1; + } + + if (g_venc_chns[channel].status < CHN_STATUS_OPEN) { + DRM_MEDIA_LOGE("venc should be opened before init osd"); + return -2; + } + + drm_codec_type_e enCodecType = g_venc_chns[channel].venc_attr.attr.stVencAttr.enType; + if (((enCodecType == DRM_CODEC_TYPE_MJPEG) || (enCodecType == DRM_CODEC_TYPE_JPEG))) { + g_venc_mtx.lock(); + g_venc_chns[channel].bColorTblInit = true; + g_venc_mtx.unlock(); + + return 0; + } + + int ret = 0; + const uint32_t *pu32ArgbColorTbl = NULL; + uint32_t u32AVUYColorTbl[VENC_RGN_COLOR_NUM] = {0}; + + if (stColorTbl) { + if (stColorTbl->bColorDichotomyEnable) { + DRM_MEDIA_LOGI("venc channel:[%d] user define color table(Dichotomy:[true])", channel); + + std::sort(stColorTbl->u32ArgbTbl, stColorTbl->u32ArgbTbl + VENC_RGN_COLOR_NUM); + g_venc_chns[channel].bColorDichotomyEnable = true; + } else { + DRM_MEDIA_LOGI("venc channel:[%d] user define color table(Dichotomy:[false])", channel); + g_venc_chns[channel].bColorDichotomyEnable = false; + } + + pu32ArgbColorTbl = stColorTbl->u32ArgbTbl; + } else { + DRM_MEDIA_LOGI("venc channel:[%d] default color table(Dichotomy:[true])", channel); + + g_venc_chns[channel].bColorDichotomyEnable = true; + pu32ArgbColorTbl = u32DftARGB8888ColorTbl; + } + + color_tbl_argb_to_avuy(pu32ArgbColorTbl, u32AVUYColorTbl); + + g_venc_mtx.lock(); + ret = libdrm::video_encoder_set_osd_plt(g_venc_chns[channel].media_flow, u32AVUYColorTbl); + if (ret) { + g_venc_mtx.unlock(); + return -3; + } + + memcpy(g_venc_chns[channel].u32ArgbColorTbl, pu32ArgbColorTbl, VENC_RGN_COLOR_NUM * 4); + g_venc_chns[channel].bColorTblInit = true; + g_venc_mtx.unlock(); + + return 0; +} + +static void argb8888_to_region_data(int channel, const drm_bitmap_t *pstBitmap, uint8_t *data, uint32_t canvasWidth, uint32_t canvasHeight) +{ + uint32_t ColorValue; + uint8_t *CanvasLineStart; + uint8_t TransColorId = 0; + uint32_t *BitmapLineStart; + uint32_t TransColor = 0x00000000; + uint32_t TargetWidth, TargetHeight; + + TargetWidth = (pstBitmap->u32Width > canvasWidth) ? canvasWidth : pstBitmap->u32Width; + TargetHeight = (pstBitmap->u32Height > canvasHeight) ? canvasHeight : pstBitmap->u32Height; + + DRM_MEDIA_LOGD("bitmap:[%d, %d] -> canvas:[%d, %d], target:[%d, %d]", pstBitmap->u32Width, pstBitmap->u32Height, canvasWidth, canvasHeight, TargetWidth, TargetHeight); + + memset(data, TransColorId, canvasWidth * canvasHeight); + + for (uint32_t i = 0; i < TargetHeight; i++) { + CanvasLineStart = data + i * canvasWidth; + BitmapLineStart = (uint32_t *)pstBitmap->pData + i * pstBitmap->u32Width; + + for (uint32_t j = 0; j < TargetWidth; j++) { + ColorValue = *(BitmapLineStart + j); + + if (ColorValue == TransColor) { + continue; + } + + if (g_venc_chns[channel].bColorDichotomyEnable) { + *(CanvasLineStart + j) = find_argb_color_tbl_by_dichotomy(g_venc_chns[channel].u32ArgbColorTbl, PALETTE_TABLE_LEN, ColorValue); + } else { + *(CanvasLineStart + j) = find_argb_color_tbl_by_order(g_venc_chns[channel].u32ArgbColorTbl, PALETTE_TABLE_LEN, ColorValue); + } + } + } +} + +int drm_mpi_venc_region_set_bitmap(int channel, const drm_osd_region_info_t *pstRgnInfo, const drm_bitmap_t *pstBitmap) +{ + int ret = 0; + uint8_t *media_osd_data = NULL; + + if ((channel < DRM_VENC_CHANNEL_00) || (channel >= DRM_VENC_CHANNEL_BUTT)) { + return -1; + } + + g_venc_mtx.lock(); + if ((g_venc_chns[channel].status < CHN_STATUS_OPEN) || (g_venc_chns[channel].bColorTblInit == false)) { + g_venc_mtx.unlock(); + return -2; + } else { + g_venc_chns[channel].chn_ref_cnt++; + } + g_venc_mtx.unlock(); + + uint8_t u8Align = 16; + uint8_t u8PlaneCnt = 1; + bool bIsJpegLight = false; + drm_region_type_e region_type = REGION_TYPE_OVERLAY; + drm_codec_type_e enCodecType = g_venc_chns[channel].venc_attr.attr.stVencAttr.enType; + + if (((enCodecType == DRM_CODEC_TYPE_MJPEG) || (enCodecType == DRM_CODEC_TYPE_JPEG))) { + bIsJpegLight = true; + u8Align = 2; + u8PlaneCnt = 4; + region_type = REGION_TYPE_OVERLAY_EX; + } + + if (pstRgnInfo && !pstRgnInfo->u8Enable) { + DrmOsdRegionData media_osd_rgn; + + memset(&media_osd_rgn, 0x00, sizeof(media_osd_rgn)); + media_osd_rgn.region_id = pstRgnInfo->enRegionId; + media_osd_rgn.enable = pstRgnInfo->u8Enable; + media_osd_rgn.region_type = region_type; + + if (g_venc_chns[channel].venc_attr.bFullFunc) { + ret = libdrm::video_encoder_set_osd_region(g_venc_chns[channel].media_flow_list.back(), &media_osd_rgn, u8PlaneCnt); + } else { + ret = libdrm::video_encoder_set_osd_region(g_venc_chns[channel].media_flow, &media_osd_rgn); + } + + if (ret) { + ret = -3; + } + + goto deref; + } + + if (!pstBitmap || !pstBitmap->pData || !pstBitmap->u32Width || !pstBitmap->u32Height) { + ret = -4; + goto deref; + } + + if (!pstRgnInfo || !pstRgnInfo->u32Width || !pstRgnInfo->u32Height) { + ret = -5; + goto deref; + } + + if ((pstRgnInfo->u32PosX % u8Align) || (pstRgnInfo->u32PosY % u8Align) || (pstRgnInfo->u32Width % u8Align) || (pstRgnInfo->u32Height % u8Align)) { + DRM_MEDIA_LOGE(" = <%d, %d, %d, %d> must be %u aligned", pstRgnInfo->u32PosX, pstRgnInfo->u32PosY, pstRgnInfo->u32Width, pstRgnInfo->u32Height, u8Align); + + ret = -6; + goto deref; + } + + if (!bIsJpegLight) { + uint32_t total_pix_num = pstRgnInfo->u32Width * pstRgnInfo->u32Height; + media_osd_data = (uint8_t *)malloc(total_pix_num); + if (!media_osd_data) { + DRM_MEDIA_LOGE("no space left, RgnInfo pixels:[%d]", total_pix_num); + + ret = -7; + goto deref; + } + + switch (pstBitmap->enPixelFormat) { + case PIXEL_FORMAT_ARGB_8888: + argb8888_to_region_data(channel, pstBitmap, media_osd_data, pstRgnInfo->u32Width, pstRgnInfo->u32Height); + break; + + default: + DRM_MEDIA_LOGE("not support bitmap pixel format:[%d]", pstBitmap->enPixelFormat); + ret = -8; + goto deref; + } + } else { + if ((pstBitmap->u32Width != pstRgnInfo->u32Width) || (pstBitmap->u32Height != pstRgnInfo->u32Height)) { + DRM_MEDIA_LOGE("JpegLight:RgnInfo:[%ux%u] should be equal to BitMap:[%ux%u]", pstRgnInfo->u32Width, pstRgnInfo->u32Height, pstBitmap->u32Width, pstBitmap->u32Height); + ret = -9; + goto deref; + } + + media_osd_data = (uint8_t *)pstBitmap->pData; + } + + DrmOsdRegionData media_osd_rgn; + media_osd_rgn.buffer = media_osd_data; + media_osd_rgn.region_id = pstRgnInfo->enRegionId; + media_osd_rgn.pos_x = pstRgnInfo->u32PosX; + media_osd_rgn.pos_y = pstRgnInfo->u32PosY; + media_osd_rgn.width = pstRgnInfo->u32Width; + media_osd_rgn.height = pstRgnInfo->u32Height; + media_osd_rgn.inverse = pstRgnInfo->u8Inverse; + media_osd_rgn.enable = pstRgnInfo->u8Enable; + media_osd_rgn.region_type = region_type; + + if (g_venc_chns[channel].venc_attr.bFullFunc) { + ret = libdrm::video_encoder_set_osd_region(g_venc_chns[channel].media_flow_list.back(), &media_osd_rgn, u8PlaneCnt); + } else { + ret = libdrm::video_encoder_set_osd_region(g_venc_chns[channel].media_flow, &media_osd_rgn, u8PlaneCnt); + } + + if (ret) { + ret = -10; + } + + if (!bIsJpegLight && media_osd_data) { + free(media_osd_data); + } + +deref: + g_venc_mtx.lock(); + g_venc_chns[channel].chn_ref_cnt--; + g_venc_mtx.unlock(); + + return ret; +} + +int drm_mpi_venc_region_set_cover(int channel, const drm_osd_region_info_t *pstRgnInfo, const drm_cover_info_t *pstCoverInfo) +{ + int ret = 0; + uint8_t color_id = 0xFF; + uint32_t total_pix_num = 0; + uint8_t *media_cover_data = NULL; + + if ((channel < DRM_VENC_CHANNEL_00) || (channel >= DRM_VENC_CHANNEL_BUTT)) { + return -1; + } + + if ((g_venc_chns[channel].status < CHN_STATUS_OPEN) || (g_venc_chns[channel].bColorTblInit == false)) { + return -2; + } + + uint8_t u8Align = 16; + uint8_t u8PlaneCnt = 1; + bool bIsJpegLight = false; + drm_region_type_e region_type = REGION_TYPE_OVERLAY; + drm_codec_type_e enCodecType = g_venc_chns[channel].venc_attr.attr.stVencAttr.enType; + + if (((enCodecType == DRM_CODEC_TYPE_MJPEG) || (enCodecType == DRM_CODEC_TYPE_JPEG)) && (!g_venc_chns[channel].venc_attr.bFullFunc)) { + bIsJpegLight = true; + u8Align = 2; + u8PlaneCnt = 0; + region_type = REGION_TYPE_COVER_EX; + } + + if (pstRgnInfo && !pstRgnInfo->u8Enable) { + DrmOsdRegionData media_osd_rgn; + + memset(&media_osd_rgn, 0x00, sizeof(media_osd_rgn)); + media_osd_rgn.region_id = pstRgnInfo->enRegionId; + media_osd_rgn.enable = pstRgnInfo->u8Enable; + media_osd_rgn.region_type = region_type; + + ret = libdrm::video_encoder_set_osd_region( g_venc_chns[channel].media_flow, &media_osd_rgn); + if (ret) { + ret = -3; + } + + return ret; + } + + if (!pstCoverInfo) { + return -4; + } + + if (!pstRgnInfo || !pstRgnInfo->u32Width || !pstRgnInfo->u32Height) { + return -5; + } + + if ((pstRgnInfo->u32PosX % u8Align) || (pstRgnInfo->u32PosY % u8Align) || (pstRgnInfo->u32Width % u8Align) || (pstRgnInfo->u32Height % u8Align)) { + DRM_MEDIA_LOGE(" = <%d, %d, %d, %d> must be %d aligned", pstRgnInfo->u32PosX, pstRgnInfo->u32PosY, pstRgnInfo->u32Width, pstRgnInfo->u32Height, u8Align); + return -6; + } + + if (pstCoverInfo->enPixelFormat != PIXEL_FORMAT_ARGB_8888) { + DRM_MEDIA_LOGE("not support cover pixel format:[%d]", pstCoverInfo->enPixelFormat); + return -7; + } + + if (!bIsJpegLight) { + total_pix_num = pstRgnInfo->u32Width * pstRgnInfo->u32Height; + media_cover_data = (uint8_t *)malloc(total_pix_num); + if (!media_cover_data) { + DRM_MEDIA_LOGE("no space left, RgnInfo pixels:[%d]", total_pix_num); + return -8; + } + + color_id = find_argb_color_tbl_by_order(g_venc_chns[channel].u32ArgbColorTbl, PALETTE_TABLE_LEN, pstCoverInfo->u32Color); + memset(media_cover_data, color_id, total_pix_num); + } + + DrmOsdRegionData media_osd_rgn; + media_osd_rgn.buffer = media_cover_data; + media_osd_rgn.region_id = pstRgnInfo->enRegionId; + media_osd_rgn.pos_x = pstRgnInfo->u32PosX; + media_osd_rgn.pos_y = pstRgnInfo->u32PosY; + media_osd_rgn.width = pstRgnInfo->u32Width; + media_osd_rgn.height = pstRgnInfo->u32Height; + media_osd_rgn.inverse = pstRgnInfo->u8Inverse; + media_osd_rgn.enable = pstRgnInfo->u8Enable; + media_osd_rgn.region_type = region_type; + media_osd_rgn.cover_color = pstCoverInfo->u32Color; + + ret = libdrm::video_encoder_set_osd_region(g_venc_chns[channel].media_flow, &media_osd_rgn, u8PlaneCnt); + if (ret) { + ret = -9; + } + + if (media_cover_data) { + free(media_cover_data); + } + + return ret; +} + +int drm_mpi_venc_region_set_coverEx(int channel, const drm_osd_region_info_t *pstRgnInfo, const drm_cover_info_t *pstCoverInfo) +{ + int ret = 0; + + if ((channel < DRM_VENC_CHANNEL_00) || (channel >= DRM_VENC_CHANNEL_BUTT)) { + return -1; + } + + if (g_venc_chns[channel].status < CHN_STATUS_OPEN) { + return -2; + } + + if (pstRgnInfo && !pstRgnInfo->u8Enable) { + DrmOsdRegionData media_osd_rgn; + + memset(&media_osd_rgn, 0x00, sizeof(media_osd_rgn)); + media_osd_rgn.region_id = pstRgnInfo->enRegionId; + media_osd_rgn.enable = pstRgnInfo->u8Enable; + media_osd_rgn.region_type = REGION_TYPE_COVER_EX; + + ret = libdrm::video_encoder_set_osd_region(g_venc_chns[channel].media_flow, &media_osd_rgn); + if (ret) { + ret = -3; + } + + return ret; + } + + if (!pstCoverInfo) { + return -4; + } + + if (!pstRgnInfo || !pstRgnInfo->u32Width || !pstRgnInfo->u32Height) { + return -5; + } + + uint8_t u8Align = 2; + uint8_t u8PlaneCnt = 0; + + if ((pstRgnInfo->u32PosX % u8Align) || (pstRgnInfo->u32PosY % u8Align) || (pstRgnInfo->u32Width % u8Align) || (pstRgnInfo->u32Height % u8Align)) { + DRM_MEDIA_LOGE(" = <%d, %d, %d, %d> must be %d aligned", pstRgnInfo->u32PosX, pstRgnInfo->u32PosY, pstRgnInfo->u32Width, pstRgnInfo->u32Height, u8Align); + return -6; + } + + if (pstCoverInfo->enPixelFormat != PIXEL_FORMAT_ARGB_8888) { + DRM_MEDIA_LOGE("Not support cover pixel format:[%d]", pstCoverInfo->enPixelFormat); + return -7; + } + + DrmOsdRegionData media_osd_rgn; + + media_osd_rgn.buffer = NULL; + media_osd_rgn.region_id = pstRgnInfo->enRegionId; + media_osd_rgn.pos_x = pstRgnInfo->u32PosX; + media_osd_rgn.pos_y = pstRgnInfo->u32PosY; + media_osd_rgn.width = pstRgnInfo->u32Width; + media_osd_rgn.height = pstRgnInfo->u32Height; + media_osd_rgn.inverse = pstRgnInfo->u8Inverse; + media_osd_rgn.enable = pstRgnInfo->u8Enable; + media_osd_rgn.region_type = REGION_TYPE_COVER_EX; + media_osd_rgn.cover_color = pstCoverInfo->u32Color; + + ret = libdrm::video_encoder_set_osd_region(g_venc_chns[channel].media_flow, &media_osd_rgn, u8PlaneCnt); + if (ret) { + ret = -8; + } + + return ret; +} + #ifdef __cplusplus } #endif diff --git a/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/common/vepu580_tune.h b/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/common/vepu580_tune.h index 4808aa686..5582ea53f 100644 --- a/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/common/vepu580_tune.h +++ b/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/common/vepu580_tune.h @@ -31,7 +31,7 @@ typedef enum MotionLevel_e { MOTION_LEVEL_UNKNOW_SCENE = 3, } MotionLevel; -extern RK_S32 ctu_madp_cnt_thd[6][8]; -extern RK_S32 madp_num_map[5][4]; +//extern RK_S32 ctu_madp_cnt_thd[6][8]; +//extern RK_S32 madp_num_map[5][4]; #endif diff --git a/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h264e/Makefile b/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h264e/Makefile index 254130c5c..1e1925008 100644 --- a/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h264e/Makefile +++ b/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h264e/Makefile @@ -1,3 +1,3 @@ obj-y += hal_h264e_vepu541.o -obj-n += hal_h264e_vepu580_tune.o +obj-y += hal_h264e_vepu580_tune.o obj-y += hal_h264e_vepu580.o diff --git a/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h264e/hal_h264e_vepu580.c b/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h264e/hal_h264e_vepu580.c index 3bca9d4c7..71d116aad 100644 --- a/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h264e/hal_h264e_vepu580.c +++ b/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h264e/hal_h264e_vepu580.c @@ -13,10 +13,10 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - #define MODULE_TAG "hal_h264e_vepu580" #include +#include #include "../../../../osal/inc/mpp_env.h" #include "../../../../osal/inc/mpp_mem.h" @@ -36,77 +36,78 @@ #include "../common/vepu541_common.h" #include "hal_h264e_vepu580_reg.h" #include "../../../base/inc/mpp_enc_cb_param.h" - -#define DUMP_REG 0 -#define MAX_TASK_CNT 2 - -typedef struct HalH264eVepu580Ctx_t { - MppEncCfgSet *cfg; - - MppDev dev; - RK_S32 frame_cnt; - RK_U32 task_cnt; - - /* buffers management */ - HalBufs hw_recn; - RK_S32 pixel_buf_fbc_hdr_size; - RK_S32 pixel_buf_fbc_bdy_size; - RK_S32 pixel_buf_size; - RK_S32 thumb_buf_size; - RK_S32 max_buf_cnt; - MppDevRegOffCfgs *offsets; - - /* external line buffer over 4K */ - MppBufferGroup ext_line_buf_grp; - MppBuffer ext_line_bufs[MAX_TASK_CNT]; - RK_S32 ext_line_buf_size; - - /* syntax for input from enc_impl */ - RK_U32 updated; - H264eSps *sps; - H264ePps *pps; - H264eDpb *dpb; - H264eSlice *slice; - H264eFrmInfo *frms; - H264eReorderInfo *reorder; - H264eMarkingInfo *marking; - H264ePrefixNal *prefix; - - /* syntax for output to enc_impl */ - EncRcTaskInfo hal_rc_cfg; - - /* roi */ - void *roi_data; - - /* osd */ - Vepu541OsdCfg osd_cfg; - - /* finetune */ - void *tune; - - /* two-pass deflicker */ - MppBuffer buf_pass1; - - /* register */ - HalVepu580RegSet *regs_sets; - - /* frame parallel info */ - RK_S32 task_idx; - RK_S32 curr_idx; - RK_S32 prev_idx; - HalVepu580RegSet *regs_set; - MppBuffer ext_line_buf; - - /* slice low delay output callback */ - MppCbCtx *output_cb; - RK_S32 poll_slice_max; - RK_S32 poll_cfg_size; - MppDevPollCfg *poll_cfgs; -} HalH264eVepu580Ctx; - -#define CHROMA_KLUT_TAB_SIZE (24 * sizeof(RK_U32)) - -static RK_U32 h264e_klut_weight[30] = { +#include "hal_h264e_vepu580_private.h" + +// #define DUMP_REG 0 +// #define MAX_TASK_CNT 2 + +// typedef struct HalH264eVepu580Ctx_t { +// MppEncCfgSet *cfg; + +// MppDev dev; +// RK_S32 frame_cnt; +// RK_U32 task_cnt; + +// /* buffers management */ +// HalBufs hw_recn; +// RK_S32 pixel_buf_fbc_hdr_size; +// RK_S32 pixel_buf_fbc_bdy_size; +// RK_S32 pixel_buf_size; +// RK_S32 thumb_buf_size; +// RK_S32 max_buf_cnt; +// MppDevRegOffCfgs *offsets; + +// /* external line buffer over 4K */ +// MppBufferGroup ext_line_buf_grp; +// MppBuffer ext_line_bufs[MAX_TASK_CNT]; +// RK_S32 ext_line_buf_size; + +// /* syntax for input from enc_impl */ +// RK_U32 updated; +// H264eSps *sps; +// H264ePps *pps; +// H264eDpb *dpb; +// H264eSlice *slice; +// H264eFrmInfo *frms; +// H264eReorderInfo *reorder; +// H264eMarkingInfo *marking; +// H264ePrefixNal *prefix; + +// /* syntax for output to enc_impl */ +// EncRcTaskInfo hal_rc_cfg; + +// /* roi */ +// void *roi_data; + +// /* osd */ +// Vepu541OsdCfg osd_cfg; + +// /* finetune */ +// void *tune; + +// /* two-pass deflicker */ +// MppBuffer buf_pass1; + +// /* register */ +// HalVepu580RegSet *regs_sets; + +// /* frame parallel info */ +// RK_S32 task_idx; +// RK_S32 curr_idx; +// RK_S32 prev_idx; +// HalVepu580RegSet *regs_set; +// MppBuffer ext_line_buf; + +// /* slice low delay output callback */ +// MppCbCtx *output_cb; +// RK_S32 poll_slice_max; +// RK_S32 poll_cfg_size; +// MppDevPollCfg *poll_cfgs; +// } HalH264eVepu580Ctx; + +// #define CHROMA_KLUT_TAB_SIZE (24 * sizeof(RK_U32)) + +/*static*/ RK_U32 h264e_klut_weight[30] = { 0x0a000010, 0x00064000, 0x14000020, 0x000c8000, 0x28000040, 0x00194000, 0x50800080, 0x0032c000, 0xa1000100, 0x00658000, 0x42800200, 0x00cb0001, diff --git a/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h264e/hal_h264e_vepu580_private.h b/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h264e/hal_h264e_vepu580_private.h new file mode 100644 index 000000000..88271481a --- /dev/null +++ b/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h264e/hal_h264e_vepu580_private.h @@ -0,0 +1,97 @@ +#ifndef __HAL_H264E_VEPU580_PRIVATE_H__ +#define __HAL_H264E_VEPU580_PRIVATE_H__ + +#include +#include + +#include "../../../../osal/inc/mpp_env.h" +#include "../../../../osal/inc/mpp_mem.h" +#include "../../../../osal/inc/mpp_common.h" +#include "../../../base/inc/mpp_frame_impl.h" +#include "../../../base/inc/mpp_packet_impl.h" +#include "../../../codec/inc/mpp_rc.h" + +#include "../../../codec/enc/h264/h264e_sps.h" +#include "../../../codec/enc/h264/h264e_pps.h" +#include "../../../codec/enc/h264/h264e_dpb.h" +#include "../../../codec/enc/h264/h264e_slice.h" + +#include "../../common/h264/hal_h264e_debug.h" +#include "../../common/hal_bufs.h" +#include "../../inc/mpp_enc_hal.h" +#include "../common/vepu541_common.h" +#include "hal_h264e_vepu580_reg.h" +#include "../../../base/inc/mpp_enc_cb_param.h" + +#define DUMP_REG 0 +#define MAX_TASK_CNT 2 + +#define CHROMA_KLUT_TAB_SIZE (24 * sizeof(RK_U32)) + +typedef struct HalH264eVepu580Ctx_t { + MppEncCfgSet *cfg; + + MppDev dev; + RK_S32 frame_cnt; + RK_U32 task_cnt; + + /* buffers management */ + HalBufs hw_recn; + RK_S32 pixel_buf_fbc_hdr_size; + RK_S32 pixel_buf_fbc_bdy_size; + RK_S32 pixel_buf_size; + RK_S32 thumb_buf_size; + RK_S32 max_buf_cnt; + MppDevRegOffCfgs *offsets; + + /* external line buffer over 4K */ + MppBufferGroup ext_line_buf_grp; + MppBuffer ext_line_bufs[MAX_TASK_CNT]; + RK_S32 ext_line_buf_size; + + /* syntax for input from enc_impl */ + RK_U32 updated; + H264eSps *sps; + H264ePps *pps; + H264eDpb *dpb; + H264eSlice *slice; + H264eFrmInfo *frms; + H264eReorderInfo *reorder; + H264eMarkingInfo *marking; + H264ePrefixNal *prefix; + + /* syntax for output to enc_impl */ + EncRcTaskInfo hal_rc_cfg; + + /* roi */ + void *roi_data; + + /* osd */ + Vepu541OsdCfg osd_cfg; + + /* finetune */ + void *tune; + + /* two-pass deflicker */ + MppBuffer buf_pass1; + + /* register */ + HalVepu580RegSet *regs_sets; + + /* frame parallel info */ + RK_S32 task_idx; + RK_S32 curr_idx; + RK_S32 prev_idx; + HalVepu580RegSet *regs_set; + MppBuffer ext_line_buf; + + /* slice low delay output callback */ + MppCbCtx *output_cb; + RK_S32 poll_slice_max; + RK_S32 poll_cfg_size; + MppDevPollCfg *poll_cfgs; +} HalH264eVepu580Ctx; + +extern RK_U32 h264e_klut_weight[30]; + +#endif diff --git a/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h264e/hal_h264e_vepu580_tune.c b/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h264e/hal_h264e_vepu580_tune.c index febcd85b7..de24382e5 100644 --- a/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h264e/hal_h264e_vepu580_tune.c +++ b/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h264e/hal_h264e_vepu580_tune.c @@ -13,8 +13,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - #include "../common/vepu580_tune.h" +#include "hal_h264e_vepu580_private.h" #define HAL_H264E_DBG_CONTENT (0x00000200) #define hal_h264e_dbg_content(fmt, ...) hal_h264e_dbg_f(HAL_H264E_DBG_CONTENT, fmt, ## __VA_ARGS__) @@ -47,7 +47,7 @@ typedef struct HalH264eVepu580Tune_t { static RK_S32 mb_avg_madp_thd[6] = {192, 128, 64, 192, 128, 64}; -RK_S32 ctu_madp_cnt_thd[6][8] = { +static RK_S32 ctu_madp_cnt_thd[6][8] = { {50, 100, 130, 50, 100, 550, 500, 550}, {100, 150, 200, 80, 120, 500, 450, 550}, {150, 200, 250, 100, 150, 450, 400, 450}, @@ -56,7 +56,7 @@ RK_S32 ctu_madp_cnt_thd[6][8] = { {150, 200, 250, 100, 150, 450, 400, 450} }; -RK_S32 madp_num_map[5][4] = { +static RK_S32 madp_num_map[5][4] = { {0, 0, 0, 1}, {0, 0, 1, 0}, {0, 0, 1, 1}, diff --git a/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h265e/Makefile b/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h265e/Makefile index 77286171a..654ddc791 100644 --- a/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h265e/Makefile +++ b/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h265e/Makefile @@ -1,3 +1,3 @@ obj-y += hal_h265e_vepu541.o -obj-n += hal_h265e_vepu580_tune.o +obj-y += hal_h265e_vepu580_tune.o obj-y += hal_h265e_vepu580.o diff --git a/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h265e/hal_h265e_vepu580.c b/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h265e/hal_h265e_vepu580.c index f776ef93f..dfc46fb20 100644 --- a/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h265e/hal_h265e_vepu580.c +++ b/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h265e/hal_h265e_vepu580.c @@ -13,7 +13,6 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - #define MODULE_TAG "hal_h265e_v580" #include @@ -37,93 +36,94 @@ #include "../../../base/inc/mpp_enc_cb_param.h" #include "../../../../osal/inc/mpp_service.h" +#include "hal_h265e_vepu580_private.h" -#define MAX_TILE_NUM 4 +// #define MAX_TILE_NUM 4 #define hal_h265e_err(fmt, ...) \ do {\ mpp_err_f(fmt, ## __VA_ARGS__);\ } while (0) -typedef struct vepu580_h265_fbk_t { - RK_U32 hw_status; /* 0:corret, 1:error */ - RK_U32 qp_sum; - RK_U32 out_strm_size; - RK_U32 out_hw_strm_size; - RK_S64 sse_sum; - RK_U32 st_lvl64_inter_num; - RK_U32 st_lvl32_inter_num; - RK_U32 st_lvl16_inter_num; - RK_U32 st_lvl8_inter_num; - RK_U32 st_lvl32_intra_num; - RK_U32 st_lvl16_intra_num; - RK_U32 st_lvl8_intra_num; - RK_U32 st_lvl4_intra_num; - RK_U32 st_cu_num_qp[52]; - RK_U32 st_madp; - RK_U32 st_madi; - RK_U32 st_md_sad_b16num0; - RK_U32 st_md_sad_b16num1; - RK_U32 st_md_sad_b16num2; - RK_U32 st_md_sad_b16num3; - RK_U32 st_madi_b16num0; - RK_U32 st_madi_b16num1; - RK_U32 st_madi_b16num2; - RK_U32 st_madi_b16num3; - RK_U32 st_mb_num; - RK_U32 st_ctu_num; -} vepu580_h265_fbk; - -typedef struct H265eV580HalContext_t { - MppEncHalApi api; - MppDev dev; - void *regs[MAX_TILE_NUM]; - void *reg_out[MAX_TILE_NUM]; - - vepu580_h265_fbk feedback; - void *dump_files; - RK_U32 frame_cnt_gen_ready; - - RK_S32 frame_type; - RK_S32 last_frame_type; - - /* @frame_cnt starts from ZERO */ - RK_U32 frame_cnt; - Vepu541OsdCfg osd_cfg; - MppDevRegOffCfgs *reg_cfg; - void *roi_data; - MppEncCfgSet *cfg; - - MppBufferGroup tile_grp; - MppBuffer hw_tile_buf[MAX_TILE_NUM]; - MppBuffer hw_tile_stream[MAX_TILE_NUM - 1]; - MppBuffer buf_pass1; - - RK_U32 enc_mode; - RK_U32 frame_size; - RK_S32 max_buf_cnt; - RK_S32 hdr_status; - void *input_fmt; - RK_U8 *src_buf; - RK_U8 *dst_buf; - RK_S32 buf_size; - RK_U32 frame_num; - HalBufs dpb_bufs; - RK_S32 fbc_header_len; - RK_U32 tile_num; - RK_U32 tile_parall_en; - RK_U32 tile_dump_err; - - RK_S32 poll_slice_max; - RK_S32 poll_cfg_size; - MppDevPollCfg *poll_cfgs; - MppCbCtx *output_cb; - - /* finetune */ - void *tune; -} H265eV580HalContext; - -#define TILE_BUF_SIZE MPP_ALIGN(128 * 1024, 256) +// typedef struct vepu580_h265_fbk_t { +// RK_U32 hw_status; /* 0:corret, 1:error */ +// RK_U32 qp_sum; +// RK_U32 out_strm_size; +// RK_U32 out_hw_strm_size; +// RK_S64 sse_sum; +// RK_U32 st_lvl64_inter_num; +// RK_U32 st_lvl32_inter_num; +// RK_U32 st_lvl16_inter_num; +// RK_U32 st_lvl8_inter_num; +// RK_U32 st_lvl32_intra_num; +// RK_U32 st_lvl16_intra_num; +// RK_U32 st_lvl8_intra_num; +// RK_U32 st_lvl4_intra_num; +// RK_U32 st_cu_num_qp[52]; +// RK_U32 st_madp; +// RK_U32 st_madi; +// RK_U32 st_md_sad_b16num0; +// RK_U32 st_md_sad_b16num1; +// RK_U32 st_md_sad_b16num2; +// RK_U32 st_md_sad_b16num3; +// RK_U32 st_madi_b16num0; +// RK_U32 st_madi_b16num1; +// RK_U32 st_madi_b16num2; +// RK_U32 st_madi_b16num3; +// RK_U32 st_mb_num; +// RK_U32 st_ctu_num; +// } vepu580_h265_fbk; + +// typedef struct H265eV580HalContext_t { +// MppEncHalApi api; +// MppDev dev; +// void *regs[MAX_TILE_NUM]; +// void *reg_out[MAX_TILE_NUM]; + +// vepu580_h265_fbk feedback; +// void *dump_files; +// RK_U32 frame_cnt_gen_ready; + +// RK_S32 frame_type; +// RK_S32 last_frame_type; + +// /* @frame_cnt starts from ZERO */ +// RK_U32 frame_cnt; +// Vepu541OsdCfg osd_cfg; +// MppDevRegOffCfgs *reg_cfg; +// void *roi_data; +// MppEncCfgSet *cfg; + +// MppBufferGroup tile_grp; +// MppBuffer hw_tile_buf[MAX_TILE_NUM]; +// MppBuffer hw_tile_stream[MAX_TILE_NUM - 1]; +// MppBuffer buf_pass1; + +// RK_U32 enc_mode; +// RK_U32 frame_size; +// RK_S32 max_buf_cnt; +// RK_S32 hdr_status; +// void *input_fmt; +// RK_U8 *src_buf; +// RK_U8 *dst_buf; +// RK_S32 buf_size; +// RK_U32 frame_num; +// HalBufs dpb_bufs; +// RK_S32 fbc_header_len; +// RK_U32 tile_num; +// RK_U32 tile_parall_en; +// RK_U32 tile_dump_err; + +// RK_S32 poll_slice_max; +// RK_S32 poll_cfg_size; +// MppDevPollCfg *poll_cfgs; +// MppCbCtx *output_cb; + +// /* finetune */ +// void *tune; +// } H265eV580HalContext; + +// #define TILE_BUF_SIZE MPP_ALIGN(128 * 1024, 256) static RK_U32 klut_weight[24] = { 0x50800080, 0x00330000, 0xA1000100, 0x00660000, 0x42000200, 0x00CC0001, diff --git a/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h265e/hal_h265e_vepu580_private.h b/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h265e/hal_h265e_vepu580_private.h new file mode 100644 index 000000000..885214263 --- /dev/null +++ b/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h265e/hal_h265e_vepu580_private.h @@ -0,0 +1,107 @@ +#ifndef __HAL_H265E_VEPU580_PRIVATE_H__ +#define __HAL_H265E_VEPU580_PRIVATE_H__ + +#include +#include + +#include "../../../../osal/inc/mpp_env.h" +#include "../../../../osal/inc/mpp_mem.h" +#include "../../../../osal/inc/mpp_soc.h" +#include "../../../../osal/inc/mpp_common.h" +#include "../../../base/inc/mpp_frame_impl.h" +#include "../../../base/inc/mpp_packet_impl.h" + +#include "../../common/h265/hal_h265e_debug.h" +#include "../../../common/h265e_syntax_new.h" +#include "../../common/hal_bufs.h" +#include "../common/rkv_enc_def.h" +#include "../common/vepu541_common.h" +#include "hal_h265e_vepu580.h" +#include "hal_h265e_vepu580_reg.h" +#include "../../../base/inc/mpp_enc_cb_param.h" + +#include "../../../../osal/inc/mpp_service.h" + +#define MAX_TILE_NUM 4 + +typedef struct vepu580_h265_fbk_t { + RK_U32 hw_status; /* 0:corret, 1:error */ + RK_U32 qp_sum; + RK_U32 out_strm_size; + RK_U32 out_hw_strm_size; + RK_S64 sse_sum; + RK_U32 st_lvl64_inter_num; + RK_U32 st_lvl32_inter_num; + RK_U32 st_lvl16_inter_num; + RK_U32 st_lvl8_inter_num; + RK_U32 st_lvl32_intra_num; + RK_U32 st_lvl16_intra_num; + RK_U32 st_lvl8_intra_num; + RK_U32 st_lvl4_intra_num; + RK_U32 st_cu_num_qp[52]; + RK_U32 st_madp; + RK_U32 st_madi; + RK_U32 st_md_sad_b16num0; + RK_U32 st_md_sad_b16num1; + RK_U32 st_md_sad_b16num2; + RK_U32 st_md_sad_b16num3; + RK_U32 st_madi_b16num0; + RK_U32 st_madi_b16num1; + RK_U32 st_madi_b16num2; + RK_U32 st_madi_b16num3; + RK_U32 st_mb_num; + RK_U32 st_ctu_num; +} vepu580_h265_fbk; + +typedef struct H265eV580HalContext_t { + MppEncHalApi api; + MppDev dev; + void *regs[MAX_TILE_NUM]; + void *reg_out[MAX_TILE_NUM]; + + vepu580_h265_fbk feedback; + void *dump_files; + RK_U32 frame_cnt_gen_ready; + + RK_S32 frame_type; + RK_S32 last_frame_type; + + /* @frame_cnt starts from ZERO */ + RK_U32 frame_cnt; + Vepu541OsdCfg osd_cfg; + MppDevRegOffCfgs *reg_cfg; + void *roi_data; + MppEncCfgSet *cfg; + + MppBufferGroup tile_grp; + MppBuffer hw_tile_buf[MAX_TILE_NUM]; + MppBuffer hw_tile_stream[MAX_TILE_NUM - 1]; + MppBuffer buf_pass1; + + RK_U32 enc_mode; + RK_U32 frame_size; + RK_S32 max_buf_cnt; + RK_S32 hdr_status; + void *input_fmt; + RK_U8 *src_buf; + RK_U8 *dst_buf; + RK_S32 buf_size; + RK_U32 frame_num; + HalBufs dpb_bufs; + RK_S32 fbc_header_len; + RK_U32 tile_num; + RK_U32 tile_parall_en; + RK_U32 tile_dump_err; + + RK_S32 poll_slice_max; + RK_S32 poll_cfg_size; + MppDevPollCfg *poll_cfgs; + MppCbCtx *output_cb; + + /* finetune */ + void *tune; +} H265eV580HalContext; + +#define TILE_BUF_SIZE MPP_ALIGN(128 * 1024, 256) + +#endif diff --git a/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h265e/hal_h265e_vepu580_tune.c b/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h265e/hal_h265e_vepu580_tune.c index 590fcb139..1145e5e10 100644 --- a/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h265e/hal_h265e_vepu580_tune.c +++ b/project/3rdparty/source/rockchip/rkmpp/mpp/hal/rkenc/h265e/hal_h265e_vepu580_tune.c @@ -13,8 +13,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - #include "../common/vepu580_tune.h" +#include "hal_h265e_vepu580_private.h" #define HAL_H265E_DBG_CONTENT (0x00200000) #define hal_h264e_dbg_content(fmt, ...) hal_h264e_dbg_f(HAL_H264E_DBG_CONTENT, fmt, ## __VA_ARGS__) @@ -201,6 +201,23 @@ static RK_S32 rime_multi[4][3] = { {4, 4, 4}, }; +static RK_S32 ctu_madp_cnt_thd[6][8] = { + {50, 100, 130, 50, 100, 550, 500, 550}, + {100, 150, 200, 80, 120, 500, 450, 550}, + {150, 200, 250, 100, 150, 450, 400, 450}, + {50, 100, 130, 50, 100, 550, 500, 550}, + {100, 150, 200, 80, 120, 500, 450, 550}, + {150, 200, 250, 100, 150, 450, 400, 450} +}; + +static RK_S32 madp_num_map[5][4] = { + {0, 0, 0, 1}, + {0, 0, 1, 0}, + {0, 0, 1, 1}, + {1, 0, 0, 0}, + {1, 1, 1, 1}, +}; + static HalH265eVepu580Tune *vepu580_h265e_tune_init(H265eV580HalContext *ctx) { HalH265eVepu580Tune *tune = mpp_malloc(HalH265eVepu580Tune, 1); diff --git a/project/3rdparty/source/rockchip/rkmpp/mpp/mpp_info.cpp b/project/3rdparty/source/rockchip/rkmpp/mpp/mpp_info.cpp index 09e8546d9..737d61f6f 100644 --- a/project/3rdparty/source/rockchip/rkmpp/mpp/mpp_info.cpp +++ b/project/3rdparty/source/rockchip/rkmpp/mpp/mpp_info.cpp @@ -23,41 +23,11 @@ #include "../osal/inc/mpp_env.h" #include "inc/mpp_info.h" -#include "version.h" - -/* - * To avoid string | grep author getting multiple results - * use commit to replace author - */ -static const char mpp_version[] = MPP_VERSION; -static const RK_S32 mpp_history_cnt = MPP_VER_HIST_CNT; -static const char *mpp_history[] = { - MPP_VER_HIST_0, - MPP_VER_HIST_1, - MPP_VER_HIST_2, - MPP_VER_HIST_3, - MPP_VER_HIST_4, - MPP_VER_HIST_5, - MPP_VER_HIST_6, - MPP_VER_HIST_7, - MPP_VER_HIST_8, - MPP_VER_HIST_9, -}; +static const char *mpp_version = "rockchip-rkmpp - " __DATE__ " " __TIME__; void show_mpp_version(void) { - RK_U32 show_history = 0; - - mpp_env_get_u32("mpp_show_history", &show_history, 0); - - if (show_history) { - RK_S32 i; - mpp_log("mpp version history %d:\n", mpp_history_cnt); - for (i = 0; i < mpp_history_cnt; i++) - mpp_log("%s\n", mpp_history[i]); - } else - mpp_log("mpp version: %s\n", mpp_version); } const char *get_mpp_version(void) diff --git a/project/3rdparty/source/rockchip/rkmpp/mpp/version.h b/project/3rdparty/source/rockchip/rkmpp/mpp/version.h deleted file mode 100644 index 33202b6b8..000000000 --- a/project/3rdparty/source/rockchip/rkmpp/mpp/version.h +++ /dev/null @@ -1,33 +0,0 @@ -/* - * Copyright 2010 Rockchip Electronics S.LSI 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. - */ - -#ifndef __VERSION_H__ -#define __VERSION_H__ - -#define MPP_VERSION "d7f0b0e9 author: sayon.chen 2022-09-27 [hal_h265]: Fix memset strmbuf align_offset maybe overflow" -#define MPP_VER_HIST_CNT 10 -#define MPP_VER_HIST_0 "d7f0b0e9 author: sayon.chen 2022-09-27 [hal_h265]: Fix memset strmbuf align_offset maybe overflow (HEAD -> develop, origin/develop, origin/HEAD)" -#define MPP_VER_HIST_1 "35625579 author: sayon.chen 2022-09-27 [vepu580_hevc]: Support enc max with up to 16384" -#define MPP_VER_HIST_2 "27e4974b author: Herman Chen 2022-09-27 [hal_vepu580]: Adjusting default parameters" -#define MPP_VER_HIST_3 "45739cd4 author: Herman Chen 2022-09-27 [mpp_enc]: Clear split arg and out when disabled" -#define MPP_VER_HIST_4 "9b2c8f30 author: Herman Chen 2022-09-26 [mpp_enc]: reduce extra log on IDR request" -#define MPP_VER_HIST_5 "b0ae2b71 author: sayon.chen 2022-09-24 [h265d_param]: DXVA slice param use dynamic malloc" -#define MPP_VER_HIST_6 "ba13512f author: toby.zhang 2022-09-24 [hal_h265e_vepu580]: Adjusting tuning parameters" -#define MPP_VER_HIST_7 "d654d25e author: sayon.chen 2022-09-23 [h265d_ref]: Add miss ref used by current check" -#define MPP_VER_HIST_8 "69127d46 author: Yandong Lin 2022-09-23 [h264d_parser]: fix last empty eos pkt send to hw issue in avcc case" -#define MPP_VER_HIST_9 "a2094ca3 author: sayon.chen 2022-09-22 [h265d]: Modify hw resolution capability check method" - -#endif /*__VERSION_H__*/