Merge "msm: vidc: Keep v4l2 plane count instance-specific" (89fd48e0) · Commits · e / devices / android_kernel_sony_msm8998

drivers/media/platform/msm/vidc/msm_vdec.c

+32 −27

Original line number	Diff line number	Diff line
		@@ -667,7 +667,7 @@ static int is_ctrl_valid_for_codec(struct msm_vidc_inst *inst,
		int rc = 0;
		switch (ctrl->id) {
		case V4L2_CID_MPEG_VIDC_VIDEO_MVC_BUFFER_LAYOUT:
		if (inst->fmts[OUTPUT_PORT]->fourcc != V4L2_PIX_FMT_H264_MVC) {
		if (inst->fmts[OUTPUT_PORT].fourcc != V4L2_PIX_FMT_H264_MVC) {
		dprintk(VIDC_ERR, "Control %#x only valid for MVC\n",
		ctrl->id);
		rc = -ENOTSUPP;
		@@ -675,7 +675,7 @@ static int is_ctrl_valid_for_codec(struct msm_vidc_inst *inst,
		}
		break;
		case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
		if (inst->fmts[OUTPUT_PORT]->fourcc == V4L2_PIX_FMT_H264_MVC &&
		if (inst->fmts[OUTPUT_PORT].fourcc == V4L2_PIX_FMT_H264_MVC &&
		ctrl->val != V4L2_MPEG_VIDEO_H264_PROFILE_STEREO_HIGH) {
		dprintk(VIDC_ERR,
		"Profile %#x not supported for MVC\n",
		@@ -685,7 +685,7 @@ static int is_ctrl_valid_for_codec(struct msm_vidc_inst *inst,
		}
		break;
		case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
		if (inst->fmts[OUTPUT_PORT]->fourcc == V4L2_PIX_FMT_H264_MVC &&
		if (inst->fmts[OUTPUT_PORT].fourcc == V4L2_PIX_FMT_H264_MVC &&
		ctrl->val >= V4L2_MPEG_VIDEO_H264_LEVEL_5_2) {
		dprintk(VIDC_ERR, "Level %#x not supported for MVC\n",
		ctrl->val);
		@@ -896,10 +896,10 @@ int msm_vdec_prepare_buf(struct msm_vidc_inst *inst,
		case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
		break;
		case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
		if (b->length != inst->fmts[CAPTURE_PORT]->num_planes) {
		if (b->length != inst->fmts[CAPTURE_PORT].num_planes) {
		dprintk(VIDC_ERR,
		"Planes mismatch: needed: %d, allocated: %d\n",
		inst->fmts[CAPTURE_PORT]->num_planes,
		inst->fmts[CAPTURE_PORT].num_planes,
		b->length);
		rc = -EINVAL;
		break;
		@@ -975,10 +975,10 @@ int msm_vdec_release_buf(struct msm_vidc_inst *inst,
		case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
		break;
		case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
		if (b->length != inst->fmts[CAPTURE_PORT]->num_planes) {
		if (b->length != inst->fmts[CAPTURE_PORT].num_planes) {
		dprintk(VIDC_ERR,
		"Planes mismatch: needed: %d, to release: %d\n",
		inst->fmts[CAPTURE_PORT]->num_planes, b->length);
		inst->fmts[CAPTURE_PORT].num_planes, b->length);
		rc = -EINVAL;
		break;
		}
		@@ -1099,9 +1099,9 @@ int msm_vdec_g_fmt(struct msm_vidc_inst inst, struct v4l2_format f)

		hdev = inst->core->device;
		if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
		fmt = inst->fmts[CAPTURE_PORT];
		fmt = &inst->fmts[CAPTURE_PORT];
		else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
		fmt = inst->fmts[OUTPUT_PORT];
		fmt = &inst->fmts[OUTPUT_PORT];
		else
		return -ENOTSUPP;

		@@ -1250,6 +1250,8 @@ int msm_vdec_s_fmt(struct msm_vidc_inst inst, struct v4l2_format f)
		rc = -EINVAL;
		goto err_invalid_fmt;
		}
		memcpy(&inst->fmts[fmt->type], fmt,
		sizeof(struct msm_vidc_format));

		inst->prop.width[CAPTURE_PORT] = f->fmt.pix_mp.width;
		inst->prop.height[CAPTURE_PORT] = f->fmt.pix_mp.height;
		@@ -1257,7 +1259,6 @@ int msm_vdec_s_fmt(struct msm_vidc_inst inst, struct v4l2_format f)
		msm_comm_get_hal_output_buffer(inst),
		f->fmt.pix_mp.pixelformat);

		inst->fmts[fmt->type] = fmt;
		if (msm_comm_get_stream_output_mode(inst) ==
		HAL_VIDEO_DECODER_SECONDARY) {
		frame_sz.buffer_type = HAL_BUFFER_OUTPUT2;
		@@ -1272,10 +1273,10 @@ int msm_vdec_s_fmt(struct msm_vidc_inst inst, struct v4l2_format f)
		}

		f->fmt.pix_mp.plane_fmt[0].sizeimage =
		fmt->get_frame_size(0,
		inst->fmts[fmt->type].get_frame_size(0,
		f->fmt.pix_mp.height, f->fmt.pix_mp.width);

		extra_idx = EXTRADATA_IDX(fmt->num_planes);
		extra_idx = EXTRADATA_IDX(inst->fmts[fmt->type].num_planes);
		if (extra_idx && extra_idx < VIDEO_MAX_PLANES) {
		f->fmt.pix_mp.plane_fmt[extra_idx].sizeimage =
		VENUS_EXTRADATA_SIZE(
		@@ -1283,8 +1284,8 @@ int msm_vdec_s_fmt(struct msm_vidc_inst inst, struct v4l2_format f)
		inst->prop.width[CAPTURE_PORT]);
		}

		f->fmt.pix_mp.num_planes = fmt->num_planes;
		for (i = 0; i < fmt->num_planes; ++i) {
		f->fmt.pix_mp.num_planes = inst->fmts[fmt->type].num_planes;
		for (i = 0; i < inst->fmts[fmt->type].num_planes; ++i) {
		inst->bufq[CAPTURE_PORT].vb2_bufq.plane_sizes[i] =
		f->fmt.pix_mp.plane_fmt[i].sizeimage;
		}
		@@ -1303,6 +1304,8 @@ int msm_vdec_s_fmt(struct msm_vidc_inst inst, struct v4l2_format f)
		rc = -EINVAL;
		goto err_invalid_fmt;
		}
		memcpy(&inst->fmts[fmt->type], fmt,
		sizeof(struct msm_vidc_format));

		rc = msm_comm_try_state(inst, MSM_VIDC_CORE_INIT_DONE);
		if (rc) {
		@@ -1310,17 +1313,16 @@ int msm_vdec_s_fmt(struct msm_vidc_inst inst, struct v4l2_format f)
		goto err_invalid_fmt;
		}

		if (!(get_hal_codec(fmt->fourcc) &
		if (!(get_hal_codec(inst->fmts[fmt->type].fourcc) &
		inst->core->dec_codec_supported)) {
		dprintk(VIDC_ERR,
		"Codec(%#x) is not present in the supported codecs list(%#x)\n",
		get_hal_codec(fmt->fourcc),
		get_hal_codec(inst->fmts[fmt->type].fourcc),
		inst->core->dec_codec_supported);
		rc = -EINVAL;
		goto err_invalid_fmt;
		}

		inst->fmts[fmt->type] = fmt;
		rc = msm_comm_try_state(inst, MSM_VIDC_OPEN_DONE);
		if (rc) {
		dprintk(VIDC_ERR, "Failed to open instance\n");
		@@ -1343,14 +1345,15 @@ int msm_vdec_s_fmt(struct msm_vidc_inst inst, struct v4l2_format f)
		frame_sz.height);
		msm_comm_try_set_prop(inst, HAL_PARAM_FRAME_SIZE, &frame_sz);

		max_input_size = get_frame_size(inst, fmt, f->type, 0);
		max_input_size = get_frame_size(
		inst, &inst->fmts[fmt->type], f->type, 0);
		if (f->fmt.pix_mp.plane_fmt[0].sizeimage > max_input_size \|\|
		!f->fmt.pix_mp.plane_fmt[0].sizeimage) {
		f->fmt.pix_mp.plane_fmt[0].sizeimage = max_input_size;
		}

		f->fmt.pix_mp.num_planes = fmt->num_planes;
		for (i = 0; i < fmt->num_planes; ++i) {
		f->fmt.pix_mp.num_planes = inst->fmts[fmt->type].num_planes;
		for (i = 0; i < inst->fmts[fmt->type].num_planes; ++i) {
		inst->bufq[OUTPUT_PORT].vb2_bufq.plane_sizes[i] =
		f->fmt.pix_mp.plane_fmt[i].sizeimage;
		}
		@@ -1464,20 +1467,20 @@ static int msm_vdec_queue_setup(struct vb2_queue *q,

		switch (q->type) {
		case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
		*num_planes = inst->fmts[OUTPUT_PORT]->num_planes;
		*num_planes = inst->fmts[OUTPUT_PORT].num_planes;
		if (*num_buffers < MIN_NUM_OUTPUT_BUFFERS \|\|
		*num_buffers > MAX_NUM_OUTPUT_BUFFERS)
		*num_buffers = MIN_NUM_OUTPUT_BUFFERS;
		for (i = 0; i < *num_planes; i++) {
		sizes[i] = get_frame_size(inst,
		inst->fmts[OUTPUT_PORT], q->type, i);
		&inst->fmts[OUTPUT_PORT], q->type, i);
		}
		rc = set_actual_buffer_count(inst, *num_buffers,
		HAL_BUFFER_INPUT);
		break;
		case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
		dprintk(VIDC_DBG, "Getting bufreqs on capture plane\n");
		*num_planes = inst->fmts[CAPTURE_PORT]->num_planes;
		*num_planes = inst->fmts[CAPTURE_PORT].num_planes;
		rc = msm_comm_try_state(inst, MSM_VIDC_OPEN_DONE);
		if (rc) {
		dprintk(VIDC_ERR, "Failed to open instance\n");
		@@ -1562,7 +1565,7 @@ static int msm_vdec_queue_setup(struct vb2_queue *q,
		}

		extra_idx =
		EXTRADATA_IDX(inst->fmts[CAPTURE_PORT]->num_planes);
		EXTRADATA_IDX(inst->fmts[CAPTURE_PORT].num_planes);
		if (extra_idx && extra_idx < VIDEO_MAX_PLANES) {
		sizes[extra_idx] =
		VENUS_EXTRADATA_SIZE(
		@@ -1663,7 +1666,7 @@ static inline int start_streaming(struct msm_vidc_inst *inst)
		unsigned int buffer_size;
		struct msm_vidc_format *fmt = NULL;

		fmt = inst->fmts[CAPTURE_PORT];
		fmt = &inst->fmts[CAPTURE_PORT];
		buffer_size = fmt->get_frame_size(0,
		inst->prop.height[CAPTURE_PORT],
		inst->prop.width[CAPTURE_PORT]);
		@@ -1885,8 +1888,6 @@ int msm_vdec_inst_init(struct msm_vidc_inst *inst)
		dprintk(VIDC_ERR, "Invalid input = %pK\n", inst);
		return -EINVAL;
		}
		inst->fmts[OUTPUT_PORT] = &vdec_formats[2];
		inst->fmts[CAPTURE_PORT] = &vdec_formats[0];
		inst->prop.height[CAPTURE_PORT] = DEFAULT_HEIGHT;
		inst->prop.width[CAPTURE_PORT] = DEFAULT_WIDTH;
		inst->prop.height[OUTPUT_PORT] = DEFAULT_HEIGHT;
		@@ -1902,6 +1903,10 @@ int msm_vdec_inst_init(struct msm_vidc_inst *inst)
		inst->buffer_mode_set[OUTPUT_PORT] = HAL_BUFFER_MODE_STATIC;
		inst->buffer_mode_set[CAPTURE_PORT] = HAL_BUFFER_MODE_STATIC;
		inst->prop.fps = DEFAULT_FPS;
		memcpy(&inst->fmts[OUTPUT_PORT], &vdec_formats[2],
		sizeof(struct msm_vidc_format));
		memcpy(&inst->fmts[CAPTURE_PORT], &vdec_formats[0],
		sizeof(struct msm_vidc_format));
		return rc;
		}

drivers/media/platform/msm/vidc/msm_venc.c

+31 −27

Original line number	Diff line number	Diff line
		@@ -1485,7 +1485,7 @@ static int msm_venc_queue_setup(struct vb2_queue *q,
		default:
		break;
		}
		inst->fmts[CAPTURE_PORT]->num_planes = *num_planes;
		inst->fmts[CAPTURE_PORT].num_planes = *num_planes;

		for (i = 0; i < *num_planes; i++) {
		int extra_idx = EXTRADATA_IDX(*num_planes);
		@@ -1560,7 +1560,7 @@ static int msm_venc_queue_setup(struct vb2_queue *q,
		break;
		}

		inst->fmts[OUTPUT_PORT]->num_planes = *num_planes;
		inst->fmts[OUTPUT_PORT].num_planes = *num_planes;
		rc = call_hfi_op(hdev, session_set_property, inst->session,
		property_id, &new_buf_count);
		if (rc)
		@@ -1570,12 +1570,12 @@ static int msm_venc_queue_setup(struct vb2_queue *q,
		inst->buff_req.buffer[0].buffer_size,
		inst->buff_req.buffer[0].buffer_alignment,
		inst->buff_req.buffer[0].buffer_count_actual);
		sizes[0] = inst->fmts[OUTPUT_PORT]->get_frame_size(
		sizes[0] = inst->fmts[OUTPUT_PORT].get_frame_size(
		0, inst->prop.height[OUTPUT_PORT],
		inst->prop.width[OUTPUT_PORT]);

		extra_idx =
		EXTRADATA_IDX(inst->fmts[OUTPUT_PORT]->num_planes);
		EXTRADATA_IDX(inst->fmts[OUTPUT_PORT].num_planes);
		if (extra_idx && (extra_idx < VIDEO_MAX_PLANES)) {
		buff_req_buffer = get_buff_req_buffer(inst,
		HAL_BUFFER_EXTRADATA_INPUT);
		@@ -1610,7 +1610,7 @@ static int msm_venc_toggle_hier_p(struct msm_vidc_inst *inst, int layers)
		return -EINVAL;
		}

		if (inst->fmts[CAPTURE_PORT]->fourcc != V4L2_PIX_FMT_VP8)
		if (inst->fmts[CAPTURE_PORT].fourcc != V4L2_PIX_FMT_VP8)
		return 0;

		num_enh_layers = layers ? : 0;
		@@ -2177,10 +2177,10 @@ static int try_set_ctrl(struct msm_vidc_inst inst, struct v4l2_ctrl ctrl)

		switch (ctrl->id) {
		case V4L2_CID_MPEG_VIDC_VIDEO_IDR_PERIOD:
		if (inst->fmts[CAPTURE_PORT]->fourcc != V4L2_PIX_FMT_H264 &&
		inst->fmts[CAPTURE_PORT]->fourcc !=
		if (inst->fmts[CAPTURE_PORT].fourcc != V4L2_PIX_FMT_H264 &&
		inst->fmts[CAPTURE_PORT].fourcc !=
		V4L2_PIX_FMT_H264_NO_SC &&
		inst->fmts[CAPTURE_PORT]->fourcc !=
		inst->fmts[CAPTURE_PORT].fourcc !=
		V4L2_PIX_FMT_HEVC) {
		dprintk(VIDC_ERR,
		"Control %#x only valid for H264 and HEVC\n",
		@@ -2669,8 +2669,8 @@ static int try_set_ctrl(struct msm_vidc_inst inst, struct v4l2_ctrl ctrl)
		break;
		case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_DELIVERY_MODE: {
		bool codec_avc =
		inst->fmts[CAPTURE_PORT]->fourcc == V4L2_PIX_FMT_H264 \|\|
		inst->fmts[CAPTURE_PORT]->fourcc ==
		inst->fmts[CAPTURE_PORT].fourcc == V4L2_PIX_FMT_H264 \|\|
		inst->fmts[CAPTURE_PORT].fourcc ==
		V4L2_PIX_FMT_H264_NO_SC;

		temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE);
		@@ -2696,8 +2696,8 @@ static int try_set_ctrl(struct msm_vidc_inst inst, struct v4l2_ctrl ctrl)
		cir_mbs = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_CIR_MBS);

		is_cont_intra_supported =
		(inst->fmts[CAPTURE_PORT]->fourcc == V4L2_PIX_FMT_H264) \|\|
		(inst->fmts[CAPTURE_PORT]->fourcc == V4L2_PIX_FMT_HEVC);
		(inst->fmts[CAPTURE_PORT].fourcc == V4L2_PIX_FMT_H264) \|\|
		(inst->fmts[CAPTURE_PORT].fourcc == V4L2_PIX_FMT_HEVC);

		if (is_cont_intra_supported) {
		if (ctrl->val != HAL_INTRA_REFRESH_NONE)
		@@ -3054,7 +3054,7 @@ static int try_set_ctrl(struct msm_vidc_inst inst, struct v4l2_ctrl ctrl)

		break;
		case V4L2_CID_MPEG_VIDC_VIDEO_HIER_B_NUM_LAYERS:
		if (inst->fmts[CAPTURE_PORT]->fourcc != V4L2_PIX_FMT_HEVC) {
		if (inst->fmts[CAPTURE_PORT].fourcc != V4L2_PIX_FMT_HEVC) {
		dprintk(VIDC_ERR, "Hier B supported for HEVC only\n");
		rc = -ENOTSUPP;
		break;
		@@ -3483,8 +3483,6 @@ int msm_venc_inst_init(struct msm_vidc_inst *inst)
		dprintk(VIDC_ERR, "Invalid input = %pK\n", inst);
		return -EINVAL;
		}
		inst->fmts[CAPTURE_PORT] = &venc_formats[4];
		inst->fmts[OUTPUT_PORT] = &venc_formats[0];
		inst->prop.height[CAPTURE_PORT] = DEFAULT_HEIGHT;
		inst->prop.width[CAPTURE_PORT] = DEFAULT_WIDTH;
		inst->prop.height[OUTPUT_PORT] = DEFAULT_HEIGHT;
		@@ -3501,6 +3499,10 @@ int msm_venc_inst_init(struct msm_vidc_inst *inst)
		inst->buffer_mode_set[CAPTURE_PORT] = HAL_BUFFER_MODE_STATIC;
		inst->prop.fps = DEFAULT_FPS;
		inst->capability.pixelprocess_capabilities = 0;
		memcpy(&inst->fmts[CAPTURE_PORT], &venc_formats[4],
		sizeof(struct msm_vidc_format));
		memcpy(&inst->fmts[OUTPUT_PORT], &venc_formats[0],
		sizeof(struct msm_vidc_format));
		return rc;
		}

		@@ -3624,7 +3626,8 @@ int msm_venc_s_fmt(struct msm_vidc_inst inst, struct v4l2_format f)
		goto exit;
		}

		inst->fmts[fmt->type] = fmt;
		memcpy(&inst->fmts[fmt->type], fmt,
		sizeof(struct msm_vidc_format));

		rc = msm_comm_try_state(inst, MSM_VIDC_OPEN_DONE);
		if (rc) {
		@@ -3676,7 +3679,8 @@ int msm_venc_s_fmt(struct msm_vidc_inst inst, struct v4l2_format f)
		rc = -EINVAL;
		goto exit;
		}
		inst->fmts[fmt->type] = fmt;
		memcpy(&inst->fmts[fmt->type], fmt,
		sizeof(struct msm_vidc_format));

		msm_comm_set_color_format(inst, HAL_BUFFER_INPUT, fmt->fourcc);
		} else {
		@@ -3686,7 +3690,7 @@ int msm_venc_s_fmt(struct msm_vidc_inst inst, struct v4l2_format f)
		goto exit;
		}

		f->fmt.pix_mp.num_planes = fmt->num_planes;
		f->fmt.pix_mp.num_planes = inst->fmts[fmt->type].num_planes;

		if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
		struct hal_frame_size frame_sz = {0};
		@@ -3717,12 +3721,12 @@ int msm_venc_s_fmt(struct msm_vidc_inst inst, struct v4l2_format f)
		struct hal_buffer_requirements *bufreq = NULL;
		int extra_idx = 0;

		for (i = 0; i < fmt->num_planes; ++i) {
		for (i = 0; i < inst->fmts[fmt->type].num_planes; ++i) {
		f->fmt.pix_mp.plane_fmt[i].sizeimage =
		fmt->get_frame_size(i,
		inst->fmts[fmt->type].get_frame_size(i,
		f->fmt.pix_mp.height, f->fmt.pix_mp.width);
		}
		extra_idx = EXTRADATA_IDX(fmt->num_planes);
		extra_idx = EXTRADATA_IDX(inst->fmts[fmt->type].num_planes);
		if (extra_idx && (extra_idx < VIDEO_MAX_PLANES)) {
		bufreq = get_buff_req_buffer(inst,
		HAL_BUFFER_EXTRADATA_INPUT);
		@@ -3757,11 +3761,11 @@ int msm_venc_g_fmt(struct msm_vidc_inst inst, struct v4l2_format f)
		}

		if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
		fmt = inst->fmts[CAPTURE_PORT];
		fmt = &inst->fmts[CAPTURE_PORT];
		height = inst->prop.height[CAPTURE_PORT];
		width = inst->prop.width[CAPTURE_PORT];
		} else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
		fmt = inst->fmts[OUTPUT_PORT];
		fmt = &inst->fmts[OUTPUT_PORT];
		height = inst->prop.height[OUTPUT_PORT];
		width = inst->prop.width[OUTPUT_PORT];
		} else {
		@@ -3864,10 +3868,10 @@ int msm_venc_prepare_buf(struct msm_vidc_inst *inst,
		case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
		break;
		case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
		if (b->length != inst->fmts[CAPTURE_PORT]->num_planes) {
		if (b->length != inst->fmts[CAPTURE_PORT].num_planes) {
		dprintk(VIDC_ERR,
		"Planes mismatch: needed: %d, allocated: %d\n",
		inst->fmts[CAPTURE_PORT]->num_planes,
		inst->fmts[CAPTURE_PORT].num_planes,
		b->length);
		rc = -EINVAL;
		break;
		@@ -3935,10 +3939,10 @@ int msm_venc_release_buf(struct msm_vidc_inst *inst,
		break;
		case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: {
		if (b->length !=
		inst->fmts[CAPTURE_PORT]->num_planes) {
		inst->fmts[CAPTURE_PORT].num_planes) {
		dprintk(VIDC_ERR,
		"Planes mismatch: needed: %d, to release: %d\n",
		inst->fmts[CAPTURE_PORT]->num_planes,
		inst->fmts[CAPTURE_PORT].num_planes,
		b->length);
		rc = -EINVAL;
		break;

drivers/media/platform/msm/vidc/msm_vidc.c

+2 −2

Original line number	Diff line number	Diff line
		@@ -682,7 +682,7 @@ static bool valid_v4l2_buffer(struct v4l2_buffer *b,
		MAX_PORT_NUM;

		return port != MAX_PORT_NUM &&
		inst->fmts[port]->num_planes == b->length;
		inst->fmts[port].num_planes == b->length;
		}

		int msm_vidc_prepare_buf(void instance, struct v4l2_buffer b)
		@@ -849,7 +849,7 @@ int msm_vidc_qbuf(void instance, struct v4l2_buffer b)
		dprintk(VIDC_DBG, "Queueing device address = %pa\n",
		&binfo->device_addr[i]);

		if (inst->fmts[OUTPUT_PORT]->fourcc ==
		if (inst->fmts[OUTPUT_PORT].fourcc ==
		V4L2_PIX_FMT_HEVC_HYBRID && binfo->handle[i] &&
		b->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
		rc = msm_comm_smem_cache_operations(inst,

drivers/media/platform/msm/vidc/msm_vidc_common.c

+13 −13

Original line number	Diff line number	Diff line
		@@ -521,12 +521,12 @@ static int msm_comm_vote_bus(struct msm_vidc_core *core)
		struct v4l2_control ctrl;

		codec = inst->session_type == MSM_VIDC_DECODER ?
		inst->fmts[OUTPUT_PORT]->fourcc :
		inst->fmts[CAPTURE_PORT]->fourcc;
		inst->fmts[OUTPUT_PORT].fourcc :
		inst->fmts[CAPTURE_PORT].fourcc;

		yuv = inst->session_type == MSM_VIDC_DECODER ?
		inst->fmts[CAPTURE_PORT]->fourcc :
		inst->fmts[OUTPUT_PORT]->fourcc;
		inst->fmts[CAPTURE_PORT].fourcc :
		inst->fmts[OUTPUT_PORT].fourcc;

		vote_data[i].domain = get_hal_domain(inst->session_type);
		vote_data[i].codec = get_hal_codec(codec);
		@@ -1004,8 +1004,8 @@ static void handle_session_init_done(enum hal_command_response cmd, void *data)
		core = inst->core;
		hdev = inst->core->device;
		codec = inst->session_type == MSM_VIDC_DECODER ?
		inst->fmts[OUTPUT_PORT]->fourcc :
		inst->fmts[CAPTURE_PORT]->fourcc;
		inst->fmts[OUTPUT_PORT].fourcc :
		inst->fmts[CAPTURE_PORT].fourcc;

		/* check if capabilities are available for this session */
		for (i = 0; i < VIDC_MAX_SESSIONS; i++) {
		@@ -2028,7 +2028,7 @@ static void handle_fbd(enum hal_command_response cmd, void *data)
		ns_to_timeval(time_usec * NSEC_PER_USEC);
		vbuf->flags = 0;
		extra_idx =
		EXTRADATA_IDX(inst->fmts[CAPTURE_PORT]->num_planes);
		EXTRADATA_IDX(inst->fmts[CAPTURE_PORT].num_planes);
		if (extra_idx && extra_idx < VIDEO_MAX_PLANES) {
		vb->planes[extra_idx].m.userptr =
		(unsigned long)fill_buf_done->extra_data_buffer;
		@@ -2279,8 +2279,8 @@ int msm_comm_scale_clocks_load(struct msm_vidc_core *core,
		list_for_each_entry(inst, &core->instances, list) {

		codec = inst->session_type == MSM_VIDC_DECODER ?
		inst->fmts[OUTPUT_PORT]->fourcc :
		inst->fmts[CAPTURE_PORT]->fourcc;
		inst->fmts[OUTPUT_PORT].fourcc :
		inst->fmts[CAPTURE_PORT].fourcc;

		if (msm_comm_turbo_session(inst))
		clk_scale_data.power_mode[num_sessions] =
		@@ -2711,9 +2711,9 @@ static int msm_comm_session_init(int flipped_state,
		goto exit;
		}
		if (inst->session_type == MSM_VIDC_DECODER) {
		fourcc = inst->fmts[OUTPUT_PORT]->fourcc;
		fourcc = inst->fmts[OUTPUT_PORT].fourcc;
		} else if (inst->session_type == MSM_VIDC_ENCODER) {
		fourcc = inst->fmts[CAPTURE_PORT]->fourcc;
		fourcc = inst->fmts[CAPTURE_PORT].fourcc;
		} else {
		dprintk(VIDC_ERR, "Invalid session\n");
		return -EINVAL;
		@@ -3601,7 +3601,7 @@ static void populate_frame_data(struct vidc_frame_data *data,
		data->buffer_type = msm_comm_get_hal_output_buffer(inst);
		}

		extra_idx = EXTRADATA_IDX(inst->fmts[port]->num_planes);
		extra_idx = EXTRADATA_IDX(inst->fmts[port].num_planes);
		if (extra_idx && extra_idx < VIDEO_MAX_PLANES &&
		vb->planes[extra_idx].m.userptr) {
		data->extradata_addr = vb->planes[extra_idx].m.userptr;
		@@ -5276,7 +5276,7 @@ void msm_comm_print_inst_info(struct msm_vidc_inst *inst)
		port = is_decode ? OUTPUT_PORT : CAPTURE_PORT;
		dprintk(VIDC_ERR,
		"%s session, Codec type: %s HxW: %d x %d fps: %d bitrate: %d bit-depth: %s\n",
		is_decode ? "Decode" : "Encode", inst->fmts[port]->name,
		is_decode ? "Decode" : "Encode", inst->fmts[port].name,
		inst->prop.height[port], inst->prop.width[port],
		inst->prop.fps, inst->prop.bitrate,
		!inst->bit_depth ? "8" : "10");

drivers/media/platform/msm/vidc/msm_vidc_dcvs.c

+4 −4

Original line number	Diff line number	Diff line
		@@ -237,8 +237,8 @@ void msm_dcvs_init_load(struct msm_vidc_inst *inst)
		}

		fourcc = inst->session_type == MSM_VIDC_DECODER ?
		inst->fmts[OUTPUT_PORT]->fourcc :
		inst->fmts[CAPTURE_PORT]->fourcc;
		inst->fmts[OUTPUT_PORT].fourcc :
		inst->fmts[CAPTURE_PORT].fourcc;

		for (i = 0; i < num_rows; i++) {
		bool matches = msm_dcvs_check_codec_supported(
		@@ -589,7 +589,7 @@ static bool msm_dcvs_check_supported(struct msm_vidc_inst *inst)
		}
		is_codec_supported =
		msm_dcvs_check_codec_supported(
		inst->fmts[OUTPUT_PORT]->fourcc,
		inst->fmts[OUTPUT_PORT].fourcc,
		inst->dcvs.supported_codecs,
		inst->session_type);
		if (!is_codec_supported \|\|
		@@ -607,7 +607,7 @@ static bool msm_dcvs_check_supported(struct msm_vidc_inst *inst)
		inst->dcvs.extra_buffer_count = DCVS_ENC_EXTRA_OUTPUT_BUFFERS;
		is_codec_supported =
		msm_dcvs_check_codec_supported(
		inst->fmts[CAPTURE_PORT]->fourcc,
		inst->fmts[CAPTURE_PORT].fourcc,
		inst->dcvs.supported_codecs,
		inst->session_type);
		if (!is_codec_supported \|\|