2 * vivid-kthread-cap.h - video/vbi capture thread 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/module.h>
21 #include <linux/errno.h>
22 #include <linux/kernel.h>
23 #include <linux/init.h>
24 #include <linux/sched.h>
25 #include <linux/slab.h>
26 #include <linux/font.h>
27 #include <linux/mutex.h>
28 #include <linux/videodev2.h>
29 #include <linux/kthread.h>
30 #include <linux/freezer.h>
31 #include <linux/random.h>
32 #include <linux/v4l2-dv-timings.h>
33 #include <asm/div64.h>
34 #include <media/videobuf2-vmalloc.h>
35 #include <media/v4l2-dv-timings.h>
36 #include <media/v4l2-ioctl.h>
37 #include <media/v4l2-fh.h>
38 #include <media/v4l2-event.h>
40 #include "vivid-core.h"
41 #include "vivid-vid-common.h"
42 #include "vivid-vid-cap.h"
43 #include "vivid-vid-out.h"
44 #include "vivid-radio-common.h"
45 #include "vivid-radio-rx.h"
46 #include "vivid-radio-tx.h"
47 #include "vivid-sdr-cap.h"
48 #include "vivid-vbi-cap.h"
49 #include "vivid-vbi-out.h"
50 #include "vivid-osd.h"
51 #include "vivid-ctrls.h"
52 #include "vivid-kthread-cap.h"
54 static inline v4l2_std_id
vivid_get_std_cap(const struct vivid_dev
*dev
)
56 if (vivid_is_sdtv_cap(dev
))
61 static void copy_pix(struct vivid_dev
*dev
, int win_y
, int win_x
,
62 u16
*cap
, const u16
*osd
)
65 int left
= dev
->overlay_out_left
;
66 int top
= dev
->overlay_out_top
;
67 int fb_x
= win_x
+ left
;
68 int fb_y
= win_y
+ top
;
73 if (dev
->bitmap_out
) {
74 const u8
*p
= dev
->bitmap_out
;
75 unsigned stride
= (dev
->compose_out
.width
+ 7) / 8;
77 win_x
-= dev
->compose_out
.left
;
78 win_y
-= dev
->compose_out
.top
;
79 if (!(p
[stride
* win_y
+ win_x
/ 8] & (1 << (win_x
& 7))))
83 for (i
= 0; i
< dev
->clipcount_out
; i
++) {
84 struct v4l2_rect
*r
= &dev
->clips_out
[i
].c
;
86 if (fb_y
>= r
->top
&& fb_y
< r
->top
+ r
->height
&&
87 fb_x
>= r
->left
&& fb_x
< r
->left
+ r
->width
)
90 if ((dev
->fbuf_out_flags
& V4L2_FBUF_FLAG_CHROMAKEY
) &&
91 *osd
!= dev
->chromakey_out
)
93 if ((dev
->fbuf_out_flags
& V4L2_FBUF_FLAG_SRC_CHROMAKEY
) &&
94 out
== dev
->chromakey_out
)
96 if (dev
->fmt_cap
->alpha_mask
) {
97 if ((dev
->fbuf_out_flags
& V4L2_FBUF_FLAG_GLOBAL_ALPHA
) &&
98 dev
->global_alpha_out
)
100 if ((dev
->fbuf_out_flags
& V4L2_FBUF_FLAG_LOCAL_ALPHA
) &&
101 *cap
& dev
->fmt_cap
->alpha_mask
)
103 if ((dev
->fbuf_out_flags
& V4L2_FBUF_FLAG_LOCAL_INV_ALPHA
) &&
104 !(*cap
& dev
->fmt_cap
->alpha_mask
))
110 static void blend_line(struct vivid_dev
*dev
, unsigned y_offset
, unsigned x_offset
,
111 u8
*vcapbuf
, const u8
*vosdbuf
,
112 unsigned width
, unsigned pixsize
)
116 for (x
= 0; x
< width
; x
++, vcapbuf
+= pixsize
, vosdbuf
+= pixsize
) {
117 copy_pix(dev
, y_offset
, x_offset
+ x
,
118 (u16
*)vcapbuf
, (const u16
*)vosdbuf
);
122 static void scale_line(const u8
*src
, u8
*dst
, unsigned srcw
, unsigned dstw
, unsigned twopixsize
)
124 /* Coarse scaling with Bresenham */
132 * We always combine two pixels to prevent color bleed in the packed
137 int_part
= srcw
/ dstw
;
138 fract_part
= srcw
% dstw
;
139 for (x
= 0; x
< dstw
; x
++, dst
+= twopixsize
) {
140 memcpy(dst
, src
+ src_x
* twopixsize
, twopixsize
);
151 * Precalculate the rectangles needed to perform video looping:
153 * The nominal pipeline is that the video output buffer is cropped by
154 * crop_out, scaled to compose_out, overlaid with the output overlay,
155 * cropped on the capture side by crop_cap and scaled again to the video
156 * capture buffer using compose_cap.
158 * To keep things efficient we calculate the intersection of compose_out
159 * and crop_cap (since that's the only part of the video that will
160 * actually end up in the capture buffer), determine which part of the
161 * video output buffer that is and which part of the video capture buffer
162 * so we can scale the video straight from the output buffer to the capture
163 * buffer without any intermediate steps.
165 * If we need to deal with an output overlay, then there is no choice and
166 * that intermediate step still has to be taken. For the output overlay
167 * support we calculate the intersection of the framebuffer and the overlay
168 * window (which may be partially or wholly outside of the framebuffer
169 * itself) and the intersection of that with loop_vid_copy (i.e. the part of
170 * the actual looped video that will be overlaid). The result is calculated
171 * both in framebuffer coordinates (loop_fb_copy) and compose_out coordinates
172 * (loop_vid_overlay). Finally calculate the part of the capture buffer that
173 * will receive that overlaid video.
175 static void vivid_precalc_copy_rects(struct vivid_dev
*dev
)
177 /* Framebuffer rectangle */
178 struct v4l2_rect r_fb
= {
179 0, 0, dev
->display_width
, dev
->display_height
181 /* Overlay window rectangle in framebuffer coordinates */
182 struct v4l2_rect r_overlay
= {
183 dev
->overlay_out_left
, dev
->overlay_out_top
,
184 dev
->compose_out
.width
, dev
->compose_out
.height
187 dev
->loop_vid_copy
= rect_intersect(&dev
->crop_cap
, &dev
->compose_out
);
189 dev
->loop_vid_out
= dev
->loop_vid_copy
;
190 rect_scale(&dev
->loop_vid_out
, &dev
->compose_out
, &dev
->crop_out
);
191 dev
->loop_vid_out
.left
+= dev
->crop_out
.left
;
192 dev
->loop_vid_out
.top
+= dev
->crop_out
.top
;
194 dev
->loop_vid_cap
= dev
->loop_vid_copy
;
195 rect_scale(&dev
->loop_vid_cap
, &dev
->crop_cap
, &dev
->compose_cap
);
198 "loop_vid_copy: %dx%d@%dx%d loop_vid_out: %dx%d@%dx%d loop_vid_cap: %dx%d@%dx%d\n",
199 dev
->loop_vid_copy
.width
, dev
->loop_vid_copy
.height
,
200 dev
->loop_vid_copy
.left
, dev
->loop_vid_copy
.top
,
201 dev
->loop_vid_out
.width
, dev
->loop_vid_out
.height
,
202 dev
->loop_vid_out
.left
, dev
->loop_vid_out
.top
,
203 dev
->loop_vid_cap
.width
, dev
->loop_vid_cap
.height
,
204 dev
->loop_vid_cap
.left
, dev
->loop_vid_cap
.top
);
206 r_overlay
= rect_intersect(&r_fb
, &r_overlay
);
208 /* shift r_overlay to the same origin as compose_out */
209 r_overlay
.left
+= dev
->compose_out
.left
- dev
->overlay_out_left
;
210 r_overlay
.top
+= dev
->compose_out
.top
- dev
->overlay_out_top
;
212 dev
->loop_vid_overlay
= rect_intersect(&r_overlay
, &dev
->loop_vid_copy
);
213 dev
->loop_fb_copy
= dev
->loop_vid_overlay
;
215 /* shift dev->loop_fb_copy back again to the fb origin */
216 dev
->loop_fb_copy
.left
-= dev
->compose_out
.left
- dev
->overlay_out_left
;
217 dev
->loop_fb_copy
.top
-= dev
->compose_out
.top
- dev
->overlay_out_top
;
219 dev
->loop_vid_overlay_cap
= dev
->loop_vid_overlay
;
220 rect_scale(&dev
->loop_vid_overlay_cap
, &dev
->crop_cap
, &dev
->compose_cap
);
223 "loop_fb_copy: %dx%d@%dx%d loop_vid_overlay: %dx%d@%dx%d loop_vid_overlay_cap: %dx%d@%dx%d\n",
224 dev
->loop_fb_copy
.width
, dev
->loop_fb_copy
.height
,
225 dev
->loop_fb_copy
.left
, dev
->loop_fb_copy
.top
,
226 dev
->loop_vid_overlay
.width
, dev
->loop_vid_overlay
.height
,
227 dev
->loop_vid_overlay
.left
, dev
->loop_vid_overlay
.top
,
228 dev
->loop_vid_overlay_cap
.width
, dev
->loop_vid_overlay_cap
.height
,
229 dev
->loop_vid_overlay_cap
.left
, dev
->loop_vid_overlay_cap
.top
);
232 static void *plane_vaddr(struct tpg_data
*tpg
, struct vivid_buffer
*buf
,
233 unsigned p
, unsigned bpl
[TPG_MAX_PLANES
], unsigned h
)
238 if (p
== 0 || tpg_g_buffers(tpg
) > 1)
239 return vb2_plane_vaddr(&buf
->vb
, p
);
240 vbuf
= vb2_plane_vaddr(&buf
->vb
, 0);
241 for (i
= 0; i
< p
; i
++)
242 vbuf
+= bpl
[i
] * h
/ tpg
->vdownsampling
[i
];
246 static int vivid_copy_buffer(struct vivid_dev
*dev
, unsigned p
, u8
*vcapbuf
,
247 struct vivid_buffer
*vid_cap_buf
)
249 bool blank
= dev
->must_blank
[vid_cap_buf
->vb
.v4l2_buf
.index
];
250 struct tpg_data
*tpg
= &dev
->tpg
;
251 struct vivid_buffer
*vid_out_buf
= NULL
;
252 unsigned vdiv
= dev
->fmt_out
->vdownsampling
[p
];
253 unsigned twopixsize
= tpg_g_twopixelsize(tpg
, p
);
254 unsigned img_width
= tpg_hdiv(tpg
, p
, dev
->compose_cap
.width
);
255 unsigned img_height
= dev
->compose_cap
.height
;
256 unsigned stride_cap
= tpg
->bytesperline
[p
];
257 unsigned stride_out
= dev
->bytesperline_out
[p
];
258 unsigned stride_osd
= dev
->display_byte_stride
;
259 unsigned hmax
= (img_height
* tpg
->perc_fill
) / 100;
263 bool blend
= dev
->bitmap_out
|| dev
->clipcount_out
|| dev
->fbuf_out_flags
;
264 /* Coarse scaling with Bresenham */
265 unsigned vid_out_int_part
;
266 unsigned vid_out_fract_part
;
267 unsigned vid_out_y
= 0;
268 unsigned vid_out_error
= 0;
269 unsigned vid_overlay_int_part
= 0;
270 unsigned vid_overlay_fract_part
= 0;
271 unsigned vid_overlay_y
= 0;
272 unsigned vid_overlay_error
= 0;
273 unsigned vid_cap_left
= tpg_hdiv(tpg
, p
, dev
->loop_vid_cap
.left
);
274 unsigned vid_cap_right
;
277 vid_out_int_part
= dev
->loop_vid_out
.height
/ dev
->loop_vid_cap
.height
;
278 vid_out_fract_part
= dev
->loop_vid_out
.height
% dev
->loop_vid_cap
.height
;
280 if (!list_empty(&dev
->vid_out_active
))
281 vid_out_buf
= list_entry(dev
->vid_out_active
.next
,
282 struct vivid_buffer
, list
);
283 if (vid_out_buf
== NULL
)
286 vid_cap_buf
->vb
.v4l2_buf
.field
= vid_out_buf
->vb
.v4l2_buf
.field
;
288 voutbuf
= plane_vaddr(tpg
, vid_out_buf
, p
,
289 dev
->bytesperline_out
, dev
->fmt_out_rect
.height
);
290 if (p
< dev
->fmt_out
->buffers
)
291 voutbuf
+= vid_out_buf
->vb
.v4l2_planes
[p
].data_offset
;
292 voutbuf
+= tpg_hdiv(tpg
, p
, dev
->loop_vid_out
.left
) +
293 (dev
->loop_vid_out
.top
/ vdiv
) * stride_out
;
294 vcapbuf
+= tpg_hdiv(tpg
, p
, dev
->compose_cap
.left
) +
295 (dev
->compose_cap
.top
/ vdiv
) * stride_cap
;
297 if (dev
->loop_vid_copy
.width
== 0 || dev
->loop_vid_copy
.height
== 0) {
299 * If there is nothing to copy, then just fill the capture window
302 for (y
= 0; y
< hmax
/ vdiv
; y
++, vcapbuf
+= stride_cap
)
303 memcpy(vcapbuf
, tpg
->black_line
[p
], img_width
);
307 if (dev
->overlay_out_enabled
&&
308 dev
->loop_vid_overlay
.width
&& dev
->loop_vid_overlay
.height
) {
309 vosdbuf
= dev
->video_vbase
;
310 vosdbuf
+= (dev
->loop_fb_copy
.left
* twopixsize
) / 2 +
311 dev
->loop_fb_copy
.top
* stride_osd
;
312 vid_overlay_int_part
= dev
->loop_vid_overlay
.height
/
313 dev
->loop_vid_overlay_cap
.height
;
314 vid_overlay_fract_part
= dev
->loop_vid_overlay
.height
%
315 dev
->loop_vid_overlay_cap
.height
;
318 vid_cap_right
= tpg_hdiv(tpg
, p
, dev
->loop_vid_cap
.left
+ dev
->loop_vid_cap
.width
);
319 /* quick is true if no video scaling is needed */
320 quick
= dev
->loop_vid_out
.width
== dev
->loop_vid_cap
.width
;
322 dev
->cur_scaled_line
= dev
->loop_vid_out
.height
;
323 for (y
= 0; y
< hmax
; y
+= vdiv
, vcapbuf
+= stride_cap
) {
324 /* osdline is true if this line requires overlay blending */
325 bool osdline
= vosdbuf
&& y
>= dev
->loop_vid_overlay_cap
.top
&&
326 y
< dev
->loop_vid_overlay_cap
.top
+ dev
->loop_vid_overlay_cap
.height
;
329 * If this line of the capture buffer doesn't get any video, then
330 * just fill with black.
332 if (y
< dev
->loop_vid_cap
.top
||
333 y
>= dev
->loop_vid_cap
.top
+ dev
->loop_vid_cap
.height
) {
334 memcpy(vcapbuf
, tpg
->black_line
[p
], img_width
);
338 /* fill the left border with black */
339 if (dev
->loop_vid_cap
.left
)
340 memcpy(vcapbuf
, tpg
->black_line
[p
], vid_cap_left
);
342 /* fill the right border with black */
343 if (vid_cap_right
< img_width
)
344 memcpy(vcapbuf
+ vid_cap_right
, tpg
->black_line
[p
],
345 img_width
- vid_cap_right
);
347 if (quick
&& !osdline
) {
348 memcpy(vcapbuf
+ vid_cap_left
,
349 voutbuf
+ vid_out_y
* stride_out
,
350 tpg_hdiv(tpg
, p
, dev
->loop_vid_cap
.width
));
351 goto update_vid_out_y
;
353 if (dev
->cur_scaled_line
== vid_out_y
) {
354 memcpy(vcapbuf
+ vid_cap_left
, dev
->scaled_line
,
355 tpg_hdiv(tpg
, p
, dev
->loop_vid_cap
.width
));
356 goto update_vid_out_y
;
359 scale_line(voutbuf
+ vid_out_y
* stride_out
, dev
->scaled_line
,
360 tpg_hdiv(tpg
, p
, dev
->loop_vid_out
.width
),
361 tpg_hdiv(tpg
, p
, dev
->loop_vid_cap
.width
),
362 tpg_g_twopixelsize(tpg
, p
));
365 * Offset in bytes within loop_vid_copy to the start of the
366 * loop_vid_overlay rectangle.
369 ((dev
->loop_vid_overlay
.left
- dev
->loop_vid_copy
.left
) *
371 u8
*osd
= vosdbuf
+ vid_overlay_y
* stride_osd
;
373 scale_line(voutbuf
+ vid_out_y
* stride_out
, dev
->blended_line
,
374 dev
->loop_vid_out
.width
, dev
->loop_vid_copy
.width
,
375 tpg_g_twopixelsize(tpg
, p
));
377 blend_line(dev
, vid_overlay_y
+ dev
->loop_vid_overlay
.top
,
378 dev
->loop_vid_overlay
.left
,
379 dev
->blended_line
+ offset
, osd
,
380 dev
->loop_vid_overlay
.width
, twopixsize
/ 2);
382 memcpy(dev
->blended_line
+ offset
,
383 osd
, (dev
->loop_vid_overlay
.width
* twopixsize
) / 2);
384 scale_line(dev
->blended_line
, dev
->scaled_line
,
385 dev
->loop_vid_copy
.width
, dev
->loop_vid_cap
.width
,
386 tpg_g_twopixelsize(tpg
, p
));
388 dev
->cur_scaled_line
= vid_out_y
;
389 memcpy(vcapbuf
+ vid_cap_left
, dev
->scaled_line
,
390 tpg_hdiv(tpg
, p
, dev
->loop_vid_cap
.width
));
394 vid_overlay_y
+= vid_overlay_int_part
;
395 vid_overlay_error
+= vid_overlay_fract_part
;
396 if (vid_overlay_error
>= dev
->loop_vid_overlay_cap
.height
) {
397 vid_overlay_error
-= dev
->loop_vid_overlay_cap
.height
;
401 vid_out_y
+= vid_out_int_part
;
402 vid_out_error
+= vid_out_fract_part
;
403 if (vid_out_error
>= dev
->loop_vid_cap
.height
/ vdiv
) {
404 vid_out_error
-= dev
->loop_vid_cap
.height
/ vdiv
;
411 for (; y
< img_height
; y
+= vdiv
, vcapbuf
+= stride_cap
)
412 memcpy(vcapbuf
, tpg
->contrast_line
[p
], img_width
);
416 static void vivid_fillbuff(struct vivid_dev
*dev
, struct vivid_buffer
*buf
)
418 struct tpg_data
*tpg
= &dev
->tpg
;
419 unsigned factor
= V4L2_FIELD_HAS_T_OR_B(dev
->field_cap
) ? 2 : 1;
420 unsigned line_height
= 16 / factor
;
421 bool is_tv
= vivid_is_sdtv_cap(dev
);
422 bool is_60hz
= is_tv
&& (dev
->std_cap
& V4L2_STD_525_60
);
425 u8
*basep
[TPG_MAX_PLANES
][2];
429 bool is_loop
= false;
431 if (dev
->loop_video
&& dev
->can_loop_video
&&
432 ((vivid_is_svid_cap(dev
) && !VIVID_INVALID_SIGNAL(dev
->std_signal_mode
)) ||
433 (vivid_is_hdmi_cap(dev
) && !VIVID_INVALID_SIGNAL(dev
->dv_timings_signal_mode
))))
436 buf
->vb
.v4l2_buf
.sequence
= dev
->vid_cap_seq_count
;
438 * Take the timestamp now if the timestamp source is set to
439 * "Start of Exposure".
441 if (dev
->tstamp_src_is_soe
)
442 v4l2_get_timestamp(&buf
->vb
.v4l2_buf
.timestamp
);
443 if (dev
->field_cap
== V4L2_FIELD_ALTERNATE
) {
445 * 60 Hz standards start with the bottom field, 50 Hz standards
446 * with the top field. So if the 0-based seq_count is even,
447 * then the field is TOP for 50 Hz and BOTTOM for 60 Hz
450 buf
->vb
.v4l2_buf
.field
= ((dev
->vid_cap_seq_count
& 1) ^ is_60hz
) ?
451 V4L2_FIELD_BOTTOM
: V4L2_FIELD_TOP
;
453 * The sequence counter counts frames, not fields. So divide
456 buf
->vb
.v4l2_buf
.sequence
/= 2;
458 buf
->vb
.v4l2_buf
.field
= dev
->field_cap
;
460 tpg_s_field(tpg
, buf
->vb
.v4l2_buf
.field
,
461 dev
->field_cap
== V4L2_FIELD_ALTERNATE
);
462 tpg_s_perc_fill_blank(tpg
, dev
->must_blank
[buf
->vb
.v4l2_buf
.index
]);
464 vivid_precalc_copy_rects(dev
);
466 for (p
= 0; p
< tpg_g_planes(tpg
); p
++) {
467 void *vbuf
= plane_vaddr(tpg
, buf
, p
,
468 tpg
->bytesperline
, tpg
->buf_height
);
471 * The first plane of a multiplanar format has a non-zero
472 * data_offset. This helps testing whether the application
473 * correctly supports non-zero data offsets.
475 if (p
< tpg_g_buffers(tpg
) && dev
->fmt_cap
->data_offset
[p
]) {
476 memset(vbuf
, dev
->fmt_cap
->data_offset
[p
] & 0xff,
477 dev
->fmt_cap
->data_offset
[p
]);
478 vbuf
+= dev
->fmt_cap
->data_offset
[p
];
480 tpg_calc_text_basep(tpg
, basep
, p
, vbuf
);
481 if (!is_loop
|| vivid_copy_buffer(dev
, p
, vbuf
, buf
))
482 tpg_fill_plane_buffer(tpg
, vivid_get_std_cap(dev
), p
, vbuf
);
484 dev
->must_blank
[buf
->vb
.v4l2_buf
.index
] = false;
486 /* Updates stream time, only update at the start of a new frame. */
487 if (dev
->field_cap
!= V4L2_FIELD_ALTERNATE
|| (buf
->vb
.v4l2_buf
.sequence
& 1) == 0)
488 dev
->ms_vid_cap
= jiffies_to_msecs(jiffies
- dev
->jiffies_vid_cap
);
490 ms
= dev
->ms_vid_cap
;
491 if (dev
->osd_mode
<= 1) {
492 snprintf(str
, sizeof(str
), " %02d:%02d:%02d:%03d %u%s",
493 (ms
/ (60 * 60 * 1000)) % 24,
494 (ms
/ (60 * 1000)) % 60,
497 buf
->vb
.v4l2_buf
.sequence
,
498 (dev
->field_cap
== V4L2_FIELD_ALTERNATE
) ?
499 (buf
->vb
.v4l2_buf
.field
== V4L2_FIELD_TOP
?
500 " top" : " bottom") : "");
501 tpg_gen_text(tpg
, basep
, line
++ * line_height
, 16, str
);
503 if (dev
->osd_mode
== 0) {
504 snprintf(str
, sizeof(str
), " %dx%d, input %d ",
505 dev
->src_rect
.width
, dev
->src_rect
.height
, dev
->input
);
506 tpg_gen_text(tpg
, basep
, line
++ * line_height
, 16, str
);
508 gain
= v4l2_ctrl_g_ctrl(dev
->gain
);
509 mutex_lock(dev
->ctrl_hdl_user_vid
.lock
);
510 snprintf(str
, sizeof(str
),
511 " brightness %3d, contrast %3d, saturation %3d, hue %d ",
512 dev
->brightness
->cur
.val
,
513 dev
->contrast
->cur
.val
,
514 dev
->saturation
->cur
.val
,
516 tpg_gen_text(tpg
, basep
, line
++ * line_height
, 16, str
);
517 snprintf(str
, sizeof(str
),
518 " autogain %d, gain %3d, alpha 0x%02x ",
519 dev
->autogain
->cur
.val
, gain
, dev
->alpha
->cur
.val
);
520 mutex_unlock(dev
->ctrl_hdl_user_vid
.lock
);
521 tpg_gen_text(tpg
, basep
, line
++ * line_height
, 16, str
);
522 mutex_lock(dev
->ctrl_hdl_user_aud
.lock
);
523 snprintf(str
, sizeof(str
),
524 " volume %3d, mute %d ",
525 dev
->volume
->cur
.val
, dev
->mute
->cur
.val
);
526 mutex_unlock(dev
->ctrl_hdl_user_aud
.lock
);
527 tpg_gen_text(tpg
, basep
, line
++ * line_height
, 16, str
);
528 mutex_lock(dev
->ctrl_hdl_user_gen
.lock
);
529 snprintf(str
, sizeof(str
), " int32 %d, int64 %lld, bitmask %08x ",
531 *dev
->int64
->p_cur
.p_s64
,
532 dev
->bitmask
->cur
.val
);
533 tpg_gen_text(tpg
, basep
, line
++ * line_height
, 16, str
);
534 snprintf(str
, sizeof(str
), " boolean %d, menu %s, string \"%s\" ",
535 dev
->boolean
->cur
.val
,
536 dev
->menu
->qmenu
[dev
->menu
->cur
.val
],
537 dev
->string
->p_cur
.p_char
);
538 tpg_gen_text(tpg
, basep
, line
++ * line_height
, 16, str
);
539 snprintf(str
, sizeof(str
), " integer_menu %lld, value %d ",
540 dev
->int_menu
->qmenu_int
[dev
->int_menu
->cur
.val
],
541 dev
->int_menu
->cur
.val
);
542 mutex_unlock(dev
->ctrl_hdl_user_gen
.lock
);
543 tpg_gen_text(tpg
, basep
, line
++ * line_height
, 16, str
);
544 if (dev
->button_pressed
) {
545 dev
->button_pressed
--;
546 snprintf(str
, sizeof(str
), " button pressed!");
547 tpg_gen_text(tpg
, basep
, line
++ * line_height
, 16, str
);
552 * If "End of Frame" is specified at the timestamp source, then take
555 if (!dev
->tstamp_src_is_soe
)
556 v4l2_get_timestamp(&buf
->vb
.v4l2_buf
.timestamp
);
557 buf
->vb
.v4l2_buf
.timestamp
.tv_sec
+= dev
->time_wrap_offset
;
561 * Return true if this pixel coordinate is a valid video pixel.
563 static bool valid_pix(struct vivid_dev
*dev
, int win_y
, int win_x
, int fb_y
, int fb_x
)
567 if (dev
->bitmap_cap
) {
569 * Only if the corresponding bit in the bitmap is set can
570 * the video pixel be shown. Coordinates are relative to
571 * the overlay window set by VIDIOC_S_FMT.
573 const u8
*p
= dev
->bitmap_cap
;
574 unsigned stride
= (dev
->compose_cap
.width
+ 7) / 8;
576 if (!(p
[stride
* win_y
+ win_x
/ 8] & (1 << (win_x
& 7))))
580 for (i
= 0; i
< dev
->clipcount_cap
; i
++) {
582 * Only if the framebuffer coordinate is not in any of the
583 * clip rectangles will be video pixel be shown.
585 struct v4l2_rect
*r
= &dev
->clips_cap
[i
].c
;
587 if (fb_y
>= r
->top
&& fb_y
< r
->top
+ r
->height
&&
588 fb_x
>= r
->left
&& fb_x
< r
->left
+ r
->width
)
595 * Draw the image into the overlay buffer.
596 * Note that the combination of overlay and multiplanar is not supported.
598 static void vivid_overlay(struct vivid_dev
*dev
, struct vivid_buffer
*buf
)
600 struct tpg_data
*tpg
= &dev
->tpg
;
601 unsigned pixsize
= tpg_g_twopixelsize(tpg
, 0) / 2;
602 void *vbase
= dev
->fb_vbase_cap
;
603 void *vbuf
= vb2_plane_vaddr(&buf
->vb
, 0);
604 unsigned img_width
= dev
->compose_cap
.width
;
605 unsigned img_height
= dev
->compose_cap
.height
;
606 unsigned stride
= tpg
->bytesperline
[0];
607 /* if quick is true, then valid_pix() doesn't have to be called */
608 bool quick
= dev
->bitmap_cap
== NULL
&& dev
->clipcount_cap
== 0;
609 int x
, y
, w
, out_x
= 0;
612 * Overlay support is only supported for formats that have a twopixelsize
613 * that's >= 2. Warn and bail out if that's not the case.
615 if (WARN_ON(pixsize
== 0))
617 if ((dev
->overlay_cap_field
== V4L2_FIELD_TOP
||
618 dev
->overlay_cap_field
== V4L2_FIELD_BOTTOM
) &&
619 dev
->overlay_cap_field
!= buf
->vb
.v4l2_buf
.field
)
622 vbuf
+= dev
->compose_cap
.left
* pixsize
+ dev
->compose_cap
.top
* stride
;
623 x
= dev
->overlay_cap_left
;
630 w
= dev
->fb_cap
.fmt
.width
- x
;
636 if (dev
->overlay_cap_top
>= 0)
637 vbase
+= dev
->overlay_cap_top
* dev
->fb_cap
.fmt
.bytesperline
;
638 for (y
= dev
->overlay_cap_top
;
639 y
< dev
->overlay_cap_top
+ (int)img_height
;
640 y
++, vbuf
+= stride
) {
643 if (y
< 0 || y
> dev
->fb_cap
.fmt
.height
)
646 memcpy(vbase
+ x
* pixsize
,
647 vbuf
+ out_x
* pixsize
, w
* pixsize
);
648 vbase
+= dev
->fb_cap
.fmt
.bytesperline
;
651 for (px
= 0; px
< w
; px
++) {
652 if (!valid_pix(dev
, y
- dev
->overlay_cap_top
,
653 px
+ out_x
, y
, px
+ x
))
655 memcpy(vbase
+ (px
+ x
) * pixsize
,
656 vbuf
+ (px
+ out_x
) * pixsize
,
659 vbase
+= dev
->fb_cap
.fmt
.bytesperline
;
663 static void vivid_thread_vid_cap_tick(struct vivid_dev
*dev
, int dropped_bufs
)
665 struct vivid_buffer
*vid_cap_buf
= NULL
;
666 struct vivid_buffer
*vbi_cap_buf
= NULL
;
668 dprintk(dev
, 1, "Video Capture Thread Tick\n");
670 while (dropped_bufs
-- > 1)
671 tpg_update_mv_count(&dev
->tpg
,
672 dev
->field_cap
== V4L2_FIELD_NONE
||
673 dev
->field_cap
== V4L2_FIELD_ALTERNATE
);
675 /* Drop a certain percentage of buffers. */
676 if (dev
->perc_dropped_buffers
&&
677 prandom_u32_max(100) < dev
->perc_dropped_buffers
)
680 spin_lock(&dev
->slock
);
681 if (!list_empty(&dev
->vid_cap_active
)) {
682 vid_cap_buf
= list_entry(dev
->vid_cap_active
.next
, struct vivid_buffer
, list
);
683 list_del(&vid_cap_buf
->list
);
685 if (!list_empty(&dev
->vbi_cap_active
)) {
686 if (dev
->field_cap
!= V4L2_FIELD_ALTERNATE
||
687 (dev
->vbi_cap_seq_count
& 1)) {
688 vbi_cap_buf
= list_entry(dev
->vbi_cap_active
.next
,
689 struct vivid_buffer
, list
);
690 list_del(&vbi_cap_buf
->list
);
693 spin_unlock(&dev
->slock
);
695 if (!vid_cap_buf
&& !vbi_cap_buf
)
700 vivid_fillbuff(dev
, vid_cap_buf
);
701 dprintk(dev
, 1, "filled buffer %d\n",
702 vid_cap_buf
->vb
.v4l2_buf
.index
);
705 if (dev
->overlay_cap_owner
&& dev
->fb_cap
.base
&&
706 dev
->fb_cap
.fmt
.pixelformat
== dev
->fmt_cap
->fourcc
)
707 vivid_overlay(dev
, vid_cap_buf
);
709 vb2_buffer_done(&vid_cap_buf
->vb
, dev
->dqbuf_error
?
710 VB2_BUF_STATE_ERROR
: VB2_BUF_STATE_DONE
);
711 dprintk(dev
, 2, "vid_cap buffer %d done\n",
712 vid_cap_buf
->vb
.v4l2_buf
.index
);
716 if (dev
->stream_sliced_vbi_cap
)
717 vivid_sliced_vbi_cap_process(dev
, vbi_cap_buf
);
719 vivid_raw_vbi_cap_process(dev
, vbi_cap_buf
);
720 vb2_buffer_done(&vbi_cap_buf
->vb
, dev
->dqbuf_error
?
721 VB2_BUF_STATE_ERROR
: VB2_BUF_STATE_DONE
);
722 dprintk(dev
, 2, "vbi_cap %d done\n",
723 vbi_cap_buf
->vb
.v4l2_buf
.index
);
725 dev
->dqbuf_error
= false;
728 /* Update the test pattern movement counters */
729 tpg_update_mv_count(&dev
->tpg
, dev
->field_cap
== V4L2_FIELD_NONE
||
730 dev
->field_cap
== V4L2_FIELD_ALTERNATE
);
733 static int vivid_thread_vid_cap(void *data
)
735 struct vivid_dev
*dev
= data
;
736 u64 numerators_since_start
;
737 u64 buffers_since_start
;
738 u64 next_jiffies_since_start
;
739 unsigned long jiffies_since_start
;
740 unsigned long cur_jiffies
;
741 unsigned wait_jiffies
;
743 unsigned denominator
;
746 dprintk(dev
, 1, "Video Capture Thread Start\n");
750 /* Resets frame counters */
751 dev
->cap_seq_offset
= 0;
752 dev
->cap_seq_count
= 0;
753 dev
->cap_seq_resync
= false;
754 dev
->jiffies_vid_cap
= jiffies
;
758 if (kthread_should_stop())
761 mutex_lock(&dev
->mutex
);
762 cur_jiffies
= jiffies
;
763 if (dev
->cap_seq_resync
) {
764 dev
->jiffies_vid_cap
= cur_jiffies
;
765 dev
->cap_seq_offset
= dev
->cap_seq_count
+ 1;
766 dev
->cap_seq_count
= 0;
767 dev
->cap_seq_resync
= false;
769 numerator
= dev
->timeperframe_vid_cap
.numerator
;
770 denominator
= dev
->timeperframe_vid_cap
.denominator
;
772 if (dev
->field_cap
== V4L2_FIELD_ALTERNATE
)
775 /* Calculate the number of jiffies since we started streaming */
776 jiffies_since_start
= cur_jiffies
- dev
->jiffies_vid_cap
;
777 /* Get the number of buffers streamed since the start */
778 buffers_since_start
= (u64
)jiffies_since_start
* denominator
+
779 (HZ
* numerator
) / 2;
780 do_div(buffers_since_start
, HZ
* numerator
);
783 * After more than 0xf0000000 (rounded down to a multiple of
784 * 'jiffies-per-day' to ease jiffies_to_msecs calculation)
785 * jiffies have passed since we started streaming reset the
786 * counters and keep track of the sequence offset.
788 if (jiffies_since_start
> JIFFIES_RESYNC
) {
789 dev
->jiffies_vid_cap
= cur_jiffies
;
790 dev
->cap_seq_offset
= buffers_since_start
;
791 buffers_since_start
= 0;
793 dropped_bufs
= buffers_since_start
+ dev
->cap_seq_offset
- dev
->cap_seq_count
;
794 dev
->cap_seq_count
= buffers_since_start
+ dev
->cap_seq_offset
;
795 dev
->vid_cap_seq_count
= dev
->cap_seq_count
- dev
->vid_cap_seq_start
;
796 dev
->vbi_cap_seq_count
= dev
->cap_seq_count
- dev
->vbi_cap_seq_start
;
798 vivid_thread_vid_cap_tick(dev
, dropped_bufs
);
801 * Calculate the number of 'numerators' streamed since we started,
802 * including the current buffer.
804 numerators_since_start
= ++buffers_since_start
* numerator
;
806 /* And the number of jiffies since we started */
807 jiffies_since_start
= jiffies
- dev
->jiffies_vid_cap
;
809 mutex_unlock(&dev
->mutex
);
812 * Calculate when that next buffer is supposed to start
813 * in jiffies since we started streaming.
815 next_jiffies_since_start
= numerators_since_start
* HZ
+
817 do_div(next_jiffies_since_start
, denominator
);
818 /* If it is in the past, then just schedule asap */
819 if (next_jiffies_since_start
< jiffies_since_start
)
820 next_jiffies_since_start
= jiffies_since_start
;
822 wait_jiffies
= next_jiffies_since_start
- jiffies_since_start
;
823 schedule_timeout_interruptible(wait_jiffies
? wait_jiffies
: 1);
825 dprintk(dev
, 1, "Video Capture Thread End\n");
829 static void vivid_grab_controls(struct vivid_dev
*dev
, bool grab
)
831 v4l2_ctrl_grab(dev
->ctrl_has_crop_cap
, grab
);
832 v4l2_ctrl_grab(dev
->ctrl_has_compose_cap
, grab
);
833 v4l2_ctrl_grab(dev
->ctrl_has_scaler_cap
, grab
);
836 int vivid_start_generating_vid_cap(struct vivid_dev
*dev
, bool *pstreaming
)
838 dprintk(dev
, 1, "%s\n", __func__
);
840 if (dev
->kthread_vid_cap
) {
841 u32 seq_count
= dev
->cap_seq_count
+ dev
->seq_wrap
* 128;
843 if (pstreaming
== &dev
->vid_cap_streaming
)
844 dev
->vid_cap_seq_start
= seq_count
;
846 dev
->vbi_cap_seq_start
= seq_count
;
851 /* Resets frame counters */
852 tpg_init_mv_count(&dev
->tpg
);
854 dev
->vid_cap_seq_start
= dev
->seq_wrap
* 128;
855 dev
->vbi_cap_seq_start
= dev
->seq_wrap
* 128;
857 dev
->kthread_vid_cap
= kthread_run(vivid_thread_vid_cap
, dev
,
858 "%s-vid-cap", dev
->v4l2_dev
.name
);
860 if (IS_ERR(dev
->kthread_vid_cap
)) {
861 v4l2_err(&dev
->v4l2_dev
, "kernel_thread() failed\n");
862 return PTR_ERR(dev
->kthread_vid_cap
);
865 vivid_grab_controls(dev
, true);
867 dprintk(dev
, 1, "returning from %s\n", __func__
);
871 void vivid_stop_generating_vid_cap(struct vivid_dev
*dev
, bool *pstreaming
)
873 dprintk(dev
, 1, "%s\n", __func__
);
875 if (dev
->kthread_vid_cap
== NULL
)
879 if (pstreaming
== &dev
->vid_cap_streaming
) {
880 /* Release all active buffers */
881 while (!list_empty(&dev
->vid_cap_active
)) {
882 struct vivid_buffer
*buf
;
884 buf
= list_entry(dev
->vid_cap_active
.next
,
885 struct vivid_buffer
, list
);
886 list_del(&buf
->list
);
887 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_ERROR
);
888 dprintk(dev
, 2, "vid_cap buffer %d done\n",
889 buf
->vb
.v4l2_buf
.index
);
893 if (pstreaming
== &dev
->vbi_cap_streaming
) {
894 while (!list_empty(&dev
->vbi_cap_active
)) {
895 struct vivid_buffer
*buf
;
897 buf
= list_entry(dev
->vbi_cap_active
.next
,
898 struct vivid_buffer
, list
);
899 list_del(&buf
->list
);
900 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_ERROR
);
901 dprintk(dev
, 2, "vbi_cap buffer %d done\n",
902 buf
->vb
.v4l2_buf
.index
);
906 if (dev
->vid_cap_streaming
|| dev
->vbi_cap_streaming
)
909 /* shutdown control thread */
910 vivid_grab_controls(dev
, false);
911 mutex_unlock(&dev
->mutex
);
912 kthread_stop(dev
->kthread_vid_cap
);
913 dev
->kthread_vid_cap
= NULL
;
914 mutex_lock(&dev
->mutex
);