Merge "msm: vidc: Fix setting profile & level control" (3aa6e677) · Commits · e / devices / android_kernel_fairphone_FP4

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

+174 −55

Original line number	Diff line number	Diff line
		@@ -37,13 +37,15 @@ static const char *const mpeg_video_stream_format[] = {

		static const char *const mpeg_vidc_video_alloc_mode_type[] = {
		"Buffer Allocation Static",
		"Buffer Allocation Dynamic Buffer"
		"Buffer Allocation Dynamic Buffer",
		NULL
		};

		static const char *const perf_level[] = {
		"Nominal",
		"Performance",
		"Turbo"
		"Turbo",
		NULL
		};

		static const char *const vp8_profile_level[] = {
		@@ -52,6 +54,7 @@ static const char *const vp8_profile_level[] = {
		"1.0",
		"2.0",
		"3.0",
		NULL
		};

		static const char *const vp9_level[] = {
		@@ -68,12 +71,14 @@ static const char *const vp9_level[] = {
		"5.1",
		"6.0",
		"6.1",
		NULL
		};

		static const char *const mpeg2_profile[] = {
		"Simple",
		"Main",
		"High",
		NULL
		};

		static const char *const mpeg2_level[] = {
		@@ -81,10 +86,12 @@ static const char *const mpeg2_level[] = {
		"1",
		"2",
		"3",
		NULL
		};
		static const char *const mpeg_vidc_video_entropy_mode[] = {
		"CAVLC Entropy Mode",
		"CABAC Entropy Mode",
		NULL
		};

		static struct msm_vidc_ctrl msm_vdec_ctrls[] = {
		@@ -158,23 +165,123 @@ static struct msm_vidc_ctrl msm_vdec_ctrls[] = {
		.id = V4L2_CID_MPEG_VIDEO_H264_PROFILE,
		.name = "H264 Profile",
		.type = V4L2_CTRL_TYPE_MENU,
		.minimum = V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE,
		.maximum = V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_HIGH,
		.default_value = V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE,
		.menu_skip_mask = 0,
		.default_value = V4L2_MPEG_VIDEO_H264_PROFILE_HIGH,
		.menu_skip_mask = ~(
		(1 << V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE) \|
		(1 << V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE) \|
		(1 << V4L2_MPEG_VIDEO_H264_PROFILE_MAIN) \|
		(1 << V4L2_MPEG_VIDEO_H264_PROFILE_HIGH) \|
		(1 << V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_HIGH)
		),
		.flags = V4L2_CTRL_FLAG_VOLATILE,
		.qmenu = NULL,
		.step = 1,
		},
		{
		.id = V4L2_CID_MPEG_VIDEO_H264_LEVEL,
		.name = "H264 Level",
		.type = V4L2_CTRL_TYPE_MENU,
		.minimum = V4L2_MPEG_VIDEO_H264_LEVEL_1_0,
		.maximum = V4L2_MPEG_VIDEO_H264_LEVEL_6_2,
		.default_value = V4L2_MPEG_VIDEO_H264_LEVEL_1_0,
		.menu_skip_mask = (
		.default_value = V4L2_MPEG_VIDEO_H264_LEVEL_5_0,
		.menu_skip_mask = ~(
		(1 << V4L2_MPEG_VIDEO_H264_LEVEL_1_0) \|
		(1 << V4L2_MPEG_VIDEO_H264_LEVEL_1B) \|
		(1 << V4L2_MPEG_VIDEO_H264_LEVEL_1_1) \|
		(1 << V4L2_MPEG_VIDEO_H264_LEVEL_1_2) \|
		(1 << V4L2_MPEG_VIDEO_H264_LEVEL_1_3) \|
		(1 << V4L2_MPEG_VIDEO_H264_LEVEL_2_0) \|
		(1 << V4L2_MPEG_VIDEO_H264_LEVEL_2_1) \|
		(1 << V4L2_MPEG_VIDEO_H264_LEVEL_2_2) \|
		(1 << V4L2_MPEG_VIDEO_H264_LEVEL_3_0) \|
		(1 << V4L2_MPEG_VIDEO_H264_LEVEL_3_1) \|
		(1 << V4L2_MPEG_VIDEO_H264_LEVEL_3_2) \|
		(1 << V4L2_MPEG_VIDEO_H264_LEVEL_4_0) \|
		(1 << V4L2_MPEG_VIDEO_H264_LEVEL_4_1) \|
		(1 << V4L2_MPEG_VIDEO_H264_LEVEL_4_2) \|
		(1 << V4L2_MPEG_VIDEO_H264_LEVEL_5_0) \|
		(1 << V4L2_MPEG_VIDEO_H264_LEVEL_5_1) \|
		(1 << V4L2_MPEG_VIDEO_H264_LEVEL_5_2) \|
		(1 << V4L2_MPEG_VIDEO_H264_LEVEL_6_0) \|
		(1 << V4L2_MPEG_VIDEO_H264_LEVEL_6_1) \|
		(1 << V4L2_MPEG_VIDEO_H264_LEVEL_6_2) \|
		(1 << V4L2_MPEG_VIDEO_H264_LEVEL_UNKNOWN)
		),
		.flags = V4L2_CTRL_FLAG_VOLATILE,
		.qmenu = NULL,
		.step = 1,
		},
		{
		.id = V4L2_CID_MPEG_VIDEO_HEVC_PROFILE,
		.name = "HEVC Profile",
		.type = V4L2_CTRL_TYPE_MENU,
		.minimum = V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN,
		.maximum = V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_10,
		.default_value = V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN,
		.menu_skip_mask = ~(
		(1 << V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN) \|
		(1 << V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_STILL_PICTURE) \|
		(1 << V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_10)
		),
		.flags = V4L2_CTRL_FLAG_VOLATILE,
		.qmenu = NULL,
		.step = 1,
		},
		{
		.id = V4L2_CID_MPEG_VIDEO_HEVC_LEVEL,
		.name = "HEVC Level",
		.type = V4L2_CTRL_TYPE_MENU,
		.minimum = V4L2_MPEG_VIDEO_HEVC_LEVEL_1,
		.maximum = V4L2_MPEG_VIDEO_HEVC_LEVEL_UNKNOWN,
		.default_value = V4L2_MPEG_VIDEO_HEVC_LEVEL_5,
		.menu_skip_mask = ~(
		(1 << V4L2_MPEG_VIDEO_HEVC_LEVEL_1) \|
		(1 << V4L2_MPEG_VIDEO_HEVC_LEVEL_2) \|
		(1 << V4L2_MPEG_VIDEO_HEVC_LEVEL_2_1) \|
		(1 << V4L2_MPEG_VIDEO_HEVC_LEVEL_3) \|
		(1 << V4L2_MPEG_VIDEO_HEVC_LEVEL_3_1) \|
		(1 << V4L2_MPEG_VIDEO_HEVC_LEVEL_4) \|
		(1 << V4L2_MPEG_VIDEO_HEVC_LEVEL_4_1) \|
		(1 << V4L2_MPEG_VIDEO_HEVC_LEVEL_5) \|
		(1 << V4L2_MPEG_VIDEO_HEVC_LEVEL_5_1) \|
		(1 << V4L2_MPEG_VIDEO_HEVC_LEVEL_5_2) \|
		(1 << V4L2_MPEG_VIDEO_HEVC_LEVEL_6) \|
		(1 << V4L2_MPEG_VIDEO_HEVC_LEVEL_6_1) \|
		(1 << V4L2_MPEG_VIDEO_HEVC_LEVEL_6_2) \|
		(1 << V4L2_MPEG_VIDEO_HEVC_LEVEL_UNKNOWN)
		),
		.flags = V4L2_CTRL_FLAG_VOLATILE,
		.qmenu = NULL,
		.step = 1,
		},
		{
		.id = V4L2_CID_MPEG_VIDEO_HEVC_TIER,
		.name = "HEVC Tier",
		.type = V4L2_CTRL_TYPE_MENU,
		.minimum = V4L2_MPEG_VIDEO_HEVC_TIER_MAIN,
		.maximum = V4L2_MPEG_VIDEO_HEVC_TIER_HIGH,
		.default_value = V4L2_MPEG_VIDEO_HEVC_TIER_HIGH,
		.menu_skip_mask = ~(
		(1 << V4L2_MPEG_VIDEO_HEVC_TIER_MAIN) \|
		(1 << V4L2_MPEG_VIDEO_HEVC_TIER_HIGH)
		),
		.flags = V4L2_CTRL_FLAG_VOLATILE,
		.qmenu = NULL,
		.step = 1,
		},
		{
		.id = V4L2_CID_MPEG_VIDEO_VP8_PROFILE,
		.name = "VP8 Profile",
		.type = V4L2_CTRL_TYPE_MENU,
		.minimum = V4L2_MPEG_VIDEO_VP8_PROFILE_0,
		.maximum = V4L2_MPEG_VIDEO_VP8_PROFILE_0,
		.default_value = V4L2_MPEG_VIDEO_VP8_PROFILE_0,
		.menu_skip_mask = ~(1 << V4L2_MPEG_VIDEO_VP8_PROFILE_0),
		.flags = V4L2_CTRL_FLAG_VOLATILE,
		.qmenu = NULL,
		.step = 1,
		},
		{
		.id = V4L2_CID_MPEG_VIDC_VIDEO_VP8_PROFILE_LEVEL,
		@@ -182,21 +289,34 @@ static struct msm_vidc_ctrl msm_vdec_ctrls[] = {
		.type = V4L2_CTRL_TYPE_MENU,
		.minimum = V4L2_MPEG_VIDC_VIDEO_VP8_UNUSED,
		.maximum = V4L2_MPEG_VIDC_VIDEO_VP8_VERSION_3,
		.default_value = V4L2_MPEG_VIDC_VIDEO_VP8_VERSION_0,
		.menu_skip_mask = 0,
		.default_value = V4L2_MPEG_VIDC_VIDEO_VP8_VERSION_3,
		.menu_skip_mask = ~(
		(1 << V4L2_MPEG_VIDC_VIDEO_VP8_UNUSED) \|
		(1 << V4L2_MPEG_VIDC_VIDEO_VP8_VERSION_0) \|
		(1 << V4L2_MPEG_VIDC_VIDEO_VP8_VERSION_1) \|
		(1 << V4L2_MPEG_VIDC_VIDEO_VP8_VERSION_2) \|
		(1 << V4L2_MPEG_VIDC_VIDEO_VP8_VERSION_3)
		),
		.qmenu = vp8_profile_level,
		.flags = V4L2_CTRL_FLAG_VOLATILE \| V4L2_CTRL_FLAG_READ_ONLY,
		.step = 1,
		},
		{
		.id = V4L2_CID_MPEG_VIDEO_VP9_PROFILE,
		.name = "VP9 Profile",
		.type = V4L2_CTRL_TYPE_MENU,
		.minimum = V4L2_MPEG_VIDEO_VP9_PROFILE_0,
		.maximum = V4L2_MPEG_VIDEO_VP9_PROFILE_3,
		.maximum = V4L2_MPEG_VIDEO_VP9_PROFILE_2,
		.default_value = V4L2_MPEG_VIDEO_VP9_PROFILE_0,
		.menu_skip_mask = 0,
		.menu_skip_mask = ~(
		(1 << V4L2_MPEG_VIDEO_VP9_PROFILE_0) \|
		(1 << V4L2_MPEG_VIDEO_VP9_PROFILE_1) \|
		(1 << V4L2_MPEG_VIDEO_VP9_PROFILE_2) \|
		(1 << V4L2_MPEG_VIDEO_VP9_PROFILE_3)
		),
		.qmenu = NULL,
		.flags = V4L2_CTRL_FLAG_VOLATILE \| V4L2_CTRL_FLAG_READ_ONLY,
		.step = 1,
		},
		{
		.id = V4L2_CID_MPEG_VIDC_VIDEO_VP9_LEVEL,
		@@ -205,40 +325,55 @@ static struct msm_vidc_ctrl msm_vdec_ctrls[] = {
		.minimum = V4L2_MPEG_VIDC_VIDEO_VP9_LEVEL_UNUSED,
		.maximum = V4L2_MPEG_VIDC_VIDEO_VP9_LEVEL_61,
		.default_value = V4L2_MPEG_VIDC_VIDEO_VP9_LEVEL_61,
		.menu_skip_mask = 0,
		.menu_skip_mask = ~(
		(1 << V4L2_MPEG_VIDC_VIDEO_VP9_LEVEL_UNUSED) \|
		(1 << V4L2_MPEG_VIDC_VIDEO_VP9_LEVEL_1) \|
		(1 << V4L2_MPEG_VIDC_VIDEO_VP9_LEVEL_11) \|
		(1 << V4L2_MPEG_VIDC_VIDEO_VP9_LEVEL_2) \|
		(1 << V4L2_MPEG_VIDC_VIDEO_VP9_LEVEL_21) \|
		(1 << V4L2_MPEG_VIDC_VIDEO_VP9_LEVEL_3) \|
		(1 << V4L2_MPEG_VIDC_VIDEO_VP9_LEVEL_31) \|
		(1 << V4L2_MPEG_VIDC_VIDEO_VP9_LEVEL_4) \|
		(1 << V4L2_MPEG_VIDC_VIDEO_VP9_LEVEL_41) \|
		(1 << V4L2_MPEG_VIDC_VIDEO_VP9_LEVEL_5) \|
		(1 << V4L2_MPEG_VIDC_VIDEO_VP9_LEVEL_51) \|
		(1 << V4L2_MPEG_VIDC_VIDEO_VP9_LEVEL_6) \|
		(1 << V4L2_MPEG_VIDC_VIDEO_VP9_LEVEL_61)
		),
		.qmenu = vp9_level,
		.flags = V4L2_CTRL_FLAG_VOLATILE \| V4L2_CTRL_FLAG_READ_ONLY,
		.step = 1,
		},
		{
		.id = V4L2_CID_MPEG_VIDC_VIDEO_MPEG2_PROFILE,
		.name = "MPEG2 Profile",
		.type = V4L2_CTRL_TYPE_MENU,
		.minimum = V4L2_MPEG_VIDC_VIDEO_MPEG2_PROFILE_SIMPLE,
		.maximum = V4L2_MPEG_VIDC_VIDEO_MPEG2_PROFILE_HIGH,
		.default_value = V4L2_MPEG_VIDC_VIDEO_MPEG2_PROFILE_SIMPLE,
		.maximum = V4L2_MPEG_VIDC_VIDEO_MPEG2_PROFILE_MAIN,
		.default_value = V4L2_MPEG_VIDC_VIDEO_MPEG2_PROFILE_MAIN,
		.menu_skip_mask = ~(
		(1 << V4L2_MPEG_VIDC_VIDEO_MPEG2_PROFILE_SIMPLE) \|
		(1 << V4L2_MPEG_VIDC_VIDEO_MPEG2_PROFILE_MAIN) \|
		(1 << V4L2_MPEG_VIDC_VIDEO_MPEG2_PROFILE_HIGH)
		(1 << V4L2_MPEG_VIDC_VIDEO_MPEG2_PROFILE_MAIN)
		),
		.qmenu = mpeg2_profile,
		.flags = V4L2_CTRL_FLAG_VOLATILE \| V4L2_CTRL_FLAG_READ_ONLY,
		.step = 1,
		},
		{
		.id = V4L2_CID_MPEG_VIDC_VIDEO_MPEG2_LEVEL,
		.name = "MPEG2 Level",
		.type = V4L2_CTRL_TYPE_MENU,
		.minimum = V4L2_MPEG_VIDC_VIDEO_MPEG2_LEVEL_0,
		.maximum = V4L2_MPEG_VIDC_VIDEO_MPEG2_LEVEL_3,
		.default_value = V4L2_MPEG_VIDC_VIDEO_MPEG2_LEVEL_0,
		.maximum = V4L2_MPEG_VIDC_VIDEO_MPEG2_LEVEL_2,
		.default_value = V4L2_MPEG_VIDC_VIDEO_MPEG2_LEVEL_2,
		.menu_skip_mask = ~(
		(1 << V4L2_MPEG_VIDC_VIDEO_MPEG2_LEVEL_0) \|
		(1 << V4L2_MPEG_VIDC_VIDEO_MPEG2_LEVEL_1) \|
		(1 << V4L2_MPEG_VIDC_VIDEO_MPEG2_LEVEL_2) \|
		(1 << V4L2_MPEG_VIDC_VIDEO_MPEG2_LEVEL_3)
		(1 << V4L2_MPEG_VIDC_VIDEO_MPEG2_LEVEL_2)
		),
		.qmenu = mpeg2_level,
		.flags = V4L2_CTRL_FLAG_VOLATILE \| V4L2_CTRL_FLAG_READ_ONLY,
		.step = 1,
		},
		{
		.id = V4L2_CID_MPEG_VIDC_VIDEO_CONCEAL_COLOR_8BIT,
		@@ -821,7 +956,23 @@ int msm_vdec_s_ctrl(struct msm_vidc_inst inst, struct v4l2_ctrl ctrl)

		switch (ctrl->id) {
		case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
		case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE:
		case V4L2_CID_MPEG_VIDEO_VP8_PROFILE:
		case V4L2_CID_MPEG_VIDEO_VP9_PROFILE:
		case V4L2_CID_MPEG_VIDC_VIDEO_MPEG2_PROFILE:
		inst->profile = msm_comm_v4l2_to_hfi(ctrl->id, ctrl->val);
		break;
		case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
		case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL:
		case V4L2_CID_MPEG_VIDC_VIDEO_VP8_PROFILE_LEVEL:
		case V4L2_CID_MPEG_VIDC_VIDEO_VP9_LEVEL:
		case V4L2_CID_MPEG_VIDC_VIDEO_MPEG2_LEVEL:
		inst->level = msm_comm_v4l2_to_hfi(ctrl->id, ctrl->val);
		break;
		case V4L2_CID_MPEG_VIDEO_HEVC_TIER:
		inst->level \|=
		(msm_comm_v4l2_to_hfi(ctrl->id, ctrl->val) << 28);
		break;
		case V4L2_CID_MPEG_VIDC_VIDEO_DECODE_ORDER:
		case V4L2_CID_MPEG_VIDC_VIDEO_PICTYPE_DEC_MODE:
		case V4L2_CID_MPEG_VIDC_VIDEO_CONCEAL_COLOR_8BIT:
		@@ -1072,8 +1223,6 @@ int msm_vdec_set_profile_level(struct msm_vidc_inst *inst)
		{
		int rc = 0;
		struct hfi_device *hdev;
		struct v4l2_ctrl *profile;
		struct v4l2_ctrl *level;
		struct hfi_profile_level profile_level;

		if (!inst \|\| !inst->core) {
		@@ -1082,26 +1231,9 @@ int msm_vdec_set_profile_level(struct msm_vidc_inst *inst)
		}
		hdev = inst->core->device;

		profile = msm_vdec_get_ctrl(inst, V4L2_CID_MPEG_VIDEO_H264_PROFILE);
		if (!profile) {
		dprintk(VIDC_ERR,
		"%s: failed to get profile ctrl\n", __func__);
		return -EINVAL;
		}
		level = msm_vdec_get_ctrl(inst, V4L2_CID_MPEG_VIDEO_H264_LEVEL);
		if (!level) {
		dprintk(VIDC_ERR,
		"%s: failed to get level ctrl\n", __func__);
		return -EINVAL;
		}
		profile_level.profile = profile->val;
		profile_level.level = level->val;
		if (profile_level.profile <= 0) {
		profile_level.profile = HFI_H264_PROFILE_HIGH;
		dprintk(VIDC_WARN,
		"Profile %d not supported, falling back to high\n",
		profile->val);
		}
		profile_level.profile = inst->profile;
		profile_level.level = inst->level;

		dprintk(VIDC_DBG, "%s: %#x %#x\n", __func__,
		profile_level.profile, profile_level.level);
		rc = call_hfi_op(hdev, session_set_property, inst->session,
		@@ -1113,16 +1245,6 @@ int msm_vdec_set_profile_level(struct msm_vidc_inst *inst)
		return rc;
		}

		int msm_vdec_set_profile(struct msm_vidc_inst *inst)
		{
		return msm_vdec_set_profile_level(inst);
		}

		int msm_vdec_set_level(struct msm_vidc_inst *inst)
		{
		return msm_vdec_set_profile_level(inst);
		}

		int msm_vdec_set_output_order(struct msm_vidc_inst *inst)
		{
		int rc = 0;
		@@ -1568,10 +1690,7 @@ int msm_vdec_set_properties(struct msm_vidc_inst *inst)
		rc = msm_vdec_set_input_buffer_counts(inst);
		if (rc)
		goto exit;
		rc = msm_vdec_set_profile(inst);
		if (rc)
		goto exit;
		rc = msm_vdec_set_level(inst);
		rc = msm_vdec_set_profile_level(inst);
		if (rc)
		goto exit;
		rc = msm_vdec_set_output_order(inst);

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

+54 −73

Original line number	Diff line number	Diff line
		@@ -59,24 +59,28 @@ static const char *const vp8_profile_level[] = {
		"1.0",
		"2.0",
		"3.0",
		NULL
		};

		static const char *const perf_level[] = {
		"Nominal",
		"Performance",
		"Turbo"
		"Turbo",
		NULL
		};

		static const char *const mbi_statistics[] = {
		"Camcorder Default",
		"Mode 1",
		"Mode 2",
		"Mode 3"
		"Mode 3",
		NULL
		};

		static const char *const timestamp_mode[] = {
		"Honor",
		"Ignore",
		NULL
		};

		static const char *const mpeg_video_stream_format[] = {
		@@ -271,7 +275,7 @@ static struct msm_vidc_ctrl msm_venc_ctrls[] = {
		.type = V4L2_CTRL_TYPE_MENU,
		.minimum = V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE,
		.maximum = V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_HIGH,
		.default_value = V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE,
		.default_value = V4L2_MPEG_VIDEO_H264_PROFILE_HIGH,
		.menu_skip_mask = ~(
		(1 << V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE) \|
		(1 << V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE) \|
		@@ -279,6 +283,9 @@ static struct msm_vidc_ctrl msm_venc_ctrls[] = {
		(1 << V4L2_MPEG_VIDEO_H264_PROFILE_HIGH) \|
		(1 << V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_HIGH)
		),
		.flags = V4L2_CTRL_FLAG_VOLATILE,
		.qmenu = NULL,
		.step = 1,
		},
		{
		.id = V4L2_CID_MPEG_VIDEO_H264_LEVEL,
		@@ -310,6 +317,21 @@ static struct msm_vidc_ctrl msm_venc_ctrls[] = {
		(1 << V4L2_MPEG_VIDEO_H264_LEVEL_6_2) \|
		(1 << V4L2_MPEG_VIDEO_H264_LEVEL_UNKNOWN)
		),
		.flags = V4L2_CTRL_FLAG_VOLATILE,
		.qmenu = NULL,
		.step = 1,
		},
		{
		.id = V4L2_CID_MPEG_VIDEO_VP8_PROFILE,
		.name = "VP8 Profile",
		.type = V4L2_CTRL_TYPE_MENU,
		.minimum = V4L2_MPEG_VIDEO_VP8_PROFILE_0,
		.maximum = V4L2_MPEG_VIDEO_VP8_PROFILE_0,
		.default_value = V4L2_MPEG_VIDEO_VP8_PROFILE_0,
		.menu_skip_mask = ~(1 << V4L2_MPEG_VIDEO_VP8_PROFILE_0),
		.flags = V4L2_CTRL_FLAG_VOLATILE,
		.qmenu = NULL,
		.step = 1,
		},
		{
		.id = V4L2_CID_MPEG_VIDC_VIDEO_VP8_PROFILE_LEVEL,
		@@ -317,7 +339,7 @@ static struct msm_vidc_ctrl msm_venc_ctrls[] = {
		.type = V4L2_CTRL_TYPE_MENU,
		.minimum = V4L2_MPEG_VIDC_VIDEO_VP8_UNUSED,
		.maximum = V4L2_MPEG_VIDC_VIDEO_VP8_VERSION_3,
		.default_value = V4L2_MPEG_VIDC_VIDEO_VP8_VERSION_0,
		.default_value = V4L2_MPEG_VIDC_VIDEO_VP8_VERSION_3,
		.menu_skip_mask = ~(
		(1 << V4L2_MPEG_VIDC_VIDEO_VP8_UNUSED) \|
		(1 << V4L2_MPEG_VIDC_VIDEO_VP8_VERSION_0) \|
		@@ -326,6 +348,8 @@ static struct msm_vidc_ctrl msm_venc_ctrls[] = {
		(1 << V4L2_MPEG_VIDC_VIDEO_VP8_VERSION_3)
		),
		.qmenu = vp8_profile_level,
		.flags = V4L2_CTRL_FLAG_VOLATILE \| V4L2_CTRL_FLAG_READ_ONLY,
		.step = 1,
		},
		{
		.id = V4L2_CID_MPEG_VIDEO_HEVC_PROFILE,
		@@ -339,6 +363,9 @@ static struct msm_vidc_ctrl msm_venc_ctrls[] = {
		(1 << V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_STILL_PICTURE) \|
		(1 << V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_10)
		),
		.flags = V4L2_CTRL_FLAG_VOLATILE,
		.qmenu = NULL,
		.step = 1,
		},
		{
		.id = V4L2_CID_MPEG_VIDEO_HEVC_LEVEL,
		@@ -364,6 +391,9 @@ static struct msm_vidc_ctrl msm_venc_ctrls[] = {
		(1 << V4L2_MPEG_VIDEO_HEVC_LEVEL_6_2) \|
		(1 << V4L2_MPEG_VIDEO_HEVC_LEVEL_UNKNOWN)
		),
		.flags = V4L2_CTRL_FLAG_VOLATILE,
		.qmenu = NULL,
		.step = 1,
		},
		{
		.id = V4L2_CID_MPEG_VIDEO_HEVC_TIER,
		@@ -371,11 +401,14 @@ static struct msm_vidc_ctrl msm_venc_ctrls[] = {
		.type = V4L2_CTRL_TYPE_MENU,
		.minimum = V4L2_MPEG_VIDEO_HEVC_TIER_MAIN,
		.maximum = V4L2_MPEG_VIDEO_HEVC_TIER_HIGH,
		.default_value = V4L2_MPEG_VIDEO_HEVC_TIER_MAIN,
		.default_value = V4L2_MPEG_VIDEO_HEVC_TIER_HIGH,
		.menu_skip_mask = ~(
		(1 << V4L2_MPEG_VIDEO_HEVC_TIER_MAIN) \|
		(1 << V4L2_MPEG_VIDEO_HEVC_TIER_HIGH)
		),
		.flags = V4L2_CTRL_FLAG_VOLATILE,
		.qmenu = NULL,
		.step = 1,
		},
		{
		.id = V4L2_CID_ROTATE,
		@@ -1588,17 +1621,25 @@ int msm_venc_s_ctrl(struct msm_vidc_inst inst, struct v4l2_ctrl ctrl)
		dprintk(VIDC_ERR,
		"%s: set rc enable failed.\n", __func__);
		break;
		case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
		case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE:
		case V4L2_CID_MPEG_VIDEO_VP8_PROFILE:
		inst->profile = msm_comm_v4l2_to_hfi(ctrl->id, ctrl->val);
		break;
		case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
		case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL:
		case V4L2_CID_MPEG_VIDC_VIDEO_VP8_PROFILE_LEVEL:
		inst->level = msm_comm_v4l2_to_hfi(ctrl->id, ctrl->val);
		break;
		case V4L2_CID_MPEG_VIDEO_HEVC_TIER:
		inst->level \|=
		(msm_comm_v4l2_to_hfi(ctrl->id, ctrl->val) << 28);
		break;
		case V4L2_CID_MPEG_VIDEO_B_FRAMES:
		case V4L2_CID_ROTATE:
		case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_LAYER:
		case V4L2_CID_MPEG_VIDC_VIDEO_LTRCOUNT:
		case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
		case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
		case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
		case V4L2_CID_MPEG_VIDC_VIDEO_VP8_PROFILE_LEVEL:
		case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE:
		case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL:
		case V4L2_CID_MPEG_VIDEO_HEVC_TIER:
		case V4L2_CID_HFLIP:
		case V4L2_CID_VFLIP:
		case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
		@@ -1864,11 +1905,7 @@ int msm_venc_set_profile_level(struct msm_vidc_inst *inst)
		{
		int rc = 0;
		struct hfi_device *hdev;
		struct v4l2_ctrl *profile;
		struct v4l2_ctrl *level;
		struct v4l2_ctrl *tier;
		struct hfi_profile_level profile_level;
		u32 hfi_tier;

		if (!inst \|\| !inst->core) {
		dprintk(VIDC_ERR, "%s: invalid params\n", __func__);
		@@ -1876,64 +1913,8 @@ int msm_venc_set_profile_level(struct msm_vidc_inst *inst)
		}
		hdev = inst->core->device;

		switch (inst->fmts[CAPTURE_PORT].fourcc) {
		case V4L2_PIX_FMT_H264:
		profile = msm_venc_get_ctrl(inst,
		V4L2_CID_MPEG_VIDEO_H264_PROFILE);
		level = msm_venc_get_ctrl(inst,
		V4L2_CID_MPEG_VIDEO_H264_LEVEL);
		if (!profile \|\| !level) {
		dprintk(VIDC_ERR,
		"%s: get h264 profile & level failed\n",
		__func__);
		return -EINVAL;
		}

		profile_level.profile =
		msm_comm_v4l2_to_hfi(profile->id, profile->val);
		profile_level.level =
		msm_comm_v4l2_to_hfi(level->id, level->val);
		break;
		case V4L2_PIX_FMT_HEVC:
		profile = msm_venc_get_ctrl(inst,
		V4L2_CID_MPEG_VIDEO_HEVC_PROFILE);
		level = msm_venc_get_ctrl(inst,
		V4L2_CID_MPEG_VIDEO_HEVC_LEVEL);
		tier = msm_venc_get_ctrl(inst,
		V4L2_CID_MPEG_VIDEO_HEVC_TIER);
		if (!profile \|\| !level \|\| !tier) {
		dprintk(VIDC_ERR,
		"%s: get hevc profile & level failed\n",
		__func__);
		return -EINVAL;
		}

		profile_level.profile =
		msm_comm_v4l2_to_hfi(profile->id, profile->val);
		profile_level.level =
		msm_comm_v4l2_to_hfi(level->id, level->val);
		hfi_tier = msm_comm_v4l2_to_hfi(tier->id, tier->val);
		profile_level.level \|= (hfi_tier << 28);
		break;
		case V4L2_PIX_FMT_VP8:
		level = msm_venc_get_ctrl(inst,
		V4L2_CID_MPEG_VIDC_VIDEO_VP8_PROFILE_LEVEL);
		if (!level) {
		dprintk(VIDC_ERR,

		"%s: get vp8 level failed\n", __func__);
		return -EINVAL;
		}
		profile_level.profile =
		HFI_VP8_PROFILE_MAIN;
		profile_level.level =
		msm_comm_v4l2_to_hfi(level->id, level->val);
		break;
		default:
		dprintk(VIDC_ERR, "%s: unknown fourcc %#x\n", __func__,
		inst->fmts[CAPTURE_PORT].fourcc);
		return -EINVAL;
		}
		profile_level.profile = inst->profile;
		profile_level.level = inst->level;

		dprintk(VIDC_DBG, "%s: %#x %#x\n", __func__,
		profile_level.profile, profile_level.level);

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

+119 −85

Original line number	Diff line number	Diff line
		@@ -32,6 +32,67 @@
		static void handle_session_error(enum hal_command_response cmd, void *data);
		static void msm_vidc_print_running_insts(struct msm_vidc_core *core);

		#define V4L2_H264_LEVEL_UNKNOWN V4L2_MPEG_VIDEO_H264_LEVEL_UNKNOWN
		#define V4L2_HEVC_LEVEL_UNKNOWN V4L2_MPEG_VIDEO_HEVC_LEVEL_UNKNOWN
		#define V4L2_VP9_LEVEL_61 V4L2_MPEG_VIDC_VIDEO_VP9_LEVEL_61

		int h264_level_v4l2_to_hfi[] = {
		HFI_H264_LEVEL_1,
		HFI_H264_LEVEL_1b,
		HFI_H264_LEVEL_11,
		HFI_H264_LEVEL_12,
		HFI_H264_LEVEL_13,
		HFI_H264_LEVEL_2,
		HFI_H264_LEVEL_21,
		HFI_H264_LEVEL_22,
		HFI_H264_LEVEL_3,
		HFI_H264_LEVEL_31,
		HFI_H264_LEVEL_32,
		HFI_H264_LEVEL_4,
		HFI_H264_LEVEL_41,
		HFI_H264_LEVEL_42,
		HFI_H264_LEVEL_5,
		HFI_H264_LEVEL_51,
		HFI_H264_LEVEL_52,
		HFI_H264_LEVEL_6,
		HFI_H264_LEVEL_61,
		HFI_H264_LEVEL_62,
		HFI_LEVEL_UNKNOWN,
		};

		int hevc_level_v4l2_to_hfi[] = {
		HFI_HEVC_LEVEL_1,
		HFI_HEVC_LEVEL_2,
		HFI_HEVC_LEVEL_21,
		HFI_HEVC_LEVEL_3,
		HFI_HEVC_LEVEL_31,
		HFI_HEVC_LEVEL_4,
		HFI_HEVC_LEVEL_41,
		HFI_HEVC_LEVEL_5,
		HFI_HEVC_LEVEL_51,
		HFI_HEVC_LEVEL_52,
		HFI_HEVC_LEVEL_6,
		HFI_HEVC_LEVEL_61,
		HFI_HEVC_LEVEL_62,
		HFI_LEVEL_UNKNOWN,
		};

		int vp9_level_v4l2_to_hfi[] = {
		HFI_LEVEL_UNKNOWN,
		HFI_VP9_LEVEL_1,
		HFI_VP9_LEVEL_11,
		HFI_VP9_LEVEL_2,
		HFI_VP9_LEVEL_21,
		HFI_VP9_LEVEL_3,
		HFI_VP9_LEVEL_31,
		HFI_VP9_LEVEL_4,
		HFI_VP9_LEVEL_41,
		HFI_VP9_LEVEL_5,
		HFI_VP9_LEVEL_51,
		HFI_VP9_LEVEL_6,
		HFI_VP9_LEVEL_61,
		};

		int msm_comm_g_ctrl_for_id(struct msm_vidc_inst *inst, int id)
		{
		int rc = 0;
		@@ -288,54 +349,13 @@ int msm_comm_v4l2_to_hfi(int id, int value)
		case V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_HIGH:
		return HFI_H264_PROFILE_CONSTRAINED_HIGH;
		default:
		goto unknown_value;
		return HFI_H264_PROFILE_HIGH;
		}
		case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
		switch (value) {
		case V4L2_MPEG_VIDEO_H264_LEVEL_1_0:
		return HFI_H264_LEVEL_1;
		case V4L2_MPEG_VIDEO_H264_LEVEL_1B:
		return HFI_H264_LEVEL_1b;
		case V4L2_MPEG_VIDEO_H264_LEVEL_1_1:
		return HFI_H264_LEVEL_11;
		case V4L2_MPEG_VIDEO_H264_LEVEL_1_2:
		return HFI_H264_LEVEL_12;
		case V4L2_MPEG_VIDEO_H264_LEVEL_1_3:
		return HFI_H264_LEVEL_13;
		case V4L2_MPEG_VIDEO_H264_LEVEL_2_0:
		return HFI_H264_LEVEL_2;
		case V4L2_MPEG_VIDEO_H264_LEVEL_2_1:
		return HFI_H264_LEVEL_21;
		case V4L2_MPEG_VIDEO_H264_LEVEL_2_2:
		return HFI_H264_LEVEL_22;
		case V4L2_MPEG_VIDEO_H264_LEVEL_3_0:
		return HFI_H264_LEVEL_3;
		case V4L2_MPEG_VIDEO_H264_LEVEL_3_1:
		return HFI_H264_LEVEL_31;
		case V4L2_MPEG_VIDEO_H264_LEVEL_3_2:
		return HFI_H264_LEVEL_32;
		case V4L2_MPEG_VIDEO_H264_LEVEL_4_0:
		return HFI_H264_LEVEL_4;
		case V4L2_MPEG_VIDEO_H264_LEVEL_4_1:
		return HFI_H264_LEVEL_41;
		case V4L2_MPEG_VIDEO_H264_LEVEL_4_2:
		return HFI_H264_LEVEL_42;
		case V4L2_MPEG_VIDEO_H264_LEVEL_5_0:
		return HFI_H264_LEVEL_5;
		case V4L2_MPEG_VIDEO_H264_LEVEL_5_1:
		return HFI_H264_LEVEL_51;
		case V4L2_MPEG_VIDEO_H264_LEVEL_5_2:
		return HFI_H264_LEVEL_52;
		case V4L2_MPEG_VIDEO_H264_LEVEL_6_0:
		return HFI_H264_LEVEL_6;
		case V4L2_MPEG_VIDEO_H264_LEVEL_6_1:
		return HFI_H264_LEVEL_61;
		case V4L2_MPEG_VIDEO_H264_LEVEL_6_2:
		return HFI_H264_LEVEL_62;
		case V4L2_MPEG_VIDEO_H264_LEVEL_UNKNOWN:
		return HFI_LEVEL_UNKNOWN;
		default:
		goto unknown_value;
		if (value >= 0 && value <= V4L2_H264_LEVEL_UNKNOWN) {
		return h264_level_v4l2_to_hfi[value];
		} else {
		return h264_level_v4l2_to_hfi[V4L2_H264_LEVEL_UNKNOWN];
		}
		case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
		switch (value) {
		@@ -344,7 +364,14 @@ int msm_comm_v4l2_to_hfi(int id, int value)
		case V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CABAC:
		return HFI_H264_ENTROPY_CABAC;
		default:
		goto unknown_value;
		return HFI_H264_ENTROPY_CABAC;
		}
		case V4L2_CID_MPEG_VIDEO_VP8_PROFILE:
		switch (value) {
		case V4L2_MPEG_VIDEO_VP8_PROFILE_0:
		return HFI_VP8_PROFILE_MAIN;
		default:
		return HFI_VP8_PROFILE_MAIN;
		}
		case V4L2_CID_MPEG_VIDC_VIDEO_VP8_PROFILE_LEVEL:
		switch (value) {
		@@ -359,7 +386,22 @@ int msm_comm_v4l2_to_hfi(int id, int value)
		case V4L2_MPEG_VIDC_VIDEO_VP8_UNUSED:
		return HFI_LEVEL_UNKNOWN;
		default:
		goto unknown_value;
		return HFI_LEVEL_UNKNOWN;
		}
		case V4L2_CID_MPEG_VIDEO_VP9_PROFILE:
		switch (value) {
		case V4L2_MPEG_VIDEO_VP9_PROFILE_0:
		return HFI_VP9_PROFILE_P0;
		case V4L2_MPEG_VIDEO_VP9_PROFILE_2:
		return HFI_VP9_PROFILE_P2_10B;
		default:
		return HFI_VP9_PROFILE_P0;
		}
		case V4L2_CID_MPEG_VIDC_VIDEO_VP9_LEVEL:
		if (value >= 0 && value <= V4L2_VP9_LEVEL_61) {
		return vp9_level_v4l2_to_hfi[value];
		} else {
		return vp9_level_v4l2_to_hfi[V4L2_VP9_LEVEL_61];
		}
		case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE:
		switch (value) {
		@@ -370,40 +412,13 @@ int msm_comm_v4l2_to_hfi(int id, int value)
		case V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_STILL_PICTURE:
		return HFI_HEVC_PROFILE_MAIN_STILL_PIC;
		default:
		goto unknown_value;
		return HFI_HEVC_PROFILE_MAIN;
		}
		case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL:
		switch (value) {
		case V4L2_MPEG_VIDEO_HEVC_LEVEL_1:
		return HFI_HEVC_LEVEL_1;
		case V4L2_MPEG_VIDEO_HEVC_LEVEL_2:
		return HFI_HEVC_LEVEL_2;
		case V4L2_MPEG_VIDEO_HEVC_LEVEL_2_1:
		return HFI_HEVC_LEVEL_21;
		case V4L2_MPEG_VIDEO_HEVC_LEVEL_3:
		return HFI_HEVC_LEVEL_3;
		case V4L2_MPEG_VIDEO_HEVC_LEVEL_3_1:
		return HFI_HEVC_LEVEL_31;
		case V4L2_MPEG_VIDEO_HEVC_LEVEL_4:
		return HFI_HEVC_LEVEL_4;
		case V4L2_MPEG_VIDEO_HEVC_LEVEL_4_1:
		return HFI_HEVC_LEVEL_41;
		case V4L2_MPEG_VIDEO_HEVC_LEVEL_5:
		return HFI_HEVC_LEVEL_5;
		case V4L2_MPEG_VIDEO_HEVC_LEVEL_5_1:
		return HFI_HEVC_LEVEL_51;
		case V4L2_MPEG_VIDEO_HEVC_LEVEL_5_2:
		return HFI_HEVC_LEVEL_52;
		case V4L2_MPEG_VIDEO_HEVC_LEVEL_6:
		return HFI_HEVC_LEVEL_6;
		case V4L2_MPEG_VIDEO_HEVC_LEVEL_6_1:
		return HFI_HEVC_LEVEL_61;
		case V4L2_MPEG_VIDEO_HEVC_LEVEL_6_2:
		return HFI_HEVC_LEVEL_62;
		case V4L2_MPEG_VIDEO_HEVC_LEVEL_UNKNOWN:
		return HFI_LEVEL_UNKNOWN;
		default:
		goto unknown_value;
		if (value >= 0 && value <= V4L2_HEVC_LEVEL_UNKNOWN) {
		return hevc_level_v4l2_to_hfi[value];
		} else {
		return hevc_level_v4l2_to_hfi[V4L2_HEVC_LEVEL_UNKNOWN];
		}
		case V4L2_CID_MPEG_VIDEO_HEVC_TIER:
		switch (value) {
		@@ -412,7 +427,28 @@ int msm_comm_v4l2_to_hfi(int id, int value)
		case V4L2_MPEG_VIDEO_HEVC_TIER_HIGH:
		return HFI_HEVC_TIER_HIGH;
		default:
		goto unknown_value;
		return HFI_HEVC_TIER_HIGH;
		}
		case V4L2_CID_MPEG_VIDC_VIDEO_MPEG2_PROFILE:
		switch (value) {
		case V4L2_MPEG_VIDC_VIDEO_MPEG2_PROFILE_SIMPLE:
		return HFI_MPEG2_PROFILE_SIMPLE;
		case V4L2_MPEG_VIDC_VIDEO_MPEG2_PROFILE_MAIN:
		return HFI_MPEG2_PROFILE_MAIN;
		default:
		return HFI_MPEG2_PROFILE_MAIN;
		}
		case V4L2_CID_MPEG_VIDC_VIDEO_MPEG2_LEVEL:
		/* This mapping is not defined properly in V4L2 */
		switch (value) {
		case V4L2_MPEG_VIDC_VIDEO_MPEG2_LEVEL_0:
		return HFI_MPEG2_LEVEL_LL;
		case V4L2_MPEG_VIDC_VIDEO_MPEG2_LEVEL_1:
		return HFI_MPEG2_LEVEL_ML;
		case V4L2_MPEG_VIDC_VIDEO_MPEG2_LEVEL_2:
		return HFI_MPEG2_LEVEL_HL;
		default:
		return HFI_MPEG2_LEVEL_HL;
		}
		case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
		switch (value) {
		@@ -423,12 +459,10 @@ int msm_comm_v4l2_to_hfi(int id, int value)
		case L_MODE:
		return HFI_H264_DB_MODE_SKIP_SLICE_BOUNDARY;
		default:
		goto unknown_value;
		return HFI_H264_DB_MODE_ALL_BOUNDARY;
		}
		}

		unknown_value:
		dprintk(VIDC_WARN, "Unknown control/val (%x, %d)\n", id, value);
		dprintk(VIDC_WARN, "Unknown control (%x, %d)\n", id, value);
		return -EINVAL;
		}

drivers/media/v4l2-core/v4l2-ctrls.c

+1 −0

Original line number	Diff line number	Diff line
		@@ -369,6 +369,7 @@ const char * const *v4l2_ctrl_get_menu(u32 id)
		"Scalable High Intra",
		"Stereo High",
		"Multiview High",
		"Constrained High",
		NULL,
		};
		static const char * const vui_sar_idc[] = {