tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/*
2 * vivid-kthread-cap.h - video/vbi capture thread support functions.
3 *
4 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
5 *
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.
9 *
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
17 * SOFTWARE.
18 */
19
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>
39
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"
53
54static inline v4l2_std_id vivid_get_std_cap(const struct vivid_dev *dev)
55{
56 if (vivid_is_sdtv_cap(dev))
57 return dev->std_cap;
58 return 0;
59}
60
61static void copy_pix(struct vivid_dev *dev, int win_y, int win_x,
62 u16 *cap, const u16 *osd)
63{
64 u16 out;
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;
69 int i;
70
71 out = *cap;
72 *cap = *osd;
73 if (dev->bitmap_out) {
74 const u8 *p = dev->bitmap_out;
75 unsigned stride = (dev->compose_out.width + 7) / 8;
76
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))))
80 return;
81 }
82
83 for (i = 0; i < dev->clipcount_out; i++) {
84 struct v4l2_rect *r = &dev->clips_out[i].c;
85
86 if (fb_y >= r->top && fb_y < r->top + r->height &&
87 fb_x >= r->left && fb_x < r->left + r->width)
88 return;
89 }
90 if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_CHROMAKEY) &&
91 *osd != dev->chromakey_out)
92 return;
93 if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_SRC_CHROMAKEY) &&
94 out == dev->chromakey_out)
95 return;
96 if (dev->fmt_cap->alpha_mask) {
97 if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) &&
98 dev->global_alpha_out)
99 return;
100 if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_LOCAL_ALPHA) &&
101 *cap & dev->fmt_cap->alpha_mask)
102 return;
103 if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_LOCAL_INV_ALPHA) &&
104 !(*cap & dev->fmt_cap->alpha_mask))
105 return;
106 }
107 *cap = out;
108}
109
110static void blend_line(struct vivid_dev *dev, unsigned y_offset, unsigned x_offset,
111 u8 *vcapbuf, const u8 *vosdbuf,
112 unsigned width, unsigned pixsize)
113{
114 unsigned x;
115
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);
119 }
120}
121
122static void scale_line(const u8 *src, u8 *dst, unsigned srcw, unsigned dstw, unsigned twopixsize)
123{
124 /* Coarse scaling with Bresenham */
125 unsigned int_part;
126 unsigned fract_part;
127 unsigned src_x = 0;
128 unsigned error = 0;
129 unsigned x;
130
131 /*
132 * We always combine two pixels to prevent color bleed in the packed
133 * yuv case.
134 */
135 srcw /= 2;
136 dstw /= 2;
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);
141 src_x += int_part;
142 error += fract_part;
143 if (error >= dstw) {
144 error -= dstw;
145 src_x++;
146 }
147 }
148}
149
150/*
151 * Precalculate the rectangles needed to perform video looping:
152 *
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.
157 *
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.
164 *
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.
174 */
175static void vivid_precalc_copy_rects(struct vivid_dev *dev)
176{
177 /* Framebuffer rectangle */
178 struct v4l2_rect r_fb = {
179 0, 0, dev->display_width, dev->display_height
180 };
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
185 };
186
187 dev->loop_vid_copy = rect_intersect(&dev->crop_cap, &dev->compose_out);
188
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;
193
194 dev->loop_vid_cap = dev->loop_vid_copy;
195 rect_scale(&dev->loop_vid_cap, &dev->crop_cap, &dev->compose_cap);
196
197 dprintk(dev, 1,
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);
205
206 r_overlay = rect_intersect(&r_fb, &r_overlay);
207
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;
211
212 dev->loop_vid_overlay = rect_intersect(&r_overlay, &dev->loop_vid_copy);
213 dev->loop_fb_copy = dev->loop_vid_overlay;
214
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;
218
219 dev->loop_vid_overlay_cap = dev->loop_vid_overlay;
220 rect_scale(&dev->loop_vid_overlay_cap, &dev->crop_cap, &dev->compose_cap);
221
222 dprintk(dev, 1,
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);
230}
231
232static int vivid_copy_buffer(struct vivid_dev *dev, unsigned p, u8 *vcapbuf,
233 struct vivid_buffer *vid_cap_buf)
234{
235 bool blank = dev->must_blank[vid_cap_buf->vb.v4l2_buf.index];
236 struct tpg_data *tpg = &dev->tpg;
237 struct vivid_buffer *vid_out_buf = NULL;
238 unsigned pixsize = tpg_g_twopixelsize(tpg, p) / 2;
239 unsigned img_width = dev->compose_cap.width;
240 unsigned img_height = dev->compose_cap.height;
241 unsigned stride_cap = tpg->bytesperline[p];
242 unsigned stride_out = dev->bytesperline_out[p];
243 unsigned stride_osd = dev->display_byte_stride;
244 unsigned hmax = (img_height * tpg->perc_fill) / 100;
245 u8 *voutbuf;
246 u8 *vosdbuf = NULL;
247 unsigned y;
248 bool blend = dev->bitmap_out || dev->clipcount_out || dev->fbuf_out_flags;
249 /* Coarse scaling with Bresenham */
250 unsigned vid_out_int_part;
251 unsigned vid_out_fract_part;
252 unsigned vid_out_y = 0;
253 unsigned vid_out_error = 0;
254 unsigned vid_overlay_int_part = 0;
255 unsigned vid_overlay_fract_part = 0;
256 unsigned vid_overlay_y = 0;
257 unsigned vid_overlay_error = 0;
258 unsigned vid_cap_right;
259 bool quick;
260
261 vid_out_int_part = dev->loop_vid_out.height / dev->loop_vid_cap.height;
262 vid_out_fract_part = dev->loop_vid_out.height % dev->loop_vid_cap.height;
263
264 if (!list_empty(&dev->vid_out_active))
265 vid_out_buf = list_entry(dev->vid_out_active.next,
266 struct vivid_buffer, list);
267 if (vid_out_buf == NULL)
268 return -ENODATA;
269
270 vid_cap_buf->vb.v4l2_buf.field = vid_out_buf->vb.v4l2_buf.field;
271
272 voutbuf = vb2_plane_vaddr(&vid_out_buf->vb, p) +
273 vid_out_buf->vb.v4l2_planes[p].data_offset;
274 voutbuf += dev->loop_vid_out.left * pixsize + dev->loop_vid_out.top * stride_out;
275 vcapbuf += dev->compose_cap.left * pixsize + dev->compose_cap.top * stride_cap;
276
277 if (dev->loop_vid_copy.width == 0 || dev->loop_vid_copy.height == 0) {
278 /*
279 * If there is nothing to copy, then just fill the capture window
280 * with black.
281 */
282 for (y = 0; y < hmax; y++, vcapbuf += stride_cap)
283 memcpy(vcapbuf, tpg->black_line[p], img_width * pixsize);
284 return 0;
285 }
286
287 if (dev->overlay_out_enabled &&
288 dev->loop_vid_overlay.width && dev->loop_vid_overlay.height) {
289 vosdbuf = dev->video_vbase;
290 vosdbuf += dev->loop_fb_copy.left * pixsize +
291 dev->loop_fb_copy.top * stride_osd;
292 vid_overlay_int_part = dev->loop_vid_overlay.height /
293 dev->loop_vid_overlay_cap.height;
294 vid_overlay_fract_part = dev->loop_vid_overlay.height %
295 dev->loop_vid_overlay_cap.height;
296 }
297
298 vid_cap_right = dev->loop_vid_cap.left + dev->loop_vid_cap.width;
299 /* quick is true if no video scaling is needed */
300 quick = dev->loop_vid_out.width == dev->loop_vid_cap.width;
301
302 dev->cur_scaled_line = dev->loop_vid_out.height;
303 for (y = 0; y < hmax; y++, vcapbuf += stride_cap) {
304 /* osdline is true if this line requires overlay blending */
305 bool osdline = vosdbuf && y >= dev->loop_vid_overlay_cap.top &&
306 y < dev->loop_vid_overlay_cap.top + dev->loop_vid_overlay_cap.height;
307
308 /*
309 * If this line of the capture buffer doesn't get any video, then
310 * just fill with black.
311 */
312 if (y < dev->loop_vid_cap.top ||
313 y >= dev->loop_vid_cap.top + dev->loop_vid_cap.height) {
314 memcpy(vcapbuf, tpg->black_line[p], img_width * pixsize);
315 continue;
316 }
317
318 /* fill the left border with black */
319 if (dev->loop_vid_cap.left)
320 memcpy(vcapbuf, tpg->black_line[p], dev->loop_vid_cap.left * pixsize);
321
322 /* fill the right border with black */
323 if (vid_cap_right < img_width)
324 memcpy(vcapbuf + vid_cap_right * pixsize,
325 tpg->black_line[p], (img_width - vid_cap_right) * pixsize);
326
327 if (quick && !osdline) {
328 memcpy(vcapbuf + dev->loop_vid_cap.left * pixsize,
329 voutbuf + vid_out_y * stride_out,
330 dev->loop_vid_cap.width * pixsize);
331 goto update_vid_out_y;
332 }
333 if (dev->cur_scaled_line == vid_out_y) {
334 memcpy(vcapbuf + dev->loop_vid_cap.left * pixsize,
335 dev->scaled_line,
336 dev->loop_vid_cap.width * pixsize);
337 goto update_vid_out_y;
338 }
339 if (!osdline) {
340 scale_line(voutbuf + vid_out_y * stride_out, dev->scaled_line,
341 dev->loop_vid_out.width, dev->loop_vid_cap.width,
342 tpg_g_twopixelsize(tpg, p));
343 } else {
344 /*
345 * Offset in bytes within loop_vid_copy to the start of the
346 * loop_vid_overlay rectangle.
347 */
348 unsigned offset =
349 (dev->loop_vid_overlay.left - dev->loop_vid_copy.left) * pixsize;
350 u8 *osd = vosdbuf + vid_overlay_y * stride_osd;
351
352 scale_line(voutbuf + vid_out_y * stride_out, dev->blended_line,
353 dev->loop_vid_out.width, dev->loop_vid_copy.width,
354 tpg_g_twopixelsize(tpg, p));
355 if (blend)
356 blend_line(dev, vid_overlay_y + dev->loop_vid_overlay.top,
357 dev->loop_vid_overlay.left,
358 dev->blended_line + offset, osd,
359 dev->loop_vid_overlay.width, pixsize);
360 else
361 memcpy(dev->blended_line + offset,
362 osd, dev->loop_vid_overlay.width * pixsize);
363 scale_line(dev->blended_line, dev->scaled_line,
364 dev->loop_vid_copy.width, dev->loop_vid_cap.width,
365 tpg_g_twopixelsize(tpg, p));
366 }
367 dev->cur_scaled_line = vid_out_y;
368 memcpy(vcapbuf + dev->loop_vid_cap.left * pixsize,
369 dev->scaled_line,
370 dev->loop_vid_cap.width * pixsize);
371
372update_vid_out_y:
373 if (osdline) {
374 vid_overlay_y += vid_overlay_int_part;
375 vid_overlay_error += vid_overlay_fract_part;
376 if (vid_overlay_error >= dev->loop_vid_overlay_cap.height) {
377 vid_overlay_error -= dev->loop_vid_overlay_cap.height;
378 vid_overlay_y++;
379 }
380 }
381 vid_out_y += vid_out_int_part;
382 vid_out_error += vid_out_fract_part;
383 if (vid_out_error >= dev->loop_vid_cap.height) {
384 vid_out_error -= dev->loop_vid_cap.height;
385 vid_out_y++;
386 }
387 }
388
389 if (!blank)
390 return 0;
391 for (; y < img_height; y++, vcapbuf += stride_cap)
392 memcpy(vcapbuf, tpg->contrast_line[p], img_width * pixsize);
393 return 0;
394}
395
396static void vivid_fillbuff(struct vivid_dev *dev, struct vivid_buffer *buf)
397{
398 unsigned factor = V4L2_FIELD_HAS_T_OR_B(dev->field_cap) ? 2 : 1;
399 unsigned line_height = 16 / factor;
400 bool is_tv = vivid_is_sdtv_cap(dev);
401 bool is_60hz = is_tv && (dev->std_cap & V4L2_STD_525_60);
402 unsigned p;
403 int line = 1;
404 u8 *basep[TPG_MAX_PLANES][2];
405 unsigned ms;
406 char str[100];
407 s32 gain;
408 bool is_loop = false;
409
410 if (dev->loop_video && dev->can_loop_video &&
411 ((vivid_is_svid_cap(dev) && !VIVID_INVALID_SIGNAL(dev->std_signal_mode)) ||
412 (vivid_is_hdmi_cap(dev) && !VIVID_INVALID_SIGNAL(dev->dv_timings_signal_mode))))
413 is_loop = true;
414
415 buf->vb.v4l2_buf.sequence = dev->vid_cap_seq_count;
416 /*
417 * Take the timestamp now if the timestamp source is set to
418 * "Start of Exposure".
419 */
420 if (dev->tstamp_src_is_soe)
421 v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
422 if (dev->field_cap == V4L2_FIELD_ALTERNATE) {
423 /*
424 * 60 Hz standards start with the bottom field, 50 Hz standards
425 * with the top field. So if the 0-based seq_count is even,
426 * then the field is TOP for 50 Hz and BOTTOM for 60 Hz
427 * standards.
428 */
429 buf->vb.v4l2_buf.field = ((dev->vid_cap_seq_count & 1) ^ is_60hz) ?
430 V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM;
431 /*
432 * The sequence counter counts frames, not fields. So divide
433 * by two.
434 */
435 buf->vb.v4l2_buf.sequence /= 2;
436 } else {
437 buf->vb.v4l2_buf.field = dev->field_cap;
438 }
439 tpg_s_field(&dev->tpg, buf->vb.v4l2_buf.field);
440 tpg_s_perc_fill_blank(&dev->tpg, dev->must_blank[buf->vb.v4l2_buf.index]);
441
442 vivid_precalc_copy_rects(dev);
443
444 for (p = 0; p < tpg_g_planes(&dev->tpg); p++) {
445 void *vbuf = vb2_plane_vaddr(&buf->vb, p);
446
447 /*
448 * The first plane of a multiplanar format has a non-zero
449 * data_offset. This helps testing whether the application
450 * correctly supports non-zero data offsets.
451 */
452 if (dev->fmt_cap->data_offset[p]) {
453 memset(vbuf, dev->fmt_cap->data_offset[p] & 0xff,
454 dev->fmt_cap->data_offset[p]);
455 vbuf += dev->fmt_cap->data_offset[p];
456 }
457 tpg_calc_text_basep(&dev->tpg, basep, p, vbuf);
458 if (!is_loop || vivid_copy_buffer(dev, p, vbuf, buf))
459 tpg_fillbuffer(&dev->tpg, vivid_get_std_cap(dev), p, vbuf);
460 }
461 dev->must_blank[buf->vb.v4l2_buf.index] = false;
462
463 /* Updates stream time, only update at the start of a new frame. */
464 if (dev->field_cap != V4L2_FIELD_ALTERNATE || (buf->vb.v4l2_buf.sequence & 1) == 0)
465 dev->ms_vid_cap = jiffies_to_msecs(jiffies - dev->jiffies_vid_cap);
466
467 ms = dev->ms_vid_cap;
468 if (dev->osd_mode <= 1) {
469 snprintf(str, sizeof(str), " %02d:%02d:%02d:%03d %u%s",
470 (ms / (60 * 60 * 1000)) % 24,
471 (ms / (60 * 1000)) % 60,
472 (ms / 1000) % 60,
473 ms % 1000,
474 buf->vb.v4l2_buf.sequence,
475 (dev->field_cap == V4L2_FIELD_ALTERNATE) ?
476 (buf->vb.v4l2_buf.field == V4L2_FIELD_TOP ?
477 " top" : " bottom") : "");
478 tpg_gen_text(&dev->tpg, basep, line++ * line_height, 16, str);
479 }
480 if (dev->osd_mode == 0) {
481 snprintf(str, sizeof(str), " %dx%d, input %d ",
482 dev->src_rect.width, dev->src_rect.height, dev->input);
483 tpg_gen_text(&dev->tpg, basep, line++ * line_height, 16, str);
484
485 gain = v4l2_ctrl_g_ctrl(dev->gain);
486 mutex_lock(dev->ctrl_hdl_user_vid.lock);
487 snprintf(str, sizeof(str),
488 " brightness %3d, contrast %3d, saturation %3d, hue %d ",
489 dev->brightness->cur.val,
490 dev->contrast->cur.val,
491 dev->saturation->cur.val,
492 dev->hue->cur.val);
493 tpg_gen_text(&dev->tpg, basep, line++ * line_height, 16, str);
494 snprintf(str, sizeof(str),
495 " autogain %d, gain %3d, alpha 0x%02x ",
496 dev->autogain->cur.val, gain, dev->alpha->cur.val);
497 mutex_unlock(dev->ctrl_hdl_user_vid.lock);
498 tpg_gen_text(&dev->tpg, basep, line++ * line_height, 16, str);
499 mutex_lock(dev->ctrl_hdl_user_aud.lock);
500 snprintf(str, sizeof(str),
501 " volume %3d, mute %d ",
502 dev->volume->cur.val, dev->mute->cur.val);
503 mutex_unlock(dev->ctrl_hdl_user_aud.lock);
504 tpg_gen_text(&dev->tpg, basep, line++ * line_height, 16, str);
505 mutex_lock(dev->ctrl_hdl_user_gen.lock);
506 snprintf(str, sizeof(str), " int32 %d, int64 %lld, bitmask %08x ",
507 dev->int32->cur.val,
508 *dev->int64->p_cur.p_s64,
509 dev->bitmask->cur.val);
510 tpg_gen_text(&dev->tpg, basep, line++ * line_height, 16, str);
511 snprintf(str, sizeof(str), " boolean %d, menu %s, string \"%s\" ",
512 dev->boolean->cur.val,
513 dev->menu->qmenu[dev->menu->cur.val],
514 dev->string->p_cur.p_char);
515 tpg_gen_text(&dev->tpg, basep, line++ * line_height, 16, str);
516 snprintf(str, sizeof(str), " integer_menu %lld, value %d ",
517 dev->int_menu->qmenu_int[dev->int_menu->cur.val],
518 dev->int_menu->cur.val);
519 mutex_unlock(dev->ctrl_hdl_user_gen.lock);
520 tpg_gen_text(&dev->tpg, basep, line++ * line_height, 16, str);
521 if (dev->button_pressed) {
522 dev->button_pressed--;
523 snprintf(str, sizeof(str), " button pressed!");
524 tpg_gen_text(&dev->tpg, basep, line++ * line_height, 16, str);
525 }
526 }
527
528 /*
529 * If "End of Frame" is specified at the timestamp source, then take
530 * the timestamp now.
531 */
532 if (!dev->tstamp_src_is_soe)
533 v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
534 buf->vb.v4l2_buf.timestamp.tv_sec += dev->time_wrap_offset;
535}
536
537/*
538 * Return true if this pixel coordinate is a valid video pixel.
539 */
540static bool valid_pix(struct vivid_dev *dev, int win_y, int win_x, int fb_y, int fb_x)
541{
542 int i;
543
544 if (dev->bitmap_cap) {
545 /*
546 * Only if the corresponding bit in the bitmap is set can
547 * the video pixel be shown. Coordinates are relative to
548 * the overlay window set by VIDIOC_S_FMT.
549 */
550 const u8 *p = dev->bitmap_cap;
551 unsigned stride = (dev->compose_cap.width + 7) / 8;
552
553 if (!(p[stride * win_y + win_x / 8] & (1 << (win_x & 7))))
554 return false;
555 }
556
557 for (i = 0; i < dev->clipcount_cap; i++) {
558 /*
559 * Only if the framebuffer coordinate is not in any of the
560 * clip rectangles will be video pixel be shown.
561 */
562 struct v4l2_rect *r = &dev->clips_cap[i].c;
563
564 if (fb_y >= r->top && fb_y < r->top + r->height &&
565 fb_x >= r->left && fb_x < r->left + r->width)
566 return false;
567 }
568 return true;
569}
570
571/*
572 * Draw the image into the overlay buffer.
573 * Note that the combination of overlay and multiplanar is not supported.
574 */
575static void vivid_overlay(struct vivid_dev *dev, struct vivid_buffer *buf)
576{
577 struct tpg_data *tpg = &dev->tpg;
578 unsigned pixsize = tpg_g_twopixelsize(tpg, 0) / 2;
579 void *vbase = dev->fb_vbase_cap;
580 void *vbuf = vb2_plane_vaddr(&buf->vb, 0);
581 unsigned img_width = dev->compose_cap.width;
582 unsigned img_height = dev->compose_cap.height;
583 unsigned stride = tpg->bytesperline[0];
584 /* if quick is true, then valid_pix() doesn't have to be called */
585 bool quick = dev->bitmap_cap == NULL && dev->clipcount_cap == 0;
586 int x, y, w, out_x = 0;
587
588 if ((dev->overlay_cap_field == V4L2_FIELD_TOP ||
589 dev->overlay_cap_field == V4L2_FIELD_BOTTOM) &&
590 dev->overlay_cap_field != buf->vb.v4l2_buf.field)
591 return;
592
593 vbuf += dev->compose_cap.left * pixsize + dev->compose_cap.top * stride;
594 x = dev->overlay_cap_left;
595 w = img_width;
596 if (x < 0) {
597 out_x = -x;
598 w = w - out_x;
599 x = 0;
600 } else {
601 w = dev->fb_cap.fmt.width - x;
602 if (w > img_width)
603 w = img_width;
604 }
605 if (w <= 0)
606 return;
607 if (dev->overlay_cap_top >= 0)
608 vbase += dev->overlay_cap_top * dev->fb_cap.fmt.bytesperline;
609 for (y = dev->overlay_cap_top;
610 y < dev->overlay_cap_top + (int)img_height;
611 y++, vbuf += stride) {
612 int px;
613
614 if (y < 0 || y > dev->fb_cap.fmt.height)
615 continue;
616 if (quick) {
617 memcpy(vbase + x * pixsize,
618 vbuf + out_x * pixsize, w * pixsize);
619 vbase += dev->fb_cap.fmt.bytesperline;
620 continue;
621 }
622 for (px = 0; px < w; px++) {
623 if (!valid_pix(dev, y - dev->overlay_cap_top,
624 px + out_x, y, px + x))
625 continue;
626 memcpy(vbase + (px + x) * pixsize,
627 vbuf + (px + out_x) * pixsize,
628 pixsize);
629 }
630 vbase += dev->fb_cap.fmt.bytesperline;
631 }
632}
633
634static void vivid_thread_vid_cap_tick(struct vivid_dev *dev, int dropped_bufs)
635{
636 struct vivid_buffer *vid_cap_buf = NULL;
637 struct vivid_buffer *vbi_cap_buf = NULL;
638
639 dprintk(dev, 1, "Video Capture Thread Tick\n");
640
641 while (dropped_bufs-- > 1)
642 tpg_update_mv_count(&dev->tpg,
643 dev->field_cap == V4L2_FIELD_NONE ||
644 dev->field_cap == V4L2_FIELD_ALTERNATE);
645
646 /* Drop a certain percentage of buffers. */
647 if (dev->perc_dropped_buffers &&
648 prandom_u32_max(100) < dev->perc_dropped_buffers)
649 goto update_mv;
650
651 spin_lock(&dev->slock);
652 if (!list_empty(&dev->vid_cap_active)) {
653 vid_cap_buf = list_entry(dev->vid_cap_active.next, struct vivid_buffer, list);
654 list_del(&vid_cap_buf->list);
655 }
656 if (!list_empty(&dev->vbi_cap_active)) {
657 if (dev->field_cap != V4L2_FIELD_ALTERNATE ||
658 (dev->vbi_cap_seq_count & 1)) {
659 vbi_cap_buf = list_entry(dev->vbi_cap_active.next,
660 struct vivid_buffer, list);
661 list_del(&vbi_cap_buf->list);
662 }
663 }
664 spin_unlock(&dev->slock);
665
666 if (!vid_cap_buf && !vbi_cap_buf)
667 goto update_mv;
668
669 if (vid_cap_buf) {
670 /* Fill buffer */
671 vivid_fillbuff(dev, vid_cap_buf);
672 dprintk(dev, 1, "filled buffer %d\n",
673 vid_cap_buf->vb.v4l2_buf.index);
674
675 /* Handle overlay */
676 if (dev->overlay_cap_owner && dev->fb_cap.base &&
677 dev->fb_cap.fmt.pixelformat == dev->fmt_cap->fourcc)
678 vivid_overlay(dev, vid_cap_buf);
679
680 vb2_buffer_done(&vid_cap_buf->vb, dev->dqbuf_error ?
681 VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
682 dprintk(dev, 2, "vid_cap buffer %d done\n",
683 vid_cap_buf->vb.v4l2_buf.index);
684 }
685
686 if (vbi_cap_buf) {
687 if (dev->stream_sliced_vbi_cap)
688 vivid_sliced_vbi_cap_process(dev, vbi_cap_buf);
689 else
690 vivid_raw_vbi_cap_process(dev, vbi_cap_buf);
691 vb2_buffer_done(&vbi_cap_buf->vb, dev->dqbuf_error ?
692 VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
693 dprintk(dev, 2, "vbi_cap %d done\n",
694 vbi_cap_buf->vb.v4l2_buf.index);
695 }
696 dev->dqbuf_error = false;
697
698update_mv:
699 /* Update the test pattern movement counters */
700 tpg_update_mv_count(&dev->tpg, dev->field_cap == V4L2_FIELD_NONE ||
701 dev->field_cap == V4L2_FIELD_ALTERNATE);
702}
703
704static int vivid_thread_vid_cap(void *data)
705{
706 struct vivid_dev *dev = data;
707 u64 numerators_since_start;
708 u64 buffers_since_start;
709 u64 next_jiffies_since_start;
710 unsigned long jiffies_since_start;
711 unsigned long cur_jiffies;
712 unsigned wait_jiffies;
713 unsigned numerator;
714 unsigned denominator;
715 int dropped_bufs;
716
717 dprintk(dev, 1, "Video Capture Thread Start\n");
718
719 set_freezable();
720
721 /* Resets frame counters */
722 dev->cap_seq_offset = 0;
723 dev->cap_seq_count = 0;
724 dev->cap_seq_resync = false;
725 dev->jiffies_vid_cap = jiffies;
726
727 for (;;) {
728 try_to_freeze();
729 if (kthread_should_stop())
730 break;
731
732 mutex_lock(&dev->mutex);
733 cur_jiffies = jiffies;
734 if (dev->cap_seq_resync) {
735 dev->jiffies_vid_cap = cur_jiffies;
736 dev->cap_seq_offset = dev->cap_seq_count + 1;
737 dev->cap_seq_count = 0;
738 dev->cap_seq_resync = false;
739 }
740 numerator = dev->timeperframe_vid_cap.numerator;
741 denominator = dev->timeperframe_vid_cap.denominator;
742
743 if (dev->field_cap == V4L2_FIELD_ALTERNATE)
744 denominator *= 2;
745
746 /* Calculate the number of jiffies since we started streaming */
747 jiffies_since_start = cur_jiffies - dev->jiffies_vid_cap;
748 /* Get the number of buffers streamed since the start */
749 buffers_since_start = (u64)jiffies_since_start * denominator +
750 (HZ * numerator) / 2;
751 do_div(buffers_since_start, HZ * numerator);
752
753 /*
754 * After more than 0xf0000000 (rounded down to a multiple of
755 * 'jiffies-per-day' to ease jiffies_to_msecs calculation)
756 * jiffies have passed since we started streaming reset the
757 * counters and keep track of the sequence offset.
758 */
759 if (jiffies_since_start > JIFFIES_RESYNC) {
760 dev->jiffies_vid_cap = cur_jiffies;
761 dev->cap_seq_offset = buffers_since_start;
762 buffers_since_start = 0;
763 }
764 dropped_bufs = buffers_since_start + dev->cap_seq_offset - dev->cap_seq_count;
765 dev->cap_seq_count = buffers_since_start + dev->cap_seq_offset;
766 dev->vid_cap_seq_count = dev->cap_seq_count - dev->vid_cap_seq_start;
767 dev->vbi_cap_seq_count = dev->cap_seq_count - dev->vbi_cap_seq_start;
768
769 vivid_thread_vid_cap_tick(dev, dropped_bufs);
770
771 /*
772 * Calculate the number of 'numerators' streamed since we started,
773 * including the current buffer.
774 */
775 numerators_since_start = ++buffers_since_start * numerator;
776
777 /* And the number of jiffies since we started */
778 jiffies_since_start = jiffies - dev->jiffies_vid_cap;
779
780 mutex_unlock(&dev->mutex);
781
782 /*
783 * Calculate when that next buffer is supposed to start
784 * in jiffies since we started streaming.
785 */
786 next_jiffies_since_start = numerators_since_start * HZ +
787 denominator / 2;
788 do_div(next_jiffies_since_start, denominator);
789 /* If it is in the past, then just schedule asap */
790 if (next_jiffies_since_start < jiffies_since_start)
791 next_jiffies_since_start = jiffies_since_start;
792
793 wait_jiffies = next_jiffies_since_start - jiffies_since_start;
794 schedule_timeout_interruptible(wait_jiffies ? wait_jiffies : 1);
795 }
796 dprintk(dev, 1, "Video Capture Thread End\n");
797 return 0;
798}
799
800static void vivid_grab_controls(struct vivid_dev *dev, bool grab)
801{
802 v4l2_ctrl_grab(dev->ctrl_has_crop_cap, grab);
803 v4l2_ctrl_grab(dev->ctrl_has_compose_cap, grab);
804 v4l2_ctrl_grab(dev->ctrl_has_scaler_cap, grab);
805}
806
807int vivid_start_generating_vid_cap(struct vivid_dev *dev, bool *pstreaming)
808{
809 dprintk(dev, 1, "%s\n", __func__);
810
811 if (dev->kthread_vid_cap) {
812 u32 seq_count = dev->cap_seq_count + dev->seq_wrap * 128;
813
814 if (pstreaming == &dev->vid_cap_streaming)
815 dev->vid_cap_seq_start = seq_count;
816 else
817 dev->vbi_cap_seq_start = seq_count;
818 *pstreaming = true;
819 return 0;
820 }
821
822 /* Resets frame counters */
823 tpg_init_mv_count(&dev->tpg);
824
825 dev->vid_cap_seq_start = dev->seq_wrap * 128;
826 dev->vbi_cap_seq_start = dev->seq_wrap * 128;
827
828 dev->kthread_vid_cap = kthread_run(vivid_thread_vid_cap, dev,
829 "%s-vid-cap", dev->v4l2_dev.name);
830
831 if (IS_ERR(dev->kthread_vid_cap)) {
832 v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
833 return PTR_ERR(dev->kthread_vid_cap);
834 }
835 *pstreaming = true;
836 vivid_grab_controls(dev, true);
837
838 dprintk(dev, 1, "returning from %s\n", __func__);
839 return 0;
840}
841
842void vivid_stop_generating_vid_cap(struct vivid_dev *dev, bool *pstreaming)
843{
844 dprintk(dev, 1, "%s\n", __func__);
845
846 if (dev->kthread_vid_cap == NULL)
847 return;
848
849 *pstreaming = false;
850 if (pstreaming == &dev->vid_cap_streaming) {
851 /* Release all active buffers */
852 while (!list_empty(&dev->vid_cap_active)) {
853 struct vivid_buffer *buf;
854
855 buf = list_entry(dev->vid_cap_active.next,
856 struct vivid_buffer, list);
857 list_del(&buf->list);
858 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
859 dprintk(dev, 2, "vid_cap buffer %d done\n",
860 buf->vb.v4l2_buf.index);
861 }
862 }
863
864 if (pstreaming == &dev->vbi_cap_streaming) {
865 while (!list_empty(&dev->vbi_cap_active)) {
866 struct vivid_buffer *buf;
867
868 buf = list_entry(dev->vbi_cap_active.next,
869 struct vivid_buffer, list);
870 list_del(&buf->list);
871 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
872 dprintk(dev, 2, "vbi_cap buffer %d done\n",
873 buf->vb.v4l2_buf.index);
874 }
875 }
876
877 if (dev->vid_cap_streaming || dev->vbi_cap_streaming)
878 return;
879
880 /* shutdown control thread */
881 vivid_grab_controls(dev, false);
882 mutex_unlock(&dev->mutex);
883 kthread_stop(dev->kthread_vid_cap);
884 dev->kthread_vid_cap = NULL;
885 mutex_lock(&dev->mutex);
886}