2 * vivid-vid-cap.c - video capture 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/vmalloc.h>
24 #include <linux/videodev2.h>
25 #include <linux/v4l2-dv-timings.h>
26 #include <media/v4l2-common.h>
27 #include <media/v4l2-event.h>
28 #include <media/v4l2-dv-timings.h>
29 #include <media/v4l2-rect.h>
31 #include "vivid-core.h"
32 #include "vivid-vid-common.h"
33 #include "vivid-kthread-cap.h"
34 #include "vivid-vid-cap.h"
36 /* timeperframe: min/max and default */
37 static const struct v4l2_fract
38 tpf_min
= {.numerator
= 1, .denominator
= FPS_MAX
},
39 tpf_max
= {.numerator
= FPS_MAX
, .denominator
= 1};
41 static const struct vivid_fmt formats_ovl
[] = {
43 .fourcc
= V4L2_PIX_FMT_RGB565
, /* gggbbbbb rrrrrggg */
44 .vdownsampling
= { 1 },
50 .fourcc
= V4L2_PIX_FMT_XRGB555
, /* gggbbbbb arrrrrgg */
51 .vdownsampling
= { 1 },
57 .fourcc
= V4L2_PIX_FMT_ARGB555
, /* gggbbbbb arrrrrgg */
58 .vdownsampling
= { 1 },
65 /* The number of discrete webcam framesizes */
66 #define VIVID_WEBCAM_SIZES 5
67 /* The number of discrete webcam frameintervals */
68 #define VIVID_WEBCAM_IVALS (VIVID_WEBCAM_SIZES * 2)
70 /* Sizes must be in increasing order */
71 static const struct v4l2_frmsize_discrete webcam_sizes
[VIVID_WEBCAM_SIZES
] = {
80 * Intervals must be in increasing order and there must be twice as many
81 * elements in this array as there are in webcam_sizes.
83 static const struct v4l2_fract webcam_intervals
[VIVID_WEBCAM_IVALS
] = {
96 static const struct v4l2_discrete_probe webcam_probe
= {
101 static int vid_cap_queue_setup(struct vb2_queue
*vq
,
102 unsigned *nbuffers
, unsigned *nplanes
,
103 unsigned sizes
[], struct device
*alloc_devs
[])
105 struct vivid_dev
*dev
= vb2_get_drv_priv(vq
);
106 unsigned buffers
= tpg_g_buffers(&dev
->tpg
);
107 unsigned h
= dev
->fmt_cap_rect
.height
;
110 if (dev
->field_cap
== V4L2_FIELD_ALTERNATE
) {
112 * You cannot use read() with FIELD_ALTERNATE since the field
113 * information (TOP/BOTTOM) cannot be passed back to the user.
115 if (vb2_fileio_is_active(vq
))
119 if (dev
->queue_setup_error
) {
121 * Error injection: test what happens if queue_setup() returns
124 dev
->queue_setup_error
= false;
129 * Check if the number of requested planes match
130 * the number of buffers in the current format. You can't mix that.
132 if (*nplanes
!= buffers
)
134 for (p
= 0; p
< buffers
; p
++) {
135 if (sizes
[p
] < tpg_g_line_width(&dev
->tpg
, p
) * h
+
136 dev
->fmt_cap
->data_offset
[p
])
140 for (p
= 0; p
< buffers
; p
++)
141 sizes
[p
] = tpg_g_line_width(&dev
->tpg
, p
) * h
+
142 dev
->fmt_cap
->data_offset
[p
];
145 if (vq
->num_buffers
+ *nbuffers
< 2)
146 *nbuffers
= 2 - vq
->num_buffers
;
150 dprintk(dev
, 1, "%s: count=%d\n", __func__
, *nbuffers
);
151 for (p
= 0; p
< buffers
; p
++)
152 dprintk(dev
, 1, "%s: size[%u]=%u\n", __func__
, p
, sizes
[p
]);
157 static int vid_cap_buf_prepare(struct vb2_buffer
*vb
)
159 struct vivid_dev
*dev
= vb2_get_drv_priv(vb
->vb2_queue
);
161 unsigned buffers
= tpg_g_buffers(&dev
->tpg
);
164 dprintk(dev
, 1, "%s\n", __func__
);
166 if (WARN_ON(NULL
== dev
->fmt_cap
))
169 if (dev
->buf_prepare_error
) {
171 * Error injection: test what happens if buf_prepare() returns
174 dev
->buf_prepare_error
= false;
177 for (p
= 0; p
< buffers
; p
++) {
178 size
= tpg_g_line_width(&dev
->tpg
, p
) * dev
->fmt_cap_rect
.height
+
179 dev
->fmt_cap
->data_offset
[p
];
181 if (vb2_plane_size(vb
, p
) < size
) {
182 dprintk(dev
, 1, "%s data will not fit into plane %u (%lu < %lu)\n",
183 __func__
, p
, vb2_plane_size(vb
, p
), size
);
187 vb2_set_plane_payload(vb
, p
, size
);
188 vb
->planes
[p
].data_offset
= dev
->fmt_cap
->data_offset
[p
];
194 static void vid_cap_buf_finish(struct vb2_buffer
*vb
)
196 struct vb2_v4l2_buffer
*vbuf
= to_vb2_v4l2_buffer(vb
);
197 struct vivid_dev
*dev
= vb2_get_drv_priv(vb
->vb2_queue
);
198 struct v4l2_timecode
*tc
= &vbuf
->timecode
;
200 unsigned seq
= vbuf
->sequence
;
202 if (!vivid_is_sdtv_cap(dev
))
206 * Set the timecode. Rarely used, so it is interesting to
209 vbuf
->flags
|= V4L2_BUF_FLAG_TIMECODE
;
210 if (dev
->std_cap
& V4L2_STD_525_60
)
212 tc
->type
= (fps
== 30) ? V4L2_TC_TYPE_30FPS
: V4L2_TC_TYPE_25FPS
;
214 tc
->frames
= seq
% fps
;
215 tc
->seconds
= (seq
/ fps
) % 60;
216 tc
->minutes
= (seq
/ (60 * fps
)) % 60;
217 tc
->hours
= (seq
/ (60 * 60 * fps
)) % 24;
220 static void vid_cap_buf_queue(struct vb2_buffer
*vb
)
222 struct vb2_v4l2_buffer
*vbuf
= to_vb2_v4l2_buffer(vb
);
223 struct vivid_dev
*dev
= vb2_get_drv_priv(vb
->vb2_queue
);
224 struct vivid_buffer
*buf
= container_of(vbuf
, struct vivid_buffer
, vb
);
226 dprintk(dev
, 1, "%s\n", __func__
);
228 spin_lock(&dev
->slock
);
229 list_add_tail(&buf
->list
, &dev
->vid_cap_active
);
230 spin_unlock(&dev
->slock
);
233 static int vid_cap_start_streaming(struct vb2_queue
*vq
, unsigned count
)
235 struct vivid_dev
*dev
= vb2_get_drv_priv(vq
);
239 if (vb2_is_streaming(&dev
->vb_vid_out_q
))
240 dev
->can_loop_video
= vivid_vid_can_loop(dev
);
242 if (dev
->kthread_vid_cap
)
245 dev
->vid_cap_seq_count
= 0;
246 dprintk(dev
, 1, "%s\n", __func__
);
247 for (i
= 0; i
< VIDEO_MAX_FRAME
; i
++)
248 dev
->must_blank
[i
] = tpg_g_perc_fill(&dev
->tpg
) < 100;
249 if (dev
->start_streaming_error
) {
250 dev
->start_streaming_error
= false;
253 err
= vivid_start_generating_vid_cap(dev
, &dev
->vid_cap_streaming
);
256 struct vivid_buffer
*buf
, *tmp
;
258 list_for_each_entry_safe(buf
, tmp
, &dev
->vid_cap_active
, list
) {
259 list_del(&buf
->list
);
260 vb2_buffer_done(&buf
->vb
.vb2_buf
,
261 VB2_BUF_STATE_QUEUED
);
267 /* abort streaming and wait for last buffer */
268 static void vid_cap_stop_streaming(struct vb2_queue
*vq
)
270 struct vivid_dev
*dev
= vb2_get_drv_priv(vq
);
272 dprintk(dev
, 1, "%s\n", __func__
);
273 vivid_stop_generating_vid_cap(dev
, &dev
->vid_cap_streaming
);
274 dev
->can_loop_video
= false;
277 const struct vb2_ops vivid_vid_cap_qops
= {
278 .queue_setup
= vid_cap_queue_setup
,
279 .buf_prepare
= vid_cap_buf_prepare
,
280 .buf_finish
= vid_cap_buf_finish
,
281 .buf_queue
= vid_cap_buf_queue
,
282 .start_streaming
= vid_cap_start_streaming
,
283 .stop_streaming
= vid_cap_stop_streaming
,
284 .wait_prepare
= vb2_ops_wait_prepare
,
285 .wait_finish
= vb2_ops_wait_finish
,
289 * Determine the 'picture' quality based on the current TV frequency: either
290 * COLOR for a good 'signal', GRAY (grayscale picture) for a slightly off
291 * signal or NOISE for no signal.
293 void vivid_update_quality(struct vivid_dev
*dev
)
295 unsigned freq_modulus
;
297 if (dev
->loop_video
&& (vivid_is_svid_cap(dev
) || vivid_is_hdmi_cap(dev
))) {
299 * The 'noise' will only be replaced by the actual video
300 * if the output video matches the input video settings.
302 tpg_s_quality(&dev
->tpg
, TPG_QUAL_NOISE
, 0);
305 if (vivid_is_hdmi_cap(dev
) && VIVID_INVALID_SIGNAL(dev
->dv_timings_signal_mode
)) {
306 tpg_s_quality(&dev
->tpg
, TPG_QUAL_NOISE
, 0);
309 if (vivid_is_sdtv_cap(dev
) && VIVID_INVALID_SIGNAL(dev
->std_signal_mode
)) {
310 tpg_s_quality(&dev
->tpg
, TPG_QUAL_NOISE
, 0);
313 if (!vivid_is_tv_cap(dev
)) {
314 tpg_s_quality(&dev
->tpg
, TPG_QUAL_COLOR
, 0);
319 * There is a fake channel every 6 MHz at 49.25, 55.25, etc.
320 * From +/- 0.25 MHz around the channel there is color, and from
321 * +/- 1 MHz there is grayscale (chroma is lost).
322 * Everywhere else it is just noise.
324 freq_modulus
= (dev
->tv_freq
- 676 /* (43.25-1) * 16 */) % (6 * 16);
325 if (freq_modulus
> 2 * 16) {
326 tpg_s_quality(&dev
->tpg
, TPG_QUAL_NOISE
,
327 next_pseudo_random32(dev
->tv_freq
^ 0x55) & 0x3f);
330 if (freq_modulus
< 12 /*0.75 * 16*/ || freq_modulus
> 20 /*1.25 * 16*/)
331 tpg_s_quality(&dev
->tpg
, TPG_QUAL_GRAY
, 0);
333 tpg_s_quality(&dev
->tpg
, TPG_QUAL_COLOR
, 0);
337 * Get the current picture quality and the associated afc value.
339 static enum tpg_quality
vivid_get_quality(struct vivid_dev
*dev
, s32
*afc
)
341 unsigned freq_modulus
;
345 if (tpg_g_quality(&dev
->tpg
) == TPG_QUAL_COLOR
||
346 tpg_g_quality(&dev
->tpg
) == TPG_QUAL_NOISE
)
347 return tpg_g_quality(&dev
->tpg
);
350 * There is a fake channel every 6 MHz at 49.25, 55.25, etc.
351 * From +/- 0.25 MHz around the channel there is color, and from
352 * +/- 1 MHz there is grayscale (chroma is lost).
353 * Everywhere else it is just gray.
355 freq_modulus
= (dev
->tv_freq
- 676 /* (43.25-1) * 16 */) % (6 * 16);
357 *afc
= freq_modulus
- 1 * 16;
358 return TPG_QUAL_GRAY
;
361 enum tpg_video_aspect
vivid_get_video_aspect(const struct vivid_dev
*dev
)
363 if (vivid_is_sdtv_cap(dev
))
364 return dev
->std_aspect_ratio
;
366 if (vivid_is_hdmi_cap(dev
))
367 return dev
->dv_timings_aspect_ratio
;
369 return TPG_VIDEO_ASPECT_IMAGE
;
372 static enum tpg_pixel_aspect
vivid_get_pixel_aspect(const struct vivid_dev
*dev
)
374 if (vivid_is_sdtv_cap(dev
))
375 return (dev
->std_cap
& V4L2_STD_525_60
) ?
376 TPG_PIXEL_ASPECT_NTSC
: TPG_PIXEL_ASPECT_PAL
;
378 if (vivid_is_hdmi_cap(dev
) &&
379 dev
->src_rect
.width
== 720 && dev
->src_rect
.height
<= 576)
380 return dev
->src_rect
.height
== 480 ?
381 TPG_PIXEL_ASPECT_NTSC
: TPG_PIXEL_ASPECT_PAL
;
383 return TPG_PIXEL_ASPECT_SQUARE
;
387 * Called whenever the format has to be reset which can occur when
388 * changing inputs, standard, timings, etc.
390 void vivid_update_format_cap(struct vivid_dev
*dev
, bool keep_controls
)
392 struct v4l2_bt_timings
*bt
= &dev
->dv_timings_cap
.bt
;
396 switch (dev
->input_type
[dev
->input
]) {
399 dev
->src_rect
.width
= webcam_sizes
[dev
->webcam_size_idx
].width
;
400 dev
->src_rect
.height
= webcam_sizes
[dev
->webcam_size_idx
].height
;
401 dev
->timeperframe_vid_cap
= webcam_intervals
[dev
->webcam_ival_idx
];
402 dev
->field_cap
= V4L2_FIELD_NONE
;
403 tpg_s_rgb_range(&dev
->tpg
, V4L2_DV_RGB_RANGE_AUTO
);
407 dev
->field_cap
= dev
->tv_field_cap
;
408 dev
->src_rect
.width
= 720;
409 if (dev
->std_cap
& V4L2_STD_525_60
) {
410 dev
->src_rect
.height
= 480;
411 dev
->timeperframe_vid_cap
= (struct v4l2_fract
) { 1001, 30000 };
412 dev
->service_set_cap
= V4L2_SLICED_CAPTION_525
;
414 dev
->src_rect
.height
= 576;
415 dev
->timeperframe_vid_cap
= (struct v4l2_fract
) { 1000, 25000 };
416 dev
->service_set_cap
= V4L2_SLICED_WSS_625
| V4L2_SLICED_TELETEXT_B
;
418 tpg_s_rgb_range(&dev
->tpg
, V4L2_DV_RGB_RANGE_AUTO
);
421 dev
->src_rect
.width
= bt
->width
;
422 dev
->src_rect
.height
= bt
->height
;
423 size
= V4L2_DV_BT_FRAME_WIDTH(bt
) * V4L2_DV_BT_FRAME_HEIGHT(bt
);
424 if (dev
->reduced_fps
&& can_reduce_fps(bt
)) {
425 pixelclock
= div_u64(bt
->pixelclock
* 1000, 1001);
426 bt
->flags
|= V4L2_DV_FL_REDUCED_FPS
;
428 pixelclock
= bt
->pixelclock
;
429 bt
->flags
&= ~V4L2_DV_FL_REDUCED_FPS
;
431 dev
->timeperframe_vid_cap
= (struct v4l2_fract
) {
432 size
/ 100, (u32
)pixelclock
/ 100
435 dev
->field_cap
= V4L2_FIELD_ALTERNATE
;
437 dev
->field_cap
= V4L2_FIELD_NONE
;
440 * We can be called from within s_ctrl, in that case we can't
441 * set/get controls. Luckily we don't need to in that case.
443 if (keep_controls
|| !dev
->colorspace
)
445 if (bt
->flags
& V4L2_DV_FL_IS_CE_VIDEO
) {
446 if (bt
->width
== 720 && bt
->height
<= 576)
447 v4l2_ctrl_s_ctrl(dev
->colorspace
, VIVID_CS_170M
);
449 v4l2_ctrl_s_ctrl(dev
->colorspace
, VIVID_CS_709
);
450 v4l2_ctrl_s_ctrl(dev
->real_rgb_range_cap
, 1);
452 v4l2_ctrl_s_ctrl(dev
->colorspace
, VIVID_CS_SRGB
);
453 v4l2_ctrl_s_ctrl(dev
->real_rgb_range_cap
, 0);
455 tpg_s_rgb_range(&dev
->tpg
, v4l2_ctrl_g_ctrl(dev
->rgb_range_cap
));
458 vivid_update_quality(dev
);
459 tpg_reset_source(&dev
->tpg
, dev
->src_rect
.width
, dev
->src_rect
.height
, dev
->field_cap
);
460 dev
->crop_cap
= dev
->src_rect
;
461 dev
->crop_bounds_cap
= dev
->src_rect
;
462 dev
->compose_cap
= dev
->crop_cap
;
463 if (V4L2_FIELD_HAS_T_OR_B(dev
->field_cap
))
464 dev
->compose_cap
.height
/= 2;
465 dev
->fmt_cap_rect
= dev
->compose_cap
;
466 tpg_s_video_aspect(&dev
->tpg
, vivid_get_video_aspect(dev
));
467 tpg_s_pixel_aspect(&dev
->tpg
, vivid_get_pixel_aspect(dev
));
468 tpg_update_mv_step(&dev
->tpg
);
471 /* Map the field to something that is valid for the current input */
472 static enum v4l2_field
vivid_field_cap(struct vivid_dev
*dev
, enum v4l2_field field
)
474 if (vivid_is_sdtv_cap(dev
)) {
476 case V4L2_FIELD_INTERLACED_TB
:
477 case V4L2_FIELD_INTERLACED_BT
:
478 case V4L2_FIELD_SEQ_TB
:
479 case V4L2_FIELD_SEQ_BT
:
481 case V4L2_FIELD_BOTTOM
:
482 case V4L2_FIELD_ALTERNATE
:
484 case V4L2_FIELD_INTERLACED
:
486 return V4L2_FIELD_INTERLACED
;
489 if (vivid_is_hdmi_cap(dev
))
490 return dev
->dv_timings_cap
.bt
.interlaced
? V4L2_FIELD_ALTERNATE
:
492 return V4L2_FIELD_NONE
;
495 static unsigned vivid_colorspace_cap(struct vivid_dev
*dev
)
497 if (!dev
->loop_video
|| vivid_is_webcam(dev
) || vivid_is_tv_cap(dev
))
498 return tpg_g_colorspace(&dev
->tpg
);
499 return dev
->colorspace_out
;
502 static unsigned vivid_xfer_func_cap(struct vivid_dev
*dev
)
504 if (!dev
->loop_video
|| vivid_is_webcam(dev
) || vivid_is_tv_cap(dev
))
505 return tpg_g_xfer_func(&dev
->tpg
);
506 return dev
->xfer_func_out
;
509 static unsigned vivid_ycbcr_enc_cap(struct vivid_dev
*dev
)
511 if (!dev
->loop_video
|| vivid_is_webcam(dev
) || vivid_is_tv_cap(dev
))
512 return tpg_g_ycbcr_enc(&dev
->tpg
);
513 return dev
->ycbcr_enc_out
;
516 static unsigned int vivid_hsv_enc_cap(struct vivid_dev
*dev
)
518 if (!dev
->loop_video
|| vivid_is_webcam(dev
) || vivid_is_tv_cap(dev
))
519 return tpg_g_hsv_enc(&dev
->tpg
);
520 return dev
->hsv_enc_out
;
523 static unsigned vivid_quantization_cap(struct vivid_dev
*dev
)
525 if (!dev
->loop_video
|| vivid_is_webcam(dev
) || vivid_is_tv_cap(dev
))
526 return tpg_g_quantization(&dev
->tpg
);
527 return dev
->quantization_out
;
530 int vivid_g_fmt_vid_cap(struct file
*file
, void *priv
,
531 struct v4l2_format
*f
)
533 struct vivid_dev
*dev
= video_drvdata(file
);
534 struct v4l2_pix_format_mplane
*mp
= &f
->fmt
.pix_mp
;
537 mp
->width
= dev
->fmt_cap_rect
.width
;
538 mp
->height
= dev
->fmt_cap_rect
.height
;
539 mp
->field
= dev
->field_cap
;
540 mp
->pixelformat
= dev
->fmt_cap
->fourcc
;
541 mp
->colorspace
= vivid_colorspace_cap(dev
);
542 mp
->xfer_func
= vivid_xfer_func_cap(dev
);
543 if (dev
->fmt_cap
->color_enc
== TGP_COLOR_ENC_HSV
)
544 mp
->hsv_enc
= vivid_hsv_enc_cap(dev
);
546 mp
->ycbcr_enc
= vivid_ycbcr_enc_cap(dev
);
547 mp
->quantization
= vivid_quantization_cap(dev
);
548 mp
->num_planes
= dev
->fmt_cap
->buffers
;
549 for (p
= 0; p
< mp
->num_planes
; p
++) {
550 mp
->plane_fmt
[p
].bytesperline
= tpg_g_bytesperline(&dev
->tpg
, p
);
551 mp
->plane_fmt
[p
].sizeimage
=
552 tpg_g_line_width(&dev
->tpg
, p
) * mp
->height
+
553 dev
->fmt_cap
->data_offset
[p
];
558 int vivid_try_fmt_vid_cap(struct file
*file
, void *priv
,
559 struct v4l2_format
*f
)
561 struct v4l2_pix_format_mplane
*mp
= &f
->fmt
.pix_mp
;
562 struct v4l2_plane_pix_format
*pfmt
= mp
->plane_fmt
;
563 struct vivid_dev
*dev
= video_drvdata(file
);
564 const struct vivid_fmt
*fmt
;
565 unsigned bytesperline
, max_bpl
;
570 fmt
= vivid_get_format(dev
, mp
->pixelformat
);
572 dprintk(dev
, 1, "Fourcc format (0x%08x) unknown.\n",
574 mp
->pixelformat
= V4L2_PIX_FMT_YUYV
;
575 fmt
= vivid_get_format(dev
, mp
->pixelformat
);
578 mp
->field
= vivid_field_cap(dev
, mp
->field
);
579 if (vivid_is_webcam(dev
)) {
580 const struct v4l2_frmsize_discrete
*sz
=
581 v4l2_find_nearest_format(&webcam_probe
, mp
->width
, mp
->height
);
585 } else if (vivid_is_sdtv_cap(dev
)) {
587 h
= (dev
->std_cap
& V4L2_STD_525_60
) ? 480 : 576;
589 w
= dev
->src_rect
.width
;
590 h
= dev
->src_rect
.height
;
592 if (V4L2_FIELD_HAS_T_OR_B(mp
->field
))
594 if (vivid_is_webcam(dev
) ||
595 (!dev
->has_scaler_cap
&& !dev
->has_crop_cap
&& !dev
->has_compose_cap
)) {
597 mp
->height
= h
/ factor
;
599 struct v4l2_rect r
= { 0, 0, mp
->width
, mp
->height
* factor
};
601 v4l2_rect_set_min_size(&r
, &vivid_min_rect
);
602 v4l2_rect_set_max_size(&r
, &vivid_max_rect
);
603 if (dev
->has_scaler_cap
&& !dev
->has_compose_cap
) {
604 struct v4l2_rect max_r
= { 0, 0, MAX_ZOOM
* w
, MAX_ZOOM
* h
};
606 v4l2_rect_set_max_size(&r
, &max_r
);
607 } else if (!dev
->has_scaler_cap
&& dev
->has_crop_cap
&& !dev
->has_compose_cap
) {
608 v4l2_rect_set_max_size(&r
, &dev
->src_rect
);
609 } else if (!dev
->has_scaler_cap
&& !dev
->has_crop_cap
) {
610 v4l2_rect_set_min_size(&r
, &dev
->src_rect
);
613 mp
->height
= r
.height
/ factor
;
616 /* This driver supports custom bytesperline values */
618 mp
->num_planes
= fmt
->buffers
;
619 for (p
= 0; p
< fmt
->buffers
; p
++) {
620 /* Calculate the minimum supported bytesperline value */
621 bytesperline
= (mp
->width
* fmt
->bit_depth
[p
]) >> 3;
622 /* Calculate the maximum supported bytesperline value */
623 max_bpl
= (MAX_ZOOM
* MAX_WIDTH
* fmt
->bit_depth
[p
]) >> 3;
625 if (pfmt
[p
].bytesperline
> max_bpl
)
626 pfmt
[p
].bytesperline
= max_bpl
;
627 if (pfmt
[p
].bytesperline
< bytesperline
)
628 pfmt
[p
].bytesperline
= bytesperline
;
630 pfmt
[p
].sizeimage
= (pfmt
[p
].bytesperline
* mp
->height
) /
631 fmt
->vdownsampling
[p
] + fmt
->data_offset
[p
];
633 memset(pfmt
[p
].reserved
, 0, sizeof(pfmt
[p
].reserved
));
635 for (p
= fmt
->buffers
; p
< fmt
->planes
; p
++)
636 pfmt
[0].sizeimage
+= (pfmt
[0].bytesperline
* mp
->height
*
637 (fmt
->bit_depth
[p
] / fmt
->vdownsampling
[p
])) /
638 (fmt
->bit_depth
[0] / fmt
->vdownsampling
[0]);
640 mp
->colorspace
= vivid_colorspace_cap(dev
);
641 if (fmt
->color_enc
== TGP_COLOR_ENC_HSV
)
642 mp
->hsv_enc
= vivid_hsv_enc_cap(dev
);
644 mp
->ycbcr_enc
= vivid_ycbcr_enc_cap(dev
);
645 mp
->xfer_func
= vivid_xfer_func_cap(dev
);
646 mp
->quantization
= vivid_quantization_cap(dev
);
647 memset(mp
->reserved
, 0, sizeof(mp
->reserved
));
651 int vivid_s_fmt_vid_cap(struct file
*file
, void *priv
,
652 struct v4l2_format
*f
)
654 struct v4l2_pix_format_mplane
*mp
= &f
->fmt
.pix_mp
;
655 struct vivid_dev
*dev
= video_drvdata(file
);
656 struct v4l2_rect
*crop
= &dev
->crop_cap
;
657 struct v4l2_rect
*compose
= &dev
->compose_cap
;
658 struct vb2_queue
*q
= &dev
->vb_vid_cap_q
;
659 int ret
= vivid_try_fmt_vid_cap(file
, priv
, f
);
667 if (vb2_is_busy(q
)) {
668 dprintk(dev
, 1, "%s device busy\n", __func__
);
672 if (dev
->overlay_cap_owner
&& dev
->fb_cap
.fmt
.pixelformat
!= mp
->pixelformat
) {
673 dprintk(dev
, 1, "overlay is active, can't change pixelformat\n");
677 dev
->fmt_cap
= vivid_get_format(dev
, mp
->pixelformat
);
678 if (V4L2_FIELD_HAS_T_OR_B(mp
->field
))
681 /* Note: the webcam input doesn't support scaling, cropping or composing */
683 if (!vivid_is_webcam(dev
) &&
684 (dev
->has_scaler_cap
|| dev
->has_crop_cap
|| dev
->has_compose_cap
)) {
685 struct v4l2_rect r
= { 0, 0, mp
->width
, mp
->height
};
687 if (dev
->has_scaler_cap
) {
688 if (dev
->has_compose_cap
)
689 v4l2_rect_map_inside(compose
, &r
);
692 if (dev
->has_crop_cap
&& !dev
->has_compose_cap
) {
693 struct v4l2_rect min_r
= {
696 factor
* r
.height
/ MAX_ZOOM
698 struct v4l2_rect max_r
= {
701 factor
* r
.height
* MAX_ZOOM
704 v4l2_rect_set_min_size(crop
, &min_r
);
705 v4l2_rect_set_max_size(crop
, &max_r
);
706 v4l2_rect_map_inside(crop
, &dev
->crop_bounds_cap
);
707 } else if (dev
->has_crop_cap
) {
708 struct v4l2_rect min_r
= {
710 compose
->width
/ MAX_ZOOM
,
711 factor
* compose
->height
/ MAX_ZOOM
713 struct v4l2_rect max_r
= {
715 compose
->width
* MAX_ZOOM
,
716 factor
* compose
->height
* MAX_ZOOM
719 v4l2_rect_set_min_size(crop
, &min_r
);
720 v4l2_rect_set_max_size(crop
, &max_r
);
721 v4l2_rect_map_inside(crop
, &dev
->crop_bounds_cap
);
723 } else if (dev
->has_crop_cap
&& !dev
->has_compose_cap
) {
725 v4l2_rect_set_size_to(crop
, &r
);
726 v4l2_rect_map_inside(crop
, &dev
->crop_bounds_cap
);
729 v4l2_rect_set_size_to(compose
, &r
);
730 } else if (!dev
->has_crop_cap
) {
731 v4l2_rect_map_inside(compose
, &r
);
734 v4l2_rect_set_max_size(crop
, &r
);
735 v4l2_rect_map_inside(crop
, &dev
->crop_bounds_cap
);
736 compose
->top
*= factor
;
737 compose
->height
*= factor
;
738 v4l2_rect_set_size_to(compose
, crop
);
739 v4l2_rect_map_inside(compose
, &r
);
740 compose
->top
/= factor
;
741 compose
->height
/= factor
;
743 } else if (vivid_is_webcam(dev
)) {
744 /* Guaranteed to be a match */
745 for (i
= 0; i
< ARRAY_SIZE(webcam_sizes
); i
++)
746 if (webcam_sizes
[i
].width
== mp
->width
&&
747 webcam_sizes
[i
].height
== mp
->height
)
749 dev
->webcam_size_idx
= i
;
750 if (dev
->webcam_ival_idx
>= 2 * (VIVID_WEBCAM_SIZES
- i
))
751 dev
->webcam_ival_idx
= 2 * (VIVID_WEBCAM_SIZES
- i
) - 1;
752 vivid_update_format_cap(dev
, false);
754 struct v4l2_rect r
= { 0, 0, mp
->width
, mp
->height
};
756 v4l2_rect_set_size_to(compose
, &r
);
758 v4l2_rect_set_size_to(crop
, &r
);
761 dev
->fmt_cap_rect
.width
= mp
->width
;
762 dev
->fmt_cap_rect
.height
= mp
->height
;
763 tpg_s_buf_height(&dev
->tpg
, mp
->height
);
764 tpg_s_fourcc(&dev
->tpg
, dev
->fmt_cap
->fourcc
);
765 for (p
= 0; p
< tpg_g_buffers(&dev
->tpg
); p
++)
766 tpg_s_bytesperline(&dev
->tpg
, p
, mp
->plane_fmt
[p
].bytesperline
);
767 dev
->field_cap
= mp
->field
;
768 if (dev
->field_cap
== V4L2_FIELD_ALTERNATE
)
769 tpg_s_field(&dev
->tpg
, V4L2_FIELD_TOP
, true);
771 tpg_s_field(&dev
->tpg
, dev
->field_cap
, false);
772 tpg_s_crop_compose(&dev
->tpg
, &dev
->crop_cap
, &dev
->compose_cap
);
773 if (vivid_is_sdtv_cap(dev
))
774 dev
->tv_field_cap
= mp
->field
;
775 tpg_update_mv_step(&dev
->tpg
);
779 int vidioc_g_fmt_vid_cap_mplane(struct file
*file
, void *priv
,
780 struct v4l2_format
*f
)
782 struct vivid_dev
*dev
= video_drvdata(file
);
784 if (!dev
->multiplanar
)
786 return vivid_g_fmt_vid_cap(file
, priv
, f
);
789 int vidioc_try_fmt_vid_cap_mplane(struct file
*file
, void *priv
,
790 struct v4l2_format
*f
)
792 struct vivid_dev
*dev
= video_drvdata(file
);
794 if (!dev
->multiplanar
)
796 return vivid_try_fmt_vid_cap(file
, priv
, f
);
799 int vidioc_s_fmt_vid_cap_mplane(struct file
*file
, void *priv
,
800 struct v4l2_format
*f
)
802 struct vivid_dev
*dev
= video_drvdata(file
);
804 if (!dev
->multiplanar
)
806 return vivid_s_fmt_vid_cap(file
, priv
, f
);
809 int vidioc_g_fmt_vid_cap(struct file
*file
, void *priv
,
810 struct v4l2_format
*f
)
812 struct vivid_dev
*dev
= video_drvdata(file
);
814 if (dev
->multiplanar
)
816 return fmt_sp2mp_func(file
, priv
, f
, vivid_g_fmt_vid_cap
);
819 int vidioc_try_fmt_vid_cap(struct file
*file
, void *priv
,
820 struct v4l2_format
*f
)
822 struct vivid_dev
*dev
= video_drvdata(file
);
824 if (dev
->multiplanar
)
826 return fmt_sp2mp_func(file
, priv
, f
, vivid_try_fmt_vid_cap
);
829 int vidioc_s_fmt_vid_cap(struct file
*file
, void *priv
,
830 struct v4l2_format
*f
)
832 struct vivid_dev
*dev
= video_drvdata(file
);
834 if (dev
->multiplanar
)
836 return fmt_sp2mp_func(file
, priv
, f
, vivid_s_fmt_vid_cap
);
839 int vivid_vid_cap_g_selection(struct file
*file
, void *priv
,
840 struct v4l2_selection
*sel
)
842 struct vivid_dev
*dev
= video_drvdata(file
);
844 if (!dev
->has_crop_cap
&& !dev
->has_compose_cap
)
846 if (sel
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
848 if (vivid_is_webcam(dev
))
851 sel
->r
.left
= sel
->r
.top
= 0;
852 switch (sel
->target
) {
853 case V4L2_SEL_TGT_CROP
:
854 if (!dev
->has_crop_cap
)
856 sel
->r
= dev
->crop_cap
;
858 case V4L2_SEL_TGT_CROP_DEFAULT
:
859 case V4L2_SEL_TGT_CROP_BOUNDS
:
860 if (!dev
->has_crop_cap
)
862 sel
->r
= dev
->src_rect
;
864 case V4L2_SEL_TGT_COMPOSE_BOUNDS
:
865 if (!dev
->has_compose_cap
)
867 sel
->r
= vivid_max_rect
;
869 case V4L2_SEL_TGT_COMPOSE
:
870 if (!dev
->has_compose_cap
)
872 sel
->r
= dev
->compose_cap
;
874 case V4L2_SEL_TGT_COMPOSE_DEFAULT
:
875 if (!dev
->has_compose_cap
)
877 sel
->r
= dev
->fmt_cap_rect
;
885 int vivid_vid_cap_s_selection(struct file
*file
, void *fh
, struct v4l2_selection
*s
)
887 struct vivid_dev
*dev
= video_drvdata(file
);
888 struct v4l2_rect
*crop
= &dev
->crop_cap
;
889 struct v4l2_rect
*compose
= &dev
->compose_cap
;
890 unsigned factor
= V4L2_FIELD_HAS_T_OR_B(dev
->field_cap
) ? 2 : 1;
893 if (!dev
->has_crop_cap
&& !dev
->has_compose_cap
)
895 if (s
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
897 if (vivid_is_webcam(dev
))
901 case V4L2_SEL_TGT_CROP
:
902 if (!dev
->has_crop_cap
)
904 ret
= vivid_vid_adjust_sel(s
->flags
, &s
->r
);
907 v4l2_rect_set_min_size(&s
->r
, &vivid_min_rect
);
908 v4l2_rect_set_max_size(&s
->r
, &dev
->src_rect
);
909 v4l2_rect_map_inside(&s
->r
, &dev
->crop_bounds_cap
);
911 s
->r
.height
/= factor
;
912 if (dev
->has_scaler_cap
) {
913 struct v4l2_rect fmt
= dev
->fmt_cap_rect
;
914 struct v4l2_rect max_rect
= {
916 s
->r
.width
* MAX_ZOOM
,
917 s
->r
.height
* MAX_ZOOM
919 struct v4l2_rect min_rect
= {
921 s
->r
.width
/ MAX_ZOOM
,
922 s
->r
.height
/ MAX_ZOOM
925 v4l2_rect_set_min_size(&fmt
, &min_rect
);
926 if (!dev
->has_compose_cap
)
927 v4l2_rect_set_max_size(&fmt
, &max_rect
);
928 if (!v4l2_rect_same_size(&dev
->fmt_cap_rect
, &fmt
) &&
929 vb2_is_busy(&dev
->vb_vid_cap_q
))
931 if (dev
->has_compose_cap
) {
932 v4l2_rect_set_min_size(compose
, &min_rect
);
933 v4l2_rect_set_max_size(compose
, &max_rect
);
935 dev
->fmt_cap_rect
= fmt
;
936 tpg_s_buf_height(&dev
->tpg
, fmt
.height
);
937 } else if (dev
->has_compose_cap
) {
938 struct v4l2_rect fmt
= dev
->fmt_cap_rect
;
940 v4l2_rect_set_min_size(&fmt
, &s
->r
);
941 if (!v4l2_rect_same_size(&dev
->fmt_cap_rect
, &fmt
) &&
942 vb2_is_busy(&dev
->vb_vid_cap_q
))
944 dev
->fmt_cap_rect
= fmt
;
945 tpg_s_buf_height(&dev
->tpg
, fmt
.height
);
946 v4l2_rect_set_size_to(compose
, &s
->r
);
947 v4l2_rect_map_inside(compose
, &dev
->fmt_cap_rect
);
949 if (!v4l2_rect_same_size(&s
->r
, &dev
->fmt_cap_rect
) &&
950 vb2_is_busy(&dev
->vb_vid_cap_q
))
952 v4l2_rect_set_size_to(&dev
->fmt_cap_rect
, &s
->r
);
953 v4l2_rect_set_size_to(compose
, &s
->r
);
954 v4l2_rect_map_inside(compose
, &dev
->fmt_cap_rect
);
955 tpg_s_buf_height(&dev
->tpg
, dev
->fmt_cap_rect
.height
);
958 s
->r
.height
*= factor
;
961 case V4L2_SEL_TGT_COMPOSE
:
962 if (!dev
->has_compose_cap
)
964 ret
= vivid_vid_adjust_sel(s
->flags
, &s
->r
);
967 v4l2_rect_set_min_size(&s
->r
, &vivid_min_rect
);
968 v4l2_rect_set_max_size(&s
->r
, &dev
->fmt_cap_rect
);
969 if (dev
->has_scaler_cap
) {
970 struct v4l2_rect max_rect
= {
972 dev
->src_rect
.width
* MAX_ZOOM
,
973 (dev
->src_rect
.height
/ factor
) * MAX_ZOOM
976 v4l2_rect_set_max_size(&s
->r
, &max_rect
);
977 if (dev
->has_crop_cap
) {
978 struct v4l2_rect min_rect
= {
980 s
->r
.width
/ MAX_ZOOM
,
981 (s
->r
.height
* factor
) / MAX_ZOOM
983 struct v4l2_rect max_rect
= {
985 s
->r
.width
* MAX_ZOOM
,
986 (s
->r
.height
* factor
) * MAX_ZOOM
989 v4l2_rect_set_min_size(crop
, &min_rect
);
990 v4l2_rect_set_max_size(crop
, &max_rect
);
991 v4l2_rect_map_inside(crop
, &dev
->crop_bounds_cap
);
993 } else if (dev
->has_crop_cap
) {
995 s
->r
.height
*= factor
;
996 v4l2_rect_set_max_size(&s
->r
, &dev
->src_rect
);
997 v4l2_rect_set_size_to(crop
, &s
->r
);
998 v4l2_rect_map_inside(crop
, &dev
->crop_bounds_cap
);
1000 s
->r
.height
/= factor
;
1002 v4l2_rect_set_size_to(&s
->r
, &dev
->src_rect
);
1003 s
->r
.height
/= factor
;
1005 v4l2_rect_map_inside(&s
->r
, &dev
->fmt_cap_rect
);
1006 if (dev
->bitmap_cap
&& (compose
->width
!= s
->r
.width
||
1007 compose
->height
!= s
->r
.height
)) {
1008 kfree(dev
->bitmap_cap
);
1009 dev
->bitmap_cap
= NULL
;
1017 tpg_s_crop_compose(&dev
->tpg
, crop
, compose
);
1021 int vivid_vid_cap_cropcap(struct file
*file
, void *priv
,
1022 struct v4l2_cropcap
*cap
)
1024 struct vivid_dev
*dev
= video_drvdata(file
);
1026 if (cap
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1029 switch (vivid_get_pixel_aspect(dev
)) {
1030 case TPG_PIXEL_ASPECT_NTSC
:
1031 cap
->pixelaspect
.numerator
= 11;
1032 cap
->pixelaspect
.denominator
= 10;
1034 case TPG_PIXEL_ASPECT_PAL
:
1035 cap
->pixelaspect
.numerator
= 54;
1036 cap
->pixelaspect
.denominator
= 59;
1038 case TPG_PIXEL_ASPECT_SQUARE
:
1039 cap
->pixelaspect
.numerator
= 1;
1040 cap
->pixelaspect
.denominator
= 1;
1046 int vidioc_enum_fmt_vid_overlay(struct file
*file
, void *priv
,
1047 struct v4l2_fmtdesc
*f
)
1049 struct vivid_dev
*dev
= video_drvdata(file
);
1050 const struct vivid_fmt
*fmt
;
1052 if (dev
->multiplanar
)
1055 if (f
->index
>= ARRAY_SIZE(formats_ovl
))
1058 fmt
= &formats_ovl
[f
->index
];
1060 f
->pixelformat
= fmt
->fourcc
;
1064 int vidioc_g_fmt_vid_overlay(struct file
*file
, void *priv
,
1065 struct v4l2_format
*f
)
1067 struct vivid_dev
*dev
= video_drvdata(file
);
1068 const struct v4l2_rect
*compose
= &dev
->compose_cap
;
1069 struct v4l2_window
*win
= &f
->fmt
.win
;
1070 unsigned clipcount
= win
->clipcount
;
1072 if (dev
->multiplanar
)
1075 win
->w
.top
= dev
->overlay_cap_top
;
1076 win
->w
.left
= dev
->overlay_cap_left
;
1077 win
->w
.width
= compose
->width
;
1078 win
->w
.height
= compose
->height
;
1079 win
->field
= dev
->overlay_cap_field
;
1080 win
->clipcount
= dev
->clipcount_cap
;
1081 if (clipcount
> dev
->clipcount_cap
)
1082 clipcount
= dev
->clipcount_cap
;
1083 if (dev
->bitmap_cap
== NULL
)
1085 else if (win
->bitmap
) {
1086 if (copy_to_user(win
->bitmap
, dev
->bitmap_cap
,
1087 ((compose
->width
+ 7) / 8) * compose
->height
))
1090 if (clipcount
&& win
->clips
) {
1091 if (copy_to_user(win
->clips
, dev
->clips_cap
,
1092 clipcount
* sizeof(dev
->clips_cap
[0])))
1098 int vidioc_try_fmt_vid_overlay(struct file
*file
, void *priv
,
1099 struct v4l2_format
*f
)
1101 struct vivid_dev
*dev
= video_drvdata(file
);
1102 const struct v4l2_rect
*compose
= &dev
->compose_cap
;
1103 struct v4l2_window
*win
= &f
->fmt
.win
;
1106 if (dev
->multiplanar
)
1109 win
->w
.left
= clamp_t(int, win
->w
.left
,
1110 -dev
->fb_cap
.fmt
.width
, dev
->fb_cap
.fmt
.width
);
1111 win
->w
.top
= clamp_t(int, win
->w
.top
,
1112 -dev
->fb_cap
.fmt
.height
, dev
->fb_cap
.fmt
.height
);
1113 win
->w
.width
= compose
->width
;
1114 win
->w
.height
= compose
->height
;
1115 if (win
->field
!= V4L2_FIELD_BOTTOM
&& win
->field
!= V4L2_FIELD_TOP
)
1116 win
->field
= V4L2_FIELD_ANY
;
1118 win
->global_alpha
= 0;
1119 if (win
->clipcount
&& !win
->clips
)
1121 if (win
->clipcount
> MAX_CLIPS
)
1122 win
->clipcount
= MAX_CLIPS
;
1123 if (win
->clipcount
) {
1124 if (copy_from_user(dev
->try_clips_cap
, win
->clips
,
1125 win
->clipcount
* sizeof(dev
->clips_cap
[0])))
1127 for (i
= 0; i
< win
->clipcount
; i
++) {
1128 struct v4l2_rect
*r
= &dev
->try_clips_cap
[i
].c
;
1130 r
->top
= clamp_t(s32
, r
->top
, 0, dev
->fb_cap
.fmt
.height
- 1);
1131 r
->height
= clamp_t(s32
, r
->height
, 1, dev
->fb_cap
.fmt
.height
- r
->top
);
1132 r
->left
= clamp_t(u32
, r
->left
, 0, dev
->fb_cap
.fmt
.width
- 1);
1133 r
->width
= clamp_t(u32
, r
->width
, 1, dev
->fb_cap
.fmt
.width
- r
->left
);
1136 * Yeah, so sue me, it's an O(n^2) algorithm. But n is a small
1137 * number and it's typically a one-time deal.
1139 for (i
= 0; i
< win
->clipcount
- 1; i
++) {
1140 struct v4l2_rect
*r1
= &dev
->try_clips_cap
[i
].c
;
1142 for (j
= i
+ 1; j
< win
->clipcount
; j
++) {
1143 struct v4l2_rect
*r2
= &dev
->try_clips_cap
[j
].c
;
1145 if (v4l2_rect_overlap(r1
, r2
))
1149 if (copy_to_user(win
->clips
, dev
->try_clips_cap
,
1150 win
->clipcount
* sizeof(dev
->clips_cap
[0])))
1156 int vidioc_s_fmt_vid_overlay(struct file
*file
, void *priv
,
1157 struct v4l2_format
*f
)
1159 struct vivid_dev
*dev
= video_drvdata(file
);
1160 const struct v4l2_rect
*compose
= &dev
->compose_cap
;
1161 struct v4l2_window
*win
= &f
->fmt
.win
;
1162 int ret
= vidioc_try_fmt_vid_overlay(file
, priv
, f
);
1163 unsigned bitmap_size
= ((compose
->width
+ 7) / 8) * compose
->height
;
1164 unsigned clips_size
= win
->clipcount
* sizeof(dev
->clips_cap
[0]);
1165 void *new_bitmap
= NULL
;
1171 new_bitmap
= vzalloc(bitmap_size
);
1173 if (new_bitmap
== NULL
)
1175 if (copy_from_user(new_bitmap
, win
->bitmap
, bitmap_size
)) {
1181 dev
->overlay_cap_top
= win
->w
.top
;
1182 dev
->overlay_cap_left
= win
->w
.left
;
1183 dev
->overlay_cap_field
= win
->field
;
1184 vfree(dev
->bitmap_cap
);
1185 dev
->bitmap_cap
= new_bitmap
;
1186 dev
->clipcount_cap
= win
->clipcount
;
1187 if (dev
->clipcount_cap
)
1188 memcpy(dev
->clips_cap
, dev
->try_clips_cap
, clips_size
);
1192 int vivid_vid_cap_overlay(struct file
*file
, void *fh
, unsigned i
)
1194 struct vivid_dev
*dev
= video_drvdata(file
);
1196 if (dev
->multiplanar
)
1199 if (i
&& dev
->fb_vbase_cap
== NULL
)
1202 if (i
&& dev
->fb_cap
.fmt
.pixelformat
!= dev
->fmt_cap
->fourcc
) {
1203 dprintk(dev
, 1, "mismatch between overlay and video capture pixelformats\n");
1207 if (dev
->overlay_cap_owner
&& dev
->overlay_cap_owner
!= fh
)
1209 dev
->overlay_cap_owner
= i
? fh
: NULL
;
1213 int vivid_vid_cap_g_fbuf(struct file
*file
, void *fh
,
1214 struct v4l2_framebuffer
*a
)
1216 struct vivid_dev
*dev
= video_drvdata(file
);
1218 if (dev
->multiplanar
)
1222 a
->capability
= V4L2_FBUF_CAP_BITMAP_CLIPPING
|
1223 V4L2_FBUF_CAP_LIST_CLIPPING
;
1224 a
->flags
= V4L2_FBUF_FLAG_PRIMARY
;
1225 a
->fmt
.field
= V4L2_FIELD_NONE
;
1226 a
->fmt
.colorspace
= V4L2_COLORSPACE_SRGB
;
1231 int vivid_vid_cap_s_fbuf(struct file
*file
, void *fh
,
1232 const struct v4l2_framebuffer
*a
)
1234 struct vivid_dev
*dev
= video_drvdata(file
);
1235 const struct vivid_fmt
*fmt
;
1237 if (dev
->multiplanar
)
1240 if (!capable(CAP_SYS_ADMIN
) && !capable(CAP_SYS_RAWIO
))
1243 if (dev
->overlay_cap_owner
)
1246 if (a
->base
== NULL
) {
1247 dev
->fb_cap
.base
= NULL
;
1248 dev
->fb_vbase_cap
= NULL
;
1252 if (a
->fmt
.width
< 48 || a
->fmt
.height
< 32)
1254 fmt
= vivid_get_format(dev
, a
->fmt
.pixelformat
);
1255 if (!fmt
|| !fmt
->can_do_overlay
)
1257 if (a
->fmt
.bytesperline
< (a
->fmt
.width
* fmt
->bit_depth
[0]) / 8)
1259 if (a
->fmt
.height
* a
->fmt
.bytesperline
< a
->fmt
.sizeimage
)
1262 dev
->fb_vbase_cap
= phys_to_virt((unsigned long)a
->base
);
1264 dev
->overlay_cap_left
= clamp_t(int, dev
->overlay_cap_left
,
1265 -dev
->fb_cap
.fmt
.width
, dev
->fb_cap
.fmt
.width
);
1266 dev
->overlay_cap_top
= clamp_t(int, dev
->overlay_cap_top
,
1267 -dev
->fb_cap
.fmt
.height
, dev
->fb_cap
.fmt
.height
);
1271 static const struct v4l2_audio vivid_audio_inputs
[] = {
1272 { 0, "TV", V4L2_AUDCAP_STEREO
},
1273 { 1, "Line-In", V4L2_AUDCAP_STEREO
},
1276 int vidioc_enum_input(struct file
*file
, void *priv
,
1277 struct v4l2_input
*inp
)
1279 struct vivid_dev
*dev
= video_drvdata(file
);
1281 if (inp
->index
>= dev
->num_inputs
)
1284 inp
->type
= V4L2_INPUT_TYPE_CAMERA
;
1285 switch (dev
->input_type
[inp
->index
]) {
1287 snprintf(inp
->name
, sizeof(inp
->name
), "Webcam %u",
1288 dev
->input_name_counter
[inp
->index
]);
1289 inp
->capabilities
= 0;
1292 snprintf(inp
->name
, sizeof(inp
->name
), "TV %u",
1293 dev
->input_name_counter
[inp
->index
]);
1294 inp
->type
= V4L2_INPUT_TYPE_TUNER
;
1295 inp
->std
= V4L2_STD_ALL
;
1296 if (dev
->has_audio_inputs
)
1297 inp
->audioset
= (1 << ARRAY_SIZE(vivid_audio_inputs
)) - 1;
1298 inp
->capabilities
= V4L2_IN_CAP_STD
;
1301 snprintf(inp
->name
, sizeof(inp
->name
), "S-Video %u",
1302 dev
->input_name_counter
[inp
->index
]);
1303 inp
->std
= V4L2_STD_ALL
;
1304 if (dev
->has_audio_inputs
)
1305 inp
->audioset
= (1 << ARRAY_SIZE(vivid_audio_inputs
)) - 1;
1306 inp
->capabilities
= V4L2_IN_CAP_STD
;
1309 snprintf(inp
->name
, sizeof(inp
->name
), "HDMI %u",
1310 dev
->input_name_counter
[inp
->index
]);
1311 inp
->capabilities
= V4L2_IN_CAP_DV_TIMINGS
;
1312 if (dev
->edid_blocks
== 0 ||
1313 dev
->dv_timings_signal_mode
== NO_SIGNAL
)
1314 inp
->status
|= V4L2_IN_ST_NO_SIGNAL
;
1315 else if (dev
->dv_timings_signal_mode
== NO_LOCK
||
1316 dev
->dv_timings_signal_mode
== OUT_OF_RANGE
)
1317 inp
->status
|= V4L2_IN_ST_NO_H_LOCK
;
1320 if (dev
->sensor_hflip
)
1321 inp
->status
|= V4L2_IN_ST_HFLIP
;
1322 if (dev
->sensor_vflip
)
1323 inp
->status
|= V4L2_IN_ST_VFLIP
;
1324 if (dev
->input
== inp
->index
&& vivid_is_sdtv_cap(dev
)) {
1325 if (dev
->std_signal_mode
== NO_SIGNAL
) {
1326 inp
->status
|= V4L2_IN_ST_NO_SIGNAL
;
1327 } else if (dev
->std_signal_mode
== NO_LOCK
) {
1328 inp
->status
|= V4L2_IN_ST_NO_H_LOCK
;
1329 } else if (vivid_is_tv_cap(dev
)) {
1330 switch (tpg_g_quality(&dev
->tpg
)) {
1332 inp
->status
|= V4L2_IN_ST_COLOR_KILL
;
1334 case TPG_QUAL_NOISE
:
1335 inp
->status
|= V4L2_IN_ST_NO_H_LOCK
;
1345 int vidioc_g_input(struct file
*file
, void *priv
, unsigned *i
)
1347 struct vivid_dev
*dev
= video_drvdata(file
);
1353 int vidioc_s_input(struct file
*file
, void *priv
, unsigned i
)
1355 struct vivid_dev
*dev
= video_drvdata(file
);
1356 struct v4l2_bt_timings
*bt
= &dev
->dv_timings_cap
.bt
;
1357 unsigned brightness
;
1359 if (i
>= dev
->num_inputs
)
1362 if (i
== dev
->input
)
1365 if (vb2_is_busy(&dev
->vb_vid_cap_q
) || vb2_is_busy(&dev
->vb_vbi_cap_q
))
1369 dev
->vid_cap_dev
.tvnorms
= 0;
1370 if (dev
->input_type
[i
] == TV
|| dev
->input_type
[i
] == SVID
) {
1371 dev
->tv_audio_input
= (dev
->input_type
[i
] == TV
) ? 0 : 1;
1372 dev
->vid_cap_dev
.tvnorms
= V4L2_STD_ALL
;
1374 dev
->vbi_cap_dev
.tvnorms
= dev
->vid_cap_dev
.tvnorms
;
1375 vivid_update_format_cap(dev
, false);
1377 if (dev
->colorspace
) {
1378 switch (dev
->input_type
[i
]) {
1380 v4l2_ctrl_s_ctrl(dev
->colorspace
, VIVID_CS_SRGB
);
1384 v4l2_ctrl_s_ctrl(dev
->colorspace
, VIVID_CS_170M
);
1387 if (bt
->flags
& V4L2_DV_FL_IS_CE_VIDEO
) {
1388 if (dev
->src_rect
.width
== 720 && dev
->src_rect
.height
<= 576)
1389 v4l2_ctrl_s_ctrl(dev
->colorspace
, VIVID_CS_170M
);
1391 v4l2_ctrl_s_ctrl(dev
->colorspace
, VIVID_CS_709
);
1393 v4l2_ctrl_s_ctrl(dev
->colorspace
, VIVID_CS_SRGB
);
1400 * Modify the brightness range depending on the input.
1401 * This makes it easy to use vivid to test if applications can
1402 * handle control range modifications and is also how this is
1403 * typically used in practice as different inputs may be hooked
1404 * up to different receivers with different control ranges.
1406 brightness
= 128 * i
+ dev
->input_brightness
[i
];
1407 v4l2_ctrl_modify_range(dev
->brightness
,
1408 128 * i
, 255 + 128 * i
, 1, 128 + 128 * i
);
1409 v4l2_ctrl_s_ctrl(dev
->brightness
, brightness
);
1413 int vidioc_enumaudio(struct file
*file
, void *fh
, struct v4l2_audio
*vin
)
1415 if (vin
->index
>= ARRAY_SIZE(vivid_audio_inputs
))
1417 *vin
= vivid_audio_inputs
[vin
->index
];
1421 int vidioc_g_audio(struct file
*file
, void *fh
, struct v4l2_audio
*vin
)
1423 struct vivid_dev
*dev
= video_drvdata(file
);
1425 if (!vivid_is_sdtv_cap(dev
))
1427 *vin
= vivid_audio_inputs
[dev
->tv_audio_input
];
1431 int vidioc_s_audio(struct file
*file
, void *fh
, const struct v4l2_audio
*vin
)
1433 struct vivid_dev
*dev
= video_drvdata(file
);
1435 if (!vivid_is_sdtv_cap(dev
))
1437 if (vin
->index
>= ARRAY_SIZE(vivid_audio_inputs
))
1439 dev
->tv_audio_input
= vin
->index
;
1443 int vivid_video_g_frequency(struct file
*file
, void *fh
, struct v4l2_frequency
*vf
)
1445 struct vivid_dev
*dev
= video_drvdata(file
);
1449 vf
->frequency
= dev
->tv_freq
;
1453 int vivid_video_s_frequency(struct file
*file
, void *fh
, const struct v4l2_frequency
*vf
)
1455 struct vivid_dev
*dev
= video_drvdata(file
);
1459 dev
->tv_freq
= clamp_t(unsigned, vf
->frequency
, MIN_TV_FREQ
, MAX_TV_FREQ
);
1460 if (vivid_is_tv_cap(dev
))
1461 vivid_update_quality(dev
);
1465 int vivid_video_s_tuner(struct file
*file
, void *fh
, const struct v4l2_tuner
*vt
)
1467 struct vivid_dev
*dev
= video_drvdata(file
);
1471 if (vt
->audmode
> V4L2_TUNER_MODE_LANG1_LANG2
)
1473 dev
->tv_audmode
= vt
->audmode
;
1477 int vivid_video_g_tuner(struct file
*file
, void *fh
, struct v4l2_tuner
*vt
)
1479 struct vivid_dev
*dev
= video_drvdata(file
);
1480 enum tpg_quality qual
;
1485 vt
->capability
= V4L2_TUNER_CAP_NORM
| V4L2_TUNER_CAP_STEREO
|
1486 V4L2_TUNER_CAP_LANG1
| V4L2_TUNER_CAP_LANG2
;
1487 vt
->audmode
= dev
->tv_audmode
;
1488 vt
->rangelow
= MIN_TV_FREQ
;
1489 vt
->rangehigh
= MAX_TV_FREQ
;
1490 qual
= vivid_get_quality(dev
, &vt
->afc
);
1491 if (qual
== TPG_QUAL_COLOR
)
1492 vt
->signal
= 0xffff;
1493 else if (qual
== TPG_QUAL_GRAY
)
1494 vt
->signal
= 0x8000;
1497 if (qual
== TPG_QUAL_NOISE
) {
1499 } else if (qual
== TPG_QUAL_GRAY
) {
1500 vt
->rxsubchans
= V4L2_TUNER_SUB_MONO
;
1502 unsigned channel_nr
= dev
->tv_freq
/ (6 * 16);
1503 unsigned options
= (dev
->std_cap
& V4L2_STD_NTSC_M
) ? 4 : 3;
1505 switch (channel_nr
% options
) {
1507 vt
->rxsubchans
= V4L2_TUNER_SUB_MONO
;
1510 vt
->rxsubchans
= V4L2_TUNER_SUB_STEREO
;
1513 if (dev
->std_cap
& V4L2_STD_NTSC_M
)
1514 vt
->rxsubchans
= V4L2_TUNER_SUB_MONO
| V4L2_TUNER_SUB_SAP
;
1516 vt
->rxsubchans
= V4L2_TUNER_SUB_LANG1
| V4L2_TUNER_SUB_LANG2
;
1519 vt
->rxsubchans
= V4L2_TUNER_SUB_STEREO
| V4L2_TUNER_SUB_SAP
;
1523 strlcpy(vt
->name
, "TV Tuner", sizeof(vt
->name
));
1527 /* Must remain in sync with the vivid_ctrl_standard_strings array */
1528 const v4l2_std_id vivid_standard
[] = {
1533 V4L2_STD_PAL_BG
| V4L2_STD_PAL_H
,
1540 V4L2_STD_SECAM_B
| V4L2_STD_SECAM_G
| V4L2_STD_SECAM_H
,
1547 /* Must remain in sync with the vivid_standard array */
1548 const char * const vivid_ctrl_standard_strings
[] = {
1567 int vidioc_querystd(struct file
*file
, void *priv
, v4l2_std_id
*id
)
1569 struct vivid_dev
*dev
= video_drvdata(file
);
1571 if (!vivid_is_sdtv_cap(dev
))
1573 if (dev
->std_signal_mode
== NO_SIGNAL
||
1574 dev
->std_signal_mode
== NO_LOCK
) {
1575 *id
= V4L2_STD_UNKNOWN
;
1578 if (vivid_is_tv_cap(dev
) && tpg_g_quality(&dev
->tpg
) == TPG_QUAL_NOISE
) {
1579 *id
= V4L2_STD_UNKNOWN
;
1580 } else if (dev
->std_signal_mode
== CURRENT_STD
) {
1582 } else if (dev
->std_signal_mode
== SELECTED_STD
) {
1583 *id
= dev
->query_std
;
1585 *id
= vivid_standard
[dev
->query_std_last
];
1586 dev
->query_std_last
= (dev
->query_std_last
+ 1) % ARRAY_SIZE(vivid_standard
);
1592 int vivid_vid_cap_s_std(struct file
*file
, void *priv
, v4l2_std_id id
)
1594 struct vivid_dev
*dev
= video_drvdata(file
);
1596 if (!vivid_is_sdtv_cap(dev
))
1598 if (dev
->std_cap
== id
)
1600 if (vb2_is_busy(&dev
->vb_vid_cap_q
) || vb2_is_busy(&dev
->vb_vbi_cap_q
))
1603 vivid_update_format_cap(dev
, false);
1607 static void find_aspect_ratio(u32 width
, u32 height
,
1608 u32
*num
, u32
*denom
)
1610 if (!(height
% 3) && ((height
* 4 / 3) == width
)) {
1613 } else if (!(height
% 9) && ((height
* 16 / 9) == width
)) {
1616 } else if (!(height
% 10) && ((height
* 16 / 10) == width
)) {
1619 } else if (!(height
% 4) && ((height
* 5 / 4) == width
)) {
1622 } else if (!(height
% 9) && ((height
* 15 / 9) == width
)) {
1625 } else { /* default to 16:9 */
1631 static bool valid_cvt_gtf_timings(struct v4l2_dv_timings
*timings
)
1633 struct v4l2_bt_timings
*bt
= &timings
->bt
;
1638 if (!v4l2_valid_dv_timings(timings
, &vivid_dv_timings_cap
,
1642 total_h_pixel
= V4L2_DV_BT_FRAME_WIDTH(bt
);
1643 total_v_lines
= V4L2_DV_BT_FRAME_HEIGHT(bt
);
1645 h_freq
= (u32
)bt
->pixelclock
/ total_h_pixel
;
1647 if (bt
->standards
== 0 || (bt
->standards
& V4L2_DV_BT_STD_CVT
)) {
1648 if (v4l2_detect_cvt(total_v_lines
, h_freq
, bt
->vsync
, bt
->width
,
1649 bt
->polarities
, bt
->interlaced
, timings
))
1653 if (bt
->standards
== 0 || (bt
->standards
& V4L2_DV_BT_STD_GTF
)) {
1654 struct v4l2_fract aspect_ratio
;
1656 find_aspect_ratio(bt
->width
, bt
->height
,
1657 &aspect_ratio
.numerator
,
1658 &aspect_ratio
.denominator
);
1659 if (v4l2_detect_gtf(total_v_lines
, h_freq
, bt
->vsync
,
1660 bt
->polarities
, bt
->interlaced
,
1661 aspect_ratio
, timings
))
1667 int vivid_vid_cap_s_dv_timings(struct file
*file
, void *_fh
,
1668 struct v4l2_dv_timings
*timings
)
1670 struct vivid_dev
*dev
= video_drvdata(file
);
1672 if (!vivid_is_hdmi_cap(dev
))
1674 if (!v4l2_find_dv_timings_cap(timings
, &vivid_dv_timings_cap
,
1676 !valid_cvt_gtf_timings(timings
))
1679 if (v4l2_match_dv_timings(timings
, &dev
->dv_timings_cap
, 0, false))
1681 if (vb2_is_busy(&dev
->vb_vid_cap_q
))
1684 dev
->dv_timings_cap
= *timings
;
1685 vivid_update_format_cap(dev
, false);
1689 int vidioc_query_dv_timings(struct file
*file
, void *_fh
,
1690 struct v4l2_dv_timings
*timings
)
1692 struct vivid_dev
*dev
= video_drvdata(file
);
1694 if (!vivid_is_hdmi_cap(dev
))
1696 if (dev
->dv_timings_signal_mode
== NO_SIGNAL
||
1697 dev
->edid_blocks
== 0)
1699 if (dev
->dv_timings_signal_mode
== NO_LOCK
)
1701 if (dev
->dv_timings_signal_mode
== OUT_OF_RANGE
) {
1702 timings
->bt
.pixelclock
= vivid_dv_timings_cap
.bt
.max_pixelclock
* 2;
1705 if (dev
->dv_timings_signal_mode
== CURRENT_DV_TIMINGS
) {
1706 *timings
= dev
->dv_timings_cap
;
1707 } else if (dev
->dv_timings_signal_mode
== SELECTED_DV_TIMINGS
) {
1708 *timings
= v4l2_dv_timings_presets
[dev
->query_dv_timings
];
1710 *timings
= v4l2_dv_timings_presets
[dev
->query_dv_timings_last
];
1711 dev
->query_dv_timings_last
= (dev
->query_dv_timings_last
+ 1) %
1712 dev
->query_dv_timings_size
;
1717 int vidioc_s_edid(struct file
*file
, void *_fh
,
1718 struct v4l2_edid
*edid
)
1720 struct vivid_dev
*dev
= video_drvdata(file
);
1725 memset(edid
->reserved
, 0, sizeof(edid
->reserved
));
1726 if (edid
->pad
>= dev
->num_inputs
)
1728 if (dev
->input_type
[edid
->pad
] != HDMI
|| edid
->start_block
)
1730 if (edid
->blocks
== 0) {
1731 dev
->edid_blocks
= 0;
1732 phys_addr
= CEC_PHYS_ADDR_INVALID
;
1735 if (edid
->blocks
> dev
->edid_max_blocks
) {
1736 edid
->blocks
= dev
->edid_max_blocks
;
1739 phys_addr
= cec_get_edid_phys_addr(edid
->edid
, edid
->blocks
* 128, NULL
);
1740 ret
= cec_phys_addr_validate(phys_addr
, &phys_addr
, NULL
);
1744 if (vb2_is_busy(&dev
->vb_vid_cap_q
))
1747 dev
->edid_blocks
= edid
->blocks
;
1748 memcpy(dev
->edid
, edid
->edid
, edid
->blocks
* 128);
1751 /* TODO: a proper hotplug detect cycle should be emulated here */
1752 cec_s_phys_addr(dev
->cec_rx_adap
, phys_addr
, false);
1754 for (i
= 0; i
< MAX_OUTPUTS
&& dev
->cec_tx_adap
[i
]; i
++)
1755 cec_s_phys_addr(dev
->cec_tx_adap
[i
],
1756 cec_phys_addr_for_input(phys_addr
, i
+ 1),
1761 int vidioc_enum_framesizes(struct file
*file
, void *fh
,
1762 struct v4l2_frmsizeenum
*fsize
)
1764 struct vivid_dev
*dev
= video_drvdata(file
);
1766 if (!vivid_is_webcam(dev
) && !dev
->has_scaler_cap
)
1768 if (vivid_get_format(dev
, fsize
->pixel_format
) == NULL
)
1770 if (vivid_is_webcam(dev
)) {
1771 if (fsize
->index
>= ARRAY_SIZE(webcam_sizes
))
1773 fsize
->type
= V4L2_FRMSIZE_TYPE_DISCRETE
;
1774 fsize
->discrete
= webcam_sizes
[fsize
->index
];
1779 fsize
->type
= V4L2_FRMSIZE_TYPE_STEPWISE
;
1780 fsize
->stepwise
.min_width
= MIN_WIDTH
;
1781 fsize
->stepwise
.max_width
= MAX_WIDTH
* MAX_ZOOM
;
1782 fsize
->stepwise
.step_width
= 2;
1783 fsize
->stepwise
.min_height
= MIN_HEIGHT
;
1784 fsize
->stepwise
.max_height
= MAX_HEIGHT
* MAX_ZOOM
;
1785 fsize
->stepwise
.step_height
= 2;
1789 /* timeperframe is arbitrary and continuous */
1790 int vidioc_enum_frameintervals(struct file
*file
, void *priv
,
1791 struct v4l2_frmivalenum
*fival
)
1793 struct vivid_dev
*dev
= video_drvdata(file
);
1794 const struct vivid_fmt
*fmt
;
1797 fmt
= vivid_get_format(dev
, fival
->pixel_format
);
1801 if (!vivid_is_webcam(dev
)) {
1804 if (fival
->width
< MIN_WIDTH
|| fival
->width
> MAX_WIDTH
* MAX_ZOOM
)
1806 if (fival
->height
< MIN_HEIGHT
|| fival
->height
> MAX_HEIGHT
* MAX_ZOOM
)
1808 fival
->type
= V4L2_FRMIVAL_TYPE_DISCRETE
;
1809 fival
->discrete
= dev
->timeperframe_vid_cap
;
1813 for (i
= 0; i
< ARRAY_SIZE(webcam_sizes
); i
++)
1814 if (fival
->width
== webcam_sizes
[i
].width
&&
1815 fival
->height
== webcam_sizes
[i
].height
)
1817 if (i
== ARRAY_SIZE(webcam_sizes
))
1819 if (fival
->index
>= 2 * (VIVID_WEBCAM_SIZES
- i
))
1821 fival
->type
= V4L2_FRMIVAL_TYPE_DISCRETE
;
1822 fival
->discrete
= webcam_intervals
[fival
->index
];
1826 int vivid_vid_cap_g_parm(struct file
*file
, void *priv
,
1827 struct v4l2_streamparm
*parm
)
1829 struct vivid_dev
*dev
= video_drvdata(file
);
1831 if (parm
->type
!= (dev
->multiplanar
?
1832 V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
:
1833 V4L2_BUF_TYPE_VIDEO_CAPTURE
))
1836 parm
->parm
.capture
.capability
= V4L2_CAP_TIMEPERFRAME
;
1837 parm
->parm
.capture
.timeperframe
= dev
->timeperframe_vid_cap
;
1838 parm
->parm
.capture
.readbuffers
= 1;
1842 #define FRACT_CMP(a, OP, b) \
1843 ((u64)(a).numerator * (b).denominator OP (u64)(b).numerator * (a).denominator)
1845 int vivid_vid_cap_s_parm(struct file
*file
, void *priv
,
1846 struct v4l2_streamparm
*parm
)
1848 struct vivid_dev
*dev
= video_drvdata(file
);
1849 unsigned ival_sz
= 2 * (VIVID_WEBCAM_SIZES
- dev
->webcam_size_idx
);
1850 struct v4l2_fract tpf
;
1853 if (parm
->type
!= (dev
->multiplanar
?
1854 V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
:
1855 V4L2_BUF_TYPE_VIDEO_CAPTURE
))
1857 if (!vivid_is_webcam(dev
))
1858 return vivid_vid_cap_g_parm(file
, priv
, parm
);
1860 tpf
= parm
->parm
.capture
.timeperframe
;
1862 if (tpf
.denominator
== 0)
1863 tpf
= webcam_intervals
[ival_sz
- 1];
1864 for (i
= 0; i
< ival_sz
; i
++)
1865 if (FRACT_CMP(tpf
, >=, webcam_intervals
[i
]))
1869 dev
->webcam_ival_idx
= i
;
1870 tpf
= webcam_intervals
[dev
->webcam_ival_idx
];
1871 tpf
= FRACT_CMP(tpf
, <, tpf_min
) ? tpf_min
: tpf
;
1872 tpf
= FRACT_CMP(tpf
, >, tpf_max
) ? tpf_max
: tpf
;
1874 /* resync the thread's timings */
1875 dev
->cap_seq_resync
= true;
1876 dev
->timeperframe_vid_cap
= tpf
;
1877 parm
->parm
.capture
.capability
= V4L2_CAP_TIMEPERFRAME
;
1878 parm
->parm
.capture
.timeperframe
= tpf
;
1879 parm
->parm
.capture
.readbuffers
= 1;