video: driver: update instance database with controls

Update instance database with v4l2 controls.

Change-Id: I0715edfcbf46a82c8e2f67ec298185e2cf4eb5d0
Signed-off-by: Akshata Sahukar <[email protected]>

driver/platform/waipio/src/msm_vidc_waipio.c

@@ -87,13 +87,13 @@ static struct msm_platform_core_capability core_data_waipio[] = {
 static struct msm_platform_inst_capability instance_data_waipio[] = {
 	/* {cap, domain, codec,
 	 *      min, max, step_or_mask, value,
-	 *      v4l2_id, hfi_id,
+	 *      v4l2_id,
+	 *      hfi_id,
 	 *      flags,
 	 *      parents,
 	 *      children,
 	 *      adjust, set}
 	 */
-	{CODEC},
 	{FRAME_WIDTH, ENC|DEC, CODECS_ALL, 128, 8192, 1, 1920},
 	{FRAME_HEIGHT, ENC|DEC, CODECS_ALL, 128, 8192, 1, 1080},
 	{PIX_FMTS, ENC, CODECS_ALL,
@@ -110,24 +110,11 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		MSM_VIDC_FMT_NV12_UBWC},
 	{MIN_BUFFERS_INPUT, ENC|DEC, CODECS_ALL, 0, 64, 1, 4,
 		V4L2_CID_MIN_BUFFERS_FOR_OUTPUT},
-	{MIN_BUFFERS_OUTPUT, ENC|DEC, CODECS_ALL, 0, 64, 1, 4,
-		V4L2_CID_MIN_BUFFERS_FOR_CAPTURE},
-	{DECODE_ORDER, DEC, CODECS_ALL, 0, 1, 1, 0,
-		V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY_ENABLE,
-		HFI_PROP_DECODE_ORDER_OUTPUT},
-	{THUMBNAIL_MODE, DEC, CODECS_ALL, 0, 1, 1, 0,
-		V4L2_CID_MPEG_VIDC_THUMBNAIL_MODE,
-		HFI_PROP_THUMBNAIL_MODE},
-	{SECURE_MODE, ENC|DEC, CODECS_ALL, 0, 1, 1, 0,
-		V4L2_CID_MPEG_VIDC_SECURE,
-		HFI_PROP_SECURE},
-	{LOWLATENCY_MODE, ENC|DEC, CODECS_ALL, 0, 1, 1, 0,
-		V4L2_CID_MPEG_VIDC_LOWLATENCY_REQUEST},
-	/* {LOWLATENCY_HINT, DEC, CODECS_ALL, 0, 1, 1, 0,
-		V4L2_CID_MPEG_VIDC_VIDEO_LOWLATENCY_HINT},
-	{BUF_SIZE_LIMIT, ENC|DEC, CODECS_ALL, 0, 0x0fffffff, 1, 0,
-		V4L2_CID_MPEG_VIDC_VIDEO_BUFFER_SIZE_LIMIT},
-	*/
+	{MIN_BUFFERS_OUTPUT, ENC|DEC, CODECS_ALL,
+		0, 64, 1, 4,
+		V4L2_CID_MIN_BUFFERS_FOR_CAPTURE,
+		HFI_PROP_BUFFER_FW_MIN_OUTPUT_COUNT,
+		CAP_FLAG_ROOT},
 
 	/* (8192 * 4320) / 256 */
 	{MBPF, ENC|DEC, CODECS_ALL, 64, 138240, 1, 138240},
@@ -135,31 +122,626 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 	{MBPS, ENC|DEC, CODECS_ALL, 64, 7833600, 1, 7833600},
 	{FRAME_RATE, ENC|DEC, CODECS_ALL, 1, 960, 1, 30},
 
-	{BIT_RATE, ENC|DEC, CODECS_ALL,
+	{SCALE_X, ENC, CODECS_ALL, 8192, 65536, 1, 8192},
+	{SCALE_Y, ENC, CODECS_ALL, 8192, 65536, 1, 8192},
+	{SCALE_X, DEC, CODECS_ALL, 65536, 65536, 1, 65536},
+	{SCALE_Y, DEC, CODECS_ALL, 65536, 65536, 1, 65536},
+	{B_FRAME, ENC, H264|HEVC,
+		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
+		1, V4L2_MPEG_MSM_VIDC_DISABLE,
+		V4L2_CID_MPEG_VIDEO_B_FRAMES,
+		HFI_PROP_MAX_B_FRAMES,
+		CAP_FLAG_ROOT},
+
+	/* ((4096 * 2304) / 256) * 60 fps */
+	{POWER_SAVE_MBPS, ENC, CODECS_ALL,
+		0, 2211840, 1, 2211840},
+
+	/* Batch Mode Decode */
+	{BATCH_MBPF, DEC, CODECS_ALL, 64, 34816, 1, 34816},
+	/* (4096 * 2176) / 256 */
+	{BATCH_FRAME_RATE, DEC, CODECS_ALL, 1, 120, 1, 120},
+
+	/* Lossless encoding usecase specific */
+	{LOSSLESS_FRAME_WIDTH, ENC, H264|HEVC, 128, 4096, 1, 1920},
+	{LOSSLESS_FRAME_HEIGHT, ENC, H264|HEVC, 128, 4096, 1, 1080},
+	/* (4096 * 2304) / 256 */
+	{LOSSLESS_MBPF, ENC, H264|HEVC, 64, 36864, 1, 36864},
+
+	/* All intra encoding usecase specific */
+	{ALL_INTRA_FRAME_RATE, ENC, H264|HEVC, 1, 240, 1, 30},
+
+	/* Image specific */
+	{HEVC_IMAGE_FRAME_WIDTH, ENC, HEVC, 128, 512, 1, 512},
+	{HEVC_IMAGE_FRAME_HEIGHT, ENC, HEVC, 128, 512, 1, 512},
+	{HEIC_IMAGE_FRAME_WIDTH, ENC, HEVC, 512, 16384, 1, 16384},
+	{HEIC_IMAGE_FRAME_HEIGHT, ENC, HEVC, 512, 16384, 1, 16384},
+
+	{MB_CYCLES_VSP, ENC, CODECS_ALL, 25, 25, 1, 25},
+	{MB_CYCLES_VPP, ENC, CODECS_ALL, 675, 675, 1, 675},
+	{MB_CYCLES_LP, ENC, CODECS_ALL, 320, 320, 1, 320},
+	{MB_CYCLES_VSP, DEC, CODECS_ALL, 25, 25, 1, 25},
+	{MB_CYCLES_VSP, DEC, VP9, 60, 60, 1, 60},
+	{MB_CYCLES_VPP, DEC, CODECS_ALL, 200, 200, 1, 200},
+	{MB_CYCLES_LP, DEC, CODECS_ALL, 200, 200, 1, 200},
+	{MB_CYCLES_FW, ENC|DEC, CODECS_ALL, 326389, 326389, 1, 326389},
+	{MB_CYCLES_FW_VPP, ENC|DEC, CODECS_ALL, 44156, 44156, 1, 44156},
+
+	// confirm codec
+	{B_FRAME_MIN_QP, ENC, HEVC|H264,
+		0, 51, 1, 20,
+		V4L2_CID_MPEG_VIDC_B_FRAME_MIN_QP,
+		HFI_PROP_MIN_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	{B_FRAME_MAX_QP, ENC, HEVC|H264,
+		0, 51, 1, 20,
+		V4L2_CID_MPEG_VIDC_B_FRAME_MAX_QP,
+		HFI_PROP_MAX_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	{HFLIP, ENC, CODECS_ALL,
+		V4L2_MPEG_MSM_VIDC_DISABLE,
+		V4L2_MPEG_MSM_VIDC_ENABLE,
+		1, V4L2_MPEG_MSM_VIDC_DISABLE,
+		V4L2_CID_HFLIP,
+		HFI_PROP_FLIP,
+		CAP_FLAG_ROOT},
+
+	{VFLIP, ENC, CODECS_ALL,
+		V4L2_MPEG_MSM_VIDC_DISABLE,
+		V4L2_MPEG_MSM_VIDC_ENABLE,
+		1, V4L2_MPEG_MSM_VIDC_DISABLE,
+		V4L2_CID_VFLIP,
+		HFI_PROP_FLIP,
+		CAP_FLAG_ROOT},
+
+	{PREPEND_SPSPPS_TO_IDR, ENC, CODECS_ALL,
+		V4L2_MPEG_MSM_VIDC_DISABLE,
+		V4L2_MPEG_MSM_VIDC_ENABLE,
+		1, V4L2_MPEG_MSM_VIDC_DISABLE,
+		V4L2_CID_MPEG_VIDEO_PREPEND_SPSPPS_TO_IDR,
+		HFI_PROP_SEQ_HEADER_MODE,
+		CAP_FLAG_ROOT},
+
+	{REQUEST_I_FRAME, ENC, CODECS_ALL,
+		0, 0, 0, 0,
+		V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME,
+		HFI_PROP_REQUEST_SYNC_FRAME,
+		CAP_FLAG_ROOT},
+
+	{SLICE_INTERFACE, DEC, CODECS_ALL,
+		0, 0, 0, 0,
+		V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE,
+		0},
+
+	{FRAME_RC, ENC, CODECS_ALL,
+		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
+		1, V4L2_MPEG_MSM_VIDC_ENABLE,
+		V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE,
+		0},
+
+	{BITRATE_MODE, ENC, CODECS_ALL,
+		V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
+		V4L2_MPEG_VIDEO_BITRATE_MODE_CBR,
+		/* TODO: MBR, CBR_VFR, MBR_VFR, CQ */
+		BIT(V4L2_MPEG_VIDEO_BITRATE_MODE_VBR) |
+		BIT(V4L2_MPEG_VIDEO_BITRATE_MODE_CBR),
+		V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
+		V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
+		HFI_PROP_RATE_CONTROL,
+		CAP_FLAG_ROOT | CAP_FLAG_MENU},
+
+	{HEADER_MODE, ENC, CODECS_ALL,
+		V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE,
+		V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME,
+		BIT(V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE) |
+		BIT(V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME),
+		V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE,
+		V4L2_CID_MPEG_VIDEO_HEADER_MODE,
+		HFI_PROP_SEQ_HEADER_MODE,
+		CAP_FLAG_ROOT | CAP_FLAG_MENU},
+
+	// confirm codec
+	{GOP_SIZE, ENC, CODECS_ALL,
+		0, MAX_GOP, 1, 2 * DEFAULT_FPS - 1,
+		V4L2_CID_MPEG_VIDEO_GOP_SIZE,
+		HFI_PROP_MAX_GOP_FRAMES,
+		CAP_FLAG_ROOT},
+
+	{GOP_CLOSURE, ENC, CODECS_ALL,
+		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
+		1, V4L2_MPEG_MSM_VIDC_ENABLE,
+		V4L2_CID_MPEG_VIDEO_GOP_CLOSURE,
+		0},
+
+	{BIT_RATE, ENC, CODECS_ALL,
 		1, 220000000, 1, 20000000,
-		V4L2_CID_MPEG_VIDEO_BITRATE, HFI_PROP_TOTAL_BITRATE,
+		V4L2_CID_MPEG_VIDEO_BITRATE,
+		HFI_PROP_TOTAL_BITRATE,
 		CAP_FLAG_DYNAMIC_ALLOWED,
 		/* TO DO parents */ {0},
-		{LAYER_BITRATE, SLICE_BYTE},
+		{SLICE_MAX_BYTES},
 		msm_vidc_adjust_bitrate, msm_vidc_set_s32},
 
+	{BIT_RATE, DEC, CODECS_ALL, 1, 220000000, 1, 220000000},
+
+	/* Secure usecase specific */
+	{SECURE_FRAME_WIDTH, ENC|DEC, CODECS_ALL, 128, 4096, 1, 1920},
+
+	{SECURE_FRAME_HEIGHT, ENC|DEC, CODECS_ALL, 128, 4096, 1, 1080},
+
+	/* (4096 * 2304) / 256 */
+	{SECURE_MBPF, ENC|DEC, CODECS_ALL, 64, 36864, 1, 36864},
+
+	{SECURE_MODE, ENC|DEC, CODECS_ALL,
+		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
+		1, V4L2_MPEG_MSM_VIDC_DISABLE,
+		V4L2_CID_MPEG_VIDC_SECURE,
+		HFI_PROP_SECURE,
+		CAP_FLAG_ROOT,
+		{0},
+		{0}},
+
+	{BLUR_TYPES, ENC, CODECS_ALL,
+		VIDC_BLUR_NONE, VIDC_BLUR_ADAPTIVE, 1, VIDC_BLUR_NONE,
+		V4L2_CID_MPEG_VIDC_VIDEO_BLUR_TYPES,
+		HFI_PROP_BLUR_TYPES,
+		CAP_FLAG_ROOT},
+
+	{BLUR_RESOLUTION, ENC, CODECS_ALL,
+		0, S32_MAX, 1, 0,
+		V4L2_CID_MPEG_VIDC_VIDEO_BLUR_RESOLUTION,
+		HFI_PROP_BLUR_RESOLUTION,
+		CAP_FLAG_ROOT},
+
+	/* Needed for control initialization. TODO */
+	/* {CSC_CUSTOM_MATRIX, ENC, CODECS_ALL,
+		V4L2_MPEG_MSM_VIDC_DISABLE,
+		V4L2_MPEG_MSM_VIDC_ENABLE,
+		1, V4L2_MPEG_MSM_VIDC_DISABLE,
+		V4L2_CID_MPEG_VIDC_VIDEO_VPE_CSC_CUSTOM_MATRIX,
+		HFI_PROP_CSC_MATRIX,
+		CAP_FLAG_ROOT}, */
+
+	{HEIC, ENC, HEVC,
+		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
+		1, V4L2_MPEG_MSM_VIDC_DISABLE,
+		V4L2_CID_MPEG_VIDC_HEIC,
+		HFI_PROP_HEIC_GRID_ENABLE,
+		CAP_FLAG_ROOT},
+
+	{LOWLATENCY_MODE, ENC|DEC, CODECS_ALL,
+		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
+		1, V4L2_MPEG_MSM_VIDC_DISABLE,
+		V4L2_CID_MPEG_VIDC_LOWLATENCY_REQUEST,
+		HFI_PROP_STAGE,
+		CAP_FLAG_ROOT},
+
+	{LTR_COUNT, ENC, H264|HEVC,
+		0, 2, 1, 0,
+		V4L2_CID_MPEG_VIDC_LTRCOUNT,
+		HFI_PROP_LTR_COUNT,
+		CAP_FLAG_ROOT},
+
+	{USE_LTR, ENC, H264|HEVC,
+		0, ((1 << MAX_LTR_FRAME_COUNT) - 1), 1, 0,
+		V4L2_CID_MPEG_VIDC_USELTRFRAME,
+		HFI_PROP_LTR_USE,
+		CAP_FLAG_ROOT,
+		{LTR_COUNT},
+		{0}},
+
+	{MARK_LTR, ENC, H264|HEVC,
+		0, (MAX_LTR_FRAME_COUNT - 1), 1, 0,
+		V4L2_CID_MPEG_VIDC_MARKLTRFRAME,
+		HFI_PROP_LTR_MARK,
+		CAP_FLAG_ROOT},
+
+	{BASELAYER_PRIORITY, ENC, H264|HEVC,
+		0, MAX_BASE_LAYER_PRIORITY_ID, 1, 0,
+		V4L2_CID_MPEG_VIDC_BASELAYER_PRIORITY,
+		HFI_PROP_BASELAYER_PRIORITYID,
+		CAP_FLAG_ROOT},
+
+	{IR_RANDOM, ENC, CODECS_ALL,
+		0, MAX_INTRA_REFRESH_MBS, 1, 0,
+		V4L2_CID_MPEG_VIDC_INTRA_REFRESH_PERIOD,
+		HFI_PROP_IR_RANDOM_PERIOD,
+		CAP_FLAG_ROOT},
+
+	{AU_DELIMITER, ENC, H264|HEVC,
+		V4L2_MPEG_MSM_VIDC_DISABLE,
+		V4L2_MPEG_MSM_VIDC_ENABLE,
+		1, V4L2_MPEG_MSM_VIDC_DISABLE,
+		V4L2_CID_MPEG_VIDC_AU_DELIMITER,
+		HFI_PROP_AUD,
+		CAP_FLAG_ROOT},
+
+	// confirm codec
+	{TIME_DELTA_BASED_RC, ENC, CODECS_ALL,
+		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
+		1, V4L2_MPEG_MSM_VIDC_ENABLE,
+		V4L2_CID_MPEG_VIDC_TIME_DELTA_BASED_RC,
+		HFI_PROP_TIME_DELTA_BASED_RATE_CONTROL,
+		CAP_FLAG_ROOT},
+
+	// confirm codec
+	{CONTENT_ADAPTIVE_CODING, ENC, CODECS_ALL,
+		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
+		1, V4L2_MPEG_MSM_VIDC_ENABLE,
+		V4L2_CID_MPEG_VIDC_CONTENT_ADAPTIVE_CODING,
+		HFI_PROP_CONTENT_ADAPTIVE_CODING,
+		CAP_FLAG_ROOT},
+
+	{BITRATE_BOOST, ENC, CODECS_ALL,
+		0, 100, 25, 25,
+		V4L2_CID_MPEG_VIDC_QUALITY_BITRATE_BOOST,
+		HFI_PROP_CONST_QUALITY_BITRATE_BOOST,
+		CAP_FLAG_ROOT},
+
+	{ROTATION, ENC, CODECS_ALL,
+		0, 270, 90, 0,
+		V4L2_CID_ROTATE,
+		HFI_PROP_ROTATION,
+		CAP_FLAG_ROOT},
+
+	{VBV_DELAY, ENC, CODECS_ALL,
+		0, 1000, 500, 0,
+		V4L2_CID_MPEG_VIDEO_VBV_DELAY},
+
+	/* HEVC specific */
+	{MIN_FRAME_QP, ENC, HEVC,
+		0, 51, 1, 20,
+		V4L2_CID_MPEG_VIDEO_HEVC_MIN_QP,
+		HFI_PROP_MIN_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	{MAX_FRAME_QP, ENC, HEVC,
+		0, 51, 1, 20,
+		V4L2_CID_MPEG_VIDEO_HEVC_MAX_QP,
+		HFI_PROP_MAX_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	{HEVC_HIER_QP, ENC, HEVC,
+		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
+		1, V4L2_MPEG_MSM_VIDC_DISABLE,
+		V4L2_CID_MPEG_VIDEO_HEVC_HIER_QP,
+		HFI_PROP_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	/*
+	 * HEVC I_MIN_QP, I_MAX_QP, P_MIN_QP, P_MAX_QP, B_MIN_QP, B_MAX_QP are missing
+	 */
+	{I_FRAME_QP, ENC, HEVC,
+		0, 51, 1, 10,
+		V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_QP,
+		HFI_PROP_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	{P_FRAME_QP, ENC, HEVC,
+		0, 51, 1, 20,
+		V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_QP,
+		HFI_PROP_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	{B_FRAME_QP, ENC, HEVC,
+		0, 51, 1, 20,
+		V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_QP,
+		HFI_PROP_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	{HIER_CODING_TYPE, ENC, HEVC,
+		V4L2_MPEG_VIDEO_HEVC_HIERARCHICAL_CODING_B,
+		V4L2_MPEG_VIDEO_HEVC_HIERARCHICAL_CODING_P,
+		BIT(V4L2_MPEG_VIDEO_HEVC_HIERARCHICAL_CODING_B) |
+		BIT(V4L2_MPEG_VIDEO_HEVC_HIERARCHICAL_CODING_P),
+		V4L2_MPEG_VIDEO_HEVC_HIERARCHICAL_CODING_P,
+		V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_TYPE,
+		HFI_PROP_LAYER_ENCODING_TYPE,
+		CAP_FLAG_ROOT | CAP_FLAG_MENU},
+
+	{HIER_CODING_LAYER, ENC, HEVC,
+		0, 5, 1, 0,
+		V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_LAYER,
+		HFI_PROP_LAYER_COUNT,
+		CAP_FLAG_ROOT},
+
+	{L0_QP, ENC, HEVC,
+		0, 51, 1, 20,
+		V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L0_QP,
+		HFI_PROP_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	{L1_QP, ENC, HEVC,
+		0, 51, 1, 20,
+		V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L1_QP,
+		HFI_PROP_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	{L2_QP, ENC, HEVC,
+		0, 51, 1, 20,
+		V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L2_QP,
+		HFI_PROP_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	{L3_QP, ENC, HEVC,
+		0, 51, 1, 20,
+		V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L3_QP,
+		HFI_PROP_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	{L4_QP, ENC, HEVC,
+		0, 51, 1, 20,
+		V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L4_QP,
+		HFI_PROP_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	{L5_QP, ENC, HEVC,
+		0, 51, 1, 20,
+		V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L5_QP,
+		HFI_PROP_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	{PROFILE, ENC|DEC, HEVC,
+		V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN,
+		V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_10,
+		BIT(V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN) |
+		BIT(V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_STILL_PICTURE) |
+		BIT(V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_10),
+		V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN,
+		V4L2_CID_MPEG_VIDEO_HEVC_PROFILE,
+		HFI_PROP_PROFILE,
+		CAP_FLAG_ROOT | CAP_FLAG_MENU,
+		{0},
+		{ENTROPY_MODE},
+		NULL, msm_vidc_set_u32},
+
+	{LEVEL, ENC|DEC, HEVC,
+		V4L2_MPEG_VIDEO_HEVC_LEVEL_1,
+		V4L2_MPEG_VIDEO_HEVC_LEVEL_6_2,
+		BIT(V4L2_MPEG_VIDEO_HEVC_LEVEL_1) |
+		BIT(V4L2_MPEG_VIDEO_HEVC_LEVEL_2) |
+		BIT(V4L2_MPEG_VIDEO_HEVC_LEVEL_2_1) |
+		BIT(V4L2_MPEG_VIDEO_HEVC_LEVEL_3) |
+		BIT(V4L2_MPEG_VIDEO_HEVC_LEVEL_3_1) |
+		BIT(V4L2_MPEG_VIDEO_HEVC_LEVEL_4) |
+		BIT(V4L2_MPEG_VIDEO_HEVC_LEVEL_4_1) |
+		BIT(V4L2_MPEG_VIDEO_HEVC_LEVEL_5) |
+		BIT(V4L2_MPEG_VIDEO_HEVC_LEVEL_5_1) |
+		BIT(V4L2_MPEG_VIDEO_HEVC_LEVEL_5_2) |
+		BIT(V4L2_MPEG_VIDEO_HEVC_LEVEL_6) |
+		BIT(V4L2_MPEG_VIDEO_HEVC_LEVEL_6_1) |
+		BIT(V4L2_MPEG_VIDEO_HEVC_LEVEL_6_2),
+		V4L2_MPEG_VIDEO_HEVC_LEVEL_6_2,
+		V4L2_CID_MPEG_VIDEO_HEVC_LEVEL,
+		HFI_PROP_LEVEL,
+		CAP_FLAG_ROOT | CAP_FLAG_MENU,
+		{0},
+		{0},
+		NULL, msm_vidc_set_u32},
+
+	{HEVC_TIER, ENC|DEC, HEVC,
+		V4L2_MPEG_VIDEO_HEVC_TIER_MAIN,
+		V4L2_MPEG_VIDEO_HEVC_TIER_HIGH,
+		BIT(V4L2_MPEG_VIDEO_HEVC_TIER_MAIN) |
+		BIT(V4L2_MPEG_VIDEO_HEVC_TIER_HIGH),
+		V4L2_MPEG_VIDEO_HEVC_TIER_HIGH,
+		V4L2_CID_MPEG_VIDEO_HEVC_TIER,
+		HFI_PROP_TIER,
+		CAP_FLAG_ROOT | CAP_FLAG_MENU,
+		{0},
+		{0},
+		NULL, msm_vidc_set_u32},
+
+	{LF_MODE, ENC, HEVC,
+		V4L2_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE_DISABLED,
+		DB_HEVC_DISABLE_SLICE_BOUNDARY,
+		BIT(V4L2_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE_DISABLED) |
+		BIT(V4L2_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE_ENABLED) |
+		BIT(DB_HEVC_DISABLE_SLICE_BOUNDARY),
+		V4L2_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE_ENABLED,
+		V4L2_CID_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE,
+		HFI_PROP_DEBLOCKING_MODE,
+		CAP_FLAG_ROOT | CAP_FLAG_MENU},
+
+	{LF_BETA, ENC, HEVC,
+		-6, 6, 1, 0,
+		V4L2_CID_MPEG_VIDEO_HEVC_LF_BETA_OFFSET_DIV2,
+		HFI_PROP_DEBLOCKING_MODE,
+		CAP_FLAG_ROOT},
+
+	{LF_TC, ENC, HEVC,
+		-6, 6, 1, 0,
+		V4L2_CID_MPEG_VIDEO_HEVC_LF_TC_OFFSET_DIV2,
+		HFI_PROP_DEBLOCKING_MODE,
+		CAP_FLAG_ROOT},
+
+	{LOSSLESS, ENC, HEVC,
+		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
+		1, V4L2_MPEG_MSM_VIDC_DISABLE,
+		V4L2_CID_MPEG_VIDEO_HEVC_LOSSLESS_CU,
+		HFI_PROP_RATE_CONTROL,
+		CAP_FLAG_ROOT},
+
+	{L0_BR, ENC, HEVC,
+		1, 220000000, 1, 20000000,
+		V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L0_BR,
+		HFI_PROP_BITRATE_LAYER1,
+		CAP_FLAG_ROOT},
+
+	{L1_BR, ENC, HEVC,
+		1, 220000000, 1, 20000000,
+		V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L1_BR,
+		HFI_PROP_BITRATE_LAYER2,
+		CAP_FLAG_ROOT},
+
+	{L2_BR, ENC, HEVC,
+		1, 220000000, 1, 20000000,
+		V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L2_BR,
+		HFI_PROP_BITRATE_LAYER3,
+		CAP_FLAG_ROOT},
+
+	{L3_BR, ENC, HEVC,
+		1, 220000000, 1, 20000000,
+		V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L3_BR,
+		HFI_PROP_BITRATE_LAYER4,
+		CAP_FLAG_ROOT},
+
+	{L4_BR, ENC, HEVC,
+		1, 220000000, 1, 20000000,
+		V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L4_BR,
+		HFI_PROP_BITRATE_LAYER5,
+		CAP_FLAG_ROOT},
+
+	{L5_BR, ENC, HEVC,
+		1, 220000000, 1, 20000000,
+		V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L5_BR,
+		HFI_PROP_BITRATE_LAYER6,
+		CAP_FLAG_ROOT},
+
 	{BIT_RATE, ENC, HEVC,
 		1, 160000000, 1, 20000000,
-		V4L2_CID_MPEG_VIDEO_BITRATE, HFI_PROP_TOTAL_BITRATE,
+		V4L2_CID_MPEG_VIDEO_BITRATE,
+		HFI_PROP_TOTAL_BITRATE,
 		CAP_FLAG_DYNAMIC_ALLOWED,
-		/* TO DO parents */{0},
-		{LAYER_BITRATE, SLICE_BYTE},
+		/* TODO parents */{0},
+		{SLICE_MAX_BYTES},
 		msm_vidc_adjust_bitrate, msm_vidc_set_s32},
 
+	{SLICE_MAX_BYTES, ENC, H264|HEVC,
+		1, MAX_BITRATE / DEFAULT_FPS / 8 / 10,
+		1, MAX_BITRATE / DEFAULT_FPS / 8 / 10,
+		V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES,
+		HFI_PROP_MULTI_SLICE_BYTES_COUNT,
+		CAP_FLAG_ROOT},
+
+	{SLICE_MAX_MB, ENC, H264|HEVC,
+		1, (MAX_WIDTH * MAX_HEIGHT) / 256 / DEFAULT_FPS / 10,
+		1, (MAX_WIDTH * MAX_HEIGHT) / 256 / DEFAULT_FPS / 10,
+		V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB,
+		HFI_PROP_MULTI_SLICE_MB_COUNT,
+		CAP_FLAG_ROOT},
+
+	{SLICE_MODE, ENC, H264|HEVC,
+		V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE,
+		V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_MAX_BYTES,
+		BIT(V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE) |
+		BIT(V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_MAX_MB) |
+		BIT(V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_MAX_BYTES),
+		V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE,
+		V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE,
+		0,
+		CAP_FLAG_ROOT | CAP_FLAG_MENU},
+
+	/* Mpeg2 decoder specific */
+	{BIT_RATE, DEC, MPEG2,
+		1, 40000000, 1, 20000000,
+		V4L2_CID_MPEG_VIDEO_BITRATE,
+		HFI_PROP_TOTAL_BITRATE,
+		CAP_FLAG_DYNAMIC_ALLOWED,
+		{0}, {0},
+		msm_vidc_adjust_bitrate, msm_vidc_set_s32},
+
+	{LEVEL, DEC, MPEG2,
+		V4L2_MPEG_VIDEO_MPEG2_LEVEL_LOW,
+		V4L2_MPEG_VIDEO_MPEG2_LEVEL_HIGH,
+		BIT(V4L2_MPEG_VIDEO_MPEG2_LEVEL_LOW) |
+		BIT(V4L2_MPEG_VIDEO_MPEG2_LEVEL_MAIN) |
+		BIT(V4L2_MPEG_VIDEO_MPEG2_LEVEL_HIGH_1440) |
+		BIT(V4L2_MPEG_VIDEO_MPEG2_LEVEL_HIGH),
+		V4L2_MPEG_VIDEO_MPEG2_LEVEL_HIGH,
+		V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL,
+		HFI_PROP_LEVEL,
+		CAP_FLAG_ROOT | CAP_FLAG_MENU},
+
+	{PROFILE, DEC, MPEG2,
+		V4L2_MPEG_VIDEO_MPEG2_PROFILE_SIMPLE,
+		V4L2_MPEG_VIDEO_MPEG2_PROFILE_MAIN,
+		BIT(V4L2_MPEG_VIDEO_MPEG2_PROFILE_SIMPLE) |
+		BIT(V4L2_MPEG_VIDEO_MPEG2_PROFILE_MAIN),
+		V4L2_MPEG_VIDEO_MPEG2_PROFILE_MAIN,
+		V4L2_CID_MPEG_VIDEO_MPEG2_PROFILE,
+		HFI_PROP_PROFILE,
+		CAP_FLAG_ROOT | CAP_FLAG_MENU},
+
+	{FRAME_WIDTH, DEC, MPEG2, 128, 1920, 1, 1920},
+	{FRAME_HEIGHT, DEC, MPEG2, 128, 1920, 1, 1080},
+	/* (1920 * 1088) / 256 */
+	{MBPF, DEC, MPEG2, 64, 8160, 1, 8160},
+	/* ((1920 * 1088) / 256) * 30*/
+	{MBPS, DEC, MPEG2, 64, 244800, 1, 244800},
+	{FRAME_RATE, DEC, MPEG2, 1, 30, 1, 30},
+
+	/* H264 specific */
+	{CABAC_BITRATE, ENC, H264, 1, 160000000, 1, 20000000},
+
+	{I_FRAME_QP, ENC, H264,
+		0, 51, 1, 10,
+		V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP,
+		HFI_PROP_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	{P_FRAME_QP, ENC, H264,
+		0, 51, 1, 20,
+		V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP,
+		HFI_PROP_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	{B_FRAME_QP, ENC, H264,
+		0, 51, 1, 20,
+		V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP,
+		HFI_PROP_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	{MIN_FRAME_QP, ENC, H264,
+		0, 51, 1, 20,
+		V4L2_CID_MPEG_VIDEO_H264_MIN_QP,
+		HFI_PROP_MIN_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	{MAX_FRAME_QP, ENC, H264,
+		0, 51, 1, 20,
+		V4L2_CID_MPEG_VIDEO_H264_MAX_QP,
+		HFI_PROP_MAX_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	{LF_BETA, ENC, H264,
+		-6, 6, 1, 0,
+		V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA,
+		HFI_PROP_DEBLOCKING_MODE,
+		CAP_FLAG_ROOT},
+
+	{LF_ALPHA, ENC, H264,
+		-6, 6, 1, 0,
+		V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA,
+		HFI_PROP_DEBLOCKING_MODE,
+		CAP_FLAG_ROOT},
+
+	{MB_RC, ENC, CODECS_ALL,
+		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
+		1, V4L2_MPEG_MSM_VIDC_ENABLE,
+		V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE,
+		0,
+		CAP_FLAG_ROOT},
+
+	{TRANSFORM_8X8, ENC, H264,
+		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
+		1, V4L2_MPEG_MSM_VIDC_ENABLE,
+		V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM,
+		HFI_PROP_8X8_TRANSFORM,
+		CAP_FLAG_ROOT},
+
 	{ENTROPY_MODE, ENC, H264,
 		V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC,
 		V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CABAC,
 		BIT(V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC) |
 		BIT(V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CABAC),
 		V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CABAC,
-		V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE, HFI_PROP_CABAC_SESSION,
-		CAP_FLAG_MENU,
-		{CODEC, PROFILE},
+		V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE,
+		HFI_PROP_CABAC_SESSION,
+		CAP_FLAG_ROOT | CAP_FLAG_MENU,
+		{PROFILE},
 		{BIT_RATE},
 		msm_vidc_adjust_entropy_mode, msm_vidc_set_u32},
 
@@ -172,7 +754,8 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		BIT(V4L2_MPEG_VIDEO_H264_PROFILE_HIGH) |
 		BIT(V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_10),
 		V4L2_MPEG_VIDEO_H264_PROFILE_HIGH,
-		V4L2_CID_MPEG_VIDEO_H264_PROFILE, HFI_PROP_PROFILE,
+		V4L2_CID_MPEG_VIDEO_H264_PROFILE,
+		HFI_PROP_PROFILE,
 		CAP_FLAG_ROOT | CAP_FLAG_MENU,
 		{0},
 		{ENTROPY_MODE},
@@ -180,7 +763,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 
 	{LEVEL, ENC|DEC, H264,
 		V4L2_MPEG_VIDEO_H264_LEVEL_1_0,
-		V4L2_MPEG_VIDEO_H264_LEVEL_6_2,
+		V4L2_MPEG_VIDEO_H264_LEVEL_5_1,
 		BIT(V4L2_MPEG_VIDEO_H264_LEVEL_1_0) |
 		BIT(V4L2_MPEG_VIDEO_H264_LEVEL_1B) |
 		BIT(V4L2_MPEG_VIDEO_H264_LEVEL_1_1) |
@@ -196,90 +779,121 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		BIT(V4L2_MPEG_VIDEO_H264_LEVEL_4_1) |
 		BIT(V4L2_MPEG_VIDEO_H264_LEVEL_4_2) |
 		BIT(V4L2_MPEG_VIDEO_H264_LEVEL_5_0) |
-		BIT(V4L2_MPEG_VIDEO_H264_LEVEL_5_1) |
-		BIT(V4L2_MPEG_VIDEO_H264_LEVEL_5_2) |
-		BIT(V4L2_MPEG_VIDEO_H264_LEVEL_6_0) |
-		BIT(V4L2_MPEG_VIDEO_H264_LEVEL_6_1) |
-		BIT(V4L2_MPEG_VIDEO_H264_LEVEL_6_2),
-		V4L2_MPEG_VIDEO_H264_LEVEL_6_2,
-		V4L2_CID_MPEG_VIDEO_H264_LEVEL, HFI_PROP_LEVEL,
-		/* TO DO(AS) */
+		BIT(V4L2_MPEG_VIDEO_H264_LEVEL_5_1),
+		V4L2_MPEG_VIDEO_H264_LEVEL_5_1,
+		V4L2_CID_MPEG_VIDEO_H264_LEVEL,
+		HFI_PROP_LEVEL,
 		CAP_FLAG_ROOT | CAP_FLAG_MENU,
 		{0},
 		{0},
 		NULL, msm_vidc_set_u32},
 
-	{CABAC_BITRATE, ENC, H264, 1, 160000000, 1, 20000000},
-	{VBV_DELAY, ENC, CODECS_ALL,
-		0, 1000, 500, 0,
-		V4L2_CID_MPEG_VIDEO_VBV_DELAY},
-
-	{SCALE_X, ENC, CODECS_ALL, 8192, 65536, 1, 8192},
-	{SCALE_Y, ENC, CODECS_ALL, 8192, 65536, 1, 8192},
-	{SCALE_X, DEC, CODECS_ALL, 65536, 65536, 1, 65536},
-	{SCALE_Y, DEC, CODECS_ALL, 65536, 65536, 1, 65536},
-	{B_FRAME, ENC, H264|HEVC, 0, 1, 1, 0},
-	{HIER_P_LAYERS, ENC, H264|HEVC, 0, 6, 1, 0},
-	{LTR_COUNT, ENC, H264|HEVC, 0, 2, 1, 0},
-	/* ((4096 * 2304) / 256) * 60 fps */
-	{POWER_SAVE_MBPS, ENC, CODECS_ALL,
-		0, 2211840, 1, 2211840},
-	{I_FRAME_QP, ENC, H264|HEVC, 0, 51, 1, 10},
-	{P_FRAME_QP, ENC, H264|HEVC, 0, 51, 1, 20},
-	{B_FRAME_QP, ENC, H264|HEVC, 0, 51, 1, 20},
-	{I_FRAME_QP, ENC, VP9, 0, 127, 1, 20},
-	{P_FRAME_QP, ENC, VP9, 0, 127, 1, 40},
-	{B_FRAME_QP, ENC, VP9, 0, 127, 1, 40},
-	/* 10 slices */
-	{SLICE_BYTE, ENC, H264|HEVC, 1, 10, 1, 10},
-	{SLICE_MB, ENC, H264|HEVC, 1, 10, 1, 10},
-
-	/* Mpeg2 decoder specific */
-	{FRAME_WIDTH, DEC, MPEG2, 128, 1920, 1, 1920},
-	{FRAME_HEIGHT, DEC, MPEG2, 128, 1920, 1, 1080},
-	/* (1920 * 1088) / 256 */
-	{MBPF, DEC, MPEG2, 64, 8160, 1, 8160},
-	/* ((1920 * 1088) / 256) * 30*/
-	{MBPS, DEC, MPEG2, 64, 244800, 1, 244800},
-	{FRAME_RATE, DEC, MPEG2, 1, 30, 1, 30},
-	{BIT_RATE, DEC, MPEG2, 1, 40000000, 1, 20000000},
-
-	/* Secure usecase specific */
-	{SECURE_FRAME_WIDTH, ENC|DEC, CODECS_ALL, 128, 4096, 1, 1920},
-	{SECURE_FRAME_HEIGHT, ENC|DEC, CODECS_ALL, 128, 4096, 1, 1080},
-	/* (4096 * 2304) / 256 */
-	{SECURE_MBPF, ENC|DEC, CODECS_ALL, 64, 36864, 1, 36864},
-	{SECURE_BIT_RATE, ENC|DEC, CODECS_ALL, 1, 40000000, 1, 20000000},
+	{LF_MODE, ENC, H264,
+		V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED,
+		DB_H264_DISABLE_SLICE_BOUNDARY,
+		BIT(V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED) |
+		BIT(V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED) |
+		BIT(DB_H264_DISABLE_SLICE_BOUNDARY),
+		V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED,
+		V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE,
+		HFI_PROP_DEBLOCKING_MODE,
+		CAP_FLAG_ROOT | CAP_FLAG_MENU},
+
+	{HIER_CODING, ENC, H264,
+		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
+		1, V4L2_MPEG_MSM_VIDC_DISABLE,
+		V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING,
+		HFI_PROP_LAYER_ENCODING_TYPE,
+		CAP_FLAG_ROOT},
+
+	/* TODO(AS) - ctrl init failing. Need to fix
+	{HIER_CODING_TYPE, ENC, H264,
+		V4L2_MPEG_VIDEO_H264_HIERARCHICAL_CODING_B,
+		V4L2_MPEG_VIDEO_H264_HIERARCHICAL_CODING_P,
+		BIT(V4L2_MPEG_VIDEO_H264_HIERARCHICAL_CODING_B) |
+		BIT(V4L2_MPEG_VIDEO_H264_HIERARCHICAL_CODING_P),
+		V4L2_MPEG_VIDEO_H264_HIERARCHICAL_CODING_P,
+		V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPE,
+		HFI_PROP_LAYER_ENCODING_TYPE,
+		CAP_FLAG_ROOT | CAP_FLAG_MENU},
+	*/
 
-	/* Batch Mode Decode */
-	{BATCH_MBPF, DEC, CODECS_ALL, 64, 34816, 1, 34816},
-	/* (4096 * 2176) / 256 */
-	{BATCH_FRAME_RATE, DEC, CODECS_ALL, 1, 120, 1, 120},
+	{HIER_CODING_LAYER, ENC, H264,
+		0, 6, 1, 0,
+		V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER,
+		HFI_PROP_LAYER_COUNT,
+		CAP_FLAG_ROOT},
+
+	{HIER_LAYER_QP, ENC, H264,
+		0, 0x0060033, 1, 20,
+		V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER_QP,
+		HFI_PROP_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	/* TODO: CHROMA_QP_INDEX_OFFSET is applicable to HEVC as well */
+	{CHROMA_QP_INDEX_OFFSET, ENC, H264,
+		MIN_CHROMA_QP_OFFSET, MAX_CHROMA_QP_OFFSET,
+		1, MAX_CHROMA_QP_OFFSET,
+		V4L2_CID_MPEG_VIDEO_H264_CHROMA_QP_INDEX_OFFSET,
+		HFI_PROP_CHROMA_QP_OFFSET,
+		CAP_FLAG_ROOT},
+
+	{I_FRAME_MIN_QP, ENC, H264,
+		0, 51, 1, 20,
+		V4L2_CID_MPEG_VIDEO_H264_I_FRAME_MIN_QP,
+		HFI_PROP_MIN_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	{I_FRAME_MAX_QP, ENC, H264,
+		0, 51, 1, 20,
+		V4L2_CID_MPEG_VIDEO_H264_I_FRAME_MAX_QP,
+		HFI_PROP_MIN_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	{P_FRAME_MIN_QP, ENC, H264,
+		0, 51, 1, 20,
+		V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MIN_QP,
+		HFI_PROP_MIN_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	{P_FRAME_MAX_QP, ENC, H264,
+		0, 51, 1, 20,
+		V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MAX_QP,
+		HFI_PROP_MIN_QP_PACKED,
+		CAP_FLAG_ROOT},
+
+	{DISPLAY_DELAY, DEC, CODECS_ALL,
+		0, 1, 1, 0,
+		V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY,
+		HFI_PROP_DECODE_ORDER_OUTPUT,
+		CAP_FLAG_ROOT},
+
+	{DISPLAY_DELAY_ENABLE, DEC, CODECS_ALL,
+		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
+		1, V4L2_MPEG_MSM_VIDC_DISABLE,
+		V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY_ENABLE,
+		HFI_PROP_DECODE_ORDER_OUTPUT,
+		CAP_FLAG_ROOT},
 
-	/* Lossless encoding usecase specific */
-	{LOSSLESS_FRAME_WIDTH, ENC, H264|HEVC, 128, 4096, 1, 1920},
-	{LOSSLESS_FRAME_HEIGHT, ENC, H264|HEVC, 128, 4096, 1, 1080},
-	/* (4096 * 2304) / 256 */
-	{LOSSLESS_MBPF, ENC, H264|HEVC, 64, 36864, 1, 36864},
+	/* VP9 specific */
+	{I_FRAME_QP, ENC, VP9, 0, 127, 1, 20},
 
-	/* All intra encoding usecase specific */
-	{ALL_INTRA_FRAME_RATE, ENC, H264|HEVC, 1, 240, 1, 30},
+	{P_FRAME_QP, ENC, VP9, 0, 127, 1, 40},
 
-	/* Image specific */
-	{HEVC_IMAGE_FRAME_WIDTH, ENC, HEVC, 128, 512, 1, 512},
-	{HEVC_IMAGE_FRAME_HEIGHT, ENC, HEVC, 128, 512, 1, 512},
-	{HEIC_IMAGE_FRAME_WIDTH, ENC, HEVC, 512, 16384, 1, 16384},
-	{HEIC_IMAGE_FRAME_HEIGHT, ENC, HEVC, 512, 16384, 1, 16384},
+	{B_FRAME_QP, ENC, VP9, 0, 127, 1, 40},
 
-	{MB_CYCLES_VSP, ENC, CODECS_ALL, 25, 25, 1, 25},
-	{MB_CYCLES_VPP, ENC, CODECS_ALL, 675, 675, 1, 675},
-	{MB_CYCLES_LP, ENC, CODECS_ALL, 320, 320, 1, 320},
-	{MB_CYCLES_VSP, DEC, CODECS_ALL, 25, 25, 1, 25},
-	{MB_CYCLES_VSP, DEC, VP9, 60, 60, 1, 60},
-	{MB_CYCLES_VPP, DEC, CODECS_ALL, 200, 200, 1, 200},
-	{MB_CYCLES_LP, DEC, CODECS_ALL, 200, 200, 1, 200},
-	{MB_CYCLES_FW, ENC|DEC, CODECS_ALL, 326389, 326389, 1, 326389},
-	{MB_CYCLES_FW_VPP, ENC|DEC, CODECS_ALL, 44156, 44156, 1, 44156},
+	{PROFILE, DEC, VP9,
+		V4L2_MPEG_VIDEO_VP9_PROFILE_0,
+		V4L2_MPEG_VIDEO_VP9_PROFILE_2,
+		BIT(V4L2_MPEG_VIDEO_VP9_PROFILE_0) |
+		BIT(V4L2_MPEG_VIDEO_VP9_PROFILE_2),
+		V4L2_MPEG_VIDEO_VP9_PROFILE_0,
+		V4L2_CID_MPEG_VIDEO_VP9_PROFILE,
+		HFI_PROP_PROFILE,
+		CAP_FLAG_ROOT | CAP_FLAG_MENU,
+		{0},
+		{ENTROPY_MODE},
+		NULL, msm_vidc_set_u32},
 };
 
 /*

driver/vidc/inc/hfi_property.h

@@ -233,7 +233,7 @@ enum hfi_rate_control {
 };
 #define HFI_PROP_RATE_CONTROL                                   0x0300012a
 
-#define HFI_PROP_FRAMERATE_BASED_RATE_CONTROL                   0x0300012b
+#define HFI_PROP_TIME_DELTA_BASED_RATE_CONTROL                  0x0300012b
 
 #define HFI_PROP_CONTENT_ADAPTIVE_CODING                        0x0300012c
 

driver/vidc/inc/msm_vidc_control.h

@@ -10,15 +10,25 @@
 #include "msm_vidc_inst.h"
 #include "msm_vidc_internal.h"
 
+#define MAX_GOP                 0xFFFFFFF
+#define MAX_INTRA_REFRESH_MBS   ((7680 * 4320) >> 8)
+#define MAX_BASE_LAYER_PRIORITY_ID 63
+#define MIN_CHROMA_QP_OFFSET    -12
+#define MAX_CHROMA_QP_OFFSET    12
+#define MAX_LTR_FRAME_COUNT     10
+#define MAX_BITRATE             220000000
+
 enum msm_vidc_ctrl_list_type {
 	CHILD_LIST          = BIT(0),
 	FW_LIST             = BIT(1),
 };
 
 int msm_vidc_ctrl_init(struct msm_vidc_inst *inst);
+int msm_vidc_ctrl_deinit(struct msm_vidc_inst *inst);
 int msm_v4l2_op_s_ctrl(struct v4l2_ctrl *ctrl);
 int msm_vidc_adjust_bitrate(void *instance, struct v4l2_ctrl *ctrl);
 int msm_vidc_adjust_entropy_mode(void *instance, struct v4l2_ctrl *ctrl);
+int msm_vidc_adjust_ltr_count(void *instance, struct v4l2_ctrl *ctrl);
 int msm_vidc_adjust_properties(struct msm_vidc_inst *inst);
 int msm_vidc_set_u32(void *instance,
 	enum msm_vidc_inst_capability_type cap_id);

driver/vidc/inc/msm_vidc_internal.h

@@ -24,6 +24,8 @@
 #define DEFAULT_TIMEOUT   3
 #define DEFAULT_HEIGHT    240
 #define DEFAULT_WIDTH     320
+#define MAX_HEIGHT        4320
+#define MAX_WIDTH         8192
 #define MIN_SUPPORTED_WIDTH   32
 #define MIN_SUPPORTED_HEIGHT  32
 #define DEFAULT_FPS       30
@@ -38,6 +40,9 @@
 #define DEFAULT_BSE_VPP_DELAY    2
 #define MAX_CAP_PARENTS          16
 #define MAX_CAP_CHILDREN         16
+/* TODO
+ * #define MAX_SUPERFRAME_COUNT     32
+*/
 
 /* Maintains the number of FTB's between each FBD over a window */
 #define DCVS_FTB_WINDOW 16
@@ -72,6 +77,12 @@
 #define NUM_MBS_720P (((1280 + 15) >> 4) * ((720 + 15) >> 4))
 #define NUM_MBS_4k (((4096 + 15) >> 4) * ((2304 + 15) >> 4))
 
+#define DB_H264_DISABLE_SLICE_BOUNDARY \
+		V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED_AT_SLICE_BOUNDARY
+
+#define DB_HEVC_DISABLE_SLICE_BOUNDARY \
+		V4L2_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE_DISABLED_AT_SLICE_BOUNDARY
+
 /*
  * Convert Q16 number into Integer and Fractional part upto 2 places.
  * Ex : 105752 / 65536 = 1.61; 1.61 in Q16 = 105752;
@@ -206,48 +217,18 @@ enum msm_vidc_core_capability_type {
 
 enum msm_vidc_inst_capability_type {
 	INST_CAP_NONE = 0,
-	CODEC,
 	FRAME_WIDTH,
 	FRAME_HEIGHT,
 	PIX_FMTS,
 	MIN_BUFFERS_INPUT,
 	MIN_BUFFERS_OUTPUT,
-	DECODE_ORDER,
-	THUMBNAIL_MODE,
-	SECURE_MODE,
-	LOWLATENCY_MODE,
-	LOWLATENCY_HINT,
-	BUF_SIZE_LIMIT,
 	MBPF,
 	MBPS,
 	FRAME_RATE,
-	BIT_RATE,
-	BITRATE_MODE,
-	LAYER_BITRATE,
-	ENTROPY_MODE,
-	CABAC_BITRATE,
-	VBV_DELAY,
-	LTR_COUNT,
-	LCU_SIZE,
-	POWER_SAVE_MBPS,
 	SCALE_X,
 	SCALE_Y,
-	PROFILE,
-	LEVEL,
-	I_FRAME_QP,
-	P_FRAME_QP,
-	B_FRAME_QP,
 	B_FRAME,
-	HIER_P_LAYERS,
-	BLUR_WIDTH,
-	BLUR_HEIGHT,
-	SLICE_BYTE,
-	SLICE_MB,
-	SECURE,
-	SECURE_FRAME_WIDTH,
-	SECURE_FRAME_HEIGHT,
-	SECURE_MBPF,
-	SECURE_BIT_RATE,
+	POWER_SAVE_MBPS,
 	BATCH_MBPF,
 	BATCH_FRAME_RATE,
 	LOSSLESS_FRAME_WIDTH,
@@ -263,6 +244,83 @@ enum msm_vidc_inst_capability_type {
 	MB_CYCLES_LP,
 	MB_CYCLES_FW,
 	MB_CYCLES_FW_VPP,
+	HFLIP,
+	VFLIP,
+	PREPEND_SPSPPS_TO_IDR,
+	REQUEST_I_FRAME,
+	SLICE_INTERFACE,
+	FRAME_RC,
+	BITRATE_MODE,
+	HEADER_MODE,
+	GOP_SIZE,
+	GOP_CLOSURE,
+	BIT_RATE,
+	SECURE_FRAME_WIDTH,
+	SECURE_FRAME_HEIGHT,
+	SECURE_MBPF,
+	SECURE_MODE,
+	BLUR_TYPES,
+	BLUR_RESOLUTION,
+	CSC_CUSTOM_MATRIX,
+	HEIC,
+	LOWLATENCY_MODE,
+	LTR_COUNT,
+	USE_LTR,
+	MARK_LTR,
+	BASELAYER_PRIORITY,
+	IR_RANDOM,
+	AU_DELIMITER,
+	TIME_DELTA_BASED_RC,
+	CONTENT_ADAPTIVE_CODING,
+	BITRATE_BOOST,
+	ROTATION,
+	VBV_DELAY,
+	MIN_FRAME_QP,
+	MAX_FRAME_QP,
+	HEVC_HIER_QP,
+	I_FRAME_QP,
+	P_FRAME_QP,
+	I_FRAME_MIN_QP,
+	I_FRAME_MAX_QP,
+	P_FRAME_MIN_QP,
+	P_FRAME_MAX_QP,
+	B_FRAME_QP,
+	B_FRAME_MIN_QP,
+	B_FRAME_MAX_QP,
+	HIER_CODING_TYPE,
+	HIER_CODING_LAYER,
+	L0_QP,
+	L1_QP,
+	L2_QP,
+	L3_QP,
+	L4_QP,
+	L5_QP,
+	PROFILE,
+	LEVEL,
+	HEVC_TIER,
+	LF_MODE,
+	LF_ALPHA,
+	LF_BETA,
+	LF_TC,
+	LOSSLESS,
+	L0_BR,
+	L1_BR,
+	L2_BR,
+	L3_BR,
+	L4_BR,
+	L5_BR,
+	SLICE_MAX_BYTES,
+	SLICE_MAX_MB,
+	SLICE_MODE,
+	CABAC_BITRATE,
+	MB_RC,
+	TRANSFORM_8X8,
+	ENTROPY_MODE,
+	HIER_CODING,
+	HIER_LAYER_QP,
+	CHROMA_QP_INDEX_OFFSET,
+	DISPLAY_DELAY_ENABLE,
+	DISPLAY_DELAY,
 	INST_CAP_MAX,
 };
 

driver/vidc/src/msm_vdec.c

@@ -12,6 +12,7 @@
 #include "msm_vidc_driver.h"
 #include "msm_vidc_internal.h"
 #include "msm_vidc_platform.h"
+#include "msm_vidc_control.h"
 #include "msm_vidc_debug.h"
 #include "venus_hfi.h"
 #include "hfi_packet.h"
@@ -40,17 +41,31 @@ u32 msm_vdec_deliver_as_metadata[] = {
 	HFI_PROP_BUFFER_TAG,
 };
 
-static int msm_vdec_codec_change(struct msm_vidc_inst *inst, u32 codec)
+static int msm_vdec_codec_change(struct msm_vidc_inst *inst, u32 v4l2_codec)
 {
 	int rc = 0;
 
-	d_vpr_h("%s()\n", __func__);
+	if (inst->codec && inst->fmts[INPUT_PORT].fmt.pix_mp.pixelformat == v4l2_codec)
+		return 0;
+
+	s_vpr_h(inst->sid, "%s: codec changed from %#x to %#x\n",
+		__func__, inst->fmts[INPUT_PORT].fmt.pix_mp.pixelformat, v4l2_codec);
 
-	inst->codec = v4l2_codec_to_driver(codec, __func__);
+	inst->codec = v4l2_codec_to_driver(v4l2_codec, __func__);
 	rc = msm_vidc_get_inst_capability(inst);
 	if (rc)
-		return rc;
-	return 0;
+		goto exit;
+
+	rc = msm_vidc_ctrl_deinit(inst);
+	if (rc)
+		goto exit;
+
+	rc = msm_vidc_ctrl_init(inst);
+	if(rc)
+		goto exit;
+
+exit:
+	return rc;
 }
 
 static int msm_vdec_set_resolution(struct msm_vidc_inst *inst,

driver/vidc/src/msm_venc.c

@@ -12,6 +12,7 @@
 #include "msm_vidc_driver.h"
 #include "msm_vidc_internal.h"
 #include "msm_vidc_platform.h"
+#include "msm_vidc_control.h"
 #include "msm_vidc_debug.h"
 #include "venus_hfi.h"
 #include "hfi_packet.h"
@@ -55,14 +56,30 @@ u32 msm_venc_output_subscribe_for_properties[] = {
 	HFI_PROP_BUFFER_MARK,
 };
 
-static int msm_venc_codec_change(struct msm_vidc_inst *inst, u32 codec)
+static int msm_venc_codec_change(struct msm_vidc_inst *inst, u32 v4l2_codec)
 {
 	int rc = 0;
 
-	d_vpr_h("%s()\n", __func__);
+	if (inst->codec && inst->fmts[OUTPUT_PORT].fmt.pix_mp.pixelformat == v4l2_codec)
+		return 0;
+
+	s_vpr_h(inst->sid, "%s: codec changed from %#x to %#x\n",
+		__func__, inst->fmts[OUTPUT_PORT].fmt.pix_mp.pixelformat, v4l2_codec);
 
-	inst->codec = v4l2_codec_to_driver(codec, __func__);
+	inst->codec = v4l2_codec_to_driver(v4l2_codec, __func__);
 	rc = msm_vidc_get_inst_capability(inst);
+	if (rc)
+		goto exit;
+
+	rc = msm_vidc_ctrl_deinit(inst);
+	if (rc)
+		goto exit;
+
+	rc = msm_vidc_ctrl_init(inst);
+	if (rc)
+		goto exit;
+
+exit:
 	return rc;
 }
 

driver/vidc/src/msm_vidc.c

@@ -804,9 +804,6 @@ void *msm_vidc_open(void *vidc_core, u32 session_type)
 		if (rc)
 			goto error;
 	}
-	rc = msm_vidc_ctrl_init(inst);
-	if (rc)
-		goto error;
 
 	rc = msm_vidc_vb2_queue_init(inst);
 	if (rc)

driver/vidc/src/msm_vidc_control.c

@@ -20,10 +20,6 @@ static bool is_priv_ctrl(u32 id)
 	 * Treat below standard controls as private because
 	 * we have added custom values to the controls
 	 */
-	switch (id) {
-	case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
-		return true;
-	}
 
 	return false;
 }
@@ -47,6 +43,13 @@ static const char *const mpeg_video_stream_format[] = {
 	NULL,
 };
 
+static const char *const mpeg_video_blur_types[] = {
+	"Blur None",
+	"Blur External",
+	"Blur Adaptive",
+	NULL,
+};
+
 static const char *const roi_map_type[] = {
 	"None",
 	"2-bit",
@@ -62,6 +65,8 @@ static const char * const * msm_vidc_get_qmenu_type(
 		return mpeg_video_rate_control;
 	case V4L2_CID_MPEG_VIDEO_HEVC_SIZE_OF_LENGTH_FIELD:
 		return mpeg_video_stream_format;
+	case V4L2_CID_MPEG_VIDC_VIDEO_BLUR_TYPES:
+		return mpeg_video_blur_types;
 	default:
 		s_vpr_e(inst->sid, "%s: No available qmenu for ctrl %#x\n",
 			__func__, control_id);
@@ -72,18 +77,50 @@ static const char * const * msm_vidc_get_qmenu_type(
 static const char *msm_vidc_get_priv_ctrl_name(u32 sid, u32 control_id)
 {
 	switch (control_id) {
-	case V4L2_CID_MPEG_VIDC_THUMBNAIL_MODE:
-		return "Sync Frame Decode";
 	case V4L2_CID_MPEG_VIDC_SECURE:
 		return "Secure Mode";
+	case V4L2_CID_MPEG_VIDC_HEIC:
+		return "HEIC";
 	case V4L2_CID_MPEG_VIDC_LOWLATENCY_REQUEST:
 		return "Low Latency Mode";
-	/* TODO(AS)
-	case V4L2_CID_MPEG_VIDC_VIDEO_LOWLATENCY_HINT:
-		return "Low Latency Hint";
-	case V4L2_CID_MPEG_VIDC_VIDEO_BUFFER_SIZE_LIMIT:
-		return "Buffer Size Limit";
-	*/
+	case V4L2_CID_MPEG_VIDC_CODEC_CONFIG:
+		return "Codec Config";
+	case V4L2_CID_MPEG_VIDC_B_FRAME_MIN_QP:
+		return "B frame Min QP";
+	case V4L2_CID_MPEG_VIDC_B_FRAME_MAX_QP:
+		return "B frame Max QP";
+	case V4L2_CID_MPEG_VIDC_LTRCOUNT:
+		return "LTR count";
+	case V4L2_CID_MPEG_VIDC_USELTRFRAME:
+		return "Use LTR Frame";
+	case V4L2_CID_MPEG_VIDC_MARKLTRFRAME:
+		return "Mark LTR Frame";
+	case V4L2_CID_MPEG_VIDC_BASELAYER_PRIORITY:
+		return "Baselayer Priority";
+	case V4L2_CID_MPEG_VIDC_INTRA_REFRESH_PERIOD:
+		return "Intra Refresh Period";
+	case V4L2_CID_MPEG_VIDC_AU_DELIMITER:
+		return "AU Delimiter";
+	case V4L2_CID_MPEG_VIDC_TIME_DELTA_BASED_RC:
+		return "Time Delta Based RC";
+	case V4L2_CID_MPEG_VIDC_CONTENT_ADAPTIVE_CODING:
+		return "Content Adaptive Coding";
+	case V4L2_CID_MPEG_VIDC_QUALITY_BITRATE_BOOST:
+		return "Quality Bitrate Boost";
+	case V4L2_CID_MPEG_VIDC_VIDEO_BLUR_TYPES:
+		return "Blur Types";
+	case V4L2_CID_MPEG_VIDC_VIDEO_BLUR_RESOLUTION:
+		return "Blur Resolution";
+	case V4L2_CID_MPEG_VIDC_VIDEO_VPE_CSC_CUSTOM_MATRIX:
+		return "CSC Custom Matrix";
+	case V4L2_CID_MPEG_VIDC_METADATA_ENABLE:
+		return "Metadata Enable";
+	case V4L2_CID_MPEG_VIDC_METADATA_DISABLE:
+		return "Metadata Disable";
+	case V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY:
+		return "H264 Display Delay";
+	case V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY_ENABLE:
+		return "H264 Display Delay Enable";
 	default:
 		s_vpr_e(sid, "%s: ctrl name not available for ctrl id %#x\n",
 			__func__, control_id);
@@ -169,6 +206,13 @@ static int msm_vidc_adjust_property(struct msm_vidc_inst *inst,
 
 	capability = inst->capabilities;
 
+	/*
+	 * skip for uninitialized cap properties.
+	 * Eg: Skip Tramform 8x8 cap that is uninitialized for HEVC codec
+	 */
+	if (!capability->cap[cap_id].cap)
+		return 0;
+
 	if (capability->cap[cap_id].adjust) {
 		rc = capability->cap[cap_id].adjust(inst, NULL);
 		if (rc)
@@ -180,7 +224,7 @@ static int msm_vidc_adjust_property(struct msm_vidc_inst *inst,
 	if (rc)
 		goto exit;
 
-	/* add cap_id to firmware list always */
+	/* add cap_id to firmware list  */
 	rc = msm_vidc_add_capid_to_list(inst, cap_id, FW_LIST);
 	if (rc)
 		goto exit;
@@ -252,6 +296,19 @@ exit:
 	return rc;
 }
 
+int msm_vidc_ctrl_deinit(struct msm_vidc_inst *inst)
+{
+	if (!inst) {
+		d_vpr_e("%s: invalid parameters\n", __func__);
+		return -EINVAL;
+	}
+
+	v4l2_ctrl_handler_free(&inst->ctrl_handler);
+	kfree(inst->ctrls);
+
+	return 0;
+}
+
 int msm_vidc_ctrl_init(struct msm_vidc_inst *inst)
 {
 	int rc = 0;
@@ -279,7 +336,8 @@ int msm_vidc_ctrl_init(struct msm_vidc_inst *inst)
 			num_ctrls++;
 	}
 	if (!num_ctrls) {
-		s_vpr_e(inst->sid, "%s: failed to allocate ctrl\n", __func__);
+		s_vpr_e(inst->sid, "%s: no ctrls available in cap database\n",
+			__func__);
 		return -EINVAL;
 	}
 	inst->ctrls = kcalloc(num_ctrls,
@@ -346,7 +404,7 @@ int msm_vidc_ctrl_init(struct msm_vidc_inst *inst)
 			ctrl_cfg.name = msm_vidc_get_priv_ctrl_name(inst->sid,
 					capability->cap[idx].v4l2_id);
 			if (!ctrl_cfg.name) {
-				s_vpr_e(inst->sid, "%s: invalid control, %#x\n",
+				s_vpr_e(inst->sid, "%s: %#x ctrl name is null\n",
 					__func__, ctrl_cfg.id);
 				return -EINVAL;
 			}
@@ -492,7 +550,7 @@ int msm_vidc_adjust_entropy_mode(void *instance, struct v4l2_ctrl *ctrl)
 	s32 adjusted_value;
 	enum msm_vidc_inst_capability_type parent_id;
 	struct msm_vidc_inst *inst = (struct msm_vidc_inst *) instance;
-	s32 codec = -1, profile = -1;
+	s32 profile = -1;
 
 	if (!inst || !inst->capabilities) {
 		d_vpr_e("%s: invalid params\n", __func__);
@@ -511,31 +569,29 @@ int msm_vidc_adjust_entropy_mode(void *instance, struct v4l2_ctrl *ctrl)
 	while (i < MAX_CAP_PARENTS &&
 		capability->cap[ENTROPY_MODE].parents[i]) {
 		parent_id = capability->cap[ENTROPY_MODE].parents[i];
-		if (parent_id == CODEC)
-			codec = inst->codec;
-		else if (parent_id == profile)
+		if (parent_id == PROFILE)
 			profile = capability->cap[PROFILE].value;
 		else
 			s_vpr_e(inst->sid,
 				"%s: invalid parent %d\n",
 				__func__, parent_id);
+		i++;
 	}
 
-	if (codec == -1 || profile == -1) {
+	if (profile == -1) {
 		s_vpr_e(inst->sid,
 			"%s: missing parents %d %d\n",
-			__func__, codec, profile);
+			__func__, profile);
 		return 0;
 	}
 
-	if (codec == MSM_VIDC_H264 &&
-	    (profile == V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE ||
+	if ((profile == V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE ||
 	    profile == V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE) &&
 	    adjusted_value == V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CABAC)
 		adjusted_value = V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC;
 
 	if (capability->cap[ENTROPY_MODE].value != adjusted_value) {
-		s_vpr_h(inst->sid, "%s: adjusted from %#x to %#x\n", __func__,
+		s_vpr_h(inst->sid, "%s: updated from %#x to adjusted %#x\n", __func__,
 			capability->cap[ENTROPY_MODE].value, adjusted_value);
 		capability->cap[ENTROPY_MODE].value = adjusted_value;
 	}
@@ -543,6 +599,50 @@ int msm_vidc_adjust_entropy_mode(void *instance, struct v4l2_ctrl *ctrl)
 	return rc;
 }
 
+int msm_vidc_adjust_ltr_count(void *instance, struct v4l2_ctrl *ctrl)
+{
+	int rc = 0;
+	int i = 0;
+	struct msm_vidc_inst_capability *capability;
+	s32 adjusted_value;
+	enum msm_vidc_inst_capability_type parent_id;
+	struct msm_vidc_inst *inst = (struct msm_vidc_inst *) instance;
+	s32 rc_type = -1;
+
+	if (!inst || !inst->capabilities) {
+		d_vpr_e("%s: invalid params\n", __func__);
+		return -EINVAL;
+	}
+	capability = inst->capabilities;
+
+	if (ctrl)
+		adjusted_value = ctrl->val;
+	else
+		adjusted_value = capability->cap[LTR_COUNT].value;
+
+	/* check parents and adjust cabac session value */
+	while (i < MAX_CAP_PARENTS &&
+		capability->cap[LTR_COUNT].parents[i]) {
+		parent_id = capability->cap[LTR_COUNT].parents[i];
+		i++;
+	}
+
+	if (!(rc_type == V4L2_MPEG_VIDEO_BITRATE_MODE_CBR
+		/* TODO(AS): remove comment after below rc modes are upstreamed
+		|| rc_type == RATE_CONTROL_OFF ||
+		|| rc_tpe == V4L2_MPEG_VIDEO_BITRATE_MODE_CBR_VFR
+		*/))
+		adjusted_value = 0;
+
+	if (capability->cap[LTR_COUNT].value != adjusted_value) {
+		s_vpr_h(inst->sid, "%s: adjusted from %#x to %#x\n", __func__,
+			capability->cap[LTR_COUNT].value, adjusted_value);
+		capability->cap[LTR_COUNT].value = adjusted_value;
+	}
+
+	return rc;
+}
+
 int msm_vidc_adjust_bitrate(void *instance, struct v4l2_ctrl *ctrl)
 {
 	int rc = 0;

driver/vidc/src/msm_vidc_driver.c

@@ -1280,8 +1280,8 @@ int msm_vidc_get_inst_capability(struct msm_vidc_inst *inst)
 		if (core->inst_caps[i].domain == inst->domain &&
 			core->inst_caps[i].codec == inst->codec) {
 			s_vpr_h(inst->sid,
-				"%s: copied capabilities with %#x codec\n",
-				__func__, inst->codec);
+				"%s: copied capabilities with %#x codec, %#x domain\n",
+				__func__, inst->codec, inst->domain);
 			memcpy(inst->capabilities, &core->inst_caps[i],
 				sizeof(struct msm_vidc_inst_capability));
 		}

include/uapi/vidc/media/v4l2_vidc_extensions.h

@@ -29,14 +29,15 @@
 /* vendor controls start */
 #define V4L2_CID_MPEG_VIDC_BASE                 (V4L2_CTRL_CLASS_MPEG | 0x2000)
 
+#define V4L2_MPEG_MSM_VIDC_DISABLE 0
+#define V4L2_MPEG_MSM_VIDC_ENABLE 1
+
 #define V4L2_CID_MPEG_VIDC_SECURE               (V4L2_CID_MPEG_VIDC_BASE + 0x1)
 /* HEIC encoder and decoder */
 #define V4L2_CID_MPEG_VIDC_HEIC                 (V4L2_CID_MPEG_VIDC_BASE + 0x2)
 #define V4L2_CID_MPEG_VIDC_LOWLATENCY_REQUEST   (V4L2_CID_MPEG_VIDC_BASE + 0x3)
 /* FIXme: */
 #define V4L2_CID_MPEG_VIDC_CODEC_CONFIG         (V4L2_CID_MPEG_VIDC_BASE + 0x4)
-/* thumbnail decoding */
-#define V4L2_CID_MPEG_VIDC_THUMBNAIL_MODE       (V4L2_CID_MPEG_VIDC_BASE + 0x4)
 /* B frame min/max qp */
 #define V4L2_CID_MPEG_VIDC_B_FRAME_MIN_QP       (V4L2_CID_MPEG_VIDC_BASE + 0x5)
 #define V4L2_CID_MPEG_VIDC_B_FRAME_MAX_QP       (V4L2_CID_MPEG_VIDC_BASE + 0x6)