Merge "video: driver: use macros to prepare enums & string arrays"

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;

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

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;

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))
-		goto exit;
-
-	if (buf_type_name_arr[type - 1].type != type)
+	if (type >= ARRAY_SIZE(buf_type_name_arr))
 		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))
-		goto exit;
-
-	if (inst_allow_name_arr[allow].allow != allow)
+	if (allow >= ARRAY_SIZE(inst_allow_name_arr))
 		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);
 		}