Skip to content

L
linux
Commit 1d0c86ca authored by Tomasz Stanislawski's avatar Tomasz Stanislawski Committed by Mauro Carvalho Chehab
Browse files
Options

[media] media: v4l: remove single to multiplane conversion 

This patch removes an implicit conversion between multi and single plane
formats from V4L2 framework. The conversion is to be performed by libv4l2.
Signed-off-by: default avatarTomasz Stanislawski <t.stanislaws@samsung.com>
Signed-off-by: default avatarKyungmin Park <kyungmin.park@samsung.com>
Signed-off-by: default avatarMarek Szyprowski <m.szyprowski@samsung.com>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@redhat.com>
parent 93d5a30b
Show whitespace changes
Inline Side-by-side
Showing with 12 additions and 238 deletions
drivers/media/video/v4l2-ioctl.c
View file @ 1d0c86ca
...@@ -490,63 +490,6 @@ static int check_fmt(const struct v4l2_ioctl_ops *ops, enum v4l2_buf_type type) ...@@ -490,63 +490,6 @@ static int check_fmt(const struct v4l2_ioctl_ops *ops, enum v4l2_buf_type type)
return -EINVAL; return -EINVAL;
} }
/**
* fmt_sp_to_mp() - Convert a single-plane format to its multi-planar 1-plane
* equivalent
*/
static int fmt_sp_to_mp(const struct v4l2_format *f_sp,
struct v4l2_format *f_mp)
{
struct v4l2_pix_format_mplane *pix_mp = &f_mp->fmt.pix_mp;
const struct v4l2_pix_format *pix = &f_sp->fmt.pix;
if (f_sp->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
f_mp->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
else if (f_sp->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
f_mp->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
else
return -EINVAL;
pix_mp->width = pix->width;
pix_mp->height = pix->height;
pix_mp->pixelformat = pix->pixelformat;
pix_mp->field = pix->field;
pix_mp->colorspace = pix->colorspace;
pix_mp->num_planes = 1;
pix_mp->plane_fmt[0].sizeimage = pix->sizeimage;
pix_mp->plane_fmt[0].bytesperline = pix->bytesperline;
return 0;
}
/**
* fmt_mp_to_sp() - Convert a multi-planar 1-plane format to its single-planar
* equivalent
*/
static int fmt_mp_to_sp(const struct v4l2_format *f_mp,
struct v4l2_format *f_sp)
{
const struct v4l2_pix_format_mplane *pix_mp = &f_mp->fmt.pix_mp;
struct v4l2_pix_format *pix = &f_sp->fmt.pix;
if (f_mp->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
f_sp->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
else if (f_mp->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
f_sp->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
else
return -EINVAL;
pix->width = pix_mp->width;
pix->height = pix_mp->height;
pix->pixelformat = pix_mp->pixelformat;
pix->field = pix_mp->field;
pix->colorspace = pix_mp->colorspace;
pix->sizeimage = pix_mp->plane_fmt[0].sizeimage;
pix->bytesperline = pix_mp->plane_fmt[0].bytesperline;
return 0;
}
static long __video_do_ioctl(struct file *file, static long __video_do_ioctl(struct file *file,
unsigned int cmd, void *arg) unsigned int cmd, void *arg)
{ {
...@@ -554,7 +497,6 @@ static long __video_do_ioctl(struct file *file, ...@@ -554,7 +497,6 @@ static long __video_do_ioctl(struct file *file,
const struct v4l2_ioctl_ops *ops = vfd->ioctl_ops; const struct v4l2_ioctl_ops *ops = vfd->ioctl_ops;
void *fh = file->private_data; void *fh = file->private_data;
struct v4l2_fh *vfh = NULL; struct v4l2_fh *vfh = NULL;
struct v4l2_format f_copy;
int use_fh_prio = 0; int use_fh_prio = 0;
long ret_prio = 0; long ret_prio = 0;
long ret = -ENOTTY; long ret = -ENOTTY;
...@@ -697,42 +639,15 @@ static long __video_do_ioctl(struct file *file, ...@@ -697,42 +639,15 @@ static long __video_do_ioctl(struct file *file,
switch (f->type) { switch (f->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: case V4L2_BUF_TYPE_VIDEO_CAPTURE:
if (ops->vidioc_g_fmt_vid_cap) { if (ops->vidioc_g_fmt_vid_cap)
ret = ops->vidioc_g_fmt_vid_cap(file, fh, f); ret = ops->vidioc_g_fmt_vid_cap(file, fh, f);
} else if (ops->vidioc_g_fmt_vid_cap_mplane) {
if (fmt_sp_to_mp(f, &f_copy))
break;
ret = ops->vidioc_g_fmt_vid_cap_mplane(file, fh,
&f_copy);
if (ret)
break;
/* Driver is currently in multi-planar format,
* we can't return it in single-planar API*/
if (f_copy.fmt.pix_mp.num_planes > 1) {
ret = -EBUSY;
break;
}
ret = fmt_mp_to_sp(&f_copy, f);
}
if (!ret) if (!ret)
v4l_print_pix_fmt(vfd, &f->fmt.pix); v4l_print_pix_fmt(vfd, &f->fmt.pix);
break; break;
case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
if (ops->vidioc_g_fmt_vid_cap_mplane) { if (ops->vidioc_g_fmt_vid_cap_mplane)
ret = ops->vidioc_g_fmt_vid_cap_mplane(file, ret = ops->vidioc_g_fmt_vid_cap_mplane(file,
fh, f); fh, f);
} else if (ops->vidioc_g_fmt_vid_cap) {
if (fmt_mp_to_sp(f, &f_copy))
break;
ret = ops->vidioc_g_fmt_vid_cap(file,
fh, &f_copy);
if (ret)
break;
ret = fmt_sp_to_mp(&f_copy, f);
}
if (!ret) if (!ret)
v4l_print_pix_fmt_mplane(vfd, &f->fmt.pix_mp); v4l_print_pix_fmt_mplane(vfd, &f->fmt.pix_mp);
break; break;
...@@ -742,42 +657,15 @@ static long __video_do_ioctl(struct file *file, ...@@ -742,42 +657,15 @@ static long __video_do_ioctl(struct file *file,
fh, f); fh, f);
break; break;
case V4L2_BUF_TYPE_VIDEO_OUTPUT: case V4L2_BUF_TYPE_VIDEO_OUTPUT:
if (ops->vidioc_g_fmt_vid_out) { if (ops->vidioc_g_fmt_vid_out)
ret = ops->vidioc_g_fmt_vid_out(file, fh, f); ret = ops->vidioc_g_fmt_vid_out(file, fh, f);
} else if (ops->vidioc_g_fmt_vid_out_mplane) {
if (fmt_sp_to_mp(f, &f_copy))
break;
ret = ops->vidioc_g_fmt_vid_out_mplane(file, fh,
&f_copy);
if (ret)
break;
/* Driver is currently in multi-planar format,
* we can't return it in single-planar API*/
if (f_copy.fmt.pix_mp.num_planes > 1) {
ret = -EBUSY;
break;
}
ret = fmt_mp_to_sp(&f_copy, f);
}
if (!ret) if (!ret)
v4l_print_pix_fmt(vfd, &f->fmt.pix); v4l_print_pix_fmt(vfd, &f->fmt.pix);
break; break;
case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
if (ops->vidioc_g_fmt_vid_out_mplane) { if (ops->vidioc_g_fmt_vid_out_mplane)
ret = ops->vidioc_g_fmt_vid_out_mplane(file, ret = ops->vidioc_g_fmt_vid_out_mplane(file,
fh, f); fh, f);
} else if (ops->vidioc_g_fmt_vid_out) {
if (fmt_mp_to_sp(f, &f_copy))
break;
ret = ops->vidioc_g_fmt_vid_out(file,
fh, &f_copy);
if (ret)
break;
ret = fmt_sp_to_mp(&f_copy, f);
}
if (!ret) if (!ret)
v4l_print_pix_fmt_mplane(vfd, &f->fmt.pix_mp); v4l_print_pix_fmt_mplane(vfd, &f->fmt.pix_mp);
break; break;
...@@ -834,44 +722,15 @@ static long __video_do_ioctl(struct file *file, ...@@ -834,44 +722,15 @@ static long __video_do_ioctl(struct file *file,
case V4L2_BUF_TYPE_VIDEO_CAPTURE: case V4L2_BUF_TYPE_VIDEO_CAPTURE:
CLEAR_AFTER_FIELD(f, fmt.pix); CLEAR_AFTER_FIELD(f, fmt.pix);
v4l_print_pix_fmt(vfd, &f->fmt.pix); v4l_print_pix_fmt(vfd, &f->fmt.pix);
if (ops->vidioc_s_fmt_vid_cap) { if (ops->vidioc_s_fmt_vid_cap)
ret = ops->vidioc_s_fmt_vid_cap(file, fh, f); ret = ops->vidioc_s_fmt_vid_cap(file, fh, f);
} else if (ops->vidioc_s_fmt_vid_cap_mplane) {
if (fmt_sp_to_mp(f, &f_copy))
break;
ret = ops->vidioc_s_fmt_vid_cap_mplane(file, fh,
&f_copy);
if (ret)
break;
if (f_copy.fmt.pix_mp.num_planes > 1) {
/* Drivers shouldn't adjust from 1-plane
* to more than 1-plane formats */
ret = -EBUSY;
WARN_ON(1);
break;
}
ret = fmt_mp_to_sp(&f_copy, f);
}
break; break;
case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
CLEAR_AFTER_FIELD(f, fmt.pix_mp); CLEAR_AFTER_FIELD(f, fmt.pix_mp);
v4l_print_pix_fmt_mplane(vfd, &f->fmt.pix_mp); v4l_print_pix_fmt_mplane(vfd, &f->fmt.pix_mp);
if (ops->vidioc_s_fmt_vid_cap_mplane) { if (ops->vidioc_s_fmt_vid_cap_mplane)
ret = ops->vidioc_s_fmt_vid_cap_mplane(file, ret = ops->vidioc_s_fmt_vid_cap_mplane(file,
fh, f); fh, f);
} else if (ops->vidioc_s_fmt_vid_cap &&
f->fmt.pix_mp.num_planes == 1) {
if (fmt_mp_to_sp(f, &f_copy))
break;
ret = ops->vidioc_s_fmt_vid_cap(file,
fh, &f_copy);
if (ret)
break;
ret = fmt_sp_to_mp(&f_copy, f);
}
break; break;
case V4L2_BUF_TYPE_VIDEO_OVERLAY: case V4L2_BUF_TYPE_VIDEO_OVERLAY:
CLEAR_AFTER_FIELD(f, fmt.win); CLEAR_AFTER_FIELD(f, fmt.win);
...@@ -882,44 +741,15 @@ static long __video_do_ioctl(struct file *file, ...@@ -882,44 +741,15 @@ static long __video_do_ioctl(struct file *file,
case V4L2_BUF_TYPE_VIDEO_OUTPUT: case V4L2_BUF_TYPE_VIDEO_OUTPUT:
CLEAR_AFTER_FIELD(f, fmt.pix); CLEAR_AFTER_FIELD(f, fmt.pix);
v4l_print_pix_fmt(vfd, &f->fmt.pix); v4l_print_pix_fmt(vfd, &f->fmt.pix);
if (ops->vidioc_s_fmt_vid_out) { if (ops->vidioc_s_fmt_vid_out)
ret = ops->vidioc_s_fmt_vid_out(file, fh, f); ret = ops->vidioc_s_fmt_vid_out(file, fh, f);
} else if (ops->vidioc_s_fmt_vid_out_mplane) {
if (fmt_sp_to_mp(f, &f_copy))
break;
ret = ops->vidioc_s_fmt_vid_out_mplane(file, fh,
&f_copy);
if (ret)
break;
if (f_copy.fmt.pix_mp.num_planes > 1) {
/* Drivers shouldn't adjust from 1-plane
* to more than 1-plane formats */
ret = -EBUSY;
WARN_ON(1);
break;
}
ret = fmt_mp_to_sp(&f_copy, f);
}
break; break;
case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
CLEAR_AFTER_FIELD(f, fmt.pix_mp); CLEAR_AFTER_FIELD(f, fmt.pix_mp);
v4l_print_pix_fmt_mplane(vfd, &f->fmt.pix_mp); v4l_print_pix_fmt_mplane(vfd, &f->fmt.pix_mp);
if (ops->vidioc_s_fmt_vid_out_mplane) { if (ops->vidioc_s_fmt_vid_out_mplane)
ret = ops->vidioc_s_fmt_vid_out_mplane(file, ret = ops->vidioc_s_fmt_vid_out_mplane(file,
fh, f); fh, f);
} else if (ops->vidioc_s_fmt_vid_out &&
f->fmt.pix_mp.num_planes == 1) {
if (fmt_mp_to_sp(f, &f_copy))
break;
ret = ops->vidioc_s_fmt_vid_out(file,
fh, &f_copy);
if (ret)
break;
ret = fmt_mp_to_sp(&f_copy, f);
}
break; break;
case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY: case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
CLEAR_AFTER_FIELD(f, fmt.win); CLEAR_AFTER_FIELD(f, fmt.win);
...@@ -969,44 +799,16 @@ static long __video_do_ioctl(struct file *file, ...@@ -969,44 +799,16 @@ static long __video_do_ioctl(struct file *file,
switch (f->type) { switch (f->type) {
case V4L2_BUF_TYPE_VIDEO_CAPTURE: case V4L2_BUF_TYPE_VIDEO_CAPTURE:
CLEAR_AFTER_FIELD(f, fmt.pix); CLEAR_AFTER_FIELD(f, fmt.pix);
if (ops->vidioc_try_fmt_vid_cap) { if (ops->vidioc_try_fmt_vid_cap)
ret = ops->vidioc_try_fmt_vid_cap(file, fh, f); ret = ops->vidioc_try_fmt_vid_cap(file, fh, f);
} else if (ops->vidioc_try_fmt_vid_cap_mplane) {
if (fmt_sp_to_mp(f, &f_copy))
break;
ret = ops->vidioc_try_fmt_vid_cap_mplane(file,
fh, &f_copy);
if (ret)
break;
if (f_copy.fmt.pix_mp.num_planes > 1) {
/* Drivers shouldn't adjust from 1-plane
* to more than 1-plane formats */
ret = -EBUSY;
WARN_ON(1);
break;
}
ret = fmt_mp_to_sp(&f_copy, f);
}
if (!ret) if (!ret)
v4l_print_pix_fmt(vfd, &f->fmt.pix); v4l_print_pix_fmt(vfd, &f->fmt.pix);
break; break;
case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
CLEAR_AFTER_FIELD(f, fmt.pix_mp); CLEAR_AFTER_FIELD(f, fmt.pix_mp);
if (ops->vidioc_try_fmt_vid_cap_mplane) { if (ops->vidioc_try_fmt_vid_cap_mplane)
ret = ops->vidioc_try_fmt_vid_cap_mplane(file, ret = ops->vidioc_try_fmt_vid_cap_mplane(file,
fh, f); fh, f);
} else if (ops->vidioc_try_fmt_vid_cap &&
f->fmt.pix_mp.num_planes == 1) {
if (fmt_mp_to_sp(f, &f_copy))
break;
ret = ops->vidioc_try_fmt_vid_cap(file,
fh, &f_copy);
if (ret)
break;
ret = fmt_sp_to_mp(&f_copy, f);
}
if (!ret) if (!ret)
v4l_print_pix_fmt_mplane(vfd, &f->fmt.pix_mp); v4l_print_pix_fmt_mplane(vfd, &f->fmt.pix_mp);
break; break;
...@@ -1018,44 +820,16 @@ static long __video_do_ioctl(struct file *file, ...@@ -1018,44 +820,16 @@ static long __video_do_ioctl(struct file *file,
break; break;
case V4L2_BUF_TYPE_VIDEO_OUTPUT: case V4L2_BUF_TYPE_VIDEO_OUTPUT:
CLEAR_AFTER_FIELD(f, fmt.pix); CLEAR_AFTER_FIELD(f, fmt.pix);
if (ops->vidioc_try_fmt_vid_out) { if (ops->vidioc_try_fmt_vid_out)
ret = ops->vidioc_try_fmt_vid_out(file, fh, f); ret = ops->vidioc_try_fmt_vid_out(file, fh, f);
} else if (ops->vidioc_try_fmt_vid_out_mplane) {
if (fmt_sp_to_mp(f, &f_copy))
break;
ret = ops->vidioc_try_fmt_vid_out_mplane(file,
fh, &f_copy);
if (ret)
break;
if (f_copy.fmt.pix_mp.num_planes > 1) {
/* Drivers shouldn't adjust from 1-plane
* to more than 1-plane formats */
ret = -EBUSY;
WARN_ON(1);
break;
}
ret = fmt_mp_to_sp(&f_copy, f);
}
if (!ret) if (!ret)
v4l_print_pix_fmt(vfd, &f->fmt.pix); v4l_print_pix_fmt(vfd, &f->fmt.pix);
break; break;
case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
CLEAR_AFTER_FIELD(f, fmt.pix_mp); CLEAR_AFTER_FIELD(f, fmt.pix_mp);
if (ops->vidioc_try_fmt_vid_out_mplane) { if (ops->vidioc_try_fmt_vid_out_mplane)
ret = ops->vidioc_try_fmt_vid_out_mplane(file, ret = ops->vidioc_try_fmt_vid_out_mplane(file,
fh, f); fh, f);
} else if (ops->vidioc_try_fmt_vid_out &&
f->fmt.pix_mp.num_planes == 1) {
if (fmt_mp_to_sp(f, &f_copy))
break;
ret = ops->vidioc_try_fmt_vid_out(file,
fh, &f_copy);
if (ret)
break;
ret = fmt_sp_to_mp(&f_copy, f);
}
if (!ret) if (!ret)
v4l_print_pix_fmt_mplane(vfd, &f->fmt.pix_mp); v4l_print_pix_fmt_mplane(vfd, &f->fmt.pix_mp);
break; break;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7