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

Commit d84f2d94 authored by Hans Verkuil's avatar Hans Verkuil Committed by Mauro Carvalho Chehab
Browse files

[media] v4l2-ioctl.c: use the new table for selection ioctls 



Signed-off-by: default avatarHans Verkuil <hans.verkuil@cisco.com>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@redhat.com>
parent efbceecd

drivers/media/video/v4l2-ioctl.c

+127 −135
Original line number Diff line number Diff line
@@ -555,17 +555,45 @@ static void v4l_print_ext_controls(const void *arg, bool write_only) 
	pr_cont("\n");

}



static void v4l_print_u32(const void *arg, bool write_only)

static void v4l_print_cropcap(const void *arg, bool write_only)

{

	pr_cont("value=%u\n", *(const u32 *)arg);

	const struct v4l2_cropcap *p = arg;



	pr_cont("type=%s, bounds wxh=%dx%d, x,y=%d,%d, "

		"defrect wxh=%dx%d, x,y=%d,%d\n, "

		"pixelaspect %d/%d\n",

		prt_names(p->type, v4l2_type_names),

		p->bounds.width, p->bounds.height,

		p->bounds.left, p->bounds.top,

		p->defrect.width, p->defrect.height,

		p->defrect.left, p->defrect.top,

		p->pixelaspect.numerator, p->pixelaspect.denominator);

}



static inline void dbgrect(struct video_device *vfd, char *s,

							struct v4l2_rect *r)

static void v4l_print_crop(const void *arg, bool write_only)

{

	dbgarg2("%sRect start at %dx%d, size=%dx%d\n", s, r->left, r->top,

						r->width, r->height);

};

	const struct v4l2_crop *p = arg;



	pr_cont("type=%s, wxh=%dx%d, x,y=%d,%d\n",

		prt_names(p->type, v4l2_type_names),

		p->c.width, p->c.height,

		p->c.left, p->c.top);

}



static void v4l_print_selection(const void *arg, bool write_only)

{

	const struct v4l2_selection *p = arg;



	pr_cont("type=%s, target=%d, flags=0x%x, wxh=%dx%d, x,y=%d,%d\n",

		prt_names(p->type, v4l2_type_names),

		p->target, p->flags,

		p->r.width, p->r.height, p->r.left, p->r.top);

}



static void v4l_print_u32(const void *arg, bool write_only)

{

	pr_cont("value=%u\n", *(const u32 *)arg);

}



static void dbgtimings(struct video_device *vfd,

			const struct v4l2_dv_timings *p)
@@ -1383,6 +1411,93 @@ static int v4l_try_ext_ctrls(const struct v4l2_ioctl_ops *ops, 
					-EINVAL;

}



static int v4l_g_crop(const struct v4l2_ioctl_ops *ops,

				struct file *file, void *fh, void *arg)

{

	struct v4l2_crop *p = arg;

	struct v4l2_selection s = {

		.type = p->type,

	};

	int ret;



	if (ops->vidioc_g_crop)

		return ops->vidioc_g_crop(file, fh, p);

	/* simulate capture crop using selection api */



	/* crop means compose for output devices */

	if (V4L2_TYPE_IS_OUTPUT(p->type))

		s.target = V4L2_SEL_TGT_COMPOSE_ACTIVE;

	else

		s.target = V4L2_SEL_TGT_CROP_ACTIVE;



	ret = ops->vidioc_g_selection(file, fh, &s);



	/* copying results to old structure on success */

	if (!ret)

		p->c = s.r;

	return ret;

}



static int v4l_s_crop(const struct v4l2_ioctl_ops *ops,

				struct file *file, void *fh, void *arg)

{

	struct v4l2_crop *p = arg;

	struct v4l2_selection s = {

		.type = p->type,

		.r = p->c,

	};



	if (ops->vidioc_s_crop)

		return ops->vidioc_s_crop(file, fh, p);

	/* simulate capture crop using selection api */



	/* crop means compose for output devices */

	if (V4L2_TYPE_IS_OUTPUT(p->type))

		s.target = V4L2_SEL_TGT_COMPOSE_ACTIVE;

	else

		s.target = V4L2_SEL_TGT_CROP_ACTIVE;



	return ops->vidioc_s_selection(file, fh, &s);

}



static int v4l_cropcap(const struct v4l2_ioctl_ops *ops,

				struct file *file, void *fh, void *arg)

{

	struct v4l2_cropcap *p = arg;

	struct v4l2_selection s = { .type = p->type };

	int ret;



	if (ops->vidioc_cropcap)

		return ops->vidioc_cropcap(file, fh, p);



	/* obtaining bounds */

	if (V4L2_TYPE_IS_OUTPUT(p->type))

		s.target = V4L2_SEL_TGT_COMPOSE_BOUNDS;

	else

		s.target = V4L2_SEL_TGT_CROP_BOUNDS;



	ret = ops->vidioc_g_selection(file, fh, &s);

	if (ret)

		return ret;

	p->bounds = s.r;



	/* obtaining defrect */

	if (V4L2_TYPE_IS_OUTPUT(p->type))

		s.target = V4L2_SEL_TGT_COMPOSE_DEFAULT;

	else

		s.target = V4L2_SEL_TGT_CROP_DEFAULT;



	ret = ops->vidioc_g_selection(file, fh, &s);

	if (ret)

		return ret;

	p->defrect = s.r;



	/* setting trivial pixelaspect */

	p->pixelaspect.numerator = 1;

	p->pixelaspect.denominator = 1;

	return 0;

}



struct v4l2_ioctl_info {

	unsigned int ioctl;

	u32 flags;
@@ -1472,11 +1587,11 @@ static struct v4l2_ioctl_info v4l2_ioctls[] = { 
	IOCTL_INFO_STD(VIDIOC_S_MODULATOR, vidioc_s_modulator, v4l_print_modulator, INFO_FL_PRIO),

	IOCTL_INFO_FNC(VIDIOC_G_FREQUENCY, v4l_g_frequency, v4l_print_frequency, INFO_FL_CLEAR(v4l2_frequency, tuner)),

	IOCTL_INFO_FNC(VIDIOC_S_FREQUENCY, v4l_s_frequency, v4l_print_frequency, INFO_FL_PRIO),

	IOCTL_INFO(VIDIOC_CROPCAP, INFO_FL_CLEAR(v4l2_cropcap, type)),

	IOCTL_INFO(VIDIOC_G_CROP, INFO_FL_CLEAR(v4l2_crop, type)),

	IOCTL_INFO(VIDIOC_S_CROP, INFO_FL_PRIO),

	IOCTL_INFO(VIDIOC_G_SELECTION, 0),

	IOCTL_INFO(VIDIOC_S_SELECTION, INFO_FL_PRIO),

	IOCTL_INFO_FNC(VIDIOC_CROPCAP, v4l_cropcap, v4l_print_cropcap, INFO_FL_CLEAR(v4l2_cropcap, type)),

	IOCTL_INFO_FNC(VIDIOC_G_CROP, v4l_g_crop, v4l_print_crop, INFO_FL_CLEAR(v4l2_crop, type)),

	IOCTL_INFO_FNC(VIDIOC_S_CROP, v4l_s_crop, v4l_print_crop, INFO_FL_PRIO),

	IOCTL_INFO_STD(VIDIOC_G_SELECTION, vidioc_g_selection, v4l_print_selection, 0),

	IOCTL_INFO_STD(VIDIOC_S_SELECTION, vidioc_s_selection, v4l_print_selection, INFO_FL_PRIO),

	IOCTL_INFO(VIDIOC_G_JPEGCOMP, 0),

	IOCTL_INFO(VIDIOC_S_JPEGCOMP, INFO_FL_PRIO),

	IOCTL_INFO_FNC(VIDIOC_QUERYSTD, v4l_querystd, v4l_print_std, 0),
@@ -1621,129 +1736,6 @@ static long __video_do_ioctl(struct file *file, 
	}



	switch (cmd) {

	case VIDIOC_G_CROP:

	{

		struct v4l2_crop *p = arg;



		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));



		if (ops->vidioc_g_crop) {

			ret = ops->vidioc_g_crop(file, fh, p);

		} else {

			/* simulate capture crop using selection api */

			struct v4l2_selection s = {

				.type = p->type,

			};



			/* crop means compose for output devices */

			if (V4L2_TYPE_IS_OUTPUT(p->type))

				s.target = V4L2_SEL_TGT_COMPOSE_ACTIVE;

			else

				s.target = V4L2_SEL_TGT_CROP_ACTIVE;



			ret = ops->vidioc_g_selection(file, fh, &s);



			/* copying results to old structure on success */

			if (!ret)

				p->c = s.r;

		}



		if (!ret)

			dbgrect(vfd, "", &p->c);

		break;

	}

	case VIDIOC_S_CROP:

	{

		struct v4l2_crop *p = arg;



		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));

		dbgrect(vfd, "", &p->c);



		if (ops->vidioc_s_crop) {

			ret = ops->vidioc_s_crop(file, fh, p);

		} else {

			/* simulate capture crop using selection api */

			struct v4l2_selection s = {

				.type = p->type,

				.r = p->c,

			};



			/* crop means compose for output devices */

			if (V4L2_TYPE_IS_OUTPUT(p->type))

				s.target = V4L2_SEL_TGT_COMPOSE_ACTIVE;

			else

				s.target = V4L2_SEL_TGT_CROP_ACTIVE;



			ret = ops->vidioc_s_selection(file, fh, &s);

		}

		break;

	}

	case VIDIOC_G_SELECTION:

	{

		struct v4l2_selection *p = arg;



		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));



		ret = ops->vidioc_g_selection(file, fh, p);

		if (!ret)

			dbgrect(vfd, "", &p->r);

		break;

	}

	case VIDIOC_S_SELECTION:

	{

		struct v4l2_selection *p = arg;





		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));

		dbgrect(vfd, "", &p->r);



		ret = ops->vidioc_s_selection(file, fh, p);

		break;

	}

	case VIDIOC_CROPCAP:

	{

		struct v4l2_cropcap *p = arg;



		/*FIXME: Should also show v4l2_fract pixelaspect */

		dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));

		if (ops->vidioc_cropcap) {

			ret = ops->vidioc_cropcap(file, fh, p);

		} else {

			struct v4l2_selection s = { .type = p->type };



			/* obtaining bounds */

			if (V4L2_TYPE_IS_OUTPUT(p->type))

				s.target = V4L2_SEL_TGT_COMPOSE_BOUNDS;

			else

				s.target = V4L2_SEL_TGT_CROP_BOUNDS;



			ret = ops->vidioc_g_selection(file, fh, &s);

			if (ret)

				break;

			p->bounds = s.r;



			/* obtaining defrect */

			if (V4L2_TYPE_IS_OUTPUT(p->type))

				s.target = V4L2_SEL_TGT_COMPOSE_DEFAULT;

			else

				s.target = V4L2_SEL_TGT_CROP_DEFAULT;



			ret = ops->vidioc_g_selection(file, fh, &s);

			if (ret)

				break;

			p->defrect = s.r;



			/* setting trivial pixelaspect */

			p->pixelaspect.numerator = 1;

			p->pixelaspect.denominator = 1;

		}



		if (!ret) {

			dbgrect(vfd, "bounds ", &p->bounds);

			dbgrect(vfd, "defrect ", &p->defrect);

		}

		break;

	}

	case VIDIOC_G_JPEGCOMP:

	{

		struct v4l2_jpegcompression *p = arg;