drivers/media/test-drivers/vivid/vivid-kthread-cap.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * vivid-kthread-cap.h - video/vbi capture thread support functions.
   4  *
   5  * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/errno.h>
  10 #include <linux/kernel.h>
  11 #include <linux/init.h>
  12 #include <linux/sched.h>
  13 #include <linux/slab.h>
  14 #include <linux/font.h>
  15 #include <linux/mutex.h>
  16 #include <linux/videodev2.h>
  17 #include <linux/kthread.h>
  18 #include <linux/freezer.h>
  19 #include <linux/random.h>
  20 #include <linux/v4l2-dv-timings.h>
  21 #include <asm/div64.h>
  22 #include <media/videobuf2-vmalloc.h>
  23 #include <media/v4l2-dv-timings.h>
  24 #include <media/v4l2-ioctl.h>
  25 #include <media/v4l2-fh.h>
  26 #include <media/v4l2-event.h>
  27 #include <media/v4l2-rect.h>
  28
  29 #include "vivid-core.h"
  30 #include "vivid-vid-common.h"
  31 #include "vivid-vid-cap.h"
  32 #include "vivid-vid-out.h"
  33 #include "vivid-radio-common.h"
  34 #include "vivid-radio-rx.h"
  35 #include "vivid-radio-tx.h"
  36 #include "vivid-sdr-cap.h"
  37 #include "vivid-vbi-cap.h"
  38 #include "vivid-vbi-out.h"
  39 #include "vivid-osd.h"
  40 #include "vivid-ctrls.h"
  41 #include "vivid-kthread-cap.h"
  42 #include "vivid-meta-cap.h"
  43
  44 static inline v4l2_std_id vivid_get_std_cap(const struct vivid_dev *dev)
  45 {
  46         if (vivid_is_sdtv_cap(dev))
  47                 return dev->std_cap[dev->input];
  48         return 0;
  49 }
  50
  51 static void copy_pix(struct vivid_dev *dev, int win_y, int win_x,
  52                         u16 *cap, const u16 *osd)
  53 {
  54         u16 out;
  55         int left = dev->overlay_out_left;
  56         int top = dev->overlay_out_top;
  57         int fb_x = win_x + left;
  58         int fb_y = win_y + top;
  59         int i;
  60
  61         out = *cap;
  62         *cap = *osd;
  63         if (dev->bitmap_out) {
  64                 const u8 *p = dev->bitmap_out;
  65                 unsigned stride = (dev->compose_out.width + 7) / 8;
  66
  67                 win_x -= dev->compose_out.left;
  68                 win_y -= dev->compose_out.top;
  69                 if (!(p[stride * win_y + win_x / 8] & (1 << (win_x & 7))))
  70                         return;
  71         }
  72
  73         for (i = 0; i < dev->clipcount_out; i++) {
  74                 struct v4l2_rect *r = &dev->clips_out[i].c;
  75
  76                 if (fb_y >= r->top && fb_y < r->top + r->height &&
  77                     fb_x >= r->left && fb_x < r->left + r->width)
  78                         return;
  79         }
  80         if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_CHROMAKEY) &&
  81             *osd != dev->chromakey_out)
  82                 return;
  83         if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_SRC_CHROMAKEY) &&
  84             out == dev->chromakey_out)
  85                 return;
  86         if (dev->fmt_cap->alpha_mask) {
  87                 if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) &&
  88                     dev->global_alpha_out)
  89                         return;
  90                 if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_LOCAL_ALPHA) &&
  91                     *cap & dev->fmt_cap->alpha_mask)
  92                         return;
  93                 if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_LOCAL_INV_ALPHA) &&
  94                     !(*cap & dev->fmt_cap->alpha_mask))
  95                         return;
  96         }
  97         *cap = out;
  98 }
  99
 100 static void blend_line(struct vivid_dev *dev, unsigned y_offset, unsigned x_offset,
 101                 u8 *vcapbuf, const u8 *vosdbuf,
 102                 unsigned width, unsigned pixsize)
 103 {
 104         unsigned x;
 105
 106         for (x = 0; x < width; x++, vcapbuf += pixsize, vosdbuf += pixsize) {
 107                 copy_pix(dev, y_offset, x_offset + x,
 108                          (u16 *)vcapbuf, (const u16 *)vosdbuf);
 109         }
 110 }
 111
 112 static void scale_line(const u8 *src, u8 *dst, unsigned srcw, unsigned dstw, unsigned twopixsize)
 113 {
 114         /* Coarse scaling with Bresenham */
 115         unsigned int_part;
 116         unsigned fract_part;
 117         unsigned src_x = 0;
 118         unsigned error = 0;
 119         unsigned x;
 120
 121         /*
 122          * We always combine two pixels to prevent color bleed in the packed
 123          * yuv case.
 124          */
 125         srcw /= 2;
 126         dstw /= 2;
 127         int_part = srcw / dstw;
 128         fract_part = srcw % dstw;
 129         for (x = 0; x < dstw; x++, dst += twopixsize) {
 130                 memcpy(dst, src + src_x * twopixsize, twopixsize);
 131                 src_x += int_part;
 132                 error += fract_part;
 133                 if (error >= dstw) {
 134                         error -= dstw;
 135                         src_x++;
 136                 }
 137         }
 138 }
 139
 140 /*
 141  * Precalculate the rectangles needed to perform video looping:
 142  *
 143  * The nominal pipeline is that the video output buffer is cropped by
 144  * crop_out, scaled to compose_out, overlaid with the output overlay,
 145  * cropped on the capture side by crop_cap and scaled again to the video
 146  * capture buffer using compose_cap.
 147  *
 148  * To keep things efficient we calculate the intersection of compose_out
 149  * and crop_cap (since that's the only part of the video that will
 150  * actually end up in the capture buffer), determine which part of the
 151  * video output buffer that is and which part of the video capture buffer
 152  * so we can scale the video straight from the output buffer to the capture
 153  * buffer without any intermediate steps.
 154  *
 155  * If we need to deal with an output overlay, then there is no choice and
 156  * that intermediate step still has to be taken. For the output overlay
 157  * support we calculate the intersection of the framebuffer and the overlay
 158  * window (which may be partially or wholly outside of the framebuffer
 159  * itself) and the intersection of that with loop_vid_copy (i.e. the part of
 160  * the actual looped video that will be overlaid). The result is calculated
 161  * both in framebuffer coordinates (loop_fb_copy) and compose_out coordinates
 162  * (loop_vid_overlay). Finally calculate the part of the capture buffer that
 163  * will receive that overlaid video.
 164  */
 165 static void vivid_precalc_copy_rects(struct vivid_dev *dev)
 166 {
 167         /* Framebuffer rectangle */
 168         struct v4l2_rect r_fb = {
 169                 0, 0, dev->display_width, dev->display_height
 170         };
 171         /* Overlay window rectangle in framebuffer coordinates */
 172         struct v4l2_rect r_overlay = {
 173                 dev->overlay_out_left, dev->overlay_out_top,
 174                 dev->compose_out.width, dev->compose_out.height
 175         };
 176
 177         v4l2_rect_intersect(&dev->loop_vid_copy, &dev->crop_cap, &dev->compose_out);
 178
 179         dev->loop_vid_out = dev->loop_vid_copy;
 180         v4l2_rect_scale(&dev->loop_vid_out, &dev->compose_out, &dev->crop_out);
 181         dev->loop_vid_out.left += dev->crop_out.left;
 182         dev->loop_vid_out.top += dev->crop_out.top;
 183
 184         dev->loop_vid_cap = dev->loop_vid_copy;
 185         v4l2_rect_scale(&dev->loop_vid_cap, &dev->crop_cap, &dev->compose_cap);
 186
 187         dprintk(dev, 1,
 188                 "loop_vid_copy: %dx%d@%dx%d loop_vid_out: %dx%d@%dx%d loop_vid_cap: %dx%d@%dx%d\n",
 189                 dev->loop_vid_copy.width, dev->loop_vid_copy.height,
 190                 dev->loop_vid_copy.left, dev->loop_vid_copy.top,
 191                 dev->loop_vid_out.width, dev->loop_vid_out.height,
 192                 dev->loop_vid_out.left, dev->loop_vid_out.top,
 193                 dev->loop_vid_cap.width, dev->loop_vid_cap.height,
 194                 dev->loop_vid_cap.left, dev->loop_vid_cap.top);
 195
 196         v4l2_rect_intersect(&r_overlay, &r_fb, &r_overlay);
 197
 198         /* shift r_overlay to the same origin as compose_out */
 199         r_overlay.left += dev->compose_out.left - dev->overlay_out_left;
 200         r_overlay.top += dev->compose_out.top - dev->overlay_out_top;
 201
 202         v4l2_rect_intersect(&dev->loop_vid_overlay, &r_overlay, &dev->loop_vid_copy);
 203         dev->loop_fb_copy = dev->loop_vid_overlay;
 204
 205         /* shift dev->loop_fb_copy back again to the fb origin */
 206         dev->loop_fb_copy.left -= dev->compose_out.left - dev->overlay_out_left;
 207         dev->loop_fb_copy.top -= dev->compose_out.top - dev->overlay_out_top;
 208
 209         dev->loop_vid_overlay_cap = dev->loop_vid_overlay;
 210         v4l2_rect_scale(&dev->loop_vid_overlay_cap, &dev->crop_cap, &dev->compose_cap);
 211
 212         dprintk(dev, 1,
 213                 "loop_fb_copy: %dx%d@%dx%d loop_vid_overlay: %dx%d@%dx%d loop_vid_overlay_cap: %dx%d@%dx%d\n",
 214                 dev->loop_fb_copy.width, dev->loop_fb_copy.height,
 215                 dev->loop_fb_copy.left, dev->loop_fb_copy.top,
 216                 dev->loop_vid_overlay.width, dev->loop_vid_overlay.height,
 217                 dev->loop_vid_overlay.left, dev->loop_vid_overlay.top,
 218                 dev->loop_vid_overlay_cap.width, dev->loop_vid_overlay_cap.height,
 219                 dev->loop_vid_overlay_cap.left, dev->loop_vid_overlay_cap.top);
 220 }
 221
 222 static void *plane_vaddr(struct tpg_data *tpg, struct vivid_buffer *buf,
 223                          unsigned p, unsigned bpl[TPG_MAX_PLANES], unsigned h)
 224 {
 225         unsigned i;
 226         void *vbuf;
 227
 228         if (p == 0 || tpg_g_buffers(tpg) > 1)
 229                 return vb2_plane_vaddr(&buf->vb.vb2_buf, p);
 230         vbuf = vb2_plane_vaddr(&buf->vb.vb2_buf, 0);
 231         for (i = 0; i < p; i++)
 232                 vbuf += bpl[i] * h / tpg->vdownsampling[i];
 233         return vbuf;
 234 }
 235
 236 static noinline_for_stack int vivid_copy_buffer(struct vivid_dev *dev, unsigned p,
 237                 u8 *vcapbuf, struct vivid_buffer *vid_cap_buf)
 238 {
 239         bool blank = dev->must_blank[vid_cap_buf->vb.vb2_buf.index];
 240         struct tpg_data *tpg = &dev->tpg;
 241         struct vivid_buffer *vid_out_buf = NULL;
 242         unsigned vdiv = dev->fmt_out->vdownsampling[p];
 243         unsigned twopixsize = tpg_g_twopixelsize(tpg, p);
 244         unsigned img_width = tpg_hdiv(tpg, p, dev->compose_cap.width);
 245         unsigned img_height = dev->compose_cap.height;
 246         unsigned stride_cap = tpg->bytesperline[p];
 247         unsigned stride_out = dev->bytesperline_out[p];
 248         unsigned stride_osd = dev->display_byte_stride;
 249         unsigned hmax = (img_height * tpg->perc_fill) / 100;
 250         u8 *voutbuf;
 251         u8 *vosdbuf = NULL;
 252         unsigned y;
 253         bool blend = dev->bitmap_out || dev->clipcount_out || dev->fbuf_out_flags;
 254         /* Coarse scaling with Bresenham */
 255         unsigned vid_out_int_part;
 256         unsigned vid_out_fract_part;
 257         unsigned vid_out_y = 0;
 258         unsigned vid_out_error = 0;
 259         unsigned vid_overlay_int_part = 0;
 260         unsigned vid_overlay_fract_part = 0;
 261         unsigned vid_overlay_y = 0;
 262         unsigned vid_overlay_error = 0;
 263         unsigned vid_cap_left = tpg_hdiv(tpg, p, dev->loop_vid_cap.left);
 264         unsigned vid_cap_right;
 265         bool quick;
 266
 267         vid_out_int_part = dev->loop_vid_out.height / dev->loop_vid_cap.height;
 268         vid_out_fract_part = dev->loop_vid_out.height % dev->loop_vid_cap.height;
 269
 270         if (!list_empty(&dev->vid_out_active))
 271                 vid_out_buf = list_entry(dev->vid_out_active.next,
 272                                          struct vivid_buffer, list);
 273         if (vid_out_buf == NULL)
 274                 return -ENODATA;
 275
 276         vid_cap_buf->vb.field = vid_out_buf->vb.field;
 277
 278         voutbuf = plane_vaddr(tpg, vid_out_buf, p,
 279                               dev->bytesperline_out, dev->fmt_out_rect.height);
 280         if (p < dev->fmt_out->buffers)
 281                 voutbuf += vid_out_buf->vb.vb2_buf.planes[p].data_offset;
 282         voutbuf += tpg_hdiv(tpg, p, dev->loop_vid_out.left) +
 283                 (dev->loop_vid_out.top / vdiv) * stride_out;
 284         vcapbuf += tpg_hdiv(tpg, p, dev->compose_cap.left) +
 285                 (dev->compose_cap.top / vdiv) * stride_cap;
 286
 287         if (dev->loop_vid_copy.width == 0 || dev->loop_vid_copy.height == 0) {
 288                 /*
 289                  * If there is nothing to copy, then just fill the capture window
 290                  * with black.
 291                  */
 292                 for (y = 0; y < hmax / vdiv; y++, vcapbuf += stride_cap)
 293                         memcpy(vcapbuf, tpg->black_line[p], img_width);
 294                 return 0;
 295         }
 296
 297         if (dev->overlay_out_enabled &&
 298             dev->loop_vid_overlay.width && dev->loop_vid_overlay.height) {
 299                 vosdbuf = dev->video_vbase;
 300                 vosdbuf += (dev->loop_fb_copy.left * twopixsize) / 2 +
 301                            dev->loop_fb_copy.top * stride_osd;
 302                 vid_overlay_int_part = dev->loop_vid_overlay.height /
 303                                        dev->loop_vid_overlay_cap.height;
 304                 vid_overlay_fract_part = dev->loop_vid_overlay.height %
 305                                          dev->loop_vid_overlay_cap.height;
 306         }
 307
 308         vid_cap_right = tpg_hdiv(tpg, p, dev->loop_vid_cap.left + dev->loop_vid_cap.width);
 309         /* quick is true if no video scaling is needed */
 310         quick = dev->loop_vid_out.width == dev->loop_vid_cap.width;
 311
 312         dev->cur_scaled_line = dev->loop_vid_out.height;
 313         for (y = 0; y < hmax; y += vdiv, vcapbuf += stride_cap) {
 314                 /* osdline is true if this line requires overlay blending */
 315                 bool osdline = vosdbuf && y >= dev->loop_vid_overlay_cap.top &&
 316                           y < dev->loop_vid_overlay_cap.top + dev->loop_vid_overlay_cap.height;
 317
 318                 /*
 319                  * If this line of the capture buffer doesn't get any video, then
 320                  * just fill with black.
 321                  */
 322                 if (y < dev->loop_vid_cap.top ||
 323                     y >= dev->loop_vid_cap.top + dev->loop_vid_cap.height) {
 324                         memcpy(vcapbuf, tpg->black_line[p], img_width);
 325                         continue;
 326                 }
 327
 328                 /* fill the left border with black */
 329                 if (dev->loop_vid_cap.left)
 330                         memcpy(vcapbuf, tpg->black_line[p], vid_cap_left);
 331
 332                 /* fill the right border with black */
 333                 if (vid_cap_right < img_width)
 334                         memcpy(vcapbuf + vid_cap_right, tpg->black_line[p],
 335                                 img_width - vid_cap_right);
 336
 337                 if (quick && !osdline) {
 338                         memcpy(vcapbuf + vid_cap_left,
 339                                voutbuf + vid_out_y * stride_out,
 340                                tpg_hdiv(tpg, p, dev->loop_vid_cap.width));
 341                         goto update_vid_out_y;
 342                 }
 343                 if (dev->cur_scaled_line == vid_out_y) {
 344                         memcpy(vcapbuf + vid_cap_left, dev->scaled_line,
 345                                tpg_hdiv(tpg, p, dev->loop_vid_cap.width));
 346                         goto update_vid_out_y;
 347                 }
 348                 if (!osdline) {
 349                         scale_line(voutbuf + vid_out_y * stride_out, dev->scaled_line,
 350                                 tpg_hdiv(tpg, p, dev->loop_vid_out.width),
 351                                 tpg_hdiv(tpg, p, dev->loop_vid_cap.width),
 352                                 tpg_g_twopixelsize(tpg, p));
 353                 } else {
 354                         /*
 355                          * Offset in bytes within loop_vid_copy to the start of the
 356                          * loop_vid_overlay rectangle.
 357                          */
 358                         unsigned offset =
 359                                 ((dev->loop_vid_overlay.left - dev->loop_vid_copy.left) *
 360                                  twopixsize) / 2;
 361                         u8 *osd = vosdbuf + vid_overlay_y * stride_osd;
 362
 363                         scale_line(voutbuf + vid_out_y * stride_out, dev->blended_line,
 364                                 dev->loop_vid_out.width, dev->loop_vid_copy.width,
 365                                 tpg_g_twopixelsize(tpg, p));
 366                         if (blend)
 367                                 blend_line(dev, vid_overlay_y + dev->loop_vid_overlay.top,
 368                                            dev->loop_vid_overlay.left,
 369                                            dev->blended_line + offset, osd,
 370                                            dev->loop_vid_overlay.width, twopixsize / 2);
 371                         else
 372                                 memcpy(dev->blended_line + offset,
 373                                        osd, (dev->loop_vid_overlay.width * twopixsize) / 2);
 374                         scale_line(dev->blended_line, dev->scaled_line,
 375                                         dev->loop_vid_copy.width, dev->loop_vid_cap.width,
 376                                         tpg_g_twopixelsize(tpg, p));
 377                 }
 378                 dev->cur_scaled_line = vid_out_y;
 379                 memcpy(vcapbuf + vid_cap_left, dev->scaled_line,
 380                        tpg_hdiv(tpg, p, dev->loop_vid_cap.width));
 381
 382 update_vid_out_y:
 383                 if (osdline) {
 384                         vid_overlay_y += vid_overlay_int_part;
 385                         vid_overlay_error += vid_overlay_fract_part;
 386                         if (vid_overlay_error >= dev->loop_vid_overlay_cap.height) {
 387                                 vid_overlay_error -= dev->loop_vid_overlay_cap.height;
 388                                 vid_overlay_y++;
 389                         }
 390                 }
 391                 vid_out_y += vid_out_int_part;
 392                 vid_out_error += vid_out_fract_part;
 393                 if (vid_out_error >= dev->loop_vid_cap.height / vdiv) {
 394                         vid_out_error -= dev->loop_vid_cap.height / vdiv;
 395                         vid_out_y++;
 396                 }
 397         }
 398
 399         if (!blank)
 400                 return 0;
 401         for (; y < img_height; y += vdiv, vcapbuf += stride_cap)
 402                 memcpy(vcapbuf, tpg->contrast_line[p], img_width);
 403         return 0;
 404 }
 405
 406 static void vivid_fillbuff(struct vivid_dev *dev, struct vivid_buffer *buf)
 407 {
 408         struct tpg_data *tpg = &dev->tpg;
 409         unsigned factor = V4L2_FIELD_HAS_T_OR_B(dev->field_cap) ? 2 : 1;
 410         unsigned line_height = 16 / factor;
 411         bool is_tv = vivid_is_sdtv_cap(dev);
 412         bool is_60hz = is_tv && (dev->std_cap[dev->input] & V4L2_STD_525_60);
 413         unsigned p;
 414         int line = 1;
 415         u8 *basep[TPG_MAX_PLANES][2];
 416         unsigned ms;
 417         char str[100];
 418         s32 gain;
 419         bool is_loop = false;
 420
 421         if (dev->loop_video && dev->can_loop_video &&
 422                 ((vivid_is_svid_cap(dev) &&
 423                 !VIVID_INVALID_SIGNAL(dev->std_signal_mode[dev->input])) ||
 424                 (vivid_is_hdmi_cap(dev) &&
 425                 !VIVID_INVALID_SIGNAL(dev->dv_timings_signal_mode[dev->input]))))
 426                 is_loop = true;
 427
 428         buf->vb.sequence = dev->vid_cap_seq_count;
 429         v4l2_ctrl_s_ctrl(dev->ro_int32, buf->vb.sequence & 0xff);
 430         if (dev->field_cap == V4L2_FIELD_ALTERNATE) {
 431                 /*
 432                  * 60 Hz standards start with the bottom field, 50 Hz standards
 433                  * with the top field. So if the 0-based seq_count is even,
 434                  * then the field is TOP for 50 Hz and BOTTOM for 60 Hz
 435                  * standards.
 436                  */
 437                 buf->vb.field = ((dev->vid_cap_seq_count & 1) ^ is_60hz) ?
 438                         V4L2_FIELD_BOTTOM : V4L2_FIELD_TOP;
 439                 /*
 440                  * The sequence counter counts frames, not fields. So divide
 441                  * by two.
 442                  */
 443                 buf->vb.sequence /= 2;
 444         } else {
 445                 buf->vb.field = dev->field_cap;
 446         }
 447         tpg_s_field(tpg, buf->vb.field,
 448                     dev->field_cap == V4L2_FIELD_ALTERNATE);
 449         tpg_s_perc_fill_blank(tpg, dev->must_blank[buf->vb.vb2_buf.index]);
 450
 451         vivid_precalc_copy_rects(dev);
 452
 453         for (p = 0; p < tpg_g_planes(tpg); p++) {
 454                 void *vbuf = plane_vaddr(tpg, buf, p,
 455                                          tpg->bytesperline, tpg->buf_height);
 456
 457                 /*
 458                  * The first plane of a multiplanar format has a non-zero
 459                  * data_offset. This helps testing whether the application
 460                  * correctly supports non-zero data offsets.
 461                  */
 462                 if (p < tpg_g_buffers(tpg) && dev->fmt_cap->data_offset[p]) {
 463                         memset(vbuf, dev->fmt_cap->data_offset[p] & 0xff,
 464                                dev->fmt_cap->data_offset[p]);
 465                         vbuf += dev->fmt_cap->data_offset[p];
 466                 }
 467                 tpg_calc_text_basep(tpg, basep, p, vbuf);
 468                 if (!is_loop || vivid_copy_buffer(dev, p, vbuf, buf))
 469                         tpg_fill_plane_buffer(tpg, vivid_get_std_cap(dev),
 470                                         p, vbuf);
 471         }
 472         dev->must_blank[buf->vb.vb2_buf.index] = false;
 473
 474         /* Updates stream time, only update at the start of a new frame. */
 475         if (dev->field_cap != V4L2_FIELD_ALTERNATE ||
 476                         (dev->vid_cap_seq_count & 1) == 0)
 477                 dev->ms_vid_cap =
 478                         jiffies_to_msecs(jiffies - dev->jiffies_vid_cap);
 479
 480         ms = dev->ms_vid_cap;
 481         if (dev->osd_mode <= 1) {
 482                 snprintf(str, sizeof(str), " %02d:%02d:%02d:%03d %u%s",
 483                                 (ms / (60 * 60 * 1000)) % 24,
 484                                 (ms / (60 * 1000)) % 60,
 485                                 (ms / 1000) % 60,
 486                                 ms % 1000,
 487                                 buf->vb.sequence,
 488                                 (dev->field_cap == V4L2_FIELD_ALTERNATE) ?
 489                                         (buf->vb.field == V4L2_FIELD_TOP ?
 490                                          " top" : " bottom") : "");
 491                 tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
 492         }
 493         if (dev->osd_mode == 0) {
 494                 snprintf(str, sizeof(str), " %dx%d, input %d ",
 495                                 dev->src_rect.width, dev->src_rect.height, dev->input);
 496                 tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
 497
 498                 gain = v4l2_ctrl_g_ctrl(dev->gain);
 499                 mutex_lock(dev->ctrl_hdl_user_vid.lock);
 500                 snprintf(str, sizeof(str),
 501                         " brightness %3d, contrast %3d, saturation %3d, hue %d ",
 502                         dev->brightness->cur.val,
 503                         dev->contrast->cur.val,
 504                         dev->saturation->cur.val,
 505                         dev->hue->cur.val);
 506                 tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
 507                 snprintf(str, sizeof(str),
 508                         " autogain %d, gain %3d, alpha 0x%02x ",
 509                         dev->autogain->cur.val, gain, dev->alpha->cur.val);
 510                 mutex_unlock(dev->ctrl_hdl_user_vid.lock);
 511                 tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
 512                 mutex_lock(dev->ctrl_hdl_user_aud.lock);
 513                 snprintf(str, sizeof(str),
 514                         " volume %3d, mute %d ",
 515                         dev->volume->cur.val, dev->mute->cur.val);
 516                 mutex_unlock(dev->ctrl_hdl_user_aud.lock);
 517                 tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
 518                 mutex_lock(dev->ctrl_hdl_user_gen.lock);
 519                 snprintf(str, sizeof(str), " int32 %d, ro_int32 %d, int64 %lld, bitmask %08x ",
 520                          dev->int32->cur.val,
 521                          dev->ro_int32->cur.val,
 522                          *dev->int64->p_cur.p_s64,
 523                          dev->bitmask->cur.val);
 524                 tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
 525                 snprintf(str, sizeof(str), " boolean %d, menu %s, string \"%s\" ",
 526                         dev->boolean->cur.val,
 527                         dev->menu->qmenu[dev->menu->cur.val],
 528                         dev->string->p_cur.p_char);
 529                 tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
 530                 snprintf(str, sizeof(str), " integer_menu %lld, value %d ",
 531                         dev->int_menu->qmenu_int[dev->int_menu->cur.val],
 532                         dev->int_menu->cur.val);
 533                 mutex_unlock(dev->ctrl_hdl_user_gen.lock);
 534                 tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
 535                 if (dev->button_pressed) {
 536                         dev->button_pressed--;
 537                         snprintf(str, sizeof(str), " button pressed!");
 538                         tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
 539                 }
 540                 if (dev->osd[0]) {
 541                         if (vivid_is_hdmi_cap(dev)) {
 542                                 snprintf(str, sizeof(str),
 543                                          " OSD \"%s\"", dev->osd);
 544                                 tpg_gen_text(tpg, basep, line++ * line_height,
 545                                              16, str);
 546                         }
 547                         if (dev->osd_jiffies &&
 548                             time_is_before_jiffies(dev->osd_jiffies + 5 * HZ)) {
 549                                 dev->osd[0] = 0;
 550                                 dev->osd_jiffies = 0;
 551                         }
 552                 }
 553         }
 554 }
 555
 556 /*
 557  * Return true if this pixel coordinate is a valid video pixel.
 558  */
 559 static bool valid_pix(struct vivid_dev *dev, int win_y, int win_x, int fb_y, int fb_x)
 560 {
 561         int i;
 562
 563         if (dev->bitmap_cap) {
 564                 /*
 565                  * Only if the corresponding bit in the bitmap is set can
 566                  * the video pixel be shown. Coordinates are relative to
 567                  * the overlay window set by VIDIOC_S_FMT.
 568                  */
 569                 const u8 *p = dev->bitmap_cap;
 570                 unsigned stride = (dev->compose_cap.width + 7) / 8;
 571
 572                 if (!(p[stride * win_y + win_x / 8] & (1 << (win_x & 7))))
 573                         return false;
 574         }
 575
 576         for (i = 0; i < dev->clipcount_cap; i++) {
 577                 /*
 578                  * Only if the framebuffer coordinate is not in any of the
 579                  * clip rectangles will be video pixel be shown.
 580                  */
 581                 struct v4l2_rect *r = &dev->clips_cap[i].c;
 582
 583                 if (fb_y >= r->top && fb_y < r->top + r->height &&
 584                     fb_x >= r->left && fb_x < r->left + r->width)
 585                         return false;
 586         }
 587         return true;
 588 }
 589
 590 /*
 591  * Draw the image into the overlay buffer.
 592  * Note that the combination of overlay and multiplanar is not supported.
 593  */
 594 static void vivid_overlay(struct vivid_dev *dev, struct vivid_buffer *buf)
 595 {
 596         struct tpg_data *tpg = &dev->tpg;
 597         unsigned pixsize = tpg_g_twopixelsize(tpg, 0) / 2;
 598         void *vbase = dev->fb_vbase_cap;
 599         void *vbuf = vb2_plane_vaddr(&buf->vb.vb2_buf, 0);
 600         unsigned img_width = dev->compose_cap.width;
 601         unsigned img_height = dev->compose_cap.height;
 602         unsigned stride = tpg->bytesperline[0];
 603         /* if quick is true, then valid_pix() doesn't have to be called */
 604         bool quick = dev->bitmap_cap == NULL && dev->clipcount_cap == 0;
 605         int x, y, w, out_x = 0;
 606
 607         /*
 608          * Overlay support is only supported for formats that have a twopixelsize
 609          * that's >= 2. Warn and bail out if that's not the case.
 610          */
 611         if (WARN_ON(pixsize == 0))
 612                 return;
 613         if ((dev->overlay_cap_field == V4L2_FIELD_TOP ||
 614              dev->overlay_cap_field == V4L2_FIELD_BOTTOM) &&
 615             dev->overlay_cap_field != buf->vb.field)
 616                 return;
 617
 618         vbuf += dev->compose_cap.left * pixsize + dev->compose_cap.top * stride;
 619         x = dev->overlay_cap_left;
 620         w = img_width;
 621         if (x < 0) {
 622                 out_x = -x;
 623                 w = w - out_x;
 624                 x = 0;
 625         } else {
 626                 w = dev->fb_cap.fmt.width - x;
 627                 if (w > img_width)
 628                         w = img_width;
 629         }
 630         if (w <= 0)
 631                 return;
 632         if (dev->overlay_cap_top >= 0)
 633                 vbase += dev->overlay_cap_top * dev->fb_cap.fmt.bytesperline;
 634         for (y = dev->overlay_cap_top;
 635              y < dev->overlay_cap_top + (int)img_height;
 636              y++, vbuf += stride) {
 637                 int px;
 638
 639                 if (y < 0 || y > dev->fb_cap.fmt.height)
 640                         continue;
 641                 if (quick) {
 642                         memcpy(vbase + x * pixsize,
 643                                vbuf + out_x * pixsize, w * pixsize);
 644                         vbase += dev->fb_cap.fmt.bytesperline;
 645                         continue;
 646                 }
 647                 for (px = 0; px < w; px++) {
 648                         if (!valid_pix(dev, y - dev->overlay_cap_top,
 649                                        px + out_x, y, px + x))
 650                                 continue;
 651                         memcpy(vbase + (px + x) * pixsize,
 652                                vbuf + (px + out_x) * pixsize,
 653                                pixsize);
 654                 }
 655                 vbase += dev->fb_cap.fmt.bytesperline;
 656         }
 657 }
 658
 659 static void vivid_cap_update_frame_period(struct vivid_dev *dev)
 660 {
 661         u64 f_period;
 662
 663         f_period = (u64)dev->timeperframe_vid_cap.numerator * 1000000000;
 664         if (WARN_ON(dev->timeperframe_vid_cap.denominator == 0))
 665                 dev->timeperframe_vid_cap.denominator = 1;
 666         do_div(f_period, dev->timeperframe_vid_cap.denominator);
 667         if (dev->field_cap == V4L2_FIELD_ALTERNATE)
 668                 f_period >>= 1;
 669         /*
 670          * If "End of Frame", then offset the exposure time by 0.9
 671          * of the frame period.
 672          */
 673         dev->cap_frame_eof_offset = f_period * 9;
 674         do_div(dev->cap_frame_eof_offset, 10);
 675         dev->cap_frame_period = f_period;
 676 }
 677
 678 static noinline_for_stack void vivid_thread_vid_cap_tick(struct vivid_dev *dev,
 679                                                          int dropped_bufs)
 680 {
 681         struct vivid_buffer *vid_cap_buf = NULL;
 682         struct vivid_buffer *vbi_cap_buf = NULL;
 683         struct vivid_buffer *meta_cap_buf = NULL;
 684         u64 f_time = 0;
 685
 686         dprintk(dev, 1, "Video Capture Thread Tick\n");
 687
 688         while (dropped_bufs-- > 1)
 689                 tpg_update_mv_count(&dev->tpg,
 690                                 dev->field_cap == V4L2_FIELD_NONE ||
 691                                 dev->field_cap == V4L2_FIELD_ALTERNATE);
 692
 693         /* Drop a certain percentage of buffers. */
 694         if (dev->perc_dropped_buffers &&
 695             prandom_u32_max(100) < dev->perc_dropped_buffers)
 696                 goto update_mv;
 697
 698         spin_lock(&dev->slock);
 699         if (!list_empty(&dev->vid_cap_active)) {
 700                 vid_cap_buf = list_entry(dev->vid_cap_active.next, struct vivid_buffer, list);
 701                 list_del(&vid_cap_buf->list);
 702         }
 703         if (!list_empty(&dev->vbi_cap_active)) {
 704                 if (dev->field_cap != V4L2_FIELD_ALTERNATE ||
 705                     (dev->vbi_cap_seq_count & 1)) {
 706                         vbi_cap_buf = list_entry(dev->vbi_cap_active.next,
 707                                                  struct vivid_buffer, list);
 708                         list_del(&vbi_cap_buf->list);
 709                 }
 710         }
 711         if (!list_empty(&dev->meta_cap_active)) {
 712                 meta_cap_buf = list_entry(dev->meta_cap_active.next,
 713                                           struct vivid_buffer, list);
 714                 list_del(&meta_cap_buf->list);
 715         }
 716
 717         spin_unlock(&dev->slock);
 718
 719         if (!vid_cap_buf && !vbi_cap_buf && !meta_cap_buf)
 720                 goto update_mv;
 721
 722         f_time = dev->cap_frame_period * dev->vid_cap_seq_count +
 723                  dev->cap_stream_start + dev->time_wrap_offset;
 724
 725         if (vid_cap_buf) {
 726                 v4l2_ctrl_request_setup(vid_cap_buf->vb.vb2_buf.req_obj.req,
 727                                         &dev->ctrl_hdl_vid_cap);
 728                 /* Fill buffer */
 729                 vivid_fillbuff(dev, vid_cap_buf);
 730                 dprintk(dev, 1, "filled buffer %d\n",
 731                         vid_cap_buf->vb.vb2_buf.index);
 732
 733                 /* Handle overlay */
 734                 if (dev->overlay_cap_owner && dev->fb_cap.base &&
 735                         dev->fb_cap.fmt.pixelformat == dev->fmt_cap->fourcc)
 736                         vivid_overlay(dev, vid_cap_buf);
 737
 738                 v4l2_ctrl_request_complete(vid_cap_buf->vb.vb2_buf.req_obj.req,
 739                                            &dev->ctrl_hdl_vid_cap);
 740                 vb2_buffer_done(&vid_cap_buf->vb.vb2_buf, dev->dqbuf_error ?
 741                                 VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
 742                 dprintk(dev, 2, "vid_cap buffer %d done\n",
 743                                 vid_cap_buf->vb.vb2_buf.index);
 744
 745                 vid_cap_buf->vb.vb2_buf.timestamp = f_time;
 746                 if (!dev->tstamp_src_is_soe)
 747                         vid_cap_buf->vb.vb2_buf.timestamp += dev->cap_frame_eof_offset;
 748         }
 749
 750         if (vbi_cap_buf) {
 751                 u64 vbi_period;
 752
 753                 v4l2_ctrl_request_setup(vbi_cap_buf->vb.vb2_buf.req_obj.req,
 754                                         &dev->ctrl_hdl_vbi_cap);
 755                 if (vbi_cap_buf->vb.vb2_buf.type == V4L2_BUF_TYPE_SLICED_VBI_CAPTURE)
 756                         vivid_sliced_vbi_cap_process(dev, vbi_cap_buf);
 757                 else
 758                         vivid_raw_vbi_cap_process(dev, vbi_cap_buf);
 759                 v4l2_ctrl_request_complete(vbi_cap_buf->vb.vb2_buf.req_obj.req,
 760                                            &dev->ctrl_hdl_vbi_cap);
 761                 vb2_buffer_done(&vbi_cap_buf->vb.vb2_buf, dev->dqbuf_error ?
 762                                 VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
 763                 dprintk(dev, 2, "vbi_cap %d done\n",
 764                                 vbi_cap_buf->vb.vb2_buf.index);
 765
 766                 /* If capturing a VBI, offset by 0.05 */
 767                 vbi_period = dev->cap_frame_period * 5;
 768                 do_div(vbi_period, 100);
 769                 vbi_cap_buf->vb.vb2_buf.timestamp = f_time + dev->cap_frame_eof_offset + vbi_period;
 770         }
 771
 772         if (meta_cap_buf) {
 773                 v4l2_ctrl_request_setup(meta_cap_buf->vb.vb2_buf.req_obj.req,
 774                                         &dev->ctrl_hdl_meta_cap);
 775                 vivid_meta_cap_fillbuff(dev, meta_cap_buf, f_time);
 776                 v4l2_ctrl_request_complete(meta_cap_buf->vb.vb2_buf.req_obj.req,
 777                                            &dev->ctrl_hdl_meta_cap);
 778                 vb2_buffer_done(&meta_cap_buf->vb.vb2_buf, dev->dqbuf_error ?
 779                                 VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
 780                 dprintk(dev, 2, "meta_cap %d done\n",
 781                         meta_cap_buf->vb.vb2_buf.index);
 782                 meta_cap_buf->vb.vb2_buf.timestamp = f_time + dev->cap_frame_eof_offset;
 783         }
 784
 785         dev->dqbuf_error = false;
 786
 787 update_mv:
 788         /* Update the test pattern movement counters */
 789         tpg_update_mv_count(&dev->tpg, dev->field_cap == V4L2_FIELD_NONE ||
 790                                        dev->field_cap == V4L2_FIELD_ALTERNATE);
 791 }
 792
 793 static int vivid_thread_vid_cap(void *data)
 794 {
 795         struct vivid_dev *dev = data;
 796         u64 numerators_since_start;
 797         u64 buffers_since_start;
 798         u64 next_jiffies_since_start;
 799         unsigned long jiffies_since_start;
 800         unsigned long cur_jiffies;
 801         unsigned wait_jiffies;
 802         unsigned numerator;
 803         unsigned denominator;
 804         int dropped_bufs;
 805
 806         dprintk(dev, 1, "Video Capture Thread Start\n");
 807
 808         set_freezable();
 809
 810         /* Resets frame counters */
 811         dev->cap_seq_offset = 0;
 812         dev->cap_seq_count = 0;
 813         dev->cap_seq_resync = false;
 814         dev->jiffies_vid_cap = jiffies;
 815         dev->cap_stream_start = ktime_get_ns();
 816         vivid_cap_update_frame_period(dev);
 817
 818         for (;;) {
 819                 try_to_freeze();
 820                 if (kthread_should_stop())
 821                         break;
 822
 823                 if (!mutex_trylock(&dev->mutex)) {
 824                         schedule();
 825                         continue;
 826                 }
 827
 828                 cur_jiffies = jiffies;
 829                 if (dev->cap_seq_resync) {
 830                         dev->jiffies_vid_cap = cur_jiffies;
 831                         dev->cap_seq_offset = dev->cap_seq_count + 1;
 832                         dev->cap_seq_count = 0;
 833                         dev->cap_stream_start += dev->cap_frame_period *
 834                                                  dev->cap_seq_offset;
 835                         vivid_cap_update_frame_period(dev);
 836                         dev->cap_seq_resync = false;
 837                 }
 838                 numerator = dev->timeperframe_vid_cap.numerator;
 839                 denominator = dev->timeperframe_vid_cap.denominator;
 840
 841                 if (dev->field_cap == V4L2_FIELD_ALTERNATE)
 842                         denominator *= 2;
 843
 844                 /* Calculate the number of jiffies since we started streaming */
 845                 jiffies_since_start = cur_jiffies - dev->jiffies_vid_cap;
 846                 /* Get the number of buffers streamed since the start */
 847                 buffers_since_start = (u64)jiffies_since_start * denominator +
 848                                       (HZ * numerator) / 2;
 849                 do_div(buffers_since_start, HZ * numerator);
 850
 851                 /*
 852                  * After more than 0xf0000000 (rounded down to a multiple of
 853                  * 'jiffies-per-day' to ease jiffies_to_msecs calculation)
 854                  * jiffies have passed since we started streaming reset the
 855                  * counters and keep track of the sequence offset.
 856                  */
 857                 if (jiffies_since_start > JIFFIES_RESYNC) {
 858                         dev->jiffies_vid_cap = cur_jiffies;
 859                         dev->cap_seq_offset = buffers_since_start;
 860                         buffers_since_start = 0;
 861                 }
 862                 dropped_bufs = buffers_since_start + dev->cap_seq_offset - dev->cap_seq_count;
 863                 dev->cap_seq_count = buffers_since_start + dev->cap_seq_offset;
 864                 dev->vid_cap_seq_count = dev->cap_seq_count - dev->vid_cap_seq_start;
 865                 dev->vbi_cap_seq_count = dev->cap_seq_count - dev->vbi_cap_seq_start;
 866                 dev->meta_cap_seq_count = dev->cap_seq_count - dev->meta_cap_seq_start;
 867
 868                 vivid_thread_vid_cap_tick(dev, dropped_bufs);
 869
 870                 /*
 871                  * Calculate the number of 'numerators' streamed since we started,
 872                  * including the current buffer.
 873                  */
 874                 numerators_since_start = ++buffers_since_start * numerator;
 875
 876                 /* And the number of jiffies since we started */
 877                 jiffies_since_start = jiffies - dev->jiffies_vid_cap;
 878
 879                 mutex_unlock(&dev->mutex);
 880
 881                 /*
 882                  * Calculate when that next buffer is supposed to start
 883                  * in jiffies since we started streaming.
 884                  */
 885                 next_jiffies_since_start = numerators_since_start * HZ +
 886                                            denominator / 2;
 887                 do_div(next_jiffies_since_start, denominator);
 888                 /* If it is in the past, then just schedule asap */
 889                 if (next_jiffies_since_start < jiffies_since_start)
 890                         next_jiffies_since_start = jiffies_since_start;
 891
 892                 wait_jiffies = next_jiffies_since_start - jiffies_since_start;
 893                 while (jiffies - cur_jiffies < wait_jiffies &&
 894                        !kthread_should_stop())
 895                         schedule();
 896         }
 897         dprintk(dev, 1, "Video Capture Thread End\n");
 898         return 0;
 899 }
 900
 901 static void vivid_grab_controls(struct vivid_dev *dev, bool grab)
 902 {
 903         v4l2_ctrl_grab(dev->ctrl_has_crop_cap, grab);
 904         v4l2_ctrl_grab(dev->ctrl_has_compose_cap, grab);
 905         v4l2_ctrl_grab(dev->ctrl_has_scaler_cap, grab);
 906 }
 907
 908 int vivid_start_generating_vid_cap(struct vivid_dev *dev, bool *pstreaming)
 909 {
 910         dprintk(dev, 1, "%s\n", __func__);
 911
 912         if (dev->kthread_vid_cap) {
 913                 u32 seq_count = dev->cap_seq_count + dev->seq_wrap * 128;
 914
 915                 if (pstreaming == &dev->vid_cap_streaming)
 916                         dev->vid_cap_seq_start = seq_count;
 917                 else if (pstreaming == &dev->vbi_cap_streaming)
 918                         dev->vbi_cap_seq_start = seq_count;
 919                 else
 920                         dev->meta_cap_seq_start = seq_count;
 921                 *pstreaming = true;
 922                 return 0;
 923         }
 924
 925         /* Resets frame counters */
 926         tpg_init_mv_count(&dev->tpg);
 927
 928         dev->vid_cap_seq_start = dev->seq_wrap * 128;
 929         dev->vbi_cap_seq_start = dev->seq_wrap * 128;
 930         dev->meta_cap_seq_start = dev->seq_wrap * 128;
 931
 932         dev->kthread_vid_cap = kthread_run(vivid_thread_vid_cap, dev,
 933                         "%s-vid-cap", dev->v4l2_dev.name);
 934
 935         if (IS_ERR(dev->kthread_vid_cap)) {
 936                 int err = PTR_ERR(dev->kthread_vid_cap);
 937
 938                 dev->kthread_vid_cap = NULL;
 939                 v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
 940                 return err;
 941         }
 942         *pstreaming = true;
 943         vivid_grab_controls(dev, true);
 944
 945         dprintk(dev, 1, "returning from %s\n", __func__);
 946         return 0;
 947 }
 948
 949 void vivid_stop_generating_vid_cap(struct vivid_dev *dev, bool *pstreaming)
 950 {
 951         dprintk(dev, 1, "%s\n", __func__);
 952
 953         if (dev->kthread_vid_cap == NULL)
 954                 return;
 955
 956         *pstreaming = false;
 957         if (pstreaming == &dev->vid_cap_streaming) {
 958                 /* Release all active buffers */
 959                 while (!list_empty(&dev->vid_cap_active)) {
 960                         struct vivid_buffer *buf;
 961
 962                         buf = list_entry(dev->vid_cap_active.next,
 963                                          struct vivid_buffer, list);
 964                         list_del(&buf->list);
 965                         v4l2_ctrl_request_complete(buf->vb.vb2_buf.req_obj.req,
 966                                                    &dev->ctrl_hdl_vid_cap);
 967                         vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
 968                         dprintk(dev, 2, "vid_cap buffer %d done\n",
 969                                 buf->vb.vb2_buf.index);
 970                 }
 971         }
 972
 973         if (pstreaming == &dev->vbi_cap_streaming) {
 974                 while (!list_empty(&dev->vbi_cap_active)) {
 975                         struct vivid_buffer *buf;
 976
 977                         buf = list_entry(dev->vbi_cap_active.next,
 978                                          struct vivid_buffer, list);
 979                         list_del(&buf->list);
 980                         v4l2_ctrl_request_complete(buf->vb.vb2_buf.req_obj.req,
 981                                                    &dev->ctrl_hdl_vbi_cap);
 982                         vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
 983                         dprintk(dev, 2, "vbi_cap buffer %d done\n",
 984                                 buf->vb.vb2_buf.index);
 985                 }
 986         }
 987
 988         if (pstreaming == &dev->meta_cap_streaming) {
 989                 while (!list_empty(&dev->meta_cap_active)) {
 990                         struct vivid_buffer *buf;
 991
 992                         buf = list_entry(dev->meta_cap_active.next,
 993                                          struct vivid_buffer, list);
 994                         list_del(&buf->list);
 995                         v4l2_ctrl_request_complete(buf->vb.vb2_buf.req_obj.req,
 996                                                    &dev->ctrl_hdl_meta_cap);
 997                         vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
 998                         dprintk(dev, 2, "meta_cap buffer %d done\n",
 999                                 buf->vb.vb2_buf.index);
1000                 }
1001         }
1002
1003         if (dev->vid_cap_streaming || dev->vbi_cap_streaming ||
1004             dev->meta_cap_streaming)
1005                 return;
1006
1007         /* shutdown control thread */
1008         vivid_grab_controls(dev, false);
1009         kthread_stop(dev->kthread_vid_cap);
1010         dev->kthread_vid_cap = NULL;
1011 }