Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 61344c19 authored by Amit Shekhar's avatar Amit Shekhar
Browse files

msm: vidc: Check image encode capabilities 



For heic/hevc image session, check respective capabilities to
allow or reject.

Change-Id: I4e565e6614a7863f75ecd4719480b850e1af43ae
Signed-off-by: default avatarAmit Shekhar <ashekhar@codeaurora.org>
parent b00fc832

msm/vidc/msm_venc.c

+76 −66
Original line number Diff line number Diff line
@@ -1506,12 +1506,6 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) 
				"%s: set bitrate mode failed\n", __func__);

		break;

	}

	case V4L2_CID_MPEG_VIDC_COMPRESSION_QUALITY:

		inst->frame_quality = ctrl->val;

		break;

	case V4L2_CID_MPEG_VIDC_IMG_GRID_SIZE:

		inst->grid_enable = ctrl->val;

		break;

	case V4L2_CID_MPEG_VIDEO_BITRATE:

		inst->clk_data.bitrate = ctrl->val;

		if (inst->state == MSM_VIDC_START_DONE) {
@@ -1774,6 +1768,8 @@ int msm_venc_s_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl) 
					__func__);

		}

		break;

	case V4L2_CID_MPEG_VIDC_COMPRESSION_QUALITY:

	case V4L2_CID_MPEG_VIDC_IMG_GRID_SIZE:

	case V4L2_CID_MPEG_VIDC_VIDEO_HEVC_MAX_HIER_CODING_LAYER:

	case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_TYPE:

	case V4L2_CID_ROTATE:
@@ -2800,40 +2796,73 @@ int msm_venc_set_qp_range(struct msm_vidc_inst *inst) 
	return rc;

}



int msm_venc_set_frame_quality(struct msm_vidc_inst *inst)

static void set_all_intra_preconditions(struct msm_vidc_inst *inst)

{

	int rc = 0;

	struct hfi_device *hdev;

	struct v4l2_ctrl *ctrl;

	struct hfi_heic_frame_quality frame_quality;

	struct v4l2_ctrl *ctrl = NULL, *ctrl_t = NULL;



	if (!inst || !inst->core) {

		dprintk(VIDC_ERR, "%s: invalid params\n", __func__);

		return -EINVAL;

	/* Disable multi slice */

	ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE);

	if (ctrl->val) {

		dprintk(VIDC_HIGH, "Disable multi slice for all intra\n");

		ctrl->val = V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE;

	}

	hdev = inst->core->device;



	if (inst->rc_type != V4L2_MPEG_VIDEO_BITRATE_MODE_CQ)

		return 0;

	/* Disable LTR */

	ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_VIDEO_LTRCOUNT);

	if (ctrl->val) {

		dprintk(VIDC_HIGH, "Disable LTR for all intra\n");

		ctrl->val = 0;

	}



	ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_COMPRESSION_QUALITY);

	frame_quality.frame_quality = ctrl->val;

	/* Disable Layer encoding */

	ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_LAYER);

	ctrl_t = get_ctrl(inst,

		V4L2_CID_MPEG_VIDC_VIDEO_HEVC_MAX_HIER_CODING_LAYER);

	if (ctrl->val || ctrl_t->val) {

		dprintk(VIDC_HIGH, "Disable layer encoding for all intra\n");

		ctrl->val = 0;

		ctrl_t->val = 0;

	}



	dprintk(VIDC_HIGH, "%s: %d\n", __func__, frame_quality.frame_quality);

	rc = call_hfi_op(hdev, session_set_property, inst->session,

		HFI_PROPERTY_CONFIG_HEIC_FRAME_QUALITY, &frame_quality,

		sizeof(frame_quality));

	if (rc)

		dprintk(VIDC_ERR, "%s: set property failed\n", __func__);

	/* Disable IR */

	ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_VIDEO_INTRA_REFRESH_RANDOM);

	ctrl_t = get_ctrl(inst, V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB);

	if (ctrl->val || ctrl_t->val) {

		dprintk(VIDC_HIGH, "Disable IR for all intra\n");

		ctrl->val = 0;

		ctrl_t->val = 0;

	}



	return rc;

	return;

}



int msm_venc_set_grid(struct msm_vidc_inst *inst)

static void set_heif_preconditions(struct msm_vidc_inst *inst)

{

	struct v4l2_ctrl *ctrl = NULL;



	/* Reset PFrames */

	ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDEO_GOP_SIZE);

	if (ctrl->val) {

		dprintk(VIDC_HIGH, "Reset P-frame count for HEIF\n");

		ctrl->val = 0;

	}



	/* Reset BFrames */

	ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDEO_B_FRAMES);

	if (ctrl->val) {

		dprintk(VIDC_HIGH, "Reset B-frame count for HEIF\n");

		ctrl->val = 0;

	}



	return;

}



int msm_venc_set_image_properties(struct msm_vidc_inst *inst)

{

	int rc = 0;

	struct hfi_device *hdev;

	struct v4l2_ctrl *ctrl;

	struct hfi_heic_frame_quality frame_quality;

	struct hfi_heic_grid_enable grid_enable;



	if (!inst || !inst->core) {
@@ -2845,6 +2874,17 @@ int msm_venc_set_grid(struct msm_vidc_inst *inst) 
	if (inst->rc_type != V4L2_MPEG_VIDEO_BITRATE_MODE_CQ)

		return 0;



	ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_COMPRESSION_QUALITY);

	frame_quality.frame_quality = ctrl->val;



	dprintk(VIDC_HIGH, "%s: frame quality: %d\n", __func__,

		frame_quality.frame_quality);

	rc = call_hfi_op(hdev, session_set_property, inst->session,

		HFI_PROPERTY_CONFIG_HEIC_FRAME_QUALITY, &frame_quality,

		sizeof(frame_quality));

	if (rc)

		dprintk(VIDC_ERR, "%s: set frame quality failed\n", __func__);



	ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_IMG_GRID_SIZE);



	/* Need a change in HFI if we want to pass size */
@@ -2853,12 +2893,16 @@ int msm_venc_set_grid(struct msm_vidc_inst *inst) 
	else

		grid_enable.grid_enable = true;



	dprintk(VIDC_HIGH, "%s: %d\n", __func__, grid_enable.grid_enable);

	dprintk(VIDC_HIGH, "%s: grid enable: %d\n", __func__,

		grid_enable.grid_enable);

	rc = call_hfi_op(hdev, session_set_property, inst->session,

		HFI_PROPERTY_CONFIG_HEIC_GRID_ENABLE, &grid_enable,

		sizeof(grid_enable));

	if (rc)

		dprintk(VIDC_ERR, "%s: set property failed\n", __func__);

		dprintk(VIDC_ERR, "%s: set grid enable failed\n", __func__);



	set_all_intra_preconditions(inst);

	set_heif_preconditions(inst);



	return rc;

}
@@ -4020,7 +4064,7 @@ int msm_venc_set_lossless(struct msm_vidc_inst *inst) 


int handle_all_intra_restrictions(struct msm_vidc_inst *inst)

{

	struct v4l2_ctrl *ctrl, *ctrl_t;

	struct v4l2_ctrl *ctrl = NULL;

	u32 n_fps, fps_max;

	struct msm_vidc_capability *capability;

	struct v4l2_format *f;
@@ -4071,38 +4115,7 @@ int handle_all_intra_restrictions(struct msm_vidc_inst *inst) 
		return -ENOTSUPP;

	}



	/* Disable multi slice */

	ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE);

	if (ctrl->val) {

		dprintk(VIDC_HIGH, "Disable multi slice for all intra\n");

		ctrl->val = V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE;

	}



	/* Disable LTR */

	ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_VIDEO_LTRCOUNT);

	if (ctrl->val) {

		dprintk(VIDC_HIGH, "Disable LTR for all intra\n");

		ctrl->val = 0;

	}



	/* Disable Layer encoding */

	ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_LAYER);

	ctrl_t = get_ctrl(inst,

		V4L2_CID_MPEG_VIDC_VIDEO_HEVC_MAX_HIER_CODING_LAYER);

	if (ctrl->val || ctrl_t->val) {

		dprintk(VIDC_HIGH, "Disable layer encoding for all intra\n");

		ctrl->val = 0;

		ctrl_t->val = 0;

	}



	/* Disable IR */

	ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_VIDEO_INTRA_REFRESH_RANDOM);

	ctrl_t = get_ctrl(inst, V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB);

	if (ctrl->val || ctrl_t->val) {

		dprintk(VIDC_HIGH, "Disable IR for all intra\n");

		ctrl->val = 0;

		ctrl_t->val = 0;

	}

	set_all_intra_preconditions(inst);



	return 0;

}
@@ -4162,10 +4175,7 @@ int msm_venc_set_properties(struct msm_vidc_inst *inst) 
	rc = msm_venc_set_qp_range(inst);

	if (rc)

		goto exit;

	rc = msm_venc_set_frame_quality(inst);

	if (rc)

		goto exit;

	rc = msm_venc_set_grid(inst);

	rc = msm_venc_set_image_properties(inst);

	if (rc)

		goto exit;

	rc = msm_venc_set_au_delimiter_mode(inst);

msm/vidc/msm_vidc.c

+0 −12
Original line number Diff line number Diff line
@@ -826,15 +826,6 @@ static inline int start_streaming(struct msm_vidc_inst *inst) 
		is_secondary_output_mode(inst))

		b.buffer_type = HFI_BUFFER_OUTPUT2;



	/* HEIC HW/FWK tiling encode is supported only for CQ RC mode */

	if (inst->rc_type == V4L2_MPEG_VIDEO_BITRATE_MODE_CQ) {

		if (!heic_encode_session_supported(inst)) {

			dprintk(VIDC_ERR,

				"HEIC Encode session not supported\n");

			return -ENOTSUPP;

		}

	}



	/* Check if current session is under HW capability */

	rc = msm_vidc_check_session_supported(inst);

	if (rc) {
@@ -1440,9 +1431,6 @@ static int try_get_ctrl_for_instance(struct msm_vidc_inst *inst, 
			V4L2_CID_MPEG_VIDEO_HEVC_PROFILE,

			inst->profile);

		break;

	case V4L2_CID_MPEG_VIDC_IMG_GRID_SIZE:

		ctrl->val = inst->grid_enable;

		break;

	case V4L2_CID_MPEG_VIDEO_H264_LEVEL:

		ctrl->val = msm_comm_hfi_to_v4l2(

			V4L2_CID_MPEG_VIDEO_H264_LEVEL,

msm/vidc/msm_vidc_clocks.c

+1 −2
Original line number Diff line number Diff line
@@ -1069,8 +1069,7 @@ int msm_dcvs_try_enable(struct msm_vidc_inst *inst) 
			inst->flags & VIDC_THUMBNAIL ||

			inst->clk_data.low_latency_mode ||

			inst->batch.enable ||

			inst->rc_type == V4L2_MPEG_VIDEO_BITRATE_MODE_CQ ||

			inst->grid_enable) {

			inst->rc_type == V4L2_MPEG_VIDEO_BITRATE_MODE_CQ) {

		dprintk(VIDC_HIGH, "DCVS disabled: %pK\n", inst);

		inst->clk_data.dcvs_mode = false;

		return false;

msm/vidc/msm_vidc_common.c

+54 −45
Original line number Diff line number Diff line
@@ -2387,48 +2387,6 @@ int msm_comm_vb2_buffer_done(struct msm_vidc_inst *inst, 
	return 0;

}



bool heic_encode_session_supported(struct msm_vidc_inst *inst)

{

	u32 slice_mode;

	u32 idr_period = IDR_PERIOD;

	u32 n_bframes;

	u32 n_pframes;

	struct v4l2_format *f;



	slice_mode =  msm_comm_g_ctrl_for_id(inst,

		V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE);

	n_bframes =  msm_comm_g_ctrl_for_id(inst,

		V4L2_CID_MPEG_VIDEO_B_FRAMES);

	n_pframes =  msm_comm_g_ctrl_for_id(inst,

		V4L2_CID_MPEG_VIDEO_GOP_SIZE);



	/*

	 * HEIC Encode is supported for Constant Quality RC mode only.

	 * All configurations below except grid_enable are required for any

	 * HEIC session including FWK tiled HEIC encode.

	 * grid_enable flag along with dimension check enables HW tiling.

	 */

	f = &inst->fmts[OUTPUT_PORT].v4l2_fmt;

	if (inst->session_type == MSM_VIDC_ENCODER &&

		get_hal_codec(f->fmt.pix_mp.pixelformat) ==

			HAL_VIDEO_CODEC_HEVC &&

		inst->frame_quality >= MIN_FRAME_QUALITY &&

		inst->frame_quality <= MAX_FRAME_QUALITY &&

		slice_mode == V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE &&

		idr_period == 1 &&

		n_bframes == 0 &&

		n_pframes == 0) {

		if (inst->grid_enable > 0) {

			if (f->fmt.pix_mp.width < HEIC_GRID_DIMENSION ||

				f->fmt.pix_mp.height < HEIC_GRID_DIMENSION)

				return false;

			}

		return true;

	} else {

		return false;

	}

}



static bool is_eos_buffer(struct msm_vidc_inst *inst, u32 device_addr)

{

	struct eos_buf *temp, *next;
@@ -5585,6 +5543,9 @@ static int msm_vidc_check_mbpf_supported(struct msm_vidc_inst *inst) 
		/* ignore thumbnail session */

		if (is_thumbnail_session(temp))

			continue;

		/* ignore HEIF sessions */

		if (is_image_session(temp))

			continue;

		mbpf += NUM_MBS_PER_FRAME(

			temp->fmts[INPUT_PORT].v4l2_fmt.fmt.pix_mp.height,

			temp->fmts[INPUT_PORT].v4l2_fmt.fmt.pix_mp.width);
@@ -5629,11 +5590,16 @@ int msm_vidc_check_scaling_supported(struct msm_vidc_inst *inst) 
	u32 x_min, x_max, y_min, y_max;

	u32 input_height, input_width, output_height, output_width;

	struct v4l2_format *f;

	struct v4l2_ctrl *ctrl = NULL;



	if (inst->grid_enable > 0) {

	/* Grid get_ctrl allowed for encode session only */

	if (is_image_session(inst)) {

		ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_IMG_GRID_SIZE);

		if (ctrl->val > 0) {

			dprintk(VIDC_HIGH, "Skip scaling check for HEIC\n");

			return 0;

		}

	}



	f = &inst->fmts[INPUT_PORT].v4l2_fmt;

	input_height = f->fmt.pix_mp.height;
@@ -5719,6 +5685,7 @@ int msm_vidc_check_session_supported(struct msm_vidc_inst *inst) 
	u32 width_min, width_max, height_min, height_max;

	u32 mbpf_max;

	struct v4l2_format *f;

	struct v4l2_ctrl *ctrl = NULL;



	if (!inst || !inst->core || !inst->core->device) {

		dprintk(VIDC_ERR, "%s: Invalid parameter\n", __func__);
@@ -5774,6 +5741,48 @@ int msm_vidc_check_session_supported(struct msm_vidc_inst *inst) 
	input_height = f->fmt.pix_mp.height;

	input_width = f->fmt.pix_mp.width;



	if (is_image_session(inst)) {

		if (is_secure_session(inst)) {

			dprintk(VIDC_ERR,

				"Secure image encode isn't supported!\n");

			return -ENOTSUPP;

		}



		ctrl = get_ctrl(inst, V4L2_CID_MPEG_VIDC_IMG_GRID_SIZE);

		if (ctrl->val > 0) {

			if (inst->fmts[INPUT_PORT].v4l2_fmt.fmt.pix_mp.pixelformat !=

				V4L2_PIX_FMT_NV12 &&

				inst->fmts[INPUT_PORT].v4l2_fmt.fmt.pix_mp.pixelformat !=

				V4L2_PIX_FMT_NV12_512)

				return -ENOTSUPP;



			width_min =

				capability->cap[CAP_HEIC_IMAGE_FRAME_WIDTH].min;

			width_max =

				capability->cap[CAP_HEIC_IMAGE_FRAME_WIDTH].max;

			height_min =

				capability->cap[CAP_HEIC_IMAGE_FRAME_HEIGHT].min;

			height_max =

				capability->cap[CAP_HEIC_IMAGE_FRAME_HEIGHT].max;

			mbpf_max = capability->cap[CAP_MBS_PER_FRAME].max;



			input_height = ALIGN(input_height, 512);

			input_width = ALIGN(input_width, 512);

			output_height = input_height;

			output_width = input_width;

		} else {

			width_min =

				capability->cap[CAP_HEVC_IMAGE_FRAME_WIDTH].min;

			width_max =

				capability->cap[CAP_HEVC_IMAGE_FRAME_WIDTH].max;

			height_min =

				capability->cap[CAP_HEVC_IMAGE_FRAME_HEIGHT].min;

			height_max =

				capability->cap[CAP_HEVC_IMAGE_FRAME_HEIGHT].max;

			mbpf_max = capability->cap[CAP_MBS_PER_FRAME].max;

		}

	}



	if (inst->session_type == MSM_VIDC_ENCODER && (input_width % 2 != 0 ||

			input_height % 2 != 0 || output_width % 2 != 0 ||

			output_height % 2 != 0)) {

msm/vidc/msm_vidc_common.h

+8 −0
Original line number Diff line number Diff line
@@ -84,6 +84,14 @@ static inline u32 get_v4l2_codec(struct msm_vidc_inst *inst) 
	return f->fmt.pix_mp.pixelformat;

}



static inline bool is_image_session(struct msm_vidc_inst *inst)

{

	/* Grid may or may not be enabled for an image encode session */

	return inst->session_type == MSM_VIDC_ENCODER &&

		get_v4l2_codec(inst) == V4L2_PIX_FMT_HEVC &&

		inst->rc_type == V4L2_MPEG_VIDEO_BITRATE_MODE_CQ;

}



static inline bool is_realtime_session(struct msm_vidc_inst *inst)

{

	return !!(inst->flags & VIDC_REALTIME);