diff --git a/driver/vidc/inc/msm_vidc_core.h b/driver/vidc/inc/msm_vidc_core.h index 79d44c872e..5c0e682aff 100644 --- a/driver/vidc/inc/msm_vidc_core.h +++ b/driver/vidc/inc/msm_vidc_core.h @@ -17,6 +17,12 @@ struct msm_vidc_core; #define MAX_EVENTS 30 +#define FOREACH_CORE_STATE(CORE_STATE) { \ + CORE_STATE(CORE_DEINIT) \ + CORE_STATE(CORE_INIT_WAIT) \ + CORE_STATE(CORE_INIT) \ +} + #define call_venus_op(d, op, ...) \ (((d) && (d)->venus_ops && (d)->venus_ops->op) ? \ ((d)->venus_ops->op(__VA_ARGS__)):0) @@ -57,11 +63,7 @@ struct msm_vidc_core_power { u64 bw_llcc; }; -enum msm_vidc_core_state { - MSM_VIDC_CORE_DEINIT = 0, - MSM_VIDC_CORE_INIT_WAIT = 1, - MSM_VIDC_CORE_INIT = 2, -}; +enum msm_vidc_core_state FOREACH_CORE_STATE(GENERATE_MSM_VIDC_ENUM); struct msm_vidc_core { struct platform_device *pdev; diff --git a/driver/vidc/inc/msm_vidc_inst.h b/driver/vidc/inc/msm_vidc_inst.h index 9da4473236..6196871220 100644 --- a/driver/vidc/inc/msm_vidc_inst.h +++ b/driver/vidc/inc/msm_vidc_inst.h @@ -13,6 +13,16 @@ struct msm_vidc_inst; +#define FOREACH_STATE(STATE) { \ + STATE(NONE) \ + STATE(OPEN) \ + STATE(INPUT_STREAMING) \ + STATE(OUTPUT_STREAMING) \ + STATE(STREAMING) \ + STATE(CLOSE) \ + STATE(ERROR) \ +} + #define call_session_op(c, op, ...) \ (((c) && (c)->session_ops && (c)->session_ops->op) ? \ ((c)->session_ops->op(__VA_ARGS__)) : 0) @@ -70,14 +80,7 @@ struct msm_vidc_buffers_info { struct msm_vidc_buffers partial_data; }; -enum msm_vidc_state { - MSM_VIDC_OPEN = 1, - MSM_VIDC_INPUT_STREAMING = 2, - MSM_VIDC_OUTPUT_STREAMING = 3, - MSM_VIDC_STREAMING = 4, - MSM_VIDC_CLOSE = 5, - MSM_VIDC_ERROR = 6, -}; +enum msm_vidc_state FOREACH_STATE(GENERATE_MSM_VIDC_ENUM); #define MSM_VIDC_SUB_STATE_NONE 0 #define MSM_VIDC_MAX_SUB_STATES 6 diff --git a/driver/vidc/inc/msm_vidc_internal.h b/driver/vidc/inc/msm_vidc_internal.h index 26ef886aa6..5fe78f407b 100644 --- a/driver/vidc/inc/msm_vidc_internal.h +++ b/driver/vidc/inc/msm_vidc_internal.h @@ -173,6 +173,230 @@ enum msm_vidc_metadata_bits { #define MAX_DPB_LIST_ARRAY_SIZE (16 * 4) #define MAX_DPB_LIST_PAYLOAD_SIZE (16 * 4 * 4) +#define GENERATE_ENUM(ENUM) ENUM, +#define GENERATE_STRING(STRING) (#STRING), + +/* append MSM_VIDC_ to prepare enum */ +#define GENERATE_MSM_VIDC_ENUM(ENUM) MSM_VIDC_##ENUM, + +/* append MSM_VIDC_BUF_ to prepare enum */ +#define GENERATE_MSM_VIDC_BUF_ENUM(ENUM) MSM_VIDC_BUF_##ENUM, + +/** + * msm_vidc_prepare_dependency_list() api will prepare caps_list by looping over + * enums(msm_vidc_inst_capability_type) from 0 to INST_CAP_MAX and arranges the + * node in such a way that parents willbe at the front and dependent children + * in the back. + * + * caps_list preparation may become CPU intensive task, so to save CPU cycles, + * organize enum in proper order(root caps at the beginning and dependent caps + * at back), so that during caps_list preparation num CPU cycles spent will reduce. + * + * Note: It will work, if enum kept at different places, but not efficient. + * + * - place all metadata cap(META_*) af the front. + * - place all root(no parent) enums before PROFILE cap. + * - place all intermittent(having both parent and child) enums before MIN_FRAME_QP cap. + * - place all leaf(no child) enums before INST_CAP_MAX cap. + */ +#define FOREACH_CAP(CAP) { \ + CAP(INST_CAP_NONE) \ + CAP(META_SEQ_HDR_NAL) \ + CAP(META_BITSTREAM_RESOLUTION) \ + CAP(META_CROP_OFFSETS) \ + CAP(META_DPB_MISR) \ + CAP(META_OPB_MISR) \ + CAP(META_INTERLACE) \ + CAP(META_OUTBUF_FENCE) \ + CAP(META_LTR_MARK_USE) \ + CAP(META_TIMESTAMP) \ + CAP(META_CONCEALED_MB_CNT) \ + CAP(META_HIST_INFO) \ + CAP(META_PICTURE_TYPE) \ + CAP(META_SEI_MASTERING_DISP) \ + CAP(META_SEI_CLL) \ + CAP(META_HDR10PLUS) \ + CAP(META_BUF_TAG) \ + CAP(META_DPB_TAG_LIST) \ + CAP(META_SUBFRAME_OUTPUT) \ + CAP(META_ENC_QP_METADATA) \ + CAP(META_DEC_QP_METADATA) \ + CAP(META_MAX_NUM_REORDER_FRAMES) \ + CAP(META_EVA_STATS) \ + CAP(META_ROI_INFO) \ + CAP(META_SALIENCY_INFO) \ + CAP(META_TRANSCODING_STAT_INFO) \ + CAP(META_DOLBY_RPU) \ + CAP(FRAME_WIDTH) \ + CAP(LOSSLESS_FRAME_WIDTH) \ + CAP(SECURE_FRAME_WIDTH) \ + CAP(FRAME_HEIGHT) \ + CAP(LOSSLESS_FRAME_HEIGHT) \ + CAP(SECURE_FRAME_HEIGHT) \ + CAP(PIX_FMTS) \ + CAP(MIN_BUFFERS_INPUT) \ + CAP(MIN_BUFFERS_OUTPUT) \ + CAP(MBPF) \ + CAP(BATCH_MBPF) \ + CAP(BATCH_FPS) \ + CAP(LOSSLESS_MBPF) \ + CAP(SECURE_MBPF) \ + CAP(FRAME_RATE) \ + CAP(OPERATING_RATE) \ + CAP(INPUT_RATE) \ + CAP(TIMESTAMP_RATE) \ + CAP(SCALE_FACTOR) \ + CAP(MB_CYCLES_VSP) \ + CAP(MB_CYCLES_VPP) \ + CAP(MB_CYCLES_LP) \ + CAP(MB_CYCLES_FW) \ + CAP(MB_CYCLES_FW_VPP) \ + CAP(CLIENT_ID) \ + CAP(SECURE_MODE) \ + CAP(FENCE_ID) \ + CAP(FENCE_FD) \ + CAP(TS_REORDER) \ + CAP(HFLIP) \ + CAP(VFLIP) \ + CAP(ROTATION) \ + CAP(SUPER_FRAME) \ + CAP(HEADER_MODE) \ + CAP(PREPEND_SPSPPS_TO_IDR) \ + CAP(WITHOUT_STARTCODE) \ + CAP(NAL_LENGTH_FIELD) \ + CAP(REQUEST_I_FRAME) \ + CAP(BITRATE_MODE) \ + CAP(LOSSLESS) \ + CAP(FRAME_SKIP_MODE) \ + CAP(FRAME_RC_ENABLE) \ + CAP(GOP_CLOSURE) \ + CAP(CSC) \ + CAP(CSC_CUSTOM_MATRIX) \ + CAP(USE_LTR) \ + CAP(MARK_LTR) \ + CAP(BASELAYER_PRIORITY) \ + CAP(IR_TYPE) \ + CAP(AU_DELIMITER) \ + CAP(GRID) \ + CAP(I_FRAME_MIN_QP) \ + CAP(P_FRAME_MIN_QP) \ + CAP(B_FRAME_MIN_QP) \ + CAP(I_FRAME_MAX_QP) \ + CAP(P_FRAME_MAX_QP) \ + CAP(B_FRAME_MAX_QP) \ + CAP(LAYER_TYPE) \ + CAP(LAYER_ENABLE) \ + CAP(L0_BR) \ + CAP(L1_BR) \ + CAP(L2_BR) \ + CAP(L3_BR) \ + CAP(L4_BR) \ + CAP(L5_BR) \ + CAP(LEVEL) \ + CAP(HEVC_TIER) \ + CAP(AV1_TIER) \ + CAP(DISPLAY_DELAY_ENABLE) \ + CAP(DISPLAY_DELAY) \ + CAP(CONCEAL_COLOR_8BIT) \ + CAP(CONCEAL_COLOR_10BIT) \ + CAP(LF_MODE) \ + CAP(LF_ALPHA) \ + CAP(LF_BETA) \ + CAP(SLICE_MAX_BYTES) \ + CAP(SLICE_MAX_MB) \ + CAP(MB_RC) \ + CAP(CHROMA_QP_INDEX_OFFSET) \ + CAP(PIPE) \ + CAP(POC) \ + CAP(CODED_FRAMES) \ + CAP(BIT_DEPTH) \ + CAP(CODEC_CONFIG) \ + CAP(BITSTREAM_SIZE_OVERWRITE) \ + CAP(THUMBNAIL_MODE) \ + CAP(DEFAULT_HEADER) \ + CAP(RAP_FRAME) \ + CAP(SEQ_CHANGE_AT_SYNC_FRAME) \ + CAP(QUALITY_MODE) \ + CAP(PRIORITY) \ + CAP(FIRMWARE_PRIORITY_OFFSET) \ + CAP(CRITICAL_PRIORITY) \ + CAP(RESERVE_DURATION) \ + CAP(DPB_LIST) \ + CAP(FILM_GRAIN) \ + CAP(SUPER_BLOCK) \ + CAP(DRAP) \ + CAP(ENC_IP_CR) \ + CAP(COMPLEXITY) \ + CAP(CABAC_MAX_BITRATE) \ + CAP(CAVLC_MAX_BITRATE) \ + CAP(ALLINTRA_MAX_BITRATE) \ + CAP(LOWLATENCY_MAX_BITRATE) \ + CAP(LAST_FLAG_EVENT_ENABLE) \ + CAP(NUM_COMV) \ + CAP(PROFILE) \ + CAP(ENH_LAYER_COUNT) \ + CAP(BIT_RATE) \ + CAP(LOWLATENCY_MODE) \ + CAP(GOP_SIZE) \ + CAP(B_FRAME) \ + CAP(ALL_INTRA) \ + CAP(MIN_QUALITY) \ + CAP(CONTENT_ADAPTIVE_CODING) \ + CAP(BLUR_TYPES) \ + CAP(REQUEST_PREPROCESS) \ + CAP(SLICE_MODE) \ + CAP(MIN_FRAME_QP) \ + CAP(MAX_FRAME_QP) \ + CAP(I_FRAME_QP) \ + CAP(P_FRAME_QP) \ + CAP(B_FRAME_QP) \ + CAP(TIME_DELTA_BASED_RC) \ + CAP(CONSTANT_QUALITY) \ + CAP(VBV_DELAY) \ + CAP(PEAK_BITRATE) \ + CAP(ENTROPY_MODE) \ + CAP(TRANSFORM_8X8) \ + CAP(STAGE) \ + CAP(LTR_COUNT) \ + CAP(IR_PERIOD) \ + CAP(BITRATE_BOOST) \ + CAP(BLUR_RESOLUTION) \ + CAP(OUTPUT_ORDER) \ + CAP(INPUT_BUF_HOST_MAX_COUNT) \ + CAP(OUTPUT_BUF_HOST_MAX_COUNT) \ + CAP(DELIVERY_MODE) \ + CAP(VUI_TIMING_INFO) \ + CAP(SLICE_DECODE) \ + CAP(INST_CAP_MAX) \ +} + +#define FOREACH_BUF_TYPE(BUF_TYPE) { \ + BUF_TYPE(NONE) \ + BUF_TYPE(INPUT) \ + BUF_TYPE(OUTPUT) \ + BUF_TYPE(INPUT_META) \ + BUF_TYPE(OUTPUT_META) \ + BUF_TYPE(READ_ONLY) \ + BUF_TYPE(QUEUE) \ + BUF_TYPE(BIN) \ + BUF_TYPE(ARP) \ + BUF_TYPE(COMV) \ + BUF_TYPE(NON_COMV) \ + BUF_TYPE(LINE) \ + BUF_TYPE(DPB) \ + BUF_TYPE(PERSIST) \ + BUF_TYPE(VPSS) \ + BUF_TYPE(PARTIAL_DATA) \ +} + +#define FOREACH_ALLOW(ALLOW) { \ + ALLOW(MSM_VIDC_DISALLOW) \ + ALLOW(MSM_VIDC_ALLOW) \ + ALLOW(MSM_VIDC_DEFER) \ + ALLOW(MSM_VIDC_DISCARD) \ + ALLOW(MSM_VIDC_IGNORE) \ +} + enum msm_vidc_domain_type { MSM_VIDC_ENCODER = BIT(0), MSM_VIDC_DECODER = BIT(1), @@ -198,23 +422,7 @@ enum msm_vidc_colorformat_type { MSM_VIDC_FMT_META = BIT(31), }; -enum msm_vidc_buffer_type { - MSM_VIDC_BUF_INPUT = 1, - MSM_VIDC_BUF_OUTPUT = 2, - MSM_VIDC_BUF_INPUT_META = 3, - MSM_VIDC_BUF_OUTPUT_META = 4, - MSM_VIDC_BUF_READ_ONLY = 5, - MSM_VIDC_BUF_QUEUE = 6, - MSM_VIDC_BUF_BIN = 7, - MSM_VIDC_BUF_ARP = 8, - MSM_VIDC_BUF_COMV = 9, - MSM_VIDC_BUF_NON_COMV = 10, - MSM_VIDC_BUF_LINE = 11, - MSM_VIDC_BUF_DPB = 12, - MSM_VIDC_BUF_PERSIST = 13, - MSM_VIDC_BUF_VPSS = 14, - MSM_VIDC_BUF_PARTIAL_DATA = 15, -}; +enum msm_vidc_buffer_type FOREACH_BUF_TYPE(GENERATE_MSM_VIDC_BUF_ENUM); /* always match with v4l2 flags V4L2_BUF_FLAG_* */ enum msm_vidc_buffer_flags { @@ -381,196 +589,7 @@ enum msm_vidc_core_capability_type { CORE_CAP_MAX, }; -/** - * msm_vidc_prepare_dependency_list() api will prepare caps_list by looping over - * enums(msm_vidc_inst_capability_type) from 0 to INST_CAP_MAX and arranges the - * node in such a way that parents willbe at the front and dependent children - * in the back. - * - * caps_list preparation may become CPU intensive task, so to save CPU cycles, - * organize enum in proper order(root caps at the beginning and dependent caps - * at back), so that during caps_list preparation num CPU cycles spent will reduce. - * - * Note: It will work, if enum kept at different places, but not efficient. - */ -enum msm_vidc_inst_capability_type { - INST_CAP_NONE = 0, - /* place all metadata after this line - */ - META_SEQ_HDR_NAL, - META_BITSTREAM_RESOLUTION, - META_CROP_OFFSETS, - META_DPB_MISR, - META_OPB_MISR, - META_INTERLACE, - META_OUTBUF_FENCE, - META_LTR_MARK_USE, - META_TIMESTAMP, - META_CONCEALED_MB_CNT, - META_HIST_INFO, - META_PICTURE_TYPE, - META_SEI_MASTERING_DISP, - META_SEI_CLL, - META_HDR10PLUS, - META_BUF_TAG, - META_DPB_TAG_LIST, - META_SUBFRAME_OUTPUT, - META_ENC_QP_METADATA, - META_DEC_QP_METADATA, - META_MAX_NUM_REORDER_FRAMES, - META_EVA_STATS, - META_ROI_INFO, - META_SALIENCY_INFO, - META_TRANSCODING_STAT_INFO, - META_DOLBY_RPU, - /* end of metadata caps */ - FRAME_WIDTH, - LOSSLESS_FRAME_WIDTH, - SECURE_FRAME_WIDTH, - FRAME_HEIGHT, - LOSSLESS_FRAME_HEIGHT, - SECURE_FRAME_HEIGHT, - PIX_FMTS, - MIN_BUFFERS_INPUT, - MIN_BUFFERS_OUTPUT, - MBPF, - BATCH_MBPF, - BATCH_FPS, - LOSSLESS_MBPF, - SECURE_MBPF, - FRAME_RATE, - OPERATING_RATE, - INPUT_RATE, - TIMESTAMP_RATE, - SCALE_FACTOR, - MB_CYCLES_VSP, - MB_CYCLES_VPP, - MB_CYCLES_LP, - MB_CYCLES_FW, - MB_CYCLES_FW_VPP, - CLIENT_ID, - SECURE_MODE, - FENCE_ID, - FENCE_FD, - TS_REORDER, - HFLIP, - VFLIP, - ROTATION, - SUPER_FRAME, - HEADER_MODE, - PREPEND_SPSPPS_TO_IDR, - WITHOUT_STARTCODE, - NAL_LENGTH_FIELD, - REQUEST_I_FRAME, - BITRATE_MODE, - LOSSLESS, - FRAME_SKIP_MODE, - FRAME_RC_ENABLE, - GOP_CLOSURE, - CSC, - CSC_CUSTOM_MATRIX, - USE_LTR, - MARK_LTR, - BASELAYER_PRIORITY, - IR_TYPE, - AU_DELIMITER, - GRID, - I_FRAME_MIN_QP, - P_FRAME_MIN_QP, - B_FRAME_MIN_QP, - I_FRAME_MAX_QP, - P_FRAME_MAX_QP, - B_FRAME_MAX_QP, - LAYER_TYPE, - LAYER_ENABLE, - L0_BR, - L1_BR, - L2_BR, - L3_BR, - L4_BR, - L5_BR, - LEVEL, - HEVC_TIER, - AV1_TIER, - DISPLAY_DELAY_ENABLE, - DISPLAY_DELAY, - CONCEAL_COLOR_8BIT, - CONCEAL_COLOR_10BIT, - LF_MODE, - LF_ALPHA, - LF_BETA, - SLICE_MAX_BYTES, - SLICE_MAX_MB, - MB_RC, - CHROMA_QP_INDEX_OFFSET, - PIPE, - POC, - CODED_FRAMES, - BIT_DEPTH, - CODEC_CONFIG, - BITSTREAM_SIZE_OVERWRITE, - THUMBNAIL_MODE, - DEFAULT_HEADER, - RAP_FRAME, - SEQ_CHANGE_AT_SYNC_FRAME, - QUALITY_MODE, - PRIORITY, - FIRMWARE_PRIORITY_OFFSET, - CRITICAL_PRIORITY, - RESERVE_DURATION, - DPB_LIST, - FILM_GRAIN, - SUPER_BLOCK, - DRAP, - ENC_IP_CR, - COMPLEXITY, - CABAC_MAX_BITRATE, - CAVLC_MAX_BITRATE, - ALLINTRA_MAX_BITRATE, - LOWLATENCY_MAX_BITRATE, - LAST_FLAG_EVENT_ENABLE, - NUM_COMV, - /* place all root(no parent) enums before this line */ - - PROFILE, - ENH_LAYER_COUNT, - BIT_RATE, - LOWLATENCY_MODE, - GOP_SIZE, - B_FRAME, - ALL_INTRA, - MIN_QUALITY, - CONTENT_ADAPTIVE_CODING, - BLUR_TYPES, - REQUEST_PREPROCESS, - SLICE_MODE, - /* place all intermittent(having both parent and child) enums before this line */ - - MIN_FRAME_QP, - MAX_FRAME_QP, - I_FRAME_QP, - P_FRAME_QP, - B_FRAME_QP, - TIME_DELTA_BASED_RC, - CONSTANT_QUALITY, - VBV_DELAY, - PEAK_BITRATE, - ENTROPY_MODE, - TRANSFORM_8X8, - STAGE, - LTR_COUNT, - IR_PERIOD, - BITRATE_BOOST, - BLUR_RESOLUTION, - OUTPUT_ORDER, - INPUT_BUF_HOST_MAX_COUNT, - OUTPUT_BUF_HOST_MAX_COUNT, - DELIVERY_MODE, - VUI_TIMING_INFO, - SLICE_DECODE, - /* place all leaf(no child) enums before this line */ - INST_CAP_MAX, -}; +enum msm_vidc_inst_capability_type FOREACH_CAP(GENERATE_ENUM); enum msm_vidc_inst_capability_flags { CAP_FLAG_NONE = 0, @@ -927,13 +946,7 @@ struct msm_vidc_input_timer { u64 time_us; }; -enum msm_vidc_allow { - MSM_VIDC_DISALLOW = 0, - MSM_VIDC_ALLOW, - MSM_VIDC_DEFER, - MSM_VIDC_DISCARD, - MSM_VIDC_IGNORE, -}; +enum msm_vidc_allow FOREACH_ALLOW(GENERATE_ENUM); struct msm_vidc_ssr { bool trigger; diff --git a/driver/vidc/src/msm_vidc_driver.c b/driver/vidc/src/msm_vidc_driver.c index 8283fb0f8a..01761be851 100644 --- a/driver/vidc/src/msm_vidc_driver.c +++ b/driver/vidc/src/msm_vidc_driver.c @@ -50,293 +50,67 @@ extern struct msm_vidc_core *g_core; #define STABILITY_PAYLOAD_ID 0xFFFFFFFF00000000 #define STABILITY_PAYLOAD_SHIFT 32 -struct msm_vidc_cap_name { - enum msm_vidc_inst_capability_type cap_id; - char *name; -}; - /* do not modify the cap names as it is used in test scripts */ -static const struct msm_vidc_cap_name cap_name_arr[] = { - {INST_CAP_NONE, "INST_CAP_NONE" }, - {META_SEQ_HDR_NAL, "META_SEQ_HDR_NAL" }, - {META_BITSTREAM_RESOLUTION, "META_BITSTREAM_RESOLUTION" }, - {META_CROP_OFFSETS, "META_CROP_OFFSETS" }, - {META_DPB_MISR, "META_DPB_MISR" }, - {META_OPB_MISR, "META_OPB_MISR" }, - {META_INTERLACE, "META_INTERLACE" }, - {META_OUTBUF_FENCE, "META_OUTBUF_FENCE" }, - {META_LTR_MARK_USE, "META_LTR_MARK_USE" }, - {META_TIMESTAMP, "META_TIMESTAMP" }, - {META_CONCEALED_MB_CNT, "META_CONCEALED_MB_CNT" }, - {META_HIST_INFO, "META_HIST_INFO" }, - {META_PICTURE_TYPE, "META_PICTURE_TYPE" }, - {META_SEI_MASTERING_DISP, "META_SEI_MASTERING_DISP" }, - {META_SEI_CLL, "META_SEI_CLL" }, - {META_HDR10PLUS, "META_HDR10PLUS" }, - {META_BUF_TAG, "META_BUF_TAG" }, - {META_DPB_TAG_LIST, "META_DPB_TAG_LIST" }, - {META_SUBFRAME_OUTPUT, "META_SUBFRAME_OUTPUT" }, - {META_ENC_QP_METADATA, "META_ENC_QP_METADATA" }, - {META_DEC_QP_METADATA, "META_DEC_QP_METADATA" }, - {META_MAX_NUM_REORDER_FRAMES, "META_MAX_NUM_REORDER_FRAMES"}, - {META_EVA_STATS, "META_EVA_STATS" }, - {META_ROI_INFO, "META_ROI_INFO" }, - {META_SALIENCY_INFO, "META_SALIENCY_INFO" }, - {META_TRANSCODING_STAT_INFO, "META_TRANSCODING_STAT_INFO" }, - {META_DOLBY_RPU, "META_DOLBY_RPU" }, - {FRAME_WIDTH, "FRAME_WIDTH" }, - {LOSSLESS_FRAME_WIDTH, "LOSSLESS_FRAME_WIDTH" }, - {SECURE_FRAME_WIDTH, "SECURE_FRAME_WIDTH" }, - {FRAME_HEIGHT, "FRAME_HEIGHT" }, - {LOSSLESS_FRAME_HEIGHT, "LOSSLESS_FRAME_HEIGHT" }, - {SECURE_FRAME_HEIGHT, "SECURE_FRAME_HEIGHT" }, - {PIX_FMTS, "PIX_FMTS" }, - {MIN_BUFFERS_INPUT, "MIN_BUFFERS_INPUT" }, - {MIN_BUFFERS_OUTPUT, "MIN_BUFFERS_OUTPUT" }, - {MBPF, "MBPF" }, - {BATCH_MBPF, "BATCH_MBPF" }, - {BATCH_FPS, "BATCH_FPS" }, - {LOSSLESS_MBPF, "LOSSLESS_MBPF" }, - {SECURE_MBPF, "SECURE_MBPF" }, - {FRAME_RATE, "FRAME_RATE" }, - {OPERATING_RATE, "OPERATING_RATE" }, - {INPUT_RATE, "INPUT_RATE" }, - {TIMESTAMP_RATE, "TIMESTAMP_RATE" }, - {SCALE_FACTOR, "SCALE_FACTOR" }, - {MB_CYCLES_VSP, "MB_CYCLES_VSP" }, - {MB_CYCLES_VPP, "MB_CYCLES_VPP" }, - {MB_CYCLES_LP, "MB_CYCLES_LP" }, - {MB_CYCLES_FW, "MB_CYCLES_FW" }, - {MB_CYCLES_FW_VPP, "MB_CYCLES_FW_VPP" }, - {CLIENT_ID, "CLIENT_ID" }, - {SECURE_MODE, "SECURE_MODE" }, - {FENCE_ID, "FENCE_ID" }, - {FENCE_FD, "FENCE_FD" }, - {TS_REORDER, "TS_REORDER" }, - {HFLIP, "HFLIP" }, - {VFLIP, "VFLIP" }, - {ROTATION, "ROTATION" }, - {SUPER_FRAME, "SUPER_FRAME" }, - {HEADER_MODE, "HEADER_MODE" }, - {PREPEND_SPSPPS_TO_IDR, "PREPEND_SPSPPS_TO_IDR" }, - {WITHOUT_STARTCODE, "WITHOUT_STARTCODE" }, - {NAL_LENGTH_FIELD, "NAL_LENGTH_FIELD" }, - {REQUEST_I_FRAME, "REQUEST_I_FRAME" }, - {BITRATE_MODE, "BITRATE_MODE" }, - {LOSSLESS, "LOSSLESS" }, - {FRAME_SKIP_MODE, "FRAME_SKIP_MODE" }, - {FRAME_RC_ENABLE, "FRAME_RC_ENABLE" }, - {GOP_CLOSURE, "GOP_CLOSURE" }, - {CSC, "CSC" }, - {CSC_CUSTOM_MATRIX, "CSC_CUSTOM_MATRIX" }, - {USE_LTR, "USE_LTR" }, - {MARK_LTR, "MARK_LTR" }, - {BASELAYER_PRIORITY, "BASELAYER_PRIORITY" }, - {IR_TYPE, "IR_TYPE" }, - {AU_DELIMITER, "AU_DELIMITER" }, - {GRID, "GRID" }, - {I_FRAME_MIN_QP, "I_FRAME_MIN_QP" }, - {P_FRAME_MIN_QP, "P_FRAME_MIN_QP" }, - {B_FRAME_MIN_QP, "B_FRAME_MIN_QP" }, - {I_FRAME_MAX_QP, "I_FRAME_MAX_QP" }, - {P_FRAME_MAX_QP, "P_FRAME_MAX_QP" }, - {B_FRAME_MAX_QP, "B_FRAME_MAX_QP" }, - {LAYER_TYPE, "LAYER_TYPE" }, - {LAYER_ENABLE, "LAYER_ENABLE" }, - {L0_BR, "L0_BR" }, - {L1_BR, "L1_BR" }, - {L2_BR, "L2_BR" }, - {L3_BR, "L3_BR" }, - {L4_BR, "L4_BR" }, - {L5_BR, "L5_BR" }, - {LEVEL, "LEVEL" }, - {HEVC_TIER, "HEVC_TIER" }, - {AV1_TIER, "AV1_TIER" }, - {DISPLAY_DELAY_ENABLE, "DISPLAY_DELAY_ENABLE" }, - {DISPLAY_DELAY, "DISPLAY_DELAY" }, - {CONCEAL_COLOR_8BIT, "CONCEAL_COLOR_8BIT" }, - {CONCEAL_COLOR_10BIT, "CONCEAL_COLOR_10BIT" }, - {LF_MODE, "LF_MODE" }, - {LF_ALPHA, "LF_ALPHA" }, - {LF_BETA, "LF_BETA" }, - {SLICE_MAX_BYTES, "SLICE_MAX_BYTES" }, - {SLICE_MAX_MB, "SLICE_MAX_MB" }, - {MB_RC, "MB_RC" }, - {CHROMA_QP_INDEX_OFFSET, "CHROMA_QP_INDEX_OFFSET" }, - {PIPE, "PIPE" }, - {POC, "POC" }, - {CODED_FRAMES, "CODED_FRAMES" }, - {BIT_DEPTH, "BIT_DEPTH" }, - {CODEC_CONFIG, "CODEC_CONFIG" }, - {BITSTREAM_SIZE_OVERWRITE, "BITSTREAM_SIZE_OVERWRITE" }, - {THUMBNAIL_MODE, "THUMBNAIL_MODE" }, - {DEFAULT_HEADER, "DEFAULT_HEADER" }, - {RAP_FRAME, "RAP_FRAME" }, - {SEQ_CHANGE_AT_SYNC_FRAME, "SEQ_CHANGE_AT_SYNC_FRAME" }, - {QUALITY_MODE, "QUALITY_MODE" }, - {PRIORITY, "PRIORITY" }, - {FIRMWARE_PRIORITY_OFFSET, "FIRMWARE_PRIORITY_OFFSET" }, - {CRITICAL_PRIORITY, "CRITICAL_PRIORITY" }, - {RESERVE_DURATION, "RESERVE_DURATION" }, - {DPB_LIST, "DPB_LIST" }, - {FILM_GRAIN, "FILM_GRAIN" }, - {SUPER_BLOCK, "SUPER_BLOCK" }, - {DRAP, "DRAP" }, - {ENC_IP_CR, "ENC_IP_CR" }, - {COMPLEXITY, "COMPLEXITY" }, - {CABAC_MAX_BITRATE, "CABAC_MAX_BITRATE" }, - {CAVLC_MAX_BITRATE, "CAVLC_MAX_BITRATE" }, - {ALLINTRA_MAX_BITRATE, "ALLINTRA_MAX_BITRATE" }, - {LOWLATENCY_MAX_BITRATE, "LOWLATENCY_MAX_BITRATE" }, - {LAST_FLAG_EVENT_ENABLE, "LAST_FLAG_EVENT_ENABLE" }, - {NUM_COMV, "NUM_COMV" }, - {PROFILE, "PROFILE" }, - {ENH_LAYER_COUNT, "ENH_LAYER_COUNT" }, - {BIT_RATE, "BIT_RATE" }, - {LOWLATENCY_MODE, "LOWLATENCY_MODE" }, - {GOP_SIZE, "GOP_SIZE" }, - {B_FRAME, "B_FRAME" }, - {ALL_INTRA, "ALL_INTRA" }, - {MIN_QUALITY, "MIN_QUALITY" }, - {CONTENT_ADAPTIVE_CODING, "CONTENT_ADAPTIVE_CODING" }, - {BLUR_TYPES, "BLUR_TYPES" }, - {REQUEST_PREPROCESS, "REQUEST_PREPROCESS" }, - {SLICE_MODE, "SLICE_MODE" }, - {MIN_FRAME_QP, "MIN_FRAME_QP" }, - {MAX_FRAME_QP, "MAX_FRAME_QP" }, - {I_FRAME_QP, "I_FRAME_QP" }, - {P_FRAME_QP, "P_FRAME_QP" }, - {B_FRAME_QP, "B_FRAME_QP" }, - {TIME_DELTA_BASED_RC, "TIME_DELTA_BASED_RC" }, - {CONSTANT_QUALITY, "CONSTANT_QUALITY" }, - {VBV_DELAY, "VBV_DELAY" }, - {PEAK_BITRATE, "PEAK_BITRATE" }, - {ENTROPY_MODE, "ENTROPY_MODE" }, - {TRANSFORM_8X8, "TRANSFORM_8X8" }, - {STAGE, "STAGE" }, - {LTR_COUNT, "LTR_COUNT" }, - {IR_PERIOD, "IR_PERIOD" }, - {BITRATE_BOOST, "BITRATE_BOOST" }, - {BLUR_RESOLUTION, "BLUR_RESOLUTION" }, - {OUTPUT_ORDER, "OUTPUT_ORDER" }, - {INPUT_BUF_HOST_MAX_COUNT, "INPUT_BUF_HOST_MAX_COUNT" }, - {OUTPUT_BUF_HOST_MAX_COUNT, "OUTPUT_BUF_HOST_MAX_COUNT" }, - {DELIVERY_MODE, "DELIVERY_MODE" }, - {VUI_TIMING_INFO, "VUI_TIMING_INFO" }, - {SLICE_DECODE, "SLICE_DECODE" }, - {INST_CAP_MAX, "INST_CAP_MAX" }, -}; +static const char * const cap_name_arr[] = + FOREACH_CAP(GENERATE_STRING); const char *cap_name(enum msm_vidc_inst_capability_type cap_id) { const char *name = "UNKNOWN CAP"; - if (cap_id > ARRAY_SIZE(cap_name_arr)) + if (cap_id >= ARRAY_SIZE(cap_name_arr)) goto exit; - if (cap_name_arr[cap_id].cap_id != cap_id) - goto exit; - - name = cap_name_arr[cap_id].name; + name = cap_name_arr[cap_id]; exit: return name; } -struct msm_vidc_buf_type_name { - enum msm_vidc_buffer_type type; - char *name; -}; - -static const struct msm_vidc_buf_type_name buf_type_name_arr[] = { - {MSM_VIDC_BUF_INPUT, "INPUT" }, - {MSM_VIDC_BUF_OUTPUT, "OUTPUT" }, - {MSM_VIDC_BUF_INPUT_META, "INPUT_META" }, - {MSM_VIDC_BUF_OUTPUT_META, "OUTPUT_META" }, - {MSM_VIDC_BUF_READ_ONLY, "READ_ONLY" }, - {MSM_VIDC_BUF_QUEUE, "QUEUE" }, - {MSM_VIDC_BUF_BIN, "BIN" }, - {MSM_VIDC_BUF_ARP, "ARP" }, - {MSM_VIDC_BUF_COMV, "COMV" }, - {MSM_VIDC_BUF_NON_COMV, "NON_COMV" }, - {MSM_VIDC_BUF_LINE, "LINE" }, - {MSM_VIDC_BUF_DPB, "DPB" }, - {MSM_VIDC_BUF_PERSIST, "PERSIST" }, - {MSM_VIDC_BUF_VPSS, "VPSS" }, - {MSM_VIDC_BUF_PARTIAL_DATA, "PARTIAL_DATA" }, -}; +static const char * const buf_type_name_arr[] = + FOREACH_BUF_TYPE(GENERATE_STRING); const char *buf_name(enum msm_vidc_buffer_type type) { const char *name = "UNKNOWN BUF"; - if (!type || type > ARRAY_SIZE(buf_type_name_arr)) + if (type >= ARRAY_SIZE(buf_type_name_arr)) goto exit; - if (buf_type_name_arr[type - 1].type != type) - goto exit; - - name = buf_type_name_arr[type - 1].name; + name = buf_type_name_arr[type]; exit: return name; } -struct msm_vidc_allow_name { - enum msm_vidc_allow allow; - char *name; -}; - -static const struct msm_vidc_allow_name inst_allow_name_arr[] = { - {MSM_VIDC_DISALLOW, "MSM_VIDC_DISALLOW" }, - {MSM_VIDC_ALLOW, "MSM_VIDC_ALLOW" }, - {MSM_VIDC_DEFER, "MSM_VIDC_DEFER" }, - {MSM_VIDC_DISCARD, "MSM_VIDC_DISCARD" }, - {MSM_VIDC_IGNORE, "MSM_VIDC_IGNORE" }, -}; +static const char * const inst_allow_name_arr[] = + FOREACH_ALLOW(GENERATE_STRING); const char *allow_name(enum msm_vidc_allow allow) { const char *name = "UNKNOWN"; - if (allow > ARRAY_SIZE(inst_allow_name_arr)) + if (allow >= ARRAY_SIZE(inst_allow_name_arr)) goto exit; - if (inst_allow_name_arr[allow].allow != allow) - goto exit; - - name = inst_allow_name_arr[allow].name; + name = inst_allow_name_arr[allow]; exit: return name; } -struct msm_vidc_state_name { - enum msm_vidc_state state; - char *name; -}; - /* do not modify the state names as it is used in test scripts */ -static const struct msm_vidc_state_name state_name_arr[] = { - {MSM_VIDC_OPEN, "OPEN" }, - {MSM_VIDC_INPUT_STREAMING, "INPUT_STREAMING" }, - {MSM_VIDC_OUTPUT_STREAMING, "OUTPUT_STREAMING" }, - {MSM_VIDC_STREAMING, "STREAMING" }, - {MSM_VIDC_CLOSE, "CLOSE" }, - {MSM_VIDC_ERROR, "ERROR" }, -}; +static const char * const state_name_arr[] = + FOREACH_STATE(GENERATE_STRING); const char *state_name(enum msm_vidc_state state) { const char *name = "UNKNOWN STATE"; - if (!state || state > ARRAY_SIZE(state_name_arr)) + if (state >= ARRAY_SIZE(state_name_arr)) goto exit; - if (state_name_arr[state - 1].state != state) - goto exit; - - name = state_name_arr[state - 1].name; + name = state_name_arr[state]; exit: return name; @@ -356,16 +130,8 @@ const char *sub_state_name(enum msm_vidc_sub_state sub_state) return "SUB_STATE_NONE"; } -struct msm_vidc_core_state_name { - enum msm_vidc_core_state state; - char *name; -}; - -static const struct msm_vidc_core_state_name core_state_name_arr[] = { - {MSM_VIDC_CORE_DEINIT, "CORE_DEINIT" }, - {MSM_VIDC_CORE_INIT_WAIT, "CORE_INIT_WAIT" }, - {MSM_VIDC_CORE_INIT, "CORE_INIT" }, -}; +static const char * const core_state_name_arr[] = + FOREACH_CORE_STATE(GENERATE_STRING); const char *core_state_name(enum msm_vidc_core_state state) { @@ -374,10 +140,7 @@ const char *core_state_name(enum msm_vidc_core_state state) if (state >= ARRAY_SIZE(core_state_name_arr)) goto exit; - if (core_state_name_arr[state].state != state) - goto exit; - - name = core_state_name_arr[state].name; + name = core_state_name_arr[state]; exit: return name; @@ -5057,13 +4820,13 @@ int msm_vidc_print_buffer_info(struct msm_vidc_inst *inst) } /* Print buffer details */ - for (i = 0; i < ARRAY_SIZE(buf_type_name_arr); i++) { - buffers = msm_vidc_get_buffers(inst, buf_type_name_arr[i].type, __func__); + for (i = 1; i < ARRAY_SIZE(buf_type_name_arr); i++) { + buffers = msm_vidc_get_buffers(inst, i, __func__); if (!buffers) continue; i_vpr_h(inst, "buf: type: %11s, count %2d, extra %2d, actual %2d, size %9u\n", - buf_type_name_arr[i].name, buffers->min_count, + buf_name(i), buffers->min_count, buffers->extra_count, buffers->actual_count, buffers->size); } @@ -5105,13 +4868,13 @@ int msm_vidc_print_inst_info(struct msm_vidc_inst *inst) frame_rate, bit_rate, bit_depth); /* Print buffer details */ - for (i = 0; i < ARRAY_SIZE(buf_type_name_arr); i++) { - buffers = msm_vidc_get_buffers(inst, buf_type_name_arr[i].type, __func__); + for (i = 1; i < ARRAY_SIZE(buf_type_name_arr); i++) { + buffers = msm_vidc_get_buffers(inst, i, __func__); if (!buffers) continue; i_vpr_e(inst, "count: type: %11s, min: %2d, extra: %2d, actual: %2d\n", - buf_type_name_arr[i].name, buffers->min_count, + buf_name(i), buffers->min_count, buffers->extra_count, buffers->actual_count); list_for_each_entry(buf, &buffers->list, list) { @@ -5127,7 +4890,7 @@ int msm_vidc_print_inst_info(struct msm_vidc_inst *inst) } i_vpr_e(inst, "buf: type: %11s, index: %2d, fd: %4d, size: %9u, off: %8u, filled: %9u, daddr: %#llx, inode: %8lu, ref: %2ld, flags: %8x, ts: %16lld, attr: %8x\n", - buf_type_name_arr[i].name, buf->index, buf->fd, buf->buffer_size, + buf_name(i), buf->index, buf->fd, buf->buffer_size, buf->data_offset, buf->data_size, buf->device_addr, inode_num, ref_count, buf->flags, buf->timestamp, buf->attr); }