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

video driver is maintaining multiple tables based on enum
name pair. So this mapping might go wrong if new entry is
inserted in different position.

So added logic to prepare enums & static const char* arrays
using macros. So compiler will take care of creation and
maintaining order.

Change-Id: Id3669cf3ce150b3ababb84dce18326220f41d88d
Signed-off-by: Govindaraj Rajagopal <[email protected]>

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);
 		}