[h264e]: add SEI writing

1. write prep/codec/rc cfg to SEI
2. mpi_enc_test add SEI writting test
3. write SEI one sequence once defaultly

Change-Id: I7dd00a20afe101d7ddf17c875f0704d91a8fea2b
Signed-off-by: Lin Kesheng <lks@rock-chips.com>

mpp/hal/common/h264/hal_h264e_api.c

@@ -122,6 +122,8 @@ MPP_RET hal_h264e_init(void *hal, MppHalCfg *cfg)
     ctx->cfg = cfg->cfg;
     ctx->set = cfg->set;
 
+    ctx->sei_mode = MPP_ENC_SEI_MODE_ONE_SEQ;
+
     return api->init(hal, cfg);
 }
 

mpp/hal/common/h264/hal_h264e_com.c

@@ -730,3 +730,56 @@ MPP_RET hal_h264e_set_pps(h264e_hal_context *ctx, h264e_hal_pps *pps, h264e_hal_
     return MPP_OK;
 }
 
+void hal_h264e_sei_pack2str(char *str, h264e_hal_context *ctx)
+{
+    MppEncCfgSet *cfg = ctx->cfg;
+    MppEncH264Cfg *codec = &cfg->codec.h264;
+    MppEncPrepCfg *prep = &cfg->prep;
+    MppEncRcCfg *rc = &cfg->rc;
+
+    if (prep->change || codec->change || rc->change)
+        H264E_HAL_SPRINT(str, "frm %d: ", ctx->frame_cnt);
+
+    /* prep cfg */
+    if (prep->change) {
+        RK_U32 change = prep->change;
+
+        H264E_HAL_SPRINT(str, "[prep] ");
+        if (change & MPP_ENC_PREP_CFG_CHANGE_INPUT) {
+            H264E_HAL_SPRINT(str, "w=%d ", prep->width);
+            H264E_HAL_SPRINT(str, "h=%d ", prep->height);
+            H264E_HAL_SPRINT(str, "fmt=%d ", prep->format);
+            H264E_HAL_SPRINT(str, "h_std=%d ", prep->hor_stride);
+            H264E_HAL_SPRINT(str, "v_std=%d ", prep->ver_stride);
+        }
+    }
+
+    /* codec cfg */
+    if (codec->change) {
+        H264E_HAL_SPRINT(str, "[codec] ");
+        H264E_HAL_SPRINT(str, "profile=%d ", codec->profile);
+        H264E_HAL_SPRINT(str, "level=%d ", codec->level);
+        H264E_HAL_SPRINT(str, "b_cabac=%d ", codec->entropy_coding_mode);
+        H264E_HAL_SPRINT(str, "cabac_idc=%d ", codec->cabac_init_idc);
+        H264E_HAL_SPRINT(str, "t8x8=%d ", codec->transform8x8_mode);
+        H264E_HAL_SPRINT(str, "constrain_intra=%d ", codec->constrained_intra_pred_mode);
+        H264E_HAL_SPRINT(str, "dblk=%d:%d:%d ", codec->deblock_disable,
+                         codec->deblock_offset_alpha, codec->deblock_offset_beta);
+        H264E_HAL_SPRINT(str, "cbcr_qp_offset=%d:%d ", codec->chroma_cb_qp_offset,
+                         codec->chroma_cr_qp_offset);
+        H264E_HAL_SPRINT(str, "qp_max=%d ", codec->qp_max);
+        H264E_HAL_SPRINT(str, "qp_min=%d ", codec->qp_min);
+        H264E_HAL_SPRINT(str, "qp_max_step=%d ", codec->qp_max_step);
+    }
+
+    /* rc cfg */
+    if (rc->change) {
+        H264E_HAL_SPRINT(str, "[rc] ");
+        H264E_HAL_SPRINT(str, "rc_mode=%d ", rc->rc_mode);
+        H264E_HAL_SPRINT(str, "quality=%d ", rc->quality);
+        H264E_HAL_SPRINT(str, "bps=%d:%d:%d ", rc->bps_target, rc->bps_min, rc->bps_max);
+        H264E_HAL_SPRINT(str, "fps_in=%d:%d:%d ", rc->fps_in_num, rc->fps_in_denorm, rc->fps_in_flex);
+        H264E_HAL_SPRINT(str, "fps_out=%d:%d:%d ", rc->fps_out_num, rc->fps_out_denorm, rc->fps_out_flex);
+        H264E_HAL_SPRINT(str, "gop=%d ", rc->gop);
+    }
+}

mpp/hal/common/h264/hal_h264e_com.h

@@ -44,7 +44,8 @@ extern RK_U32 h264e_hal_log_mode;
 
 #define H264E_HAL_LOG_FILE              0x00100000
 
-
+#define H264E_SEI_CHG_SPSPPS        0x00000001
+#define H264E_SEI_CHG_RC            0x00000010
 
 #define H264E_HAL_MASK_2b               (RK_U32)0x00000003
 #define H264E_HAL_MASK_3b               (RK_U32)0x00000007
@@ -467,5 +468,6 @@ const RK_U8 h264e_zigzag_scan4[2][16];
 const RK_U8 h264e_zigzag_scan8[2][64];
 void hal_h264e_rkv_set_format(H264eHwCfg *hw_cfg, MppEncPrepCfg *prep_cfg);
 void hal_h264e_vpu_set_format(H264eHwCfg *hw_cfg, MppEncPrepCfg *prep_cfg);
+void hal_h264e_sei_pack2str(char *str, h264e_hal_context *ctx);
 
 #endif

mpp/hal/rkenc/h264e/hal_h264e_rkv.c

@@ -1636,58 +1636,6 @@ MPP_RET hal_h264e_rkv_encapsulate_nals(h264e_hal_rkv_extra_info *out)
     return MPP_OK;
 }
 
-static MPP_RET hal_h264e_rkv_sei_pack2str(char *str, h264e_hal_context *ctx)
-{
-    h264e_hal_rkv_extra_info *info = (h264e_hal_rkv_extra_info *)ctx->extra_info;
-    h264e_hal_sps *sps = &info->sps;
-    h264e_hal_pps *pps = &info->pps;
-    MppEncCfgSet *cfg = ctx->cfg;
-    MppEncPrepCfg *prep = &cfg->prep;
-    MppEncRcCfg *rc_cfg = &cfg->rc;
-
-    h264e_hal_debug_enter();
-
-    H264E_HAL_SPRINT(str, "frame %d rkvenc_cfg: ", ctx->frame_cnt);
-
-    if (info->sei_change_flg & H264E_SEI_CHG_SPSPPS) {
-        h264e_hal_log_sei("write sei extra_info_cfg");
-        H264E_HAL_SPRINT(str, "extra_info: ");
-        H264E_HAL_SPRINT(str, "pic_w %d ",                           prep->width);
-        H264E_HAL_SPRINT(str, "pic_h %d ",                           prep->height);
-        H264E_HAL_SPRINT(str, "en_cabac %d ",                        pps->b_cabac);
-        H264E_HAL_SPRINT(str, "t8x8 %d ",                            pps->b_transform_8x8_mode);
-        H264E_HAL_SPRINT(str, "cb_qp_ofst %d ",                      pps->i_chroma_qp_index_offset);
-        H264E_HAL_SPRINT(str, "pic_init_qp %d ",                     pps->i_pic_init_qp);
-        H264E_HAL_SPRINT(str, "fps %d ",                             rc_cfg->fps_in_num / rc_cfg->fps_in_denorm);
-        H264E_HAL_SPRINT(str, "src_fmt %d ",                         prep->format);
-        H264E_HAL_SPRINT(str, "profile %d ",                         sps->i_profile_idc);
-        H264E_HAL_SPRINT(str, "level %d ",                           sps->i_level_idc);
-        H264E_HAL_SPRINT(str, "key_interval %d ",                    sps->keyframe_max_interval);
-        H264E_HAL_SPRINT(str, "cr_qp_ofst %d ",                      pps->i_second_chroma_qp_index_offset);
-        H264E_HAL_SPRINT(str, "pps_id %d ",                          pps->i_id);
-        info->sei_change_flg &= ~H264E_SEI_CHG_SPSPPS;
-    }
-
-    if (info->sei_change_flg & H264E_SEI_CHG_RC) {
-        h264e_hal_log_sei("write sei rc_cfg");
-        H264E_HAL_SPRINT(str, "rc: ");
-        H264E_HAL_SPRINT(str, "mode %d ",                            rc_cfg->rc_mode);
-        H264E_HAL_SPRINT(str, "qlt %d ",                             rc_cfg->quality);
-        H264E_HAL_SPRINT(str, "bps_tgt %d ",                         rc_cfg->bps_target);
-        H264E_HAL_SPRINT(str, "bps_max %d ",                         rc_cfg->bps_max);
-        H264E_HAL_SPRINT(str, "bps_min %d ",                         rc_cfg->bps_min);
-        H264E_HAL_SPRINT(str, "fps_in %d ",                          rc_cfg->fps_in_num / rc_cfg->fps_in_denorm);
-        H264E_HAL_SPRINT(str, "fps_out %d ",                         rc_cfg->fps_out_num / rc_cfg->fps_out_denorm);
-        H264E_HAL_SPRINT(str, "gop %d ",                             rc_cfg->gop);
-        H264E_HAL_SPRINT(str, "skip_cnt %d ",                        rc_cfg->skip_cnt);
-        info->sei_change_flg &= ~H264E_SEI_CHG_RC;
-    }
-
-    h264e_hal_debug_leave();
-
-    return MPP_OK;
-}
-
 static MPP_RET hal_h264e_rkv_sei_write(h264e_hal_rkv_stream *s, RK_U8 *payload, RK_S32 payload_size, RK_S32 payload_type)
 {
     RK_S32 i = 0;
@@ -1722,7 +1670,7 @@ MPP_RET hal_h264e_rkv_sei_encode(h264e_hal_context *ctx)
     char *str = (char *)info->sei_buf;
     RK_S32 str_len = 0;
 
-    hal_h264e_rkv_sei_pack2str(str + H264E_UUID_LENGTH, ctx);
+    hal_h264e_sei_pack2str(str + H264E_UUID_LENGTH, ctx);
 
     str_len = strlen(str) + 1;
     if (str_len > H264E_SEI_BUF_SIZE) {

mpp/hal/rkenc/h264e/hal_h264e_rkv.h

@@ -55,9 +55,6 @@ enc_mode
 #define RKV_H264E_INT_BUS_READ_ERROR      0x00000080
 #define RKV_H264E_INT_TIMEOUT_ERROR       0x00000100
 
-#define H264E_SEI_CHG_SPSPPS        0x00000001
-#define H264E_SEI_CHG_RC            0x00000010
-
 #if RKV_H264E_SDK_TEST
 typedef struct h264e_hal_rkv_coveragetest_cfg_t {
     RK_U32 qp;

mpp/hal/vpu/h264e/hal_h264e_vpu.c

@@ -748,11 +748,63 @@ static MPP_RET hal_h264e_vpu_write_pps(h264e_hal_vpu_stream *stream, h264e_hal_p
     return MPP_OK;
 }
 
+static MPP_RET hal_h264e_vpu_write_sei(h264e_hal_vpu_stream *s, RK_U8 *payload, RK_S32 payload_size, RK_S32 payload_type)
+{
+    RK_S32 i = 0;
+
+    h264e_hal_debug_enter();
+
+    hal_h264e_vpu_nal_start(s, RKVENC_NAL_PRIORITY_DISPOSABLE, RKVENC_NAL_SEI);
+
+    for (i = 0; i <= payload_type - 255; i += 255)
+        hal_h264e_vpu_stream_put_bits_with_detect(s, 0xff, 8, "sei_payload_type_ff_byte");
+    hal_h264e_vpu_stream_put_bits_with_detect(s, payload_type - i, 8, "sei_last_payload_type_byte");
+
+    for (i = 0; i <= payload_size - 255; i += 255)
+        hal_h264e_vpu_stream_put_bits_with_detect(s, 0xff, 8, "sei_payload_size_ff_byte");
+    hal_h264e_vpu_stream_put_bits_with_detect( s, payload_size - i, 8, "sei_last_payload_size_byte");
+
+    for (i = 0; i < payload_size; i++)
+        hal_h264e_vpu_stream_put_bits_with_detect(s, (RK_U32)payload[i], 8, "sei_payload_data");
+
+    hal_h264e_vpu_rbsp_trailing_bits(s);
+
+    h264e_hal_debug_leave();
+
+    return MPP_OK;
+}
+
+
+MPP_RET hal_h264e_vpu_sei_encode(h264e_hal_context *ctx)
+{
+    h264e_hal_vpu_extra_info *info = (h264e_hal_vpu_extra_info *)ctx->extra_info;
+    h264e_hal_vpu_stream *sei_stream = &info->sei_stream;
+    char *str = (char *)info->sei_buf;
+    RK_S32 str_len = 0;
+
+    hal_h264e_sei_pack2str(str + H264E_UUID_LENGTH, ctx);
+
+    str_len = strlen(str) + 1;
+    if (str_len > H264E_SEI_BUF_SIZE) {
+        h264e_hal_log_err("SEI actual string length %d exceed malloced size %d", str_len, H264E_SEI_BUF_SIZE);
+        return MPP_NOK;
+    } else {
+        hal_h264e_vpu_write_sei(sei_stream, (RK_U8 *)str, str_len, H264E_SEI_USER_DATA_UNREGISTERED);
+    }
+
+    return MPP_OK;
+}
+
 static MPP_RET hal_h264e_vpu_init_extra_info(void *extra_info)
 {
+    static const RK_U8 h264e_sei_uuid[H264E_UUID_LENGTH] = {
+        0x63, 0xfc, 0x6a, 0x3c, 0xd8, 0x5c, 0x44, 0x1e,
+        0x87, 0xfb, 0x3f, 0xab, 0xec, 0xb3, 0xb6, 0x77
+    };
     h264e_hal_vpu_extra_info *info = (h264e_hal_vpu_extra_info *)extra_info;
     h264e_hal_vpu_stream *sps_stream = &info->sps_stream;
     h264e_hal_vpu_stream *pps_stream = &info->pps_stream;
+    h264e_hal_vpu_stream *sei_stream = &info->sei_stream;
 
     if (MPP_OK != hal_h264e_vpu_stream_buffer_init(sps_stream, 128)) {
         mpp_err("sps stream sw buf init failed");
@@ -762,6 +814,12 @@ static MPP_RET hal_h264e_vpu_init_extra_info(void *extra_info)
         mpp_err("pps stream sw buf init failed");
         return MPP_NOK;
     }
+    if (MPP_OK != hal_h264e_vpu_stream_buffer_init(sei_stream, H264E_SEI_BUF_SIZE)) {
+        mpp_err("sei stream sw buf init failed");
+        return MPP_NOK;
+    }
+    info->sei_buf = mpp_calloc_size(RK_U8, H264E_SEI_BUF_SIZE);
+    memcpy(info->sei_buf, h264e_sei_uuid, H264E_UUID_LENGTH);
 
     return MPP_OK;
 }
@@ -771,9 +829,12 @@ static MPP_RET hal_h264e_vpu_deinit_extra_info(void *extra_info)
     h264e_hal_vpu_extra_info *info = (h264e_hal_vpu_extra_info *)extra_info;
     h264e_hal_vpu_stream *sps_stream = &info->sps_stream;
     h264e_hal_vpu_stream *pps_stream = &info->pps_stream;
+    h264e_hal_vpu_stream *sei_stream = &info->sei_stream;
 
     MPP_FREE(sps_stream->buffer);
     MPP_FREE(pps_stream->buffer);
+    MPP_FREE(sei_stream->buffer);
+    MPP_FREE(info->sei_buf);
 
     return MPP_OK;
 }
@@ -797,6 +858,12 @@ static MPP_RET hal_h264e_vpu_set_extra_info(h264e_hal_context *ctx)
     hal_h264e_vpu_write_sps(sps_stream, sps);
     hal_h264e_vpu_write_pps(pps_stream, pps);
 
+    if (ctx->sei_mode == MPP_ENC_SEI_MODE_ONE_SEQ || ctx->sei_mode == MPP_ENC_SEI_MODE_ONE_FRAME) {
+        info->sei_change_flg |= H264E_SEI_CHG_SPSPPS;
+        hal_h264e_vpu_sei_encode(ctx);
+    }
+
+
     h264e_hal_debug_leave();
 
     return MPP_OK;
@@ -1538,8 +1605,6 @@ MPP_RET hal_h264e_vpu_wait(void *hal, HalTaskInfo *task)
         mpp_assert(avg_qp >= 0);
         mpp_assert(avg_qp <= 51);
 
-        mpp_log("qp sum %d avg %d\n", fb->qp_sum, avg_qp);
-
         result.bits = fb->out_strm_size * 8;
         result.type = syn->type;
         fb->result = &result;
@@ -1598,6 +1663,7 @@ MPP_RET hal_h264e_vpu_control(void *hal, RK_S32 cmd_type, void *param)
         h264e_hal_vpu_extra_info *src = (h264e_hal_vpu_extra_info *)ctx->extra_info;
         h264e_hal_vpu_stream *sps_stream = &src->sps_stream;
         h264e_hal_vpu_stream *pps_stream = &src->pps_stream;
+        h264e_hal_vpu_stream *sei_stream = &src->sei_stream;
 
         size_t offset = 0;
 
@@ -1609,6 +1675,9 @@ MPP_RET hal_h264e_vpu_control(void *hal, RK_S32 cmd_type, void *param)
         mpp_packet_write(pkt, offset, pps_stream->buffer, pps_stream->byte_cnt);
         offset += pps_stream->byte_cnt;
 
+        mpp_packet_write(pkt, offset, sei_stream->buffer, sei_stream->byte_cnt);
+        offset += sei_stream->byte_cnt;
+
         mpp_packet_set_length(pkt, offset);
 
         *pkt_out = pkt;

mpp/hal/vpu/h264e/hal_h264e_vpu.h

@@ -639,9 +639,12 @@ typedef struct h264e_hal_vpu_stream_t {
 typedef struct h264e_hal_vpu_extra_info_t {
     h264e_hal_vpu_stream sps_stream;
     h264e_hal_vpu_stream pps_stream;
+    h264e_hal_vpu_stream sei_stream;
     h264e_hal_sps sps;
     h264e_hal_pps pps;
     h264e_hal_sei sei;
+    RK_U8 *sei_buf;
+    RK_U32 sei_change_flg;
 } h264e_hal_vpu_extra_info;
 
 typedef struct h264e_vpu_reg_set_t {

test/mpi_enc_test.c

@@ -657,6 +657,7 @@ MPP_RET test_mpp_setup(MpiEncTestData *p)
     }
 
     /* optional */
+    p->sei_mode = MPP_ENC_SEI_MODE_ONE_SEQ;
     ret = mpi->control(ctx, MPP_ENC_SET_SEI_CFG, &p->sei_mode);
     if (ret) {
         mpp_err("mpi control enc set sei cfg failed ret %d\n", ret);