video: driver: enable image encode and decode support

Added change to enable image encode and decode support.

Decoder:
    - codec: hevc
    - input buffer size: yuv size
    - run as turbo session
    - all intra session
    - disable dcvs & batching
    - ignore admission control(skip mbps, mbpf check)

Encoder:
    - codec: hevc
    - rc mode: CQ
    - profile: MainStillPic
    - all intra session
    - output buffer size: 2 * yuv size
    - output dimension: 512 x 512
    - disable dcvs & batching
    - ignore admission control(skip mbps, mbpf check)
    - skip scaling check
    - hfi: set grid enable & disable time_delta based rc.

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

driver/platform/waipio/src/msm_vidc_waipio.c

@@ -41,15 +41,14 @@
 #define H264    MSM_VIDC_H264
 #define HEVC    MSM_VIDC_HEVC
 #define VP9     MSM_VIDC_VP9
-#define CODECS_ALL     (MSM_VIDC_H264 | MSM_VIDC_HEVC | \
-			MSM_VIDC_VP9)
+#define HEIC    MSM_VIDC_HEIC
+#define CODECS_ALL     (H264 | HEVC | VP9 | HEIC)
 
 static struct msm_platform_core_capability core_data_waipio[] = {
 	/* {type, value} */
-	{ENC_CODECS, H264|HEVC},
-	{DEC_CODECS, H264|HEVC|VP9},
-	// TODO: MAX_SESSION_COUNT needs to be changed to 16
-	{MAX_SESSION_COUNT, 3},
+	{ENC_CODECS, H264|HEVC|HEIC},
+	{DEC_CODECS, H264|HEVC|VP9|HEIC},
+	{MAX_SESSION_COUNT, 16},
 	{MAX_SECURE_SESSION_COUNT, 3},
 	{MAX_MBPF, 173056},	/* (8192x4320)/256 + (4096x2176)/256*/
 	{MAX_MBPS, 7833600},	/* max_load
@@ -103,21 +102,17 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 	{FRAME_WIDTH, DEC, CODECS_ALL, 96, 8192, 1, 1920},
 	{FRAME_WIDTH, ENC, CODECS_ALL, 128, 8192, 1, 1920},
 	{LOSSLESS_FRAME_WIDTH, ENC, H264|HEVC, 128, 4096, 1, 1920},
-	{SECURE_FRAME_WIDTH, ENC|DEC, CODECS_ALL, 128, 4096, 1, 1920},
-	{HEVC_IMAGE_FRAME_WIDTH, ENC, HEVC, 128, 512, 1, 512},
-	{HEIC_IMAGE_FRAME_WIDTH, ENC, HEVC, 512, 16384, 1, 16384},
+	{SECURE_FRAME_WIDTH, ENC|DEC, H264|HEVC|VP9, 128, 4096, 1, 1920},
 	{FRAME_HEIGHT, DEC, CODECS_ALL, 96, 8192, 1, 1080},
 	{FRAME_HEIGHT, ENC, CODECS_ALL, 128, 8192, 1, 1080},
 	{LOSSLESS_FRAME_HEIGHT, ENC, H264|HEVC, 128, 4096, 1, 1080},
-	{SECURE_FRAME_HEIGHT, ENC|DEC, CODECS_ALL, 128, 4096, 1, 1080},
-	{HEVC_IMAGE_FRAME_HEIGHT, ENC, HEVC, 128, 512, 1, 512},
-	{HEIC_IMAGE_FRAME_HEIGHT, ENC, HEVC, 512, 16384, 1, 16384},
+	{SECURE_FRAME_HEIGHT, ENC|DEC, H264|HEVC|VP9, 128, 4096, 1, 1080},
 	{PIX_FMTS, ENC, H264,
 		MSM_VIDC_FMT_NV12,
 		MSM_VIDC_FMT_NV12C,
 		MSM_VIDC_FMT_NV12 | MSM_VIDC_FMT_NV21 | MSM_VIDC_FMT_NV12C,
 		MSM_VIDC_FMT_NV12C},
-	{PIX_FMTS, ENC, HEVC,
+	{PIX_FMTS, ENC, HEVC|HEIC,
 		MSM_VIDC_FMT_NV12,
 		MSM_VIDC_FMT_TP10C,
 		MSM_VIDC_FMT_NV12 | MSM_VIDC_FMT_NV21 | MSM_VIDC_FMT_NV12C |
@@ -128,7 +123,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		{0},
 		{PROFILE, MIN_FRAME_QP, MAX_FRAME_QP, I_FRAME_QP}},
 
-	{PIX_FMTS, DEC, HEVC,
+	{PIX_FMTS, DEC, HEVC|HEIC,
 		MSM_VIDC_FMT_NV12,
 		MSM_VIDC_FMT_TP10C,
 		MSM_VIDC_FMT_NV12 | MSM_VIDC_FMT_NV21 | MSM_VIDC_FMT_NV12C |
@@ -167,10 +162,10 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 	{LOSSLESS_MBPF, ENC, H264|HEVC, 64, 36864, 1, 36864},
 	/* Batch Mode Decode */
 	/* TODO: update with new values based on updated voltage corner */
-	{BATCH_MBPF, DEC, CODECS_ALL, 64, 34816, 1, 34816},
+	{BATCH_MBPF, DEC, H264|HEVC|VP9, 64, 34816, 1, 34816},
 	/* (4096 * 2304) / 256 */
-	{BATCH_FPS, DEC, CODECS_ALL, 1, 120, 1, 120},
-	{SECURE_MBPF, ENC|DEC, CODECS_ALL, 64, 36864, 1, 36864},
+	{BATCH_FPS, DEC, H264|HEVC|VP9, 1, 120, 1, 120},
+	{SECURE_MBPF, ENC|DEC, H264|HEVC|VP9, 64, 36864, 1, 36864},
 	/* ((1920 * 1088) / 256) * 480 fps */
 	{MBPS, ENC, CODECS_ALL, 64, 3916800, 1, 3916800},
 	/* ((1920 * 1088) / 256) * 960 fps */
@@ -194,10 +189,10 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 	{OPERATING_RATE, ENC|DEC, CODECS_ALL,
 		1, INT_MAX, 1, (DEFAULT_FPS << 16)},
 
-	{SCALE_X, ENC, CODECS_ALL, 8192, 65536, 1, 8192},
-	{SCALE_X, DEC, CODECS_ALL, 65536, 65536, 1, 65536},
-	{SCALE_Y, ENC, CODECS_ALL, 8192, 65536, 1, 8192},
-	{SCALE_Y, DEC, CODECS_ALL, 65536, 65536, 1, 65536},
+	{SCALE_X, ENC, H264|HEVC, 8192, 65536, 1, 8192},
+	{SCALE_X, DEC, H264|HEVC|VP9, 65536, 65536, 1, 65536},
+	{SCALE_Y, ENC, H264|HEVC, 8192, 65536, 1, 8192},
+	{SCALE_Y, DEC, H264|HEVC|VP9, 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,
@@ -215,7 +210,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 	{MB_CYCLES_FW, ENC|DEC, CODECS_ALL, 326389, 326389, 1, 326389},
 	{MB_CYCLES_FW_VPP, ENC|DEC, CODECS_ALL, 44156, 44156, 1, 44156},
 
-	{SECURE_MODE, ENC|DEC, CODECS_ALL,
+	{SECURE_MODE, ENC|DEC, H264|HEVC|VP9,
 		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
 		1, V4L2_MPEG_MSM_VIDC_DISABLE,
 		V4L2_CID_MPEG_VIDC_SECURE,
@@ -247,7 +242,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		HFI_PROP_ROTATION,
 		CAP_FLAG_ROOT | CAP_FLAG_OUTPUT_PORT},
 
-	{SUPER_FRAME, ENC, CODECS_ALL,
+	{SUPER_FRAME, ENC, H264|HEVC,
 		0, 16, 1, 0,
 		V4L2_CID_MPEG_VIDC_SUPERFRAME,
 		0},
@@ -304,7 +299,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 	/* TODO: Firmware introduced enumeration type for this
 	 * with and without seq header.
 	 */
-	{REQUEST_I_FRAME, ENC, CODECS_ALL,
+	{REQUEST_I_FRAME, ENC, H264|HEVC,
 		0, 0, 0, 0,
 		V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME,
 		HFI_PROP_REQUEST_SYNC_FRAME,
@@ -351,12 +346,12 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 			I_FRAME_QP, CONSTANT_QUALITY},
 		msm_vidc_adjust_bitrate_mode, msm_vidc_set_u32_enum},
 
-	{LOSSLESS, ENC, HEVC,
+	{LOSSLESS, ENC, HEVC|HEIC,
 		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
 		1, V4L2_MPEG_MSM_VIDC_DISABLE,
 		V4L2_CID_MPEG_VIDEO_HEVC_LOSSLESS_CU},
 
-	{FRAME_SKIP_MODE, ENC, CODECS_ALL,
+	{FRAME_SKIP_MODE, ENC, H264|HEVC,
 		V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_DISABLED,
 		V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_BUF_LIMIT,
 		BIT(V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_DISABLED) |
@@ -367,12 +362,12 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		0,
 		CAP_FLAG_OUTPUT_PORT | CAP_FLAG_MENU},
 
-	{FRAME_RC_ENABLE, ENC, CODECS_ALL,
+	{FRAME_RC_ENABLE, ENC, H264|HEVC,
 		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
 		1, V4L2_MPEG_MSM_VIDC_ENABLE,
 		V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE},
 
-	{CONSTANT_QUALITY, ENC, HEVC,
+	{CONSTANT_QUALITY, ENC, HEVC|HEIC,
 		1, MAX_CONSTANT_QUALITY, 1, 90,
 		V4L2_CID_MPEG_VIDEO_CONSTANT_QUALITY,
 		HFI_PROP_CONSTANT_QUALITY,
@@ -389,7 +384,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		{0}, {0},
 		NULL, msm_vidc_set_u32},
 
-	{GOP_CLOSURE, ENC, CODECS_ALL,
+	{GOP_CLOSURE, ENC, H264|HEVC,
 		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
 		1, V4L2_MPEG_MSM_VIDC_ENABLE,
 		V4L2_CID_MPEG_VIDEO_GOP_CLOSURE,
@@ -425,14 +420,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		HFI_PROP_CSC_MATRIX,
 		CAP_FLAG_ROOT | CAP_FLAG_OUTPUT_PORT}, */
 
-	{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 | CAP_FLAG_OUTPUT_PORT},
-
-	{LOWLATENCY_MODE, ENC|DEC, CODECS_ALL,
+	{LOWLATENCY_MODE, ENC|DEC, H264|HEVC|VP9,
 		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
 		1, V4L2_MPEG_MSM_VIDC_DISABLE,
 		V4L2_CID_MPEG_VIDC_LOWLATENCY_REQUEST,
@@ -469,7 +457,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		HFI_PROP_BASELAYER_PRIORITYID,
 		CAP_FLAG_ROOT | CAP_FLAG_OUTPUT_PORT},
 
-	{IR_RANDOM, ENC, CODECS_ALL,
+	{IR_RANDOM, ENC, H264|HEVC,
 		0, INT_MAX, 1, 0,
 		V4L2_CID_MPEG_VIDC_INTRA_REFRESH_PERIOD,
 		HFI_PROP_IR_RANDOM_PERIOD,
@@ -496,20 +484,20 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		{BITRATE_MODE}, {0},
 		msm_vidc_adjust_delta_based_rc, msm_vidc_set_u32},
 
-	{CONTENT_ADAPTIVE_CODING, ENC, CODECS_ALL,
+	{CONTENT_ADAPTIVE_CODING, ENC, H264|HEVC,
 		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 | CAP_FLAG_OUTPUT_PORT},
 
-	{BITRATE_BOOST, ENC, CODECS_ALL,
+	{BITRATE_BOOST, ENC, H264|HEVC,
 		0, 100, 25, 25,
 		V4L2_CID_MPEG_VIDC_QUALITY_BITRATE_BOOST,
 		HFI_PROP_BITRATE_BOOST,
 		CAP_FLAG_ROOT | CAP_FLAG_OUTPUT_PORT},
 
-	{VBV_DELAY, ENC, CODECS_ALL,
+	{VBV_DELAY, ENC, H264|HEVC,
 		0, 1000, 500, 0,
 		V4L2_CID_MPEG_VIDEO_VBV_DELAY},
 
@@ -521,7 +509,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		{0}, {0},
 		NULL, msm_vidc_set_min_qp},
 
-	{MIN_FRAME_QP, ENC, HEVC,
+	{MIN_FRAME_QP, ENC, HEVC|HEIC,
 		MIN_QP_10BIT, MAX_QP, 1, MIN_QP_10BIT,
 		V4L2_CID_MPEG_VIDEO_HEVC_MIN_QP,
 		HFI_PROP_MIN_QP_PACKED,
@@ -533,7 +521,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		MIN_QP_8BIT, MAX_QP, 1, MIN_QP_8BIT,
 		V4L2_CID_MPEG_VIDEO_H264_I_FRAME_MIN_QP},
 
-	{I_FRAME_MIN_QP, ENC, HEVC,
+	{I_FRAME_MIN_QP, ENC, HEVC|HEIC,
 		MIN_QP_10BIT, MAX_QP, 1, MIN_QP_10BIT,
 		V4L2_CID_MPEG_VIDC_HEVC_I_FRAME_MIN_QP},
 
@@ -541,7 +529,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		MIN_QP_8BIT, MAX_QP, 1, MIN_QP_8BIT,
 		V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MIN_QP},
 
-	{P_FRAME_MIN_QP, ENC, HEVC,
+	{P_FRAME_MIN_QP, ENC, HEVC|HEIC,
 		MIN_QP_10BIT, MAX_QP, 1, MIN_QP_10BIT,
 		V4L2_CID_MPEG_VIDC_HEVC_P_FRAME_MIN_QP},
 
@@ -549,7 +537,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		MIN_QP_8BIT, MAX_QP, 1, MIN_QP_8BIT,
 		V4L2_CID_MPEG_VIDC_B_FRAME_MIN_QP},
 
-	{B_FRAME_MIN_QP, ENC, HEVC,
+	{B_FRAME_MIN_QP, ENC, HEVC|HEIC,
 		MIN_QP_10BIT, MAX_QP, 1, MIN_QP_10BIT,
 		V4L2_CID_MPEG_VIDC_B_FRAME_MIN_QP},
 
@@ -561,7 +549,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		{0}, {0},
 		NULL, msm_vidc_set_min_qp},
 
-	{MAX_FRAME_QP, ENC, HEVC,
+	{MAX_FRAME_QP, ENC, HEVC|HEIC,
 		MIN_QP_10BIT, MAX_QP, 1, MAX_QP,
 		V4L2_CID_MPEG_VIDEO_HEVC_MAX_QP,
 		HFI_PROP_MAX_QP_PACKED,
@@ -573,7 +561,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		MIN_QP_8BIT, MAX_QP, 1, MAX_QP,
 		V4L2_CID_MPEG_VIDEO_H264_I_FRAME_MAX_QP},
 
-	{I_FRAME_MAX_QP, ENC, HEVC,
+	{I_FRAME_MAX_QP, ENC, HEVC|HEIC,
 		MIN_QP_10BIT, MAX_QP, 1, MAX_QP,
 		V4L2_CID_MPEG_VIDC_HEVC_I_FRAME_MAX_QP},
 
@@ -581,7 +569,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		MIN_QP_8BIT, MAX_QP, 1, MAX_QP,
 		V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MAX_QP},
 
-	{P_FRAME_MAX_QP, ENC, HEVC,
+	{P_FRAME_MAX_QP, ENC, HEVC|HEIC,
 		MIN_QP_10BIT, MAX_QP, 1, MAX_QP,
 		V4L2_CID_MPEG_VIDC_HEVC_P_FRAME_MAX_QP},
 
@@ -589,18 +577,18 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		MIN_QP_8BIT, MAX_QP, 1, MAX_QP,
 		V4L2_CID_MPEG_VIDC_B_FRAME_MAX_QP},
 
-	{B_FRAME_MAX_QP, ENC, HEVC,
+	{B_FRAME_MAX_QP, ENC, HEVC|HEIC,
 		MIN_QP_10BIT, MAX_QP, 1, MAX_QP,
 		V4L2_CID_MPEG_VIDC_B_FRAME_MAX_QP},
 
-	{HEVC_HIER_QP, ENC, HEVC,
+	{HEVC_HIER_QP, ENC, HEVC|HEIC,
 		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 | CAP_FLAG_OUTPUT_PORT},
 
-	{I_FRAME_QP, ENC, HEVC,
+	{I_FRAME_QP, ENC, HEVC|HEIC,
 		MIN_QP_10BIT, MAX_QP, 1, DEFAULT_QP,
 		V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_QP,
 		HFI_PROP_QP_PACKED,
@@ -616,7 +604,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		{BITRATE_MODE}, {0},
 		NULL, msm_vidc_set_frame_qp},
 
-	{P_FRAME_QP, ENC, HEVC,
+	{P_FRAME_QP, ENC, HEVC|HEIC,
 		MIN_QP_10BIT, MAX_QP, 1, DEFAULT_QP,
 		V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_QP},
 
@@ -624,9 +612,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		MIN_QP_8BIT, MAX_QP, 1, DEFAULT_QP,
 		V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP},
 
-	{P_FRAME_QP, ENC, VP9, 0, 127, 1, 40},
-
-	{B_FRAME_QP, ENC, HEVC,
+	{B_FRAME_QP, ENC, HEVC|HEIC,
 		MIN_QP_10BIT, MAX_QP, 1, DEFAULT_QP,
 		V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_QP},
 
@@ -771,7 +757,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		{0},
 		msm_vidc_adjust_entropy_mode, msm_vidc_set_u32},
 
-	{ENTROPY_MODE, DEC, CODECS_ALL,
+	{ENTROPY_MODE, DEC, H264|HEVC|VP9,
 		V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC,
 		V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CABAC,
 		BIT(V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC) |
@@ -813,7 +799,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		{ENTROPY_MODE},
 		NULL, msm_vidc_set_u32_enum},
 
-	{PROFILE, ENC|DEC, HEVC,
+	{PROFILE, ENC|DEC, HEVC|HEIC,
 		V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN,
 		V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_10,
 		BIT(V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN) |
@@ -867,7 +853,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		{0},
 		NULL, msm_vidc_set_u32_enum},
 
-	{LEVEL, ENC|DEC, HEVC,
+	{LEVEL, ENC|DEC, HEVC|HEIC,
 		V4L2_MPEG_VIDEO_HEVC_LEVEL_1,
 		V4L2_MPEG_VIDEO_HEVC_LEVEL_6_2,
 		BIT(V4L2_MPEG_VIDEO_HEVC_LEVEL_1) |
@@ -895,7 +881,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 	 *	go/videogki
 	 */
 
-	{HEVC_TIER, ENC|DEC, HEVC,
+	{HEVC_TIER, ENC|DEC, HEVC|HEIC,
 		V4L2_MPEG_VIDEO_HEVC_TIER_MAIN,
 		V4L2_MPEG_VIDEO_HEVC_TIER_HIGH,
 		BIT(V4L2_MPEG_VIDEO_HEVC_TIER_MAIN) |
@@ -921,7 +907,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		{0}, {0},
 		NULL, msm_vidc_set_deblock_mode},
 
-	{LF_MODE, ENC, HEVC,
+	{LF_MODE, ENC, HEVC|HEIC,
 		V4L2_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE_DISABLED,
 		DB_HEVC_DISABLE_SLICE_BOUNDARY,
 		BIT(V4L2_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE_DISABLED) |
@@ -938,7 +924,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		-6, 6, 1, 0,
 		V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA},
 
-	{LF_ALPHA, ENC, HEVC,
+	{LF_ALPHA, ENC, HEVC|HEIC,
 		-6, 6, 1, 0,
 		V4L2_CID_MPEG_VIDEO_HEVC_LF_TC_OFFSET_DIV2},
 
@@ -946,11 +932,11 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		-6, 6, 1, 0,
 		V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA},
 
-	{LF_BETA, ENC, HEVC,
+	{LF_BETA, ENC, HEVC|HEIC,
 		-6, 6, 1, 0,
 		V4L2_CID_MPEG_VIDEO_HEVC_LF_BETA_OFFSET_DIV2},
 
-	{SLICE_MODE, ENC, H264|HEVC,
+	{SLICE_MODE, ENC, H264|HEVC|HEIC,
 		V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE,
 		V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_MAX_BYTES,
 		BIT(V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE) |
@@ -963,20 +949,20 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		{0}, {0},
 		NULL, msm_vidc_set_slice_count},
 
-	{SLICE_MAX_BYTES, ENC, H264|HEVC,
+	{SLICE_MAX_BYTES, ENC, H264|HEVC|HEIC,
 		1, INT_MAX, 1, INT_MAX,
 		V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES,
 		HFI_PROP_MULTI_SLICE_BYTES_COUNT,
 		CAP_FLAG_OUTPUT_PORT},
 
-	{SLICE_MAX_MB, ENC, H264|HEVC,
+	{SLICE_MAX_MB, ENC, H264|HEVC|HEIC,
 		1, INT_MAX, 1, INT_MAX,
 		V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB,
 		HFI_PROP_MULTI_SLICE_MB_COUNT,
 		CAP_FLAG_OUTPUT_PORT},
 
 	// TODO: MB level RC - mapping
-	{MB_RC, ENC, CODECS_ALL,
+	{MB_RC, ENC, H264|HEVC,
 		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
 		1, V4L2_MPEG_MSM_VIDC_ENABLE,
 		V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE,
@@ -1001,14 +987,14 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		{0}, {0},
 		NULL, msm_vidc_set_chroma_qp_index_offset},
 
-	{DISPLAY_DELAY_ENABLE, DEC, CODECS_ALL,
+	{DISPLAY_DELAY_ENABLE, DEC, H264|HEVC|VP9,
 		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 | CAP_FLAG_OUTPUT_PORT},
 
-	{DISPLAY_DELAY, DEC, CODECS_ALL,
+	{DISPLAY_DELAY, DEC, H264|HEVC|VP9,
 		0, 1, 1, 0,
 		V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY,
 		HFI_PROP_DECODE_ORDER_OUTPUT,
@@ -1042,7 +1028,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		MSM_VIDC_POWER_SAVE_MODE, 1,
 		MSM_VIDC_POWER_SAVE_MODE},
 
-	{CODED_FRAMES, DEC, CODECS_ALL,
+	{CODED_FRAMES, DEC, H264|HEVC|HEIC,
 		CODED_FRAMES_PROGRESSIVE, CODED_FRAMES_INTERLACE,
 		1, CODED_FRAMES_PROGRESSIVE,
 		0,
@@ -1052,7 +1038,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		0,
 		HFI_PROP_LUMA_CHROMA_BIT_DEPTH},
 
-	{CODEC_CONFIG, DEC, H264|HEVC, 0, 1, 1, 0,
+	{CODEC_CONFIG, DEC, H264|HEVC|HEIC, 0, 1, 1, 0,
 		V4L2_CID_MPEG_VIDC_CODEC_CONFIG},
 
 	{BITSTREAM_SIZE_OVERWRITE, DEC, CODECS_ALL, 0, INT_MAX, 1, 0,
@@ -1093,7 +1079,7 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		{0}, {0},
 		NULL, NULL},
 
-	{META_LTR_MARK_USE, ENC, CODECS_ALL,
+	{META_LTR_MARK_USE, ENC, H264|HEVC,
 		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
 		1, V4L2_MPEG_MSM_VIDC_DISABLE,
 		V4L2_CID_MPEG_VIDC_METADATA_LTR_MARK_USE_DETAILS,
@@ -1141,19 +1127,19 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		V4L2_CID_MPEG_VIDC_METADATA_HISTOGRAM_INFO,
 		HFI_PROP_HISTOGRAM_INFO},
 
-	{META_SEI_MASTERING_DISP, DEC | ENC, HEVC,
+	{META_SEI_MASTERING_DISP, DEC|ENC, HEVC|HEIC,
 		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
 		1, V4L2_MPEG_MSM_VIDC_DISABLE,
 		V4L2_CID_MPEG_VIDC_METADATA_SEI_MASTERING_DISPLAY_COLOUR,
 		HFI_PROP_SEI_MASTERING_DISPLAY_COLOUR},
 
-	{META_SEI_CLL, DEC | ENC, HEVC,
+	{META_SEI_CLL, DEC|ENC, HEVC|HEIC,
 		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
 		1, V4L2_MPEG_MSM_VIDC_DISABLE,
 		V4L2_CID_MPEG_VIDC_METADATA_SEI_CONTENT_LIGHT_LEVEL,
 		HFI_PROP_SEI_CONTENT_LIGHT_LEVEL},
 
-	{META_HDR10PLUS, DEC | ENC, HEVC,
+	{META_HDR10PLUS, DEC | ENC, HEVC|HEIC,
 		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
 		1, V4L2_MPEG_MSM_VIDC_DISABLE,
 		V4L2_CID_MPEG_VIDC_METADATA_HDR10PLUS,
@@ -1194,6 +1180,85 @@ static struct msm_platform_inst_capability instance_data_waipio[] = {
 		1, V4L2_MPEG_MSM_VIDC_DISABLE,
 		V4L2_CID_MPEG_VIDC_METADATA_ROI_INFO,
 		HFI_PROP_ROI_INFO},
+
+	/* configure image properties */
+	{FRAME_WIDTH, ENC, HEIC, 512, 16384, 1, 16384},
+	{FRAME_WIDTH, DEC, HEIC, 512, 8192, 1, 8192},
+	{FRAME_HEIGHT, ENC, HEIC, 512, 16384, 1, 16384},
+	{FRAME_HEIGHT, DEC, HEIC, 512, 8192, 1, 8192},
+	{MIN_BUFFERS_INPUT, ENC|DEC, HEIC, 0, 64, 1, 1,
+		V4L2_CID_MIN_BUFFERS_FOR_OUTPUT},
+	{MIN_BUFFERS_OUTPUT, ENC|DEC, HEIC,
+		0, 64, 1, 1,
+		V4L2_CID_MIN_BUFFERS_FOR_CAPTURE,
+		HFI_PROP_BUFFER_FW_MIN_OUTPUT_COUNT,
+		CAP_FLAG_ROOT | CAP_FLAG_OUTPUT_PORT},
+	{PIX_FMTS, ENC, HEIC,
+		MSM_VIDC_FMT_NV12,
+		MSM_VIDC_FMT_P010,
+		MSM_VIDC_FMT_NV12 | MSM_VIDC_FMT_NV21 | MSM_VIDC_FMT_P010,
+		MSM_VIDC_FMT_NV12,
+		0, 0,
+		CAP_FLAG_ROOT,
+		{0},
+		{PROFILE}},
+	{MBPF, ENC, HEIC, 64, 262144, 262144},      /* ((8192x8192)/256) */
+	{MBPF, DEC, HEIC, 36, 1048576, 1, 1048576}, /* ((16384x16384)/256) */
+	{MBPS, ENC, HEIC, 64, 262144, 262144},      /* ((8192x8192)/256)@1fps */
+	{MBPS, DEC, HEIC, 36, 1048576, 1, 1048576}, /* ((16384x16384)/256)@1fps */
+	{BITRATE_MODE, ENC, HEIC,
+		V4L2_MPEG_VIDEO_BITRATE_MODE_CQ,
+		V4L2_MPEG_VIDEO_BITRATE_MODE_CQ,
+		BIT(V4L2_MPEG_VIDEO_BITRATE_MODE_CQ),
+		V4L2_MPEG_VIDEO_BITRATE_MODE_CQ,
+		V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
+		HFI_PROP_RATE_CONTROL,
+		CAP_FLAG_ROOT | CAP_FLAG_OUTPUT_PORT | CAP_FLAG_MENU,
+		{0},
+		{TIME_DELTA_BASED_RC, CONSTANT_QUALITY},
+		msm_vidc_adjust_bitrate_mode, msm_vidc_set_u32_enum},
+	{TIME_DELTA_BASED_RC, ENC, HEIC,
+		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
+		1, V4L2_MPEG_MSM_VIDC_DISABLE,
+		V4L2_CID_MPEG_VIDC_TIME_DELTA_BASED_RC,
+		HFI_PROP_TIME_DELTA_BASED_RATE_CONTROL,
+		CAP_FLAG_ROOT | CAP_FLAG_OUTPUT_PORT,
+		{BITRATE_MODE}, {0},
+		msm_vidc_adjust_delta_based_rc, msm_vidc_set_u32},
+	{GRID, ENC, HEIC,
+		V4L2_MPEG_MSM_VIDC_DISABLE, V4L2_MPEG_MSM_VIDC_ENABLE,
+		1, V4L2_MPEG_MSM_VIDC_ENABLE,
+		0,
+		HFI_PROP_HEIC_GRID_ENABLE,
+		CAP_FLAG_ROOT | CAP_FLAG_OUTPUT_PORT,
+		{0}, {0},
+		NULL, msm_vidc_set_u32},
+	{GOP_SIZE, ENC, HEIC,
+		0, INT_MAX, 1, 0 /* all intra */,
+		V4L2_CID_MPEG_VIDEO_GOP_SIZE,
+		HFI_PROP_MAX_GOP_FRAMES,
+		CAP_FLAG_ROOT | CAP_FLAG_OUTPUT_PORT | CAP_FLAG_DYNAMIC_ALLOWED,
+		{0}, {0},
+		NULL, msm_vidc_set_u32},
+	{B_FRAME, ENC, HEIC,
+		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 | CAP_FLAG_OUTPUT_PORT,
+		{0}, {0},
+		NULL, msm_vidc_set_u32},
+	{PROFILE, ENC|DEC, HEIC,
+		V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_STILL_PICTURE,
+		V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_STILL_PICTURE,
+		BIT(V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_STILL_PICTURE),
+		V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_STILL_PICTURE,
+		V4L2_CID_MPEG_VIDEO_HEVC_PROFILE,
+		HFI_PROP_PROFILE,
+		CAP_FLAG_ROOT | CAP_FLAG_OUTPUT_PORT | CAP_FLAG_MENU,
+		{PIX_FMTS},
+		{0},
+		msm_vidc_adjust_profile, msm_vidc_set_u32_enum},
 };
 
 /*

driver/variant/iris2/src/msm_vidc_buffer_iris2.c

@@ -50,7 +50,7 @@ static u32 msm_vidc_decoder_bin_size_iris2(struct msm_vidc_inst *inst)
 	if (inst->codec == MSM_VIDC_H264)
 		HFI_BUFFER_BIN_H264D(size, width, height,
 			is_interlaced, vpp_delay, num_vpp_pipes);
-	else if (inst->codec == MSM_VIDC_HEVC)
+	else if (inst->codec == MSM_VIDC_HEVC || inst->codec == MSM_VIDC_HEIC)
 		HFI_BUFFER_BIN_H265D(size, width, height,
 			0, vpp_delay, num_vpp_pipes);
 	else if (inst->codec == MSM_VIDC_VP9)
@@ -84,7 +84,7 @@ static u32 msm_vidc_decoder_comv_size_iris2(struct msm_vidc_inst* inst)
 
 	if (inst->codec == MSM_VIDC_H264)
 		HFI_BUFFER_COMV_H264D(size, width, height, out_min_count);
-	else if (inst->codec == MSM_VIDC_HEVC)
+	else if (inst->codec == MSM_VIDC_HEVC || inst->codec == MSM_VIDC_HEIC)
 		HFI_BUFFER_COMV_H265D(size, width, height, out_min_count);
 
 	i_vpr_l(inst, "%s: size %d\n", __func__, size);
@@ -115,7 +115,7 @@ static u32 msm_vidc_decoder_non_comv_size_iris2(struct msm_vidc_inst* inst)
 
 	if (inst->codec == MSM_VIDC_H264)
 		HFI_BUFFER_NON_COMV_H264D(size, width, height, num_vpp_pipes);
-	else if (inst->codec == MSM_VIDC_HEVC)
+	else if (inst->codec == MSM_VIDC_HEVC || inst->codec == MSM_VIDC_HEIC)
 		HFI_BUFFER_NON_COMV_H265D(size, width, height, num_vpp_pipes);
 
 	i_vpr_l(inst, "%s: size %d\n", __func__, size);
@@ -167,7 +167,7 @@ static u32 msm_vidc_decoder_line_size_iris2(struct msm_vidc_inst *inst)
 	if (inst->codec == MSM_VIDC_H264)
 		HFI_BUFFER_LINE_H264D(size, width, height, is_opb,
 			num_vpp_pipes);
-	else if (inst->codec == MSM_VIDC_HEVC)
+	else if (inst->codec == MSM_VIDC_HEVC || inst->codec == MSM_VIDC_HEIC)
 		HFI_BUFFER_LINE_H265D(size, width, height, is_opb,
 			num_vpp_pipes);
 	else if (inst->codec == MSM_VIDC_VP9)
@@ -189,7 +189,7 @@ static u32 msm_vidc_decoder_persist_size_iris2(struct msm_vidc_inst *inst)
 
 	if (inst->codec == MSM_VIDC_H264)
 		HFI_BUFFER_PERSIST_H264D(size);
-	else if (inst->codec == MSM_VIDC_HEVC)
+	else if (inst->codec == MSM_VIDC_HEVC || inst->codec == MSM_VIDC_HEIC)
 		HFI_BUFFER_PERSIST_H265D(size);
 	else if (inst->codec == MSM_VIDC_VP9)
 		HFI_BUFFER_PERSIST_VP9D(size);
@@ -269,7 +269,7 @@ static u32 msm_vidc_encoder_bin_size_iris2(struct msm_vidc_inst *inst)
 	if (inst->codec == MSM_VIDC_H264)
 		HFI_BUFFER_BIN_H264E(size, inst->hfi_rc_type, width,
 			height, stage, num_vpp_pipes);
-	else if (inst->codec == MSM_VIDC_HEVC)
+	else if (inst->codec == MSM_VIDC_HEVC || inst->codec == MSM_VIDC_HEIC)
 		HFI_BUFFER_BIN_H265E(size, inst->hfi_rc_type, width,
 			height, stage, num_vpp_pipes);
 
@@ -298,7 +298,7 @@ static u32 msm_vidc_encoder_comv_size_iris2(struct msm_vidc_inst* inst)
 			HFI_CODEC_ENCODE_AVC);
 		num_ref = num_recon - 1;
 		HFI_BUFFER_COMV_H264E(size, width, height, num_ref);
-	} else if (inst->codec == MSM_VIDC_HEVC) {
+	} else if (inst->codec == MSM_VIDC_HEVC || inst->codec == MSM_VIDC_HEIC) {
 		// TODO: replace zeros with appropriate variables
 		HFI_IRIS2_ENC_RECON_BUF_COUNT(num_recon, 0, 0, 0, 0, 0,
 			HFI_CODEC_ENCODE_HEVC);
@@ -333,7 +333,7 @@ static u32 msm_vidc_encoder_non_comv_size_iris2(struct msm_vidc_inst* inst)
 
 	if (inst->codec == MSM_VIDC_H264)
 		HFI_BUFFER_NON_COMV_H264E(size, width, height, num_vpp_pipes);
-	else if (inst->codec == MSM_VIDC_HEVC)
+	else if (inst->codec == MSM_VIDC_HEVC || inst->codec == MSM_VIDC_HEIC)
 		HFI_BUFFER_NON_COMV_H265E(size, width, height, num_vpp_pipes);
 
 	i_vpr_l(inst, "%s: size %d\n", __func__, size);
@@ -371,7 +371,7 @@ static u32 msm_vidc_encoder_line_size_iris2(struct msm_vidc_inst *inst)
 
 	if (inst->codec == MSM_VIDC_H264)
 		HFI_BUFFER_LINE_H264E(size, width, height, is_tenbit, num_vpp_pipes);
-	else if (inst->codec == MSM_VIDC_HEVC)
+	else if (inst->codec == MSM_VIDC_HEVC || inst->codec == MSM_VIDC_HEIC)
 		HFI_BUFFER_LINE_H265E(size, width, height, is_tenbit, num_vpp_pipes);
 
 	i_vpr_l(inst, "%s: size %d\n", __func__, size);
@@ -402,7 +402,7 @@ static u32 msm_vidc_encoder_dpb_size_iris2(struct msm_vidc_inst *inst)
 
 	if (inst->codec == MSM_VIDC_H264)
 		HFI_BUFFER_DPB_H264E(size, width, height);
-	else if (inst->codec == MSM_VIDC_HEVC)
+	else if (inst->codec == MSM_VIDC_HEVC || inst->codec == MSM_VIDC_HEIC)
 		HFI_BUFFER_DPB_H265E(size, width, height, is_tenbit);
 
 	i_vpr_l(inst, "%s: size %d\n", __func__, size);
@@ -534,7 +534,7 @@ static int msm_buffer_encoder_dpb_count(struct msm_vidc_inst *inst)
 		// TODO: replace zeros with appropriate variables
 		HFI_IRIS2_ENC_RECON_BUF_COUNT(count, 0, 0, 0, 0, 0,
 			HFI_CODEC_ENCODE_AVC);
-	} else if (inst->codec == MSM_VIDC_HEVC) {
+	} else if (inst->codec == MSM_VIDC_HEVC || inst->codec == MSM_VIDC_HEIC) {
 		// TODO: replace zeros with appropriate variables
 		HFI_IRIS2_ENC_RECON_BUF_COUNT(count, 0, 0, 0, 0, 0,
 			HFI_CODEC_ENCODE_HEVC);

driver/variant/iris2/src/msm_vidc_power_iris2.c

@@ -214,6 +214,7 @@ static u64 __calculate_decoder(struct vidc_bus_vote_data *d)
 	num_vpp_pipes = d->num_vpp_pipes;
 
 	if (d->codec == MSM_VIDC_HEVC ||
+		d->codec == MSM_VIDC_HEIC ||
 		d->codec == MSM_VIDC_VP9) {
 		/* H264, VP8, MPEG2 use the same settings */
 		/* HEVC, VP9 use the same setting */

driver/vidc/inc/msm_vidc_driver.h

@@ -13,6 +13,7 @@
 #include "msm_vidc_inst.h"
 
 #define MSM_VIDC_SESSION_INACTIVE_THRESHOLD_MS 1000
+#define HEIC_GRID_DIMENSION 512
 
 static inline is_decode_session(struct msm_vidc_inst *inst)
 {
@@ -24,6 +25,21 @@ static inline is_encode_session(struct msm_vidc_inst *inst)
 	return inst->domain == MSM_VIDC_ENCODER;
 }
 
+static inline is_image_encode_session(struct msm_vidc_inst *inst)
+{
+	return inst->codec == MSM_VIDC_HEIC && inst->domain == MSM_VIDC_ENCODER;
+}
+
+static inline is_image_decode_session(struct msm_vidc_inst *inst)
+{
+	return inst->codec == MSM_VIDC_HEIC && inst->domain == MSM_VIDC_DECODER;
+}
+
+static inline is_image_session(struct msm_vidc_inst *inst)
+{
+	return inst->codec == MSM_VIDC_HEIC;
+}
+
 static inline is_secure_session(struct msm_vidc_inst *inst)
 {
 	return !!(inst->capabilities->cap[SECURE_MODE].value);
@@ -331,5 +347,7 @@ int msm_vidc_deinit_core_caps(struct msm_vidc_core* core);
 int msm_vidc_deinit_instance_caps(struct msm_vidc_core* core);
 int msm_vidc_update_debug_str(struct msm_vidc_inst *inst);
 bool msm_vidc_allow_decode_batch(struct msm_vidc_inst *inst);
+int msm_vidc_check_session_supported(struct msm_vidc_inst *inst);
+int msm_vidc_check_scaling_supported(struct msm_vidc_inst *inst);
 #endif // _MSM_VIDC_DRIVER_H_
 

driver/vidc/inc/msm_vidc_internal.h

@@ -115,6 +115,7 @@ enum msm_vidc_codec_type {
 	MSM_VIDC_H264              = BIT(0),
 	MSM_VIDC_HEVC              = BIT(1),
 	MSM_VIDC_VP9               = BIT(2),
+	MSM_VIDC_HEIC              = BIT(3),
 };
 
 enum msm_vidc_colorformat_type {
@@ -295,13 +296,9 @@ enum msm_vidc_inst_capability_type {
 	FRAME_WIDTH,
 	LOSSLESS_FRAME_WIDTH,
 	SECURE_FRAME_WIDTH,
-	HEVC_IMAGE_FRAME_WIDTH,
-	HEIC_IMAGE_FRAME_WIDTH,
 	FRAME_HEIGHT,
 	LOSSLESS_FRAME_HEIGHT,
 	SECURE_FRAME_HEIGHT,
-	HEVC_IMAGE_FRAME_HEIGHT,
-	HEIC_IMAGE_FRAME_HEIGHT,
 	PIX_FMTS,
 	MIN_BUFFERS_INPUT,
 	MIN_BUFFERS_OUTPUT,
@@ -346,7 +343,7 @@ enum msm_vidc_inst_capability_type {
 	BLUR_RESOLUTION,
 	CSC,
 	CSC_CUSTOM_MATRIX,
-	HEIC,
+	GRID,
 	LOWLATENCY_MODE,
 	LTR_COUNT,
 	USE_LTR,

driver/vidc/src/hfi_packet.c

@@ -206,6 +206,7 @@ u32 get_hfi_codec(struct msm_vidc_inst *inst)
 		else
 			return HFI_CODEC_DECODE_AVC;
 	case MSM_VIDC_HEVC:
+	case MSM_VIDC_HEIC:
 		if (inst->domain == MSM_VIDC_ENCODER)
 			return HFI_CODEC_ENCODE_HEVC;
 		else

driver/vidc/src/msm_vdec.c

@@ -371,7 +371,9 @@ static int msm_vdec_set_colorspace(struct msm_vidc_inst *inst,
 		return -EINVAL;
 	}
 
-	if (inst->codec != MSM_VIDC_H264 && inst->codec != MSM_VIDC_HEVC)
+	if (inst->codec != MSM_VIDC_H264 &&
+		inst->codec != MSM_VIDC_HEVC &&
+		inst->codec != MSM_VIDC_HEIC)
 		return 0;
 
 	if (inst->fmts[port].fmt.pix_mp.colorspace != V4L2_COLORSPACE_DEFAULT ||
@@ -997,7 +999,7 @@ static int msm_vdec_subscribe_input_port_settings_change(struct msm_vidc_inst *i
 	if (inst->codec == MSM_VIDC_H264) {
 		subscribe_psc_size = ARRAY_SIZE(msm_vdec_subscribe_for_psc_avc);
 		psc = msm_vdec_subscribe_for_psc_avc;
-	} else if (inst->codec == MSM_VIDC_HEVC) {
+	} else if (inst->codec == MSM_VIDC_HEVC || inst->codec == MSM_VIDC_HEIC) {
 		subscribe_psc_size = ARRAY_SIZE(msm_vdec_subscribe_for_psc_hevc);
 		psc = msm_vdec_subscribe_for_psc_hevc;
 	} else if (inst->codec == MSM_VIDC_VP9) {
@@ -1448,10 +1450,11 @@ int msm_vdec_streamon_input(struct msm_vidc_inst *inst)
 		return -EINVAL;
 	}
 
-	//rc = msm_vidc_check_session_supported(inst);
+	rc = msm_vidc_check_session_supported(inst);
 	if (rc)
 		goto error;
-	//rc = msm_vidc_check_scaling_supported(inst);
+
+	rc = msm_vidc_check_scaling_supported(inst);
 	if (rc)
 		goto error;
 
@@ -1578,7 +1581,7 @@ static int msm_vdec_subscribe_output_port_settings_change(struct msm_vidc_inst *
 	if (inst->codec == MSM_VIDC_H264) {
 		subscribe_psc_size = ARRAY_SIZE(msm_vdec_subscribe_for_psc_avc);
 		psc = msm_vdec_subscribe_for_psc_avc;
-	} else if (inst->codec == MSM_VIDC_HEVC) {
+	} else if (inst->codec == MSM_VIDC_HEVC || inst->codec == MSM_VIDC_HEIC) {
 		subscribe_psc_size = ARRAY_SIZE(msm_vdec_subscribe_for_psc_hevc);
 		psc = msm_vdec_subscribe_for_psc_hevc;
 	} else if (inst->codec == MSM_VIDC_VP9) {
@@ -1779,7 +1782,7 @@ static int msm_vdec_qbuf_batch(struct msm_vidc_inst *inst,
 		i_vpr_e(inst, "%s: qbuf not allowed\n", __func__);
 		return -EINVAL;
 	} else if (allow == MSM_VIDC_DEFER) {
-		print_vidc_buffer(VIDC_HIGH, "high", "qbuf deferred", inst, buf);
+		print_vidc_buffer(VIDC_LOW, "high", "qbuf deferred", inst, buf);
 		return 0;
 	}
 
@@ -1787,7 +1790,7 @@ static int msm_vdec_qbuf_batch(struct msm_vidc_inst *inst,
 	if (inst->power.buffer_counter > SKIP_BATCH_WINDOW) {
 		count = msm_vidc_num_buffers(inst, MSM_VIDC_BUF_OUTPUT, MSM_VIDC_ATTR_DEFERRED);
 		if (count < inst->decode_batch.size) {
-			print_vidc_buffer(VIDC_HIGH, "high", "batch-qbuf deferred", inst, buf);
+			print_vidc_buffer(VIDC_LOW, "high", "batch-qbuf deferred", inst, buf);
 			schedule_batch_work(inst);
 			return 0;
 		}
@@ -1880,7 +1883,7 @@ int msm_vdec_s_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f)
 	int rc = 0;
 	struct msm_vidc_core *core;
 	struct v4l2_format *fmt;
-	u32 codec_align;
+	u32 codec_align, pix_fmt;
 
 	if (!inst || !inst->core) {
 		d_vpr_e("%s: invalid params\n", __func__);
@@ -2007,8 +2010,8 @@ int msm_vdec_s_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f)
 		}
 		inst->buffers.output.size =
 			fmt->fmt.pix_mp.plane_fmt[0].sizeimage;
-		inst->capabilities->cap[PIX_FMTS].value =
-			v4l2_colorformat_to_driver(f->fmt.pix_mp.pixelformat, __func__);
+		pix_fmt = v4l2_colorformat_to_driver(f->fmt.pix_mp.pixelformat, __func__);
+		msm_vidc_update_cap_value(inst, PIX_FMTS, pix_fmt, __func__);
 		//rc = msm_vidc_check_session_supported(inst);
 		if (rc)
 			goto err_invalid_fmt;

driver/vidc/src/msm_venc.c

@@ -873,10 +873,11 @@ int msm_venc_streamon_input(struct msm_vidc_inst *inst)
 		return -EINVAL;
 	}
 
-	//rc = msm_vidc_check_session_supported(inst);
+	rc = msm_vidc_check_session_supported(inst);
 	if (rc)
 		goto error;
-	//rc = msm_vidc_check_scaling_supported(inst);
+
+	rc = msm_vidc_check_scaling_supported(inst);
 	if (rc)
 		goto error;
 
@@ -1070,7 +1071,7 @@ static int msm_venc_s_fmt_output(struct msm_vidc_inst *inst, struct v4l2_format
 	struct msm_vidc_core *core;
 	u32 codec_align;
 
-	if (!inst || !inst->core) {
+	if (!inst || !inst->core || !f) {
 		d_vpr_e("%s: invalid params\n", __func__);
 		return -EINVAL;
 	}
@@ -1087,11 +1088,14 @@ static int msm_venc_s_fmt_output(struct msm_vidc_inst *inst, struct v4l2_format
 	}
 	fmt->type = OUTPUT_MPLANE;
 
-	codec_align = f->fmt.pix_mp.pixelformat ==
-		V4L2_PIX_FMT_HEVC ? 32 : 16;
+	codec_align = (f->fmt.pix_mp.pixelformat == V4L2_PIX_FMT_HEVC ||
+		f->fmt.pix_mp.pixelformat == V4L2_PIX_FMT_HEIC) ? 32 : 16;
 	/* width, height is readonly for client */
 	fmt->fmt.pix_mp.width = ALIGN(inst->crop.width, codec_align);
 	fmt->fmt.pix_mp.height = ALIGN(inst->crop.height, codec_align);
+	/* use grid dimension for image session */
+	if (is_image_session(inst))
+		fmt->fmt.pix_mp.width = fmt->fmt.pix_mp.height = HEIC_GRID_DIMENSION;
 	fmt->fmt.pix_mp.pixelformat = f->fmt.pix_mp.pixelformat;
 	fmt->fmt.pix_mp.num_planes = 1;
 	fmt->fmt.pix_mp.plane_fmt[0].bytesperline = 0;
@@ -1173,6 +1177,7 @@ static int msm_venc_s_fmt_input(struct msm_vidc_inst *inst, struct v4l2_format *
 	int rc = 0;
 	struct v4l2_format *fmt;
 	struct msm_vidc_core *core;
+	u32 pix_fmt;
 
 	if (!inst || !inst->core || !inst->capabilities) {
 		d_vpr_e("%s: invalid params\n", __func__);
@@ -1183,6 +1188,8 @@ static int msm_venc_s_fmt_input(struct msm_vidc_inst *inst, struct v4l2_format *
 	fmt = &inst->fmts[INPUT_PORT];
 	fmt->type = INPUT_MPLANE;
 	fmt->fmt.pix_mp.pixelformat = f->fmt.pix_mp.pixelformat;
+	pix_fmt = v4l2_colorformat_to_driver(f->fmt.pix_mp.pixelformat, __func__);
+	msm_vidc_update_cap_value(inst, PIX_FMTS, pix_fmt, __func__);
 	fmt->fmt.pix_mp.width = VIDEO_Y_STRIDE_PIX(fmt->fmt.pix_mp.pixelformat,
 		f->fmt.pix_mp.width);
 	fmt->fmt.pix_mp.height = VIDEO_Y_SCANLINES(fmt->fmt.pix_mp.pixelformat,

driver/vidc/src/msm_vidc_buffer.c

@@ -31,7 +31,7 @@ u32 msm_vidc_input_min_count(struct msm_vidc_inst* inst)
 		return 0;
 	}
 
-	if (is_thumbnail_session(inst))
+	if (is_thumbnail_session(inst) || is_image_session(inst))
 		input_min_count = 1;
 
 	//if (is_grid_session(inst))
@@ -58,7 +58,7 @@ u32 msm_vidc_output_min_count(struct msm_vidc_inst *inst)
 	if (!is_decode_session(inst) && !is_encode_session(inst))
 		return 0;
 
-	if (is_thumbnail_session(inst))
+	if (is_thumbnail_session(inst) || is_image_session(inst))
 		return 1;
 
 	if (is_decode_session(inst)) {
@@ -70,6 +70,9 @@ u32 msm_vidc_output_min_count(struct msm_vidc_inst *inst)
 		case MSM_VIDC_VP9:
 			output_min_count = 9;
 			break;
+		case MSM_VIDC_HEIC:
+			output_min_count = 1;
+			break;
 		default:
 			output_min_count = 4;
 		}
@@ -102,7 +105,7 @@ u32 msm_vidc_input_extra_count(struct msm_vidc_inst *inst)
 	 * no extra buffers for thumbnail session because
 	 * neither dcvs nor batching will be enabled
 	 */
-	if (is_thumbnail_session(inst))
+	if (is_thumbnail_session(inst) || is_image_session(inst))
 		return 0;
 
 	if (is_decode_session(inst)) {
@@ -140,7 +143,7 @@ u32 msm_vidc_output_extra_count(struct msm_vidc_inst *inst)
 	 * no extra buffers for thumbnail session because
 	 * neither dcvs nor batching will be enabled
 	 */
-	if (is_thumbnail_session(inst))
+	if (is_thumbnail_session(inst) || is_image_session(inst))
 		return 0;
 
 	if (is_decode_session(inst)) {
@@ -180,8 +183,9 @@ u32 msm_vidc_internal_buffer_count(struct msm_vidc_inst *inst,
 			count = 1;
 		} else if (buffer_type == MSM_VIDC_BUF_COMV ||
 			buffer_type == MSM_VIDC_BUF_NON_COMV) {
-			if (inst->codec == MSM_VIDC_HEVC ||
-				inst->codec == MSM_VIDC_H264)
+			if (inst->codec == MSM_VIDC_H264 ||
+				inst->codec == MSM_VIDC_HEVC ||
+				inst->codec == MSM_VIDC_HEIC)
 				count = 1;
 			else
 				count = 0;
@@ -241,19 +245,18 @@ u32 msm_vidc_decoder_input_size(struct msm_vidc_inst *inst)
 	if (is_secure_session(inst))
 		div_factor = div_factor << 1;
 
-	/* For HEIF image, use the actual resolution to calc buffer size */
-	/* TODO: fix me
-	if (is_heif_decoder(inst)) {
+	/* For image session, use the actual resolution to calc buffer size */
+	if (is_image_session(inst)) {
 		base_res_mbs = num_mbs;
 		div_factor = 1;
 	}
-	*/
 
 	frame_size = base_res_mbs * MB_SIZE_IN_PIXEL * 3 / 2 / div_factor;
 
 	 /* multiply by 10/8 (1.25) to get size for 10 bit case */
 	if (f->fmt.pix_mp.pixelformat == V4L2_PIX_FMT_VP9 ||
-		f->fmt.pix_mp.pixelformat == V4L2_PIX_FMT_HEVC)
+		f->fmt.pix_mp.pixelformat == V4L2_PIX_FMT_HEVC ||
+		f->fmt.pix_mp.pixelformat == V4L2_PIX_FMT_HEIC)
 		frame_size = frame_size + (frame_size >> 2);
 
 	i_vpr_h(inst, "set input buffer size to %d\n", frame_size);
@@ -319,6 +322,10 @@ u32 msm_vidc_encoder_output_size(struct msm_vidc_inst *inst)
 	mbs_per_frame = NUM_MBS_PER_FRAME(width, height);
 	frame_size = (width * height * 3);
 
+	/* Image session: 2 x yuv size */
+	if (is_image_session(inst))
+		goto skip_calc;
+
 	if (mbs_per_frame < NUM_MBS_720P)
 		frame_size = frame_size << 1;
 	else if (mbs_per_frame <= NUM_MBS_4k)
@@ -333,8 +340,10 @@ u32 msm_vidc_encoder_output_size(struct msm_vidc_inst *inst)
 	if (inst->rc_type == RATE_CONTROL_LOSSLESS)
 		frame_size = (width * height * 9) >> 2; */
 
+skip_calc:
 	/* multiply by 10/8 (1.25) to get size for 10 bit case */
-	if (f->fmt.pix_mp.pixelformat == V4L2_PIX_FMT_HEVC)
+	if (f->fmt.pix_mp.pixelformat == V4L2_PIX_FMT_HEVC ||
+		f->fmt.pix_mp.pixelformat == V4L2_PIX_FMT_HEIC)
 		frame_size = frame_size + (frame_size >> 2);
 
 	return ALIGN(frame_size, SZ_4K);

driver/vidc/src/msm_vidc_control.c

@@ -279,7 +279,7 @@ static int msm_vidc_adjust_hevc_qp(struct msm_vidc_inst *inst,
 
 	capability = inst->capabilities;
 
-	if (inst->codec != MSM_VIDC_HEVC) {
+	if (!(inst->codec == MSM_VIDC_HEVC || inst->codec == MSM_VIDC_HEIC)) {
 		i_vpr_e(inst,
 			"%s: incorrect entry in database for cap %d. fix the database\n",
 			__func__, cap_id);
@@ -734,7 +734,7 @@ int msm_vidc_adjust_bitrate_mode(void *instance, struct v4l2_ctrl *ctrl)
 		goto update;
 	}
 
-	if (!frame_rc) {
+	if (!frame_rc && !is_image_session(inst)) {
 		hfi_value = HFI_RC_OFF;
 		goto update;
 	}
@@ -1562,6 +1562,9 @@ int msm_vidc_set_u32(void *instance,
 		hfi_value = inst->capabilities->cap[cap_id].value;
 	}
 
+	i_vpr_h(inst, "set cap: name: %24s, value: %#10x, hfi: %#10x\n", cap_name(cap_id),
+		inst->capabilities->cap[cap_id].value, hfi_value);
+
 	rc = msm_vidc_packetize_control(inst, cap_id, HFI_PAYLOAD_U32,
 		&hfi_value, sizeof(u32), __func__);
 
@@ -1584,6 +1587,9 @@ int msm_vidc_set_u32_enum(void *instance,
 	if (rc)
 		return -EINVAL;
 
+	i_vpr_h(inst, "set cap: name: %24s, value: %#10x, hfi: %#10x\n", cap_name(cap_id),
+		inst->capabilities->cap[cap_id].value, hfi_value);
+
 	rc = msm_vidc_packetize_control(inst, cap_id, HFI_PAYLOAD_U32_ENUM,
 		&hfi_value, sizeof(u32), __func__);
 

driver/vidc/src/msm_vidc_driver.c

@@ -45,13 +45,9 @@ static const struct msm_vidc_cap_name cap_name_arr[] = {
 	{FRAME_WIDTH,                    "FRAME_WIDTH"                },
 	{LOSSLESS_FRAME_WIDTH,           "LOSSLESS_FRAME_WIDTH"       },
 	{SECURE_FRAME_WIDTH,             "SECURE_FRAME_WIDTH"         },
-	{HEVC_IMAGE_FRAME_WIDTH,         "HEVC_IMAGE_FRAME_WIDTH"     },
-	{HEIC_IMAGE_FRAME_WIDTH,         "HEIC_IMAGE_FRAME_WIDTH"     },
 	{FRAME_HEIGHT,                   "FRAME_HEIGHT"               },
 	{LOSSLESS_FRAME_HEIGHT,          "LOSSLESS_FRAME_HEIGHT"      },
 	{SECURE_FRAME_HEIGHT,            "SECURE_FRAME_HEIGHT"        },
-	{HEVC_IMAGE_FRAME_HEIGHT,        "HEVC_IMAGE_FRAME_HEIGHT"    },
-	{HEIC_IMAGE_FRAME_HEIGHT,        "HEIC_IMAGE_FRAME_HEIGHT"    },
 	{PIX_FMTS,                       "PIX_FMTS"                   },
 	{MIN_BUFFERS_INPUT,              "MIN_BUFFERS_INPUT"          },
 	{MIN_BUFFERS_OUTPUT,             "MIN_BUFFERS_OUTPUT"         },
@@ -96,7 +92,7 @@ static const struct msm_vidc_cap_name cap_name_arr[] = {
 	{BLUR_RESOLUTION,                "BLUR_RESOLUTION"            },
 	{CSC,                            "CSC"                        },
 	{CSC_CUSTOM_MATRIX,              "CSC_CUSTOM_MATRIX"          },
-	{HEIC,                           "HEIC"                       },
+	{GRID,                           "GRID"                       },
 	{LOWLATENCY_MODE,                "LOWLATENCY_MODE"            },
 	{LTR_COUNT,                      "LTR_COUNT"                  },
 	{USE_LTR,                        "USE_LTR"                    },
@@ -374,6 +370,9 @@ enum msm_vidc_codec_type v4l2_codec_to_driver(u32 v4l2_codec, const char *func)
 	case V4L2_PIX_FMT_VP9:
 		codec = MSM_VIDC_VP9;
 		break;
+	case V4L2_PIX_FMT_HEIC:
+		codec = MSM_VIDC_HEIC;
+		break;
 	default:
 		d_vpr_e("%s: invalid v4l2 codec %#x\n", func, v4l2_codec);
 		break;
@@ -395,6 +394,9 @@ u32 v4l2_codec_from_driver(enum msm_vidc_codec_type codec, const char *func)
 	case MSM_VIDC_VP9:
 		v4l2_codec = V4L2_PIX_FMT_VP9;
 		break;
+	case MSM_VIDC_HEIC:
+		v4l2_codec = V4L2_PIX_FMT_HEIC;
+		break;
 	default:
 		d_vpr_e("%s: invalid driver codec %#x\n", func, codec);
 		break;
@@ -2013,6 +2015,12 @@ bool msm_vidc_allow_decode_batch(struct msm_vidc_inst *inst)
 		goto exit;
 	}
 
+	allow = !is_image_session(inst);
+	if (!allow) {
+		i_vpr_h(inst, "%s: image session\n", __func__);
+		goto exit;
+	}
+
 	allow = is_realtime_session(inst);
 	if (!allow) {
 		i_vpr_h(inst, "%s: non-realtime session\n", __func__);
@@ -2127,7 +2135,7 @@ int msm_vidc_queue_buffer_single(struct msm_vidc_inst *inst, struct vb2_buffer *
 		i_vpr_e(inst, "%s: qbuf not allowed\n", __func__);
 		return -EINVAL;
 	} else if (allow == MSM_VIDC_DEFER) {
-		print_vidc_buffer(VIDC_HIGH, "high", "qbuf deferred", inst, buf);
+		print_vidc_buffer(VIDC_LOW, "high", "qbuf deferred", inst, buf);
 		return 0;
 	}
 
@@ -2686,15 +2694,20 @@ int msm_vidc_add_session(struct msm_vidc_inst *inst)
 	}
 	core = inst->core;
 
+	if (!core->capabilities) {
+		i_vpr_e(inst, "%s: invalid params\n", __func__);
+		return -EINVAL;
+	}
+
 	core_lock(core, __func__);
 	list_for_each_entry(i, &core->instances, list)
 		count++;
 
-	if (count < 0xffffff /*TODO: MAX_SUPPORTED_INSTANCES*/) {
+	if (count < core->capabilities[MAX_SESSION_COUNT].value) {
 		list_add_tail(&inst->list, &core->instances);
 	} else {
 		i_vpr_e(inst, "%s: total sessions %d exceeded max limit %d\n",
-			__func__, count, MAX_SUPPORTED_INSTANCES);
+			__func__, count, core->capabilities[MAX_SESSION_COUNT].value);
 		rc = -EINVAL;
 	}
 	core_unlock(core, __func__);
@@ -3752,6 +3765,7 @@ static const char *get_codec_str(enum msm_vidc_codec_type type)
 	case MSM_VIDC_H264: return "h264";
 	case MSM_VIDC_HEVC: return "h265";
 	case MSM_VIDC_VP9:  return " vp9";
+	case MSM_VIDC_HEIC: return "heic";
 	}
 
 	return "....";
@@ -3786,3 +3800,182 @@ int msm_vidc_update_debug_str(struct msm_vidc_inst *inst)
 
 	return 0;
 }
+
+static int msm_vidc_check_mbps_supported(struct msm_vidc_inst *inst)
+{
+	u32 mbps = 0;
+	struct msm_vidc_core *core;
+	struct msm_vidc_inst *instance;
+
+	if (!inst || !inst->core) {
+		d_vpr_e("%s: invalid params\n", __func__);
+		return -EINVAL;
+	}
+	core = inst->core;
+
+	core_lock(core, __func__);
+	list_for_each_entry(instance, &core->instances, list) {
+		/* ignore invalid/error session */
+		if (instance->state == MSM_VIDC_ERROR)
+			continue;
+
+		/* ignore thumbnail, image, and non realtime sessions */
+		if (is_thumbnail_session(instance) ||
+			is_image_session(instance) ||
+			!is_realtime_session(instance))
+			continue;
+
+		mbps += msm_vidc_get_inst_load(instance, LOAD_ADMISSION_CONTROL);
+	}
+	core_unlock(core, __func__);
+
+	if (mbps > core->capabilities[MAX_MBPS].value) {
+		/* todo: print running instances */
+		//msm_vidc_print_running_insts(inst->core);
+		return -ENOMEM;
+	}
+
+	return 0;
+}
+
+static int msm_vidc_check_mbpf_supported(struct msm_vidc_inst *inst)
+{
+	u32 mbpf = 0;
+	struct msm_vidc_core *core;
+	struct msm_vidc_inst *instance;
+
+	if (!inst || !inst->core) {
+		d_vpr_e("%s: invalid params\n", __func__);
+		return -EINVAL;
+	}
+	core = inst->core;
+
+	core_lock(core, __func__);
+	list_for_each_entry(instance, &core->instances, list) {
+		/* ignore invalid/error session */
+		if (instance->state == MSM_VIDC_ERROR)
+			continue;
+
+		/* ignore thumbnail, image, and non realtime sessions */
+		if (is_thumbnail_session(instance) ||
+			is_image_session(instance) ||
+			!is_realtime_session(instance))
+			continue;
+
+		mbpf += msm_vidc_get_mbs_per_frame(instance);
+	}
+	core_unlock(core, __func__);
+
+	if (mbpf > core->capabilities[MAX_MBPF].value) {
+		/* todo: print running instances */
+		//msm_vidc_print_running_insts(inst->core);
+		return -ENOMEM;
+	}
+
+	return 0;
+}
+
+int msm_vidc_check_session_supported(struct msm_vidc_inst *inst)
+{
+	struct msm_vidc_inst_capability *capability;
+	struct v4l2_format *fmt;
+	bool allow = false;
+	int rc = 0;
+
+	if (!inst || !inst->capabilities) {
+		d_vpr_e("%s: invalid params\n", __func__);
+		return -EINVAL;
+	}
+	capability = inst->capabilities;
+
+	/* todo: enable checks for all session type */
+	if (!is_image_session(inst))
+		return 0;
+
+	if (is_image_encode_session(inst)) {
+		/* is linear color fmt */
+		allow = is_linear_colorformat(capability->cap[PIX_FMTS].value);
+		if (!allow) {
+			i_vpr_e(inst, "%s: compressed fmt: %#x\n", __func__,
+				capability->cap[PIX_FMTS].value);
+			goto exit;
+		}
+
+		/* is output grid dimension */
+		fmt = &inst->fmts[OUTPUT_PORT];
+		allow = fmt->fmt.pix_mp.width == HEIC_GRID_DIMENSION;
+		allow &= fmt->fmt.pix_mp.height == HEIC_GRID_DIMENSION;
+		if (!allow) {
+			i_vpr_e(inst, "%s: output is not a grid dimension: %u x %u\n", __func__,
+				fmt->fmt.pix_mp.width, fmt->fmt.pix_mp.height);
+			goto exit;
+		}
+
+		/* is bitrate mode CQ */
+		allow = capability->cap[BITRATE_MODE].value == HFI_RC_CQ;
+		if (!allow) {
+			i_vpr_e(inst, "%s: bitrate mode is not CQ: %#x\n", __func__,
+				capability->cap[BITRATE_MODE].value);
+			goto exit;
+		}
+
+		/* is all intra */
+		allow = !capability->cap[GOP_SIZE].value;
+		allow &= !capability->cap[B_FRAME].value;
+		if (!allow) {
+			i_vpr_e(inst, "%s: not all intra: gop: %u, bframe: %u\n", __func__,
+				capability->cap[GOP_SIZE].value, capability->cap[B_FRAME].value);
+			goto exit;
+		}
+
+		/* is time delta based rc disabled */
+		allow = !capability->cap[TIME_DELTA_BASED_RC].value;
+		if (!allow) {
+			i_vpr_e(inst, "%s: time delta based rc not disabled: %#x\n", __func__,
+				capability->cap[TIME_DELTA_BASED_RC].value);
+			goto exit;
+		}
+
+		/* is profile type Still Pic */
+		allow = (capability->cap[PROFILE].value ==
+			V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_STILL_PICTURE);
+		if (!allow) {
+			i_vpr_e(inst, "%s: profile is not still pic type: %#x\n", __func__,
+				capability->cap[PROFILE].value);
+			goto exit;
+		}
+	}
+
+	rc = msm_vidc_check_mbps_supported(inst);
+	if (rc)
+		goto exit;
+
+	rc = msm_vidc_check_mbpf_supported(inst);
+	if (rc)
+		goto exit;
+
+	/* todo: add additional checks related to capabilities */
+
+	return 0;
+
+exit:
+	i_vpr_e(inst, "%s: current session not supported\n", __func__);
+	return -EINVAL;
+}
+
+int msm_vidc_check_scaling_supported(struct msm_vidc_inst *inst)
+{
+	if (!inst) {
+		d_vpr_e("%s: invalid params\n", __func__);
+		return -EINVAL;
+	}
+
+	if (is_image_session(inst) || is_decode_session(inst)) {
+		i_vpr_h(inst, "%s: Scaling is supported for encode session only\n", __func__);
+		return 0;
+	}
+
+	/* todo: add scaling check for encode session */
+	return 0;
+}
+

driver/vidc/src/msm_vidc_memory.c

@@ -27,7 +27,7 @@ struct context_bank_info *get_context_bank(struct msm_vidc_core *core,
 	static const struct msm_vidc_buf_region_name buf_region_name[] = {
 		{MSM_VIDC_REGION_NONE,          "none"                 },
 		{MSM_VIDC_NON_SECURE,           "venus_ns"             },
-		{MSM_VIDC_NON_SECURE_PIXEL,     "venus_ns_pixel"        },
+		{MSM_VIDC_NON_SECURE_PIXEL,     "venus_ns_pixel"       },
 		{MSM_VIDC_SECURE_PIXEL,         "venus_sec_pixel"      },
 		{MSM_VIDC_SECURE_NONPIXEL,      "venus_sec_non_pixel"  },
 		{MSM_VIDC_SECURE_BITSTREAM,     "venus_sec_bitstream"  },

driver/vidc/src/msm_vidc_power.c

@@ -97,18 +97,19 @@ int msm_vidc_get_inst_load(struct msm_vidc_inst *inst,
 	 *                 | Power Request Load =       |
 	 *                 |          res * max(op, fps)|
 	 * ----------------|----------------------------|
-	 * NON-REALTIME/   | Admission Control Load = 0	|
-	 *  THUMBNAIL      | Power Request Load =       |
-	 *                 |          res * max(op, fps)|
+	 * NON-REALTIME/   | Admission Control Load = 0 |
+	 * THUMBNAIL/      | Power Request Load =       |
+	 * IMAGE           |          res * max(op, fps)|
+	 *                 |                            |
 	 * ----------------|----------------------------|
 	 */
-	if (is_thumbnail_session(inst) ||
-		(!is_realtime_session(inst) &&
-		quirks == LOAD_ADMISSION_CONTROL)) {
-		load = 0;
-	} else {
-		load = msm_vidc_get_mbps(inst, quirks);
-	}
+	if (is_thumbnail_session(inst) || is_image_session(inst))
+		goto exit;
+
+	if (!is_realtime_session(inst) && quirks == LOAD_ADMISSION_CONTROL)
+		goto exit;
+
+	load = msm_vidc_get_mbps(inst, quirks);
 
 exit:
 	return load;
@@ -228,7 +229,7 @@ int msm_vidc_scale_buses(struct msm_vidc_inst *inst)
 		return 0;
 
 	vote_data->power_mode = VIDC_POWER_NORMAL;
-	if (inst->power.buffer_counter < DCVS_FTB_WINDOW)
+	if (inst->power.buffer_counter < DCVS_FTB_WINDOW || is_image_session(inst))
 		vote_data->power_mode = VIDC_POWER_TURBO;
 	if (msm_vidc_clock_voting)
 		vote_data->power_mode = VIDC_POWER_TURBO;
@@ -419,7 +420,7 @@ static int msm_vidc_apply_dcvs(struct msm_vidc_inst *inst)
 		return -EINVAL;
 	}
 
-	if (!inst->power.dcvs_mode || inst->decode_batch.enable) {
+	if (!inst->power.dcvs_mode || inst->decode_batch.enable || is_image_session(inst)) {
 		i_vpr_l(inst, "Skip DCVS (dcvs %d, batching %d)\n",
 			inst->power.dcvs_mode, inst->decode_batch.enable);
 		inst->power.dcvs_flags = 0;
@@ -491,7 +492,7 @@ int msm_vidc_scale_clocks(struct msm_vidc_inst *inst)
 		return 0;
 
 	//todo: add turbo session check
-	if (inst->power.buffer_counter < DCVS_FTB_WINDOW) {
+	if (inst->power.buffer_counter < DCVS_FTB_WINDOW || is_image_session(inst)) {
 		inst->power.min_freq = msm_vidc_max_freq(inst);
 		inst->power.dcvs_flags = 0;
 	} else if (msm_vidc_clock_voting) {

driver/vidc/src/venus_hfi_response.c

@@ -1322,8 +1322,7 @@ static int handle_system_response(struct msm_vidc_core *core,
 	int rc = 0;
 	struct hfi_packet *packet;
 	u8 *pkt, *start_pkt;
-	bool parsed = false;
-	int i, j, k;
+	int i, j;
 	static const struct msm_vidc_core_hfi_range be[] = {
 		{HFI_SYSTEM_ERROR_BEGIN,   HFI_SYSTEM_ERROR_END,   handle_system_error     },
 		{HFI_PROP_BEGIN,           HFI_PROP_END,           handle_system_property  },
@@ -1335,25 +1334,11 @@ static int handle_system_response(struct msm_vidc_core *core,
 		pkt = start_pkt;
 		for (j = 0; j < hdr->num_packets; j++) {
 			packet = (struct hfi_packet *)pkt;
-			parsed = false;
 			if (in_range(be[i], packet->type)) {
-				parsed = true;
 				rc = be[i].handle(core, packet);
 				if (rc)
 					return -EINVAL;
 			}
-
-			/* is pkt type unknown ? */
-			if (!parsed) {
-				for (k = 0; k < ARRAY_SIZE(be); k++)
-					if (in_range(be[k], packet->type))
-						parsed |= true;
-
-				if (!parsed)
-					d_vpr_e("%s: unknown packet received %#x\n",
-						__func__, packet->type);
-			}
-
 			pkt += packet->size;
 		}
 	}
@@ -1367,8 +1352,8 @@ static int __handle_session_response(struct msm_vidc_inst *inst,
 	int rc = 0;
 	struct hfi_packet *packet;
 	u8 *pkt, *start_pkt;
-	bool dequeue = false, parsed = false;
-	int i, j, k;
+	bool dequeue = false;
+	int i, j;
 	static const struct msm_vidc_inst_hfi_range be[] = {
 		{HFI_SESSION_ERROR_BEGIN,  HFI_SESSION_ERROR_END,  handle_session_error    },
 		{HFI_INFORMATION_BEGIN,    HFI_INFORMATION_END,    handle_session_info     },
@@ -1382,26 +1367,12 @@ static int __handle_session_response(struct msm_vidc_inst *inst,
 		pkt = start_pkt;
 		for (j = 0; j < hdr->num_packets; j++) {
 			packet = (struct hfi_packet *)pkt;
-			parsed = false;
 			if (in_range(be[i], packet->type)) {
-				parsed = true;
 				dequeue |= (packet->type == HFI_CMD_BUFFER);
 				rc = be[i].handle(inst, packet);
 				if (rc)
 					goto exit;
 			}
-
-			/* is pkt type unknown ? */
-			if (!parsed) {
-				for (k = 0; k < ARRAY_SIZE(be); k++)
-					if (in_range(be[k], packet->type))
-						parsed |= true;
-
-				if (!parsed)
-					d_vpr_e("%s: unknown packet received %#x\n",
-						__func__, packet->type);
-			}
-
 			pkt += packet->size;
 		}
 	}