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

Commit 85fdb107 authored by Amit Shekhar's avatar Amit Shekhar
Browse files

msm: vidc: Fix setting profile & level control 



Fix setting profile & level control for HW decoders
and encoders.

Change-Id: I3e1816c2be1e6b6cc158da04365ce820bac59065
Signed-off-by: default avatarAmit Shekhar <ashekhar@codeaurora.org>
parent 413dd9b1

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[] = {