Commit 46a309d2 authored by Ezequiel Garcia's avatar Ezequiel Garcia Committed by Mauro Carvalho Chehab
Browse files

media: uapi: move H264 stateless controls out of staging 



The H.264 stateless 'uAPI' was staging and marked explicitly in the
V4L2 specification that it will change and is unstable.

Note that these control IDs were never exported as a public API,
they were only defined in kernel-local headers (h264-ctrls.h).

Now, the H264 stateless controls is ready to be part
of the stable uAPI.

While not too late, let's rename them and re-number their
control IDs, moving them to the newly created stateless
control class, and updating all the drivers accordingly.

Signed-off-by: default avatarEzequiel Garcia <ezequiel@collabora.com>
Tested-by: default avatarJernej Skrabec <jernej.skrabec@siol.net>
Signed-off-by: default avatarHans Verkuil <hverkuil-cisco@xs4all.nl>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab+huawei@kernel.org>
parent afc5329e

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

+18 −18
Original line number Diff line number Diff line
@@ -693,9 +693,9 @@ const char * const *v4l2_ctrl_get_menu(u32 id) 
		return h264_fp_arrangement_type;

	case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:

		return h264_fmo_map_type;

	case V4L2_CID_MPEG_VIDEO_H264_DECODE_MODE:

	case V4L2_CID_STATELESS_H264_DECODE_MODE:

		return h264_decode_mode;

	case V4L2_CID_MPEG_VIDEO_H264_START_CODE:

	case V4L2_CID_STATELESS_H264_START_CODE:

		return h264_start_code;

	case V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL:

		return mpeg_mpeg2_level;
@@ -920,14 +920,6 @@ const char *v4l2_ctrl_get_name(u32 id) 
	case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_MAX_QP:		return "H264 I-Frame Maximum QP Value";

	case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MIN_QP:		return "H264 P-Frame Minimum QP Value";

	case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MAX_QP:		return "H264 P-Frame Maximum QP Value";

	case V4L2_CID_MPEG_VIDEO_H264_SPS:			return "H264 Sequence Parameter Set";

	case V4L2_CID_MPEG_VIDEO_H264_PPS:			return "H264 Picture Parameter Set";

	case V4L2_CID_MPEG_VIDEO_H264_SCALING_MATRIX:		return "H264 Scaling Matrix";

	case V4L2_CID_MPEG_VIDEO_H264_SLICE_PARAMS:		return "H264 Slice Parameters";

	case V4L2_CID_MPEG_VIDEO_H264_DECODE_PARAMS:		return "H264 Decode Parameters";

	case V4L2_CID_MPEG_VIDEO_H264_DECODE_MODE:		return "H264 Decode Mode";

	case V4L2_CID_MPEG_VIDEO_H264_START_CODE:		return "H264 Start Code";

	case V4L2_CID_MPEG_VIDEO_H264_PRED_WEIGHTS:		return "H264 Prediction Weight Table";

	case V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL:			return "MPEG2 Level";

	case V4L2_CID_MPEG_VIDEO_MPEG2_PROFILE:			return "MPEG2 Profile";

	case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP:		return "MPEG4 I-Frame QP Value";
@@ -1185,6 +1177,14 @@ const char *v4l2_ctrl_get_name(u32 id) 
	/* Stateless Codec controls */

	/* Keep the order of the 'case's the same as in v4l2-controls.h! */

	case V4L2_CID_CODEC_STATELESS_CLASS:	return "Stateless Codec Controls";

	case V4L2_CID_STATELESS_H264_DECODE_MODE:		return "H264 Decode Mode";

	case V4L2_CID_STATELESS_H264_START_CODE:		return "H264 Start Code";

	case V4L2_CID_STATELESS_H264_SPS:			return "H264 Sequence Parameter Set";

	case V4L2_CID_STATELESS_H264_PPS:			return "H264 Picture Parameter Set";

	case V4L2_CID_STATELESS_H264_SCALING_MATRIX:		return "H264 Scaling Matrix";

	case V4L2_CID_STATELESS_H264_PRED_WEIGHTS:		return "H264 Prediction Weight Table";

	case V4L2_CID_STATELESS_H264_SLICE_PARAMS:		return "H264 Slice Parameters";

	case V4L2_CID_STATELESS_H264_DECODE_PARAMS:		return "H264 Decode Parameters";

	default:

		return NULL;

	}
@@ -1310,8 +1310,6 @@ void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type, 
	case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:

	case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:

	case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:

	case V4L2_CID_MPEG_VIDEO_H264_DECODE_MODE:

	case V4L2_CID_MPEG_VIDEO_H264_START_CODE:

	case V4L2_CID_MPEG_VIDEO_MPEG2_LEVEL:

	case V4L2_CID_MPEG_VIDEO_MPEG2_PROFILE:

	case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
@@ -1342,6 +1340,8 @@ void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type, 
	case V4L2_CID_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE:

	case V4L2_CID_MPEG_VIDEO_HEVC_DECODE_MODE:

	case V4L2_CID_MPEG_VIDEO_HEVC_START_CODE:

	case V4L2_CID_STATELESS_H264_DECODE_MODE:

	case V4L2_CID_STATELESS_H264_START_CODE:

	case V4L2_CID_CAMERA_ORIENTATION:

		*type = V4L2_CTRL_TYPE_MENU;

		break;
@@ -1436,22 +1436,22 @@ void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type, 
	case V4L2_CID_MPEG_VIDEO_FWHT_PARAMS:

		*type = V4L2_CTRL_TYPE_FWHT_PARAMS;

		break;

	case V4L2_CID_MPEG_VIDEO_H264_SPS:

	case V4L2_CID_STATELESS_H264_SPS:

		*type = V4L2_CTRL_TYPE_H264_SPS;

		break;

	case V4L2_CID_MPEG_VIDEO_H264_PPS:

	case V4L2_CID_STATELESS_H264_PPS:

		*type = V4L2_CTRL_TYPE_H264_PPS;

		break;

	case V4L2_CID_MPEG_VIDEO_H264_SCALING_MATRIX:

	case V4L2_CID_STATELESS_H264_SCALING_MATRIX:

		*type = V4L2_CTRL_TYPE_H264_SCALING_MATRIX;

		break;

	case V4L2_CID_MPEG_VIDEO_H264_SLICE_PARAMS:

	case V4L2_CID_STATELESS_H264_SLICE_PARAMS:

		*type = V4L2_CTRL_TYPE_H264_SLICE_PARAMS;

		break;

	case V4L2_CID_MPEG_VIDEO_H264_DECODE_PARAMS:

	case V4L2_CID_STATELESS_H264_DECODE_PARAMS:

		*type = V4L2_CTRL_TYPE_H264_DECODE_PARAMS;

		break;

	case V4L2_CID_MPEG_VIDEO_H264_PRED_WEIGHTS:

	case V4L2_CID_STATELESS_H264_PRED_WEIGHTS:

		*type = V4L2_CTRL_TYPE_H264_PRED_WEIGHTS;

		break;

	case V4L2_CID_MPEG_VIDEO_VP8_FRAME_HEADER:

drivers/staging/media/hantro/hantro_drv.c

+13 −13
Original line number Diff line number Diff line
@@ -231,7 +231,7 @@ queue_init(void *priv, struct vb2_queue *src_vq, struct vb2_queue *dst_vq) 


static int hantro_try_ctrl(struct v4l2_ctrl *ctrl)

{

	if (ctrl->id == V4L2_CID_MPEG_VIDEO_H264_SPS) {

	if (ctrl->id == V4L2_CID_STATELESS_H264_SPS) {

		const struct v4l2_ctrl_h264_sps *sps = ctrl->p_new.p_h264_sps;



		if (sps->chroma_format_idc > 1)
@@ -304,39 +304,39 @@ static const struct hantro_ctrl controls[] = { 
	}, {

		.codec = HANTRO_H264_DECODER,

		.cfg = {

			.id = V4L2_CID_MPEG_VIDEO_H264_DECODE_PARAMS,

			.id = V4L2_CID_STATELESS_H264_DECODE_PARAMS,

		},

	}, {

		.codec = HANTRO_H264_DECODER,

		.cfg = {

			.id = V4L2_CID_MPEG_VIDEO_H264_SPS,

			.id = V4L2_CID_STATELESS_H264_SPS,

			.ops = &hantro_ctrl_ops,

		},

	}, {

		.codec = HANTRO_H264_DECODER,

		.cfg = {

			.id = V4L2_CID_MPEG_VIDEO_H264_PPS,

			.id = V4L2_CID_STATELESS_H264_PPS,

		},

	}, {

		.codec = HANTRO_H264_DECODER,

		.cfg = {

			.id = V4L2_CID_MPEG_VIDEO_H264_SCALING_MATRIX,

			.id = V4L2_CID_STATELESS_H264_SCALING_MATRIX,

		},

	}, {

		.codec = HANTRO_H264_DECODER,

		.cfg = {

			.id = V4L2_CID_MPEG_VIDEO_H264_DECODE_MODE,

			.min = V4L2_MPEG_VIDEO_H264_DECODE_MODE_FRAME_BASED,

			.def = V4L2_MPEG_VIDEO_H264_DECODE_MODE_FRAME_BASED,

			.max = V4L2_MPEG_VIDEO_H264_DECODE_MODE_FRAME_BASED,

			.id = V4L2_CID_STATELESS_H264_DECODE_MODE,

			.min = V4L2_STATELESS_H264_DECODE_MODE_FRAME_BASED,

			.def = V4L2_STATELESS_H264_DECODE_MODE_FRAME_BASED,

			.max = V4L2_STATELESS_H264_DECODE_MODE_FRAME_BASED,

		},

	}, {

		.codec = HANTRO_H264_DECODER,

		.cfg = {

			.id = V4L2_CID_MPEG_VIDEO_H264_START_CODE,

			.min = V4L2_MPEG_VIDEO_H264_START_CODE_ANNEX_B,

			.def = V4L2_MPEG_VIDEO_H264_START_CODE_ANNEX_B,

			.max = V4L2_MPEG_VIDEO_H264_START_CODE_ANNEX_B,

			.id = V4L2_CID_STATELESS_H264_START_CODE,

			.min = V4L2_STATELESS_H264_START_CODE_ANNEX_B,

			.def = V4L2_STATELESS_H264_START_CODE_ANNEX_B,

			.max = V4L2_STATELESS_H264_START_CODE_ANNEX_B,

		},

	}, {

		.codec = HANTRO_H264_DECODER,

drivers/staging/media/hantro/hantro_h264.c

+4 −4
Original line number Diff line number Diff line
@@ -344,22 +344,22 @@ int hantro_h264_dec_prepare_run(struct hantro_ctx *ctx) 
	hantro_start_prepare_run(ctx);



	ctrls->scaling =

		hantro_get_ctrl(ctx, V4L2_CID_MPEG_VIDEO_H264_SCALING_MATRIX);

		hantro_get_ctrl(ctx, V4L2_CID_STATELESS_H264_SCALING_MATRIX);

	if (WARN_ON(!ctrls->scaling))

		return -EINVAL;



	ctrls->decode =

		hantro_get_ctrl(ctx, V4L2_CID_MPEG_VIDEO_H264_DECODE_PARAMS);

		hantro_get_ctrl(ctx, V4L2_CID_STATELESS_H264_DECODE_PARAMS);

	if (WARN_ON(!ctrls->decode))

		return -EINVAL;



	ctrls->sps =

		hantro_get_ctrl(ctx, V4L2_CID_MPEG_VIDEO_H264_SPS);

		hantro_get_ctrl(ctx, V4L2_CID_STATELESS_H264_SPS);

	if (WARN_ON(!ctrls->sps))

		return -EINVAL;



	ctrls->pps =

		hantro_get_ctrl(ctx, V4L2_CID_MPEG_VIDEO_H264_PPS);

		hantro_get_ctrl(ctx, V4L2_CID_STATELESS_H264_PPS);

	if (WARN_ON(!ctrls->pps))

		return -EINVAL;

drivers/staging/media/rkvdec/rkvdec-h264.c

+4 −4
Original line number Diff line number Diff line
@@ -1067,16 +1067,16 @@ static void rkvdec_h264_run_preamble(struct rkvdec_ctx *ctx, 
	struct v4l2_ctrl *ctrl;



	ctrl = v4l2_ctrl_find(&ctx->ctrl_hdl,

			      V4L2_CID_MPEG_VIDEO_H264_DECODE_PARAMS);

			      V4L2_CID_STATELESS_H264_DECODE_PARAMS);

	run->decode_params = ctrl ? ctrl->p_cur.p : NULL;

	ctrl = v4l2_ctrl_find(&ctx->ctrl_hdl,

			      V4L2_CID_MPEG_VIDEO_H264_SPS);

			      V4L2_CID_STATELESS_H264_SPS);

	run->sps = ctrl ? ctrl->p_cur.p : NULL;

	ctrl = v4l2_ctrl_find(&ctx->ctrl_hdl,

			      V4L2_CID_MPEG_VIDEO_H264_PPS);

			      V4L2_CID_STATELESS_H264_PPS);

	run->pps = ctrl ? ctrl->p_cur.p : NULL;

	ctrl = v4l2_ctrl_find(&ctx->ctrl_hdl,

			      V4L2_CID_MPEG_VIDEO_H264_SCALING_MATRIX);

			      V4L2_CID_STATELESS_H264_SCALING_MATRIX);

	run->scaling_matrix = ctrl ? ctrl->p_cur.p : NULL;



	rkvdec_run_preamble(ctx, &run->base);

drivers/staging/media/rkvdec/rkvdec.c

+13 −13
Original line number Diff line number Diff line
@@ -29,7 +29,7 @@ 


static int rkvdec_try_ctrl(struct v4l2_ctrl *ctrl)

{

	if (ctrl->id == V4L2_CID_MPEG_VIDEO_H264_SPS) {

	if (ctrl->id == V4L2_CID_STATELESS_H264_SPS) {

		const struct v4l2_ctrl_h264_sps *sps = ctrl->p_new.p_h264_sps;

		/*

		 * TODO: The hardware supports 10-bit and 4:2:2 profiles,
@@ -56,31 +56,31 @@ static const struct v4l2_ctrl_ops rkvdec_ctrl_ops = { 
static const struct rkvdec_ctrl_desc rkvdec_h264_ctrl_descs[] = {

	{

		.mandatory = true,

		.cfg.id = V4L2_CID_MPEG_VIDEO_H264_DECODE_PARAMS,

		.cfg.id = V4L2_CID_STATELESS_H264_DECODE_PARAMS,

	},

	{

		.mandatory = true,

		.cfg.id = V4L2_CID_MPEG_VIDEO_H264_SPS,

		.cfg.id = V4L2_CID_STATELESS_H264_SPS,

		.cfg.ops = &rkvdec_ctrl_ops,

	},

	{

		.mandatory = true,

		.cfg.id = V4L2_CID_MPEG_VIDEO_H264_PPS,

		.cfg.id = V4L2_CID_STATELESS_H264_PPS,

	},

	{

		.cfg.id = V4L2_CID_MPEG_VIDEO_H264_SCALING_MATRIX,

		.cfg.id = V4L2_CID_STATELESS_H264_SCALING_MATRIX,

	},

	{

		.cfg.id = V4L2_CID_MPEG_VIDEO_H264_DECODE_MODE,

		.cfg.min = V4L2_MPEG_VIDEO_H264_DECODE_MODE_FRAME_BASED,

		.cfg.max = V4L2_MPEG_VIDEO_H264_DECODE_MODE_FRAME_BASED,

		.cfg.def = V4L2_MPEG_VIDEO_H264_DECODE_MODE_FRAME_BASED,

		.cfg.id = V4L2_CID_STATELESS_H264_DECODE_MODE,

		.cfg.min = V4L2_STATELESS_H264_DECODE_MODE_FRAME_BASED,

		.cfg.max = V4L2_STATELESS_H264_DECODE_MODE_FRAME_BASED,

		.cfg.def = V4L2_STATELESS_H264_DECODE_MODE_FRAME_BASED,

	},

	{

		.cfg.id = V4L2_CID_MPEG_VIDEO_H264_START_CODE,

		.cfg.min = V4L2_MPEG_VIDEO_H264_START_CODE_ANNEX_B,

		.cfg.def = V4L2_MPEG_VIDEO_H264_START_CODE_ANNEX_B,

		.cfg.max = V4L2_MPEG_VIDEO_H264_START_CODE_ANNEX_B,

		.cfg.id = V4L2_CID_STATELESS_H264_START_CODE,

		.cfg.min = V4L2_STATELESS_H264_START_CODE_ANNEX_B,

		.cfg.def = V4L2_STATELESS_H264_START_CODE_ANNEX_B,

		.cfg.max = V4L2_STATELESS_H264_START_CODE_ANNEX_B,

	},

	{

		.cfg.id = V4L2_CID_MPEG_VIDEO_H264_PROFILE,