2 * vivid-vid-common.c - common video support functions.
4 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
6 * This program is free software; you may redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; version 2 of the License.
10 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
11 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
12 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
13 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
14 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
15 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
16 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20 #include <linux/errno.h>
21 #include <linux/kernel.h>
22 #include <linux/sched.h>
23 #include <linux/videodev2.h>
24 #include <linux/v4l2-dv-timings.h>
25 #include <media/v4l2-common.h>
26 #include <media/v4l2-event.h>
27 #include <media/v4l2-dv-timings.h>
29 #include "vivid-core.h"
30 #include "vivid-vid-common.h"
32 const struct v4l2_dv_timings_cap vivid_dv_timings_cap
= {
33 .type
= V4L2_DV_BT_656_1120
,
34 /* keep this initialization for compatibility with GCC < 4.4.6 */
36 V4L2_INIT_BT_TIMINGS(0, MAX_WIDTH
, 0, MAX_HEIGHT
, 14000000, 775000000,
37 V4L2_DV_BT_STD_CEA861
| V4L2_DV_BT_STD_DMT
|
38 V4L2_DV_BT_STD_CVT
| V4L2_DV_BT_STD_GTF
,
39 V4L2_DV_BT_CAP_PROGRESSIVE
| V4L2_DV_BT_CAP_INTERLACED
)
42 /* ------------------------------------------------------------------
44 ------------------------------------------------------------------*/
46 struct vivid_fmt vivid_formats
[] = {
48 .fourcc
= V4L2_PIX_FMT_YUYV
,
49 .vdownsampling
= { 1 },
54 .data_offset
= { PLANE0_DATA_OFFSET
},
57 .fourcc
= V4L2_PIX_FMT_UYVY
,
58 .vdownsampling
= { 1 },
65 .fourcc
= V4L2_PIX_FMT_YVYU
,
66 .vdownsampling
= { 1 },
73 .fourcc
= V4L2_PIX_FMT_VYUY
,
74 .vdownsampling
= { 1 },
81 .fourcc
= V4L2_PIX_FMT_YUV422P
,
82 .vdownsampling
= { 1, 1, 1 },
83 .bit_depth
= { 8, 4, 4 },
89 .fourcc
= V4L2_PIX_FMT_YUV420
,
90 .vdownsampling
= { 1, 2, 2 },
91 .bit_depth
= { 8, 4, 4 },
97 .fourcc
= V4L2_PIX_FMT_YVU420
,
98 .vdownsampling
= { 1, 2, 2 },
99 .bit_depth
= { 8, 4, 4 },
105 .fourcc
= V4L2_PIX_FMT_NV12
,
106 .vdownsampling
= { 1, 2 },
107 .bit_depth
= { 8, 8 },
113 .fourcc
= V4L2_PIX_FMT_NV21
,
114 .vdownsampling
= { 1, 2 },
115 .bit_depth
= { 8, 8 },
121 .fourcc
= V4L2_PIX_FMT_NV16
,
122 .vdownsampling
= { 1, 1 },
123 .bit_depth
= { 8, 8 },
129 .fourcc
= V4L2_PIX_FMT_NV61
,
130 .vdownsampling
= { 1, 1 },
131 .bit_depth
= { 8, 8 },
137 .fourcc
= V4L2_PIX_FMT_NV24
,
138 .vdownsampling
= { 1, 1 },
139 .bit_depth
= { 8, 16 },
145 .fourcc
= V4L2_PIX_FMT_NV42
,
146 .vdownsampling
= { 1, 1 },
147 .bit_depth
= { 8, 16 },
153 .fourcc
= V4L2_PIX_FMT_YUV555
, /* uuuvvvvv ayyyyyuu */
154 .vdownsampling
= { 1 },
158 .alpha_mask
= 0x8000,
161 .fourcc
= V4L2_PIX_FMT_YUV565
, /* uuuvvvvv yyyyyuuu */
162 .vdownsampling
= { 1 },
168 .fourcc
= V4L2_PIX_FMT_YUV444
, /* uuuuvvvv aaaayyyy */
169 .vdownsampling
= { 1 },
173 .alpha_mask
= 0xf000,
176 .fourcc
= V4L2_PIX_FMT_YUV32
, /* ayuv */
177 .vdownsampling
= { 1 },
181 .alpha_mask
= 0x000000ff,
184 .fourcc
= V4L2_PIX_FMT_GREY
,
185 .vdownsampling
= { 1 },
192 .fourcc
= V4L2_PIX_FMT_Y16
,
193 .vdownsampling
= { 1 },
200 .fourcc
= V4L2_PIX_FMT_RGB332
, /* rrrgggbb */
201 .vdownsampling
= { 1 },
207 .fourcc
= V4L2_PIX_FMT_RGB565
, /* gggbbbbb rrrrrggg */
208 .vdownsampling
= { 1 },
212 .can_do_overlay
= true,
215 .fourcc
= V4L2_PIX_FMT_RGB565X
, /* rrrrrggg gggbbbbb */
216 .vdownsampling
= { 1 },
220 .can_do_overlay
= true,
223 .fourcc
= V4L2_PIX_FMT_RGB444
, /* xxxxrrrr ggggbbbb */
224 .vdownsampling
= { 1 },
230 .fourcc
= V4L2_PIX_FMT_XRGB444
, /* xxxxrrrr ggggbbbb */
231 .vdownsampling
= { 1 },
237 .fourcc
= V4L2_PIX_FMT_ARGB444
, /* aaaarrrr ggggbbbb */
238 .vdownsampling
= { 1 },
242 .alpha_mask
= 0x00f0,
245 .fourcc
= V4L2_PIX_FMT_RGB555
, /* gggbbbbb xrrrrrgg */
246 .vdownsampling
= { 1 },
250 .can_do_overlay
= true,
253 .fourcc
= V4L2_PIX_FMT_XRGB555
, /* gggbbbbb xrrrrrgg */
254 .vdownsampling
= { 1 },
258 .can_do_overlay
= true,
261 .fourcc
= V4L2_PIX_FMT_ARGB555
, /* gggbbbbb arrrrrgg */
262 .vdownsampling
= { 1 },
266 .can_do_overlay
= true,
267 .alpha_mask
= 0x8000,
270 .fourcc
= V4L2_PIX_FMT_RGB555X
, /* xrrrrrgg gggbbbbb */
271 .vdownsampling
= { 1 },
277 .fourcc
= V4L2_PIX_FMT_XRGB555X
, /* xrrrrrgg gggbbbbb */
278 .vdownsampling
= { 1 },
284 .fourcc
= V4L2_PIX_FMT_ARGB555X
, /* arrrrrgg gggbbbbb */
285 .vdownsampling
= { 1 },
289 .alpha_mask
= 0x0080,
292 .fourcc
= V4L2_PIX_FMT_RGB24
, /* rgb */
293 .vdownsampling
= { 1 },
299 .fourcc
= V4L2_PIX_FMT_BGR24
, /* bgr */
300 .vdownsampling
= { 1 },
306 .fourcc
= V4L2_PIX_FMT_BGR666
, /* bbbbbbgg ggggrrrr rrxxxxxx */
307 .vdownsampling
= { 1 },
313 .fourcc
= V4L2_PIX_FMT_RGB32
, /* xrgb */
314 .vdownsampling
= { 1 },
320 .fourcc
= V4L2_PIX_FMT_BGR32
, /* bgrx */
321 .vdownsampling
= { 1 },
327 .fourcc
= V4L2_PIX_FMT_XRGB32
, /* xrgb */
328 .vdownsampling
= { 1 },
334 .fourcc
= V4L2_PIX_FMT_XBGR32
, /* bgrx */
335 .vdownsampling
= { 1 },
341 .fourcc
= V4L2_PIX_FMT_ARGB32
, /* argb */
342 .vdownsampling
= { 1 },
346 .alpha_mask
= 0x000000ff,
349 .fourcc
= V4L2_PIX_FMT_ABGR32
, /* bgra */
350 .vdownsampling
= { 1 },
354 .alpha_mask
= 0xff000000,
357 .fourcc
= V4L2_PIX_FMT_SBGGR8
, /* Bayer BG/GR */
358 .vdownsampling
= { 1 },
364 .fourcc
= V4L2_PIX_FMT_SGBRG8
, /* Bayer GB/RG */
365 .vdownsampling
= { 1 },
371 .fourcc
= V4L2_PIX_FMT_SGRBG8
, /* Bayer GR/BG */
372 .vdownsampling
= { 1 },
378 .fourcc
= V4L2_PIX_FMT_SRGGB8
, /* Bayer RG/GB */
379 .vdownsampling
= { 1 },
385 .fourcc
= V4L2_PIX_FMT_NV16M
,
386 .vdownsampling
= { 1, 1 },
387 .bit_depth
= { 8, 8 },
391 .data_offset
= { PLANE0_DATA_OFFSET
, 0 },
394 .fourcc
= V4L2_PIX_FMT_NV61M
,
395 .vdownsampling
= { 1, 1 },
396 .bit_depth
= { 8, 8 },
400 .data_offset
= { 0, PLANE0_DATA_OFFSET
},
403 .fourcc
= V4L2_PIX_FMT_YUV420M
,
404 .vdownsampling
= { 1, 2, 2 },
405 .bit_depth
= { 8, 4, 4 },
411 .fourcc
= V4L2_PIX_FMT_YVU420M
,
412 .vdownsampling
= { 1, 2, 2 },
413 .bit_depth
= { 8, 4, 4 },
419 .fourcc
= V4L2_PIX_FMT_NV12M
,
420 .vdownsampling
= { 1, 2 },
421 .bit_depth
= { 8, 8 },
427 .fourcc
= V4L2_PIX_FMT_NV21M
,
428 .vdownsampling
= { 1, 2 },
429 .bit_depth
= { 8, 8 },
436 /* There are 6 multiplanar formats in the list */
437 #define VIVID_MPLANAR_FORMATS 6
439 const struct vivid_fmt
*vivid_get_format(struct vivid_dev
*dev
, u32 pixelformat
)
441 const struct vivid_fmt
*fmt
;
444 for (k
= 0; k
< ARRAY_SIZE(vivid_formats
); k
++) {
445 fmt
= &vivid_formats
[k
];
446 if (fmt
->fourcc
== pixelformat
)
447 if (fmt
->buffers
== 1 || dev
->multiplanar
)
454 bool vivid_vid_can_loop(struct vivid_dev
*dev
)
456 if (dev
->src_rect
.width
!= dev
->sink_rect
.width
||
457 dev
->src_rect
.height
!= dev
->sink_rect
.height
)
459 if (dev
->fmt_cap
->fourcc
!= dev
->fmt_out
->fourcc
)
461 if (dev
->field_cap
!= dev
->field_out
)
464 * While this can be supported, it is just too much work
465 * to actually implement.
467 if (dev
->field_cap
== V4L2_FIELD_SEQ_TB
||
468 dev
->field_cap
== V4L2_FIELD_SEQ_BT
)
470 if (vivid_is_svid_cap(dev
) && vivid_is_svid_out(dev
)) {
471 if (!(dev
->std_cap
& V4L2_STD_525_60
) !=
472 !(dev
->std_out
& V4L2_STD_525_60
))
476 if (vivid_is_hdmi_cap(dev
) && vivid_is_hdmi_out(dev
))
481 void vivid_send_source_change(struct vivid_dev
*dev
, unsigned type
)
483 struct v4l2_event ev
= {
484 .type
= V4L2_EVENT_SOURCE_CHANGE
,
485 .u
.src_change
.changes
= V4L2_EVENT_SRC_CH_RESOLUTION
,
489 for (i
= 0; i
< dev
->num_inputs
; i
++) {
491 if (dev
->input_type
[i
] == type
) {
492 if (video_is_registered(&dev
->vid_cap_dev
) && dev
->has_vid_cap
)
493 v4l2_event_queue(&dev
->vid_cap_dev
, &ev
);
494 if (video_is_registered(&dev
->vbi_cap_dev
) && dev
->has_vbi_cap
)
495 v4l2_event_queue(&dev
->vbi_cap_dev
, &ev
);
501 * Conversion function that converts a single-planar format to a
502 * single-plane multiplanar format.
504 void fmt_sp2mp(const struct v4l2_format
*sp_fmt
, struct v4l2_format
*mp_fmt
)
506 struct v4l2_pix_format_mplane
*mp
= &mp_fmt
->fmt
.pix_mp
;
507 struct v4l2_plane_pix_format
*ppix
= &mp
->plane_fmt
[0];
508 const struct v4l2_pix_format
*pix
= &sp_fmt
->fmt
.pix
;
509 bool is_out
= sp_fmt
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
;
511 memset(mp
->reserved
, 0, sizeof(mp
->reserved
));
512 mp_fmt
->type
= is_out
? V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
:
513 V4L2_CAP_VIDEO_CAPTURE_MPLANE
;
514 mp
->width
= pix
->width
;
515 mp
->height
= pix
->height
;
516 mp
->pixelformat
= pix
->pixelformat
;
517 mp
->field
= pix
->field
;
518 mp
->colorspace
= pix
->colorspace
;
519 mp
->ycbcr_enc
= pix
->ycbcr_enc
;
520 mp
->quantization
= pix
->quantization
;
522 mp
->flags
= pix
->flags
;
523 ppix
->sizeimage
= pix
->sizeimage
;
524 ppix
->bytesperline
= pix
->bytesperline
;
525 memset(ppix
->reserved
, 0, sizeof(ppix
->reserved
));
528 int fmt_sp2mp_func(struct file
*file
, void *priv
,
529 struct v4l2_format
*f
, fmtfunc func
)
531 struct v4l2_format fmt
;
532 struct v4l2_pix_format_mplane
*mp
= &fmt
.fmt
.pix_mp
;
533 struct v4l2_plane_pix_format
*ppix
= &mp
->plane_fmt
[0];
534 struct v4l2_pix_format
*pix
= &f
->fmt
.pix
;
537 /* Converts to a mplane format */
539 /* Passes it to the generic mplane format function */
540 ret
= func(file
, priv
, &fmt
);
541 /* Copies back the mplane data to the single plane format */
542 pix
->width
= mp
->width
;
543 pix
->height
= mp
->height
;
544 pix
->pixelformat
= mp
->pixelformat
;
545 pix
->field
= mp
->field
;
546 pix
->colorspace
= mp
->colorspace
;
547 pix
->ycbcr_enc
= mp
->ycbcr_enc
;
548 pix
->quantization
= mp
->quantization
;
549 pix
->sizeimage
= ppix
->sizeimage
;
550 pix
->bytesperline
= ppix
->bytesperline
;
551 pix
->flags
= mp
->flags
;
555 /* v4l2_rect helper function: copy the width/height values */
556 void rect_set_size_to(struct v4l2_rect
*r
, const struct v4l2_rect
*size
)
558 r
->width
= size
->width
;
559 r
->height
= size
->height
;
562 /* v4l2_rect helper function: width and height of r should be >= min_size */
563 void rect_set_min_size(struct v4l2_rect
*r
, const struct v4l2_rect
*min_size
)
565 if (r
->width
< min_size
->width
)
566 r
->width
= min_size
->width
;
567 if (r
->height
< min_size
->height
)
568 r
->height
= min_size
->height
;
571 /* v4l2_rect helper function: width and height of r should be <= max_size */
572 void rect_set_max_size(struct v4l2_rect
*r
, const struct v4l2_rect
*max_size
)
574 if (r
->width
> max_size
->width
)
575 r
->width
= max_size
->width
;
576 if (r
->height
> max_size
->height
)
577 r
->height
= max_size
->height
;
580 /* v4l2_rect helper function: r should be inside boundary */
581 void rect_map_inside(struct v4l2_rect
*r
, const struct v4l2_rect
*boundary
)
583 rect_set_max_size(r
, boundary
);
584 if (r
->left
< boundary
->left
)
585 r
->left
= boundary
->left
;
586 if (r
->top
< boundary
->top
)
587 r
->top
= boundary
->top
;
588 if (r
->left
+ r
->width
> boundary
->width
)
589 r
->left
= boundary
->width
- r
->width
;
590 if (r
->top
+ r
->height
> boundary
->height
)
591 r
->top
= boundary
->height
- r
->height
;
594 /* v4l2_rect helper function: return true if r1 has the same size as r2 */
595 bool rect_same_size(const struct v4l2_rect
*r1
, const struct v4l2_rect
*r2
)
597 return r1
->width
== r2
->width
&& r1
->height
== r2
->height
;
600 /* v4l2_rect helper function: calculate the intersection of two rects */
601 struct v4l2_rect
rect_intersect(const struct v4l2_rect
*a
, const struct v4l2_rect
*b
)
606 r
.top
= max(a
->top
, b
->top
);
607 r
.left
= max(a
->left
, b
->left
);
608 bottom
= min(a
->top
+ a
->height
, b
->top
+ b
->height
);
609 right
= min(a
->left
+ a
->width
, b
->left
+ b
->width
);
610 r
.height
= max(0, bottom
- r
.top
);
611 r
.width
= max(0, right
- r
.left
);
616 * v4l2_rect helper function: scale rect r by to->width / from->width and
617 * to->height / from->height.
619 void rect_scale(struct v4l2_rect
*r
, const struct v4l2_rect
*from
,
620 const struct v4l2_rect
*to
)
622 if (from
->width
== 0 || from
->height
== 0) {
623 r
->left
= r
->top
= r
->width
= r
->height
= 0;
626 r
->left
= (((r
->left
- from
->left
) * to
->width
) / from
->width
) & ~1;
627 r
->width
= ((r
->width
* to
->width
) / from
->width
) & ~1;
628 r
->top
= ((r
->top
- from
->top
) * to
->height
) / from
->height
;
629 r
->height
= (r
->height
* to
->height
) / from
->height
;
632 bool rect_overlap(const struct v4l2_rect
*r1
, const struct v4l2_rect
*r2
)
635 * IF the left side of r1 is to the right of the right side of r2 OR
636 * the left side of r2 is to the right of the right side of r1 THEN
637 * they do not overlap.
639 if (r1
->left
>= r2
->left
+ r2
->width
||
640 r2
->left
>= r1
->left
+ r1
->width
)
643 * IF the top side of r1 is below the bottom of r2 OR
644 * the top side of r2 is below the bottom of r1 THEN
645 * they do not overlap.
647 if (r1
->top
>= r2
->top
+ r2
->height
||
648 r2
->top
>= r1
->top
+ r1
->height
)
652 int vivid_vid_adjust_sel(unsigned flags
, struct v4l2_rect
*r
)
654 unsigned w
= r
->width
;
655 unsigned h
= r
->height
;
657 /* sanitize w and h in case someone passes ~0 as the value */
660 if (!(flags
& V4L2_SEL_FLAG_LE
)) {
668 if (!(flags
& V4L2_SEL_FLAG_GE
)) {
678 if (w
> MAX_WIDTH
|| h
> MAX_HEIGHT
)
684 /* sanitize left and top in case someone passes ~0 as the value */
687 if (r
->left
+ w
> MAX_WIDTH
)
688 r
->left
= MAX_WIDTH
- w
;
689 if (r
->top
+ h
> MAX_HEIGHT
)
690 r
->top
= MAX_HEIGHT
- h
;
691 if ((flags
& (V4L2_SEL_FLAG_GE
| V4L2_SEL_FLAG_LE
)) ==
692 (V4L2_SEL_FLAG_GE
| V4L2_SEL_FLAG_LE
) &&
693 (r
->width
!= w
|| r
->height
!= h
))
700 int vivid_enum_fmt_vid(struct file
*file
, void *priv
,
701 struct v4l2_fmtdesc
*f
)
703 struct vivid_dev
*dev
= video_drvdata(file
);
704 const struct vivid_fmt
*fmt
;
706 if (f
->index
>= ARRAY_SIZE(vivid_formats
) -
707 (dev
->multiplanar
? 0 : VIVID_MPLANAR_FORMATS
))
710 fmt
= &vivid_formats
[f
->index
];
712 f
->pixelformat
= fmt
->fourcc
;
716 int vidioc_enum_fmt_vid_mplane(struct file
*file
, void *priv
,
717 struct v4l2_fmtdesc
*f
)
719 struct vivid_dev
*dev
= video_drvdata(file
);
721 if (!dev
->multiplanar
)
723 return vivid_enum_fmt_vid(file
, priv
, f
);
726 int vidioc_enum_fmt_vid(struct file
*file
, void *priv
,
727 struct v4l2_fmtdesc
*f
)
729 struct vivid_dev
*dev
= video_drvdata(file
);
731 if (dev
->multiplanar
)
733 return vivid_enum_fmt_vid(file
, priv
, f
);
736 int vidioc_g_std(struct file
*file
, void *priv
, v4l2_std_id
*id
)
738 struct vivid_dev
*dev
= video_drvdata(file
);
739 struct video_device
*vdev
= video_devdata(file
);
741 if (vdev
->vfl_dir
== VFL_DIR_RX
) {
742 if (!vivid_is_sdtv_cap(dev
))
746 if (!vivid_is_svid_out(dev
))
753 int vidioc_g_dv_timings(struct file
*file
, void *_fh
,
754 struct v4l2_dv_timings
*timings
)
756 struct vivid_dev
*dev
= video_drvdata(file
);
757 struct video_device
*vdev
= video_devdata(file
);
759 if (vdev
->vfl_dir
== VFL_DIR_RX
) {
760 if (!vivid_is_hdmi_cap(dev
))
762 *timings
= dev
->dv_timings_cap
;
764 if (!vivid_is_hdmi_out(dev
))
766 *timings
= dev
->dv_timings_out
;
771 int vidioc_enum_dv_timings(struct file
*file
, void *_fh
,
772 struct v4l2_enum_dv_timings
*timings
)
774 struct vivid_dev
*dev
= video_drvdata(file
);
775 struct video_device
*vdev
= video_devdata(file
);
777 if (vdev
->vfl_dir
== VFL_DIR_RX
) {
778 if (!vivid_is_hdmi_cap(dev
))
781 if (!vivid_is_hdmi_out(dev
))
784 return v4l2_enum_dv_timings_cap(timings
, &vivid_dv_timings_cap
,
788 int vidioc_dv_timings_cap(struct file
*file
, void *_fh
,
789 struct v4l2_dv_timings_cap
*cap
)
791 struct vivid_dev
*dev
= video_drvdata(file
);
792 struct video_device
*vdev
= video_devdata(file
);
794 if (vdev
->vfl_dir
== VFL_DIR_RX
) {
795 if (!vivid_is_hdmi_cap(dev
))
798 if (!vivid_is_hdmi_out(dev
))
801 *cap
= vivid_dv_timings_cap
;
805 int vidioc_g_edid(struct file
*file
, void *_fh
,
806 struct v4l2_edid
*edid
)
808 struct vivid_dev
*dev
= video_drvdata(file
);
809 struct video_device
*vdev
= video_devdata(file
);
811 memset(edid
->reserved
, 0, sizeof(edid
->reserved
));
812 if (vdev
->vfl_dir
== VFL_DIR_RX
) {
813 if (edid
->pad
>= dev
->num_inputs
)
815 if (dev
->input_type
[edid
->pad
] != HDMI
)
818 if (edid
->pad
>= dev
->num_outputs
)
820 if (dev
->output_type
[edid
->pad
] != HDMI
)
823 if (edid
->start_block
== 0 && edid
->blocks
== 0) {
824 edid
->blocks
= dev
->edid_blocks
;
827 if (dev
->edid_blocks
== 0)
829 if (edid
->start_block
>= dev
->edid_blocks
)
831 if (edid
->start_block
+ edid
->blocks
> dev
->edid_blocks
)
832 edid
->blocks
= dev
->edid_blocks
- edid
->start_block
;
833 memcpy(edid
->edid
, dev
->edid
, edid
->blocks
* 128);