[hal_apil][parser_api]: use .member type to set static api

Change-Id: Ibe7b053e1571873e32c5978f82af1fdf20ff8be8
Signed-off-by: Ding Wei <leo.ding@rock-chips.com>

mpp/codec/dec/avs/avsd_api.c

@@ -327,17 +327,17 @@ MPP_RET avsd_callback(void *decoder, void *info)
 ***********************************************************************
 */
 const ParserApi api_avsd_parser = {
-    "avsd_parse",
-    MPP_VIDEO_CodingAVSPLUS,
-    sizeof(AvsdCtx_t),
-    0,
-    avsd_init,
-    avsd_deinit,
-    avsd_prepare,
-    avsd_parse,
-    avsd_reset,
-    avsd_flush,
-    avsd_control,
-    avsd_callback,
+    .name = "avsd_parse",
+    .coding = MPP_VIDEO_CodingAVSPLUS,
+    .ctx_size = sizeof(AvsdCtx_t),
+    .flag = 0,
+    .init = avsd_init,
+    .deinit = avsd_deinit,
+    .prepare = avsd_prepare,
+    .parse = avsd_parse,
+    .reset = avsd_reset,
+    .flush = avsd_flush,
+    .control = avsd_control,
+    .callback = avsd_callback,
 };
 

mpp/codec/dec/dummy/dummy_dec_api.c

@@ -295,17 +295,17 @@ MPP_RET dummy_dec_callback(void *dec, void *err_info)
     return MPP_OK;
 }
 const ParserApi dummy_dec_parser = {
-    "dummy_dec_parser",
-    MPP_VIDEO_CodingUnused,
-    sizeof(DummyDec),
-    0,
-    dummy_dec_init,
-    dummy_dec_deinit,
-    dummy_dec_prepare,
-    dummy_dec_parse,
-    dummy_dec_reset,
-    dummy_dec_flush,
-    dummy_dec_control,
-    dummy_dec_callback,
+    .name = "dummy_dec_parser",
+    .coding = MPP_VIDEO_CodingUnused,
+    .ctx_size = sizeof(DummyDec),
+    .flag = 0,
+    .init = dummy_dec_init,
+    .deinit = dummy_dec_deinit,
+    .prepare = dummy_dec_prepare,
+    .parse = dummy_dec_parse,
+    .reset = dummy_dec_reset,
+    .flush = dummy_dec_flush,
+    .control = dummy_dec_control,
+    .callback = dummy_dec_callback,
 };
 

mpp/codec/dec/h263/h263d_api.c

@@ -313,17 +313,17 @@ MPP_RET h263d_callback(void *dec, void *err_info)
 }
 
 const ParserApi api_h263d_parser = {
-    "api_h263d_parser",
-    MPP_VIDEO_CodingH263,
-    sizeof(H263dCtx),
-    0,
-    h263d_init,
-    h263d_deinit,
-    h263d_prepare,
-    h263d_parse,
-    h263d_reset,
-    h263d_flush,
-    h263d_control,
-    h263d_callback,
+    .name = "api_h263d_parser",
+    .coding = MPP_VIDEO_CodingH263,
+    .ctx_size = sizeof(H263dCtx),
+    .flag = 0,
+    .init = h263d_init,
+    .deinit = h263d_deinit,
+    .prepare = h263d_prepare,
+    .parse = h263d_parse,
+    .reset = h263d_reset,
+    .flush = h263d_flush,
+    .control = h263d_control,
+    .callback = h263d_callback,
 };
 

mpp/codec/dec/h264/h264d_api.c

@@ -710,17 +710,17 @@ __RETURN:
 */
 
 const ParserApi api_h264d_parser = {
-    "h264d_parse",
-    MPP_VIDEO_CodingAVC,
-    sizeof(H264_DecCtx_t),
-    0,
-    h264d_init,
-    h264d_deinit,
-    h264d_prepare,
-    h264d_parse,
-    h264d_reset,
-    h264d_flush,
-    h264d_control,
-    h264d_callback,
+    .name = "h264d_parse",
+    .coding = MPP_VIDEO_CodingAVC,
+    .ctx_size = sizeof(H264_DecCtx_t),
+    .flag = 0,
+    .init = h264d_init,
+    .deinit = h264d_deinit,
+    .prepare = h264d_prepare,
+    .parse = h264d_parse,
+    .reset = h264d_reset,
+    .flush = h264d_flush,
+    .control = h264d_control,
+    .callback = h264d_callback,
 };
 

mpp/codec/dec/h265/h265d_parser.c

@@ -2044,18 +2044,18 @@ MPP_RET h265d_callback(void *ctx, void *err_info)
 
 
 const ParserApi api_h265d_parser = {
-    "h265d_parse",
-    MPP_VIDEO_CodingHEVC,
-    sizeof(H265dContext_t),
-    0,
-    h265d_init,
-    h265d_deinit,
-    h265d_prepare,
-    h265d_parse,
-    h265d_reset,
-    h265d_flush,
-    h265d_control,
-    h265d_callback,
+    .name = "h265d_parse",
+    .coding = MPP_VIDEO_CodingHEVC,
+    .ctx_size = sizeof(H265dContext_t),
+    .flag = 0,
+    .init = h265d_init,
+    .deinit = h265d_deinit,
+    .prepare = h265d_prepare,
+    .parse = h265d_parse,
+    .reset = h265d_reset,
+    .flush = h265d_flush,
+    .control = h265d_control,
+    .callback = h265d_callback,
 };
 
 

mpp/codec/dec/m2v/m2vd_api.c

@@ -28,18 +28,18 @@
 #include "m2vd_codec.h"
 
 const ParserApi api_m2vd_parser = {
-    "m2vd_parse",
-    MPP_VIDEO_CodingMPEG2,
-    sizeof(M2VDContext),
-    0,
-    m2vd_parser_init,
-    m2vd_parser_deinit,
-    m2vd_parser_prepare,
-    m2vd_parser_parse,
-    m2vd_parser_reset,
-    m2vd_parser_flush,
-    m2vd_parser_control,
-    m2vd_parser_callback,
+    .name = "m2vd_parse",
+    .coding = MPP_VIDEO_CodingMPEG2,
+    .ctx_size = sizeof(M2VDContext),
+    .flag = 0,
+    .init = m2vd_parser_init,
+    .deinit = m2vd_parser_deinit,
+    .prepare = m2vd_parser_prepare,
+    .parse = m2vd_parser_parse,
+    .reset = m2vd_parser_reset,
+    .flush = m2vd_parser_flush,
+    .control = m2vd_parser_control,
+    .callback = m2vd_parser_callback,
 };
 
 

mpp/codec/dec/vp9/vp9d_api.c

@@ -231,17 +231,17 @@ MPP_RET vp9d_callback(void *decoder, void *info)
 */
 
 const ParserApi api_vp9d_parser = {
-    "vp9d_parse",
-    MPP_VIDEO_CodingVP9,
-    sizeof(Vp9CodecContext),
-    0,
-    vp9d_init,
-    vp9d_deinit,
-    vp9d_prepare,
-    vp9d_parse,
-    vp9d_reset,
-    vp9d_flush,
-    vp9d_control,
-    vp9d_callback,
+    .name = "vp9d_parse",
+    .coding = MPP_VIDEO_CodingVP9,
+    .ctx_size = sizeof(Vp9CodecContext),
+    .flag = 0,
+    .init = vp9d_init,
+    .deinit = vp9d_deinit,
+    .prepare = vp9d_prepare,
+    .parse = vp9d_parse,
+    .reset = vp9d_reset,
+    .flush = vp9d_flush,
+    .control = vp9d_control,
+    .callback = vp9d_callback,
 };
 

mpp/hal/common/h264/hal_h264e_api.c

@@ -194,19 +194,19 @@ MPP_RET hal_h264e_control(void *hal, RK_S32 cmd_type, void *param)
 
 
 const MppHalApi hal_api_h264e = {
-    "h264e_rkvenc",
-    MPP_CTX_ENC,
-    MPP_VIDEO_CodingAVC,
-    sizeof(H264eHalContext),
-    0,
-    hal_h264e_init,
-    hal_h264e_deinit,
-    hal_h264e_gen_regs,
-    hal_h264e_start,
-    hal_h264e_wait,
-    hal_h264e_reset,
-    hal_h264e_flush,
-    hal_h264e_control,
+    .name = "h264e_rkvenc",
+    .type = MPP_CTX_ENC,
+    .coding = MPP_VIDEO_CodingAVC,
+    .ctx_size = sizeof(H264eHalContext),
+    .flag = 0,
+    .init = hal_h264e_init,
+    .deinit = hal_h264e_deinit,
+    .reg_gen = hal_h264e_gen_regs,
+    .start = hal_h264e_start,
+    .wait = hal_h264e_wait,
+    .reset = hal_h264e_reset,
+    .flush = hal_h264e_flush,
+    .control = hal_h264e_control,
 };
 
 

mpp/hal/dummy/hal_dummy_dec_api.c

@@ -74,18 +74,18 @@ MPP_RET hal_dummy_dec_control(void *hal, RK_S32 cmd_type, void *param)
 }
 
 const MppHalApi hal_api_dummy_dec = {
-    "dummy_hw_dec",
-    MPP_CTX_DEC,
-    MPP_VIDEO_CodingUnused,
-    0,
-    0,
-    hal_dummy_dec_init,
-    hal_dummy_dec_deinit,
-    hal_dummy_dec_gen_regs,
-    hal_dummy_dec_start,
-    hal_dummy_dec_wait,
-    hal_dummy_dec_reset,
-    hal_dummy_dec_flush,
-    hal_dummy_dec_control,
+    .name = "dummy_hw_dec",
+    .type = MPP_CTX_DEC,
+    .coding = MPP_VIDEO_CodingUnused,
+    .ctx_size = 0,
+    .flag = 0,
+    .init = hal_dummy_dec_init,
+    .deinit = hal_dummy_dec_deinit,
+    .reg_gen = hal_dummy_dec_gen_regs,
+    .start = hal_dummy_dec_start,
+    .wait = hal_dummy_dec_wait,
+    .reset = hal_dummy_dec_reset,
+    .flush = hal_dummy_dec_flush,
+    .control = hal_dummy_dec_control,
 };
 

mpp/hal/dummy/hal_dummy_enc_api.c

@@ -74,18 +74,19 @@ MPP_RET hal_dummy_enc_control(void *hal, RK_S32 cmd_type, void *param)
 }
 
 const MppHalApi hal_api_dummy_enc = {
-    "dummy_hw_enc",
-    MPP_CTX_ENC,
-    MPP_VIDEO_CodingUnused,
-    0,
-    0,
-    hal_dummy_enc_init,
-    hal_dummy_enc_deinit,
-    hal_dummy_enc_gen_regs,
-    hal_dummy_enc_start,
-    hal_dummy_enc_wait,
-    hal_dummy_enc_reset,
-    hal_dummy_enc_flush,
-    hal_dummy_enc_control,
+    .name = "dummy_hw_enc",
+    .type = MPP_CTX_ENC,
+    .coding = MPP_VIDEO_CodingUnused,
+    .ctx_size = 0,
+    .flag = 0,
+    .init = hal_dummy_enc_init,
+    .deinit = hal_dummy_enc_deinit,
+    .reg_gen = hal_dummy_enc_gen_regs,
+    .start = hal_dummy_enc_start,
+    .wait = hal_dummy_enc_wait,
+    .reset = hal_dummy_enc_reset,
+    .flush = hal_dummy_enc_flush,
+    .control = hal_dummy_enc_control,
 };
 
+

mpp/hal/rkdec/avsd/hal_avsd_api.c

@@ -374,18 +374,19 @@ MPP_RET hal_avsd_control(void *decoder, RK_S32 cmd_type, void *param)
 
 
 const MppHalApi hal_api_avsd = {
-    "avsd_rkdec",
-    MPP_CTX_DEC,
-    MPP_VIDEO_CodingAVSPLUS,
-    sizeof(AvsdHalCtx_t),
-    0,
-    hal_avsd_init,
-    hal_avsd_deinit,
-    hal_avsd_gen_regs,
-    hal_avsd_start,
-    hal_avsd_wait,
-    hal_avsd_reset,
-    hal_avsd_flush,
-    hal_avsd_control,
+    .name = "avsd_rkdec",
+    .type = MPP_CTX_DEC,
+    .coding = MPP_VIDEO_CodingAVSPLUS,
+    .ctx_size = sizeof(AvsdHalCtx_t),
+    .flag = 0,
+    .init = hal_avsd_init,
+    .deinit = hal_avsd_deinit,
+    .reg_gen = hal_avsd_gen_regs,
+    .start = hal_avsd_start,
+    .wait = hal_avsd_wait,
+    .reset = hal_avsd_reset,
+    .flush = hal_avsd_flush,
+    .control = hal_avsd_control,
 };
 
+

mpp/hal/rkdec/vp9d/hal_vp9d_api.c

@@ -991,18 +991,18 @@ MPP_RET hal_vp9d_control(void *hal, RK_S32 cmd_type, void *param)
 
 
 const MppHalApi hal_api_vp9d = {
-    "vp9d_rkdec",
-    MPP_CTX_DEC,
-    MPP_VIDEO_CodingVP9,
-    sizeof(hal_vp9_context_t),
-    0,
-    hal_vp9d_init,
-    hal_vp9d_deinit,
-    hal_vp9d_gen_regs,
-    hal_vp9d_start,
-    hal_vp9d_wait,
-    hal_vp9d_reset,
-    hal_vp9d_flush,
-    hal_vp9d_control,
+    .name = "vp9d_rkdec",
+    .type = MPP_CTX_DEC,
+    .coding = MPP_VIDEO_CodingVP9,
+    .ctx_size = sizeof(hal_vp9_context_t),
+    .flag = 0,
+    .init = hal_vp9d_init,
+    .deinit = hal_vp9d_deinit,
+    .reg_gen = hal_vp9d_gen_regs,
+    .start = hal_vp9d_start,
+    .wait = hal_vp9d_wait,
+    .reset = hal_vp9d_reset,
+    .flush = hal_vp9d_flush,
+    .control = hal_vp9d_control,
 };
 

mpp/hal/vpu/h263d/hal_h263d_reg.c

@@ -337,18 +337,19 @@ MPP_RET hal_vpu_h263d_control(void *hal, RK_S32 cmd_type, void *param)
 }
 
 const MppHalApi hal_api_h263d = {
-    "h263d_vpu",
-    MPP_CTX_DEC,
-    MPP_VIDEO_CodingH263,
-    sizeof(hal_h263_ctx),
-    0,
-    hal_vpu_h263d_init,
-    hal_vpu_h263d_deinit,
-    hal_vpu_h263d_gen_regs,
-    hal_vpu_h263d_start,
-    hal_vpu_h263d_wait,
-    hal_vpu_h263d_reset,
-    hal_vpu_h263d_flush,
-    hal_vpu_h263d_control,
+    .name = "h263d_vpu",
+    .type = MPP_CTX_DEC,
+    .coding = MPP_VIDEO_CodingH263,
+    .ctx_size = sizeof(hal_h263_ctx),
+    .flag = 0,
+    .init = hal_vpu_h263d_init,
+    .deinit = hal_vpu_h263d_deinit,
+    .reg_gen = hal_vpu_h263d_gen_regs,
+    .start = hal_vpu_h263d_start,
+    .wait = hal_vpu_h263d_wait,
+    .reset = hal_vpu_h263d_reset,
+    .flush = hal_vpu_h263d_flush,
+    .control = hal_vpu_h263d_control,
 };
 
+

mpp/hal/vpu/m2vd/hal_m2vd_api.c

@@ -22,22 +22,18 @@
 #include "hal_m2vd_reg.h"
 
 const MppHalApi hal_api_m2vd = {
-    "m2vd_rkdec",
-    MPP_CTX_DEC,
-    MPP_VIDEO_CodingMPEG2,
-    sizeof(M2VDHalContext),
-    0,
-    hal_m2vd_init,
-    hal_m2vd_deinit,
-    hal_m2vd_gen_regs,
-    hal_m2vd_start,
-    hal_m2vd_wait,
-    hal_m2vd_reset,
-    hal_m2vd_flush,
-    hal_m2vd_control,
+    .name = "m2vd_rkdec",
+    .type = MPP_CTX_DEC,
+    .coding = MPP_VIDEO_CodingMPEG2,
+    .ctx_size = sizeof(M2VDHalContext),
+    .flag = 0,
+    .init = hal_m2vd_init,
+    .deinit = hal_m2vd_deinit,
+    .reg_gen = hal_m2vd_gen_regs,
+    .start = hal_m2vd_start,
+    .wait = hal_m2vd_wait,
+    .reset = hal_m2vd_reset,
+    .flush = hal_m2vd_flush,
+    .control = hal_m2vd_control,
 };
 
-
-
-
-

mpp/hal/vpu/mpg4d/hal_m4vd_api.c

@@ -198,17 +198,19 @@ MPP_RET hal_vpu_mpg4d_control(void *hal, RK_S32 cmd_type, void *param)
 }
 
 const MppHalApi hal_api_mpg4d = {
-    "mpg4d_vpu",
-    MPP_CTX_DEC,
-    MPP_VIDEO_CodingMPEG4,
-    sizeof(hal_mpg4_ctx),
-    0,
-    hal_vpu_mpg4d_init,
-    hal_vpu_mpg4d_deinit,
-    hal_vpu_mpg4d_gen_regs,
-    hal_vpu_mpg4d_start,
-    hal_vpu_mpg4d_wait,
-    hal_vpu_mpg4d_reset,
-    hal_vpu_mpg4d_flush,
-    hal_vpu_mpg4d_control,
+    .name = "mpg4d_vpu",
+    .type = MPP_CTX_DEC,
+    .coding = MPP_VIDEO_CodingMPEG4,
+    .ctx_size = sizeof(hal_mpg4_ctx),
+    .flag = 0,
+    .init = hal_vpu_mpg4d_init,
+    .deinit = hal_vpu_mpg4d_deinit,
+    .reg_gen = hal_vpu_mpg4d_gen_regs,
+    .start = hal_vpu_mpg4d_start,
+    .wait = hal_vpu_mpg4d_wait,
+    .reset = hal_vpu_mpg4d_reset,
+    .flush = hal_vpu_mpg4d_flush,
+    .control = hal_vpu_mpg4d_control,
 };
+
+