// SPDX-License-Identifier: GPL-2.0-only
|
/*
|
* vivid-kthread-cap.h - video/vbi capture thread support functions.
|
*
|
* Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
|
*/
|
|
#include <linux/module.h>
|
#include <linux/errno.h>
|
#include <linux/kernel.h>
|
#include <linux/init.h>
|
#include <linux/sched.h>
|
#include <linux/slab.h>
|
#include <linux/font.h>
|
#include <linux/mutex.h>
|
#include <linux/videodev2.h>
|
#include <linux/kthread.h>
|
#include <linux/freezer.h>
|
#include <linux/random.h>
|
#include <linux/v4l2-dv-timings.h>
|
#include <asm/div64.h>
|
#include <media/videobuf2-vmalloc.h>
|
#include <media/v4l2-dv-timings.h>
|
#include <media/v4l2-ioctl.h>
|
#include <media/v4l2-fh.h>
|
#include <media/v4l2-event.h>
|
#include <media/v4l2-rect.h>
|
|
#include "vivid-core.h"
|
#include "vivid-vid-common.h"
|
#include "vivid-vid-cap.h"
|
#include "vivid-vid-out.h"
|
#include "vivid-radio-common.h"
|
#include "vivid-radio-rx.h"
|
#include "vivid-radio-tx.h"
|
#include "vivid-sdr-cap.h"
|
#include "vivid-vbi-cap.h"
|
#include "vivid-vbi-out.h"
|
#include "vivid-osd.h"
|
#include "vivid-ctrls.h"
|
#include "vivid-kthread-cap.h"
|
#include "vivid-meta-cap.h"
|
|
static inline v4l2_std_id vivid_get_std_cap(const struct vivid_dev *dev)
|
{
|
if (vivid_is_sdtv_cap(dev))
|
return dev->std_cap[dev->input];
|
return 0;
|
}
|
|
static void copy_pix(struct vivid_dev *dev, int win_y, int win_x,
|
u16 *cap, const u16 *osd)
|
{
|
u16 out;
|
int left = dev->overlay_out_left;
|
int top = dev->overlay_out_top;
|
int fb_x = win_x + left;
|
int fb_y = win_y + top;
|
int i;
|
|
out = *cap;
|
*cap = *osd;
|
if (dev->bitmap_out) {
|
const u8 *p = dev->bitmap_out;
|
unsigned stride = (dev->compose_out.width + 7) / 8;
|
|
win_x -= dev->compose_out.left;
|
win_y -= dev->compose_out.top;
|
if (!(p[stride * win_y + win_x / 8] & (1 << (win_x & 7))))
|
return;
|
}
|
|
for (i = 0; i < dev->clipcount_out; i++) {
|
struct v4l2_rect *r = &dev->clips_out[i].c;
|
|
if (fb_y >= r->top && fb_y < r->top + r->height &&
|
fb_x >= r->left && fb_x < r->left + r->width)
|
return;
|
}
|
if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_CHROMAKEY) &&
|
*osd != dev->chromakey_out)
|
return;
|
if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_SRC_CHROMAKEY) &&
|
out == dev->chromakey_out)
|
return;
|
if (dev->fmt_cap->alpha_mask) {
|
if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) &&
|
dev->global_alpha_out)
|
return;
|
if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_LOCAL_ALPHA) &&
|
*cap & dev->fmt_cap->alpha_mask)
|
return;
|
if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_LOCAL_INV_ALPHA) &&
|
!(*cap & dev->fmt_cap->alpha_mask))
|
return;
|
}
|
*cap = out;
|
}
|
|
static void blend_line(struct vivid_dev *dev, unsigned y_offset, unsigned x_offset,
|
u8 *vcapbuf, const u8 *vosdbuf,
|
unsigned width, unsigned pixsize)
|
{
|
unsigned x;
|
|
for (x = 0; x < width; x++, vcapbuf += pixsize, vosdbuf += pixsize) {
|
copy_pix(dev, y_offset, x_offset + x,
|
(u16 *)vcapbuf, (const u16 *)vosdbuf);
|
}
|
}
|
|
static void scale_line(const u8 *src, u8 *dst, unsigned srcw, unsigned dstw, unsigned twopixsize)
|
{
|
/* Coarse scaling with Bresenham */
|
unsigned int_part;
|
unsigned fract_part;
|
unsigned src_x = 0;
|
unsigned error = 0;
|
unsigned x;
|
|
/*
|
* We always combine two pixels to prevent color bleed in the packed
|
* yuv case.
|
*/
|
srcw /= 2;
|
dstw /= 2;
|
int_part = srcw / dstw;
|
fract_part = srcw % dstw;
|
for (x = 0; x < dstw; x++, dst += twopixsize) {
|
memcpy(dst, src + src_x * twopixsize, twopixsize);
|
src_x += int_part;
|
error += fract_part;
|
if (error >= dstw) {
|
error -= dstw;
|
src_x++;
|
}
|
}
|
}
|
|
/*
|
* Precalculate the rectangles needed to perform video looping:
|
*
|
* The nominal pipeline is that the video output buffer is cropped by
|
* crop_out, scaled to compose_out, overlaid with the output overlay,
|
* cropped on the capture side by crop_cap and scaled again to the video
|
* capture buffer using compose_cap.
|
*
|
* To keep things efficient we calculate the intersection of compose_out
|
* and crop_cap (since that's the only part of the video that will
|
* actually end up in the capture buffer), determine which part of the
|
* video output buffer that is and which part of the video capture buffer
|
* so we can scale the video straight from the output buffer to the capture
|
* buffer without any intermediate steps.
|
*
|
* If we need to deal with an output overlay, then there is no choice and
|
* that intermediate step still has to be taken. For the output overlay
|
* support we calculate the intersection of the framebuffer and the overlay
|
* window (which may be partially or wholly outside of the framebuffer
|
* itself) and the intersection of that with loop_vid_copy (i.e. the part of
|
* the actual looped video that will be overlaid). The result is calculated
|
* both in framebuffer coordinates (loop_fb_copy) and compose_out coordinates
|
* (loop_vid_overlay). Finally calculate the part of the capture buffer that
|
* will receive that overlaid video.
|
*/
|
static void vivid_precalc_copy_rects(struct vivid_dev *dev)
|
{
|
/* Framebuffer rectangle */
|
struct v4l2_rect r_fb = {
|
0, 0, dev->display_width, dev->display_height
|
};
|
/* Overlay window rectangle in framebuffer coordinates */
|
struct v4l2_rect r_overlay = {
|
dev->overlay_out_left, dev->overlay_out_top,
|
dev->compose_out.width, dev->compose_out.height
|
};
|
|
v4l2_rect_intersect(&dev->loop_vid_copy, &dev->crop_cap, &dev->compose_out);
|
|
dev->loop_vid_out = dev->loop_vid_copy;
|
v4l2_rect_scale(&dev->loop_vid_out, &dev->compose_out, &dev->crop_out);
|
dev->loop_vid_out.left += dev->crop_out.left;
|
dev->loop_vid_out.top += dev->crop_out.top;
|
|
dev->loop_vid_cap = dev->loop_vid_copy;
|
v4l2_rect_scale(&dev->loop_vid_cap, &dev->crop_cap, &dev->compose_cap);
|
|
dprintk(dev, 1,
|
"loop_vid_copy: %dx%d@%dx%d loop_vid_out: %dx%d@%dx%d loop_vid_cap: %dx%d@%dx%d\n",
|
dev->loop_vid_copy.width, dev->loop_vid_copy.height,
|
dev->loop_vid_copy.left, dev->loop_vid_copy.top,
|
dev->loop_vid_out.width, dev->loop_vid_out.height,
|
dev->loop_vid_out.left, dev->loop_vid_out.top,
|
dev->loop_vid_cap.width, dev->loop_vid_cap.height,
|
dev->loop_vid_cap.left, dev->loop_vid_cap.top);
|
|
v4l2_rect_intersect(&r_overlay, &r_fb, &r_overlay);
|
|
/* shift r_overlay to the same origin as compose_out */
|
r_overlay.left += dev->compose_out.left - dev->overlay_out_left;
|
r_overlay.top += dev->compose_out.top - dev->overlay_out_top;
|
|
v4l2_rect_intersect(&dev->loop_vid_overlay, &r_overlay, &dev->loop_vid_copy);
|
dev->loop_fb_copy = dev->loop_vid_overlay;
|
|
/* shift dev->loop_fb_copy back again to the fb origin */
|
dev->loop_fb_copy.left -= dev->compose_out.left - dev->overlay_out_left;
|
dev->loop_fb_copy.top -= dev->compose_out.top - dev->overlay_out_top;
|
|
dev->loop_vid_overlay_cap = dev->loop_vid_overlay;
|
v4l2_rect_scale(&dev->loop_vid_overlay_cap, &dev->crop_cap, &dev->compose_cap);
|
|
dprintk(dev, 1,
|
"loop_fb_copy: %dx%d@%dx%d loop_vid_overlay: %dx%d@%dx%d loop_vid_overlay_cap: %dx%d@%dx%d\n",
|
dev->loop_fb_copy.width, dev->loop_fb_copy.height,
|
dev->loop_fb_copy.left, dev->loop_fb_copy.top,
|
dev->loop_vid_overlay.width, dev->loop_vid_overlay.height,
|
dev->loop_vid_overlay.left, dev->loop_vid_overlay.top,
|
dev->loop_vid_overlay_cap.width, dev->loop_vid_overlay_cap.height,
|
dev->loop_vid_overlay_cap.left, dev->loop_vid_overlay_cap.top);
|
}
|
|
static void *plane_vaddr(struct tpg_data *tpg, struct vivid_buffer *buf,
|
unsigned p, unsigned bpl[TPG_MAX_PLANES], unsigned h)
|
{
|
unsigned i;
|
void *vbuf;
|
|
if (p == 0 || tpg_g_buffers(tpg) > 1)
|
return vb2_plane_vaddr(&buf->vb.vb2_buf, p);
|
vbuf = vb2_plane_vaddr(&buf->vb.vb2_buf, 0);
|
for (i = 0; i < p; i++)
|
vbuf += bpl[i] * h / tpg->vdownsampling[i];
|
return vbuf;
|
}
|
|
static noinline_for_stack int vivid_copy_buffer(struct vivid_dev *dev, unsigned p,
|
u8 *vcapbuf, struct vivid_buffer *vid_cap_buf)
|
{
|
bool blank = dev->must_blank[vid_cap_buf->vb.vb2_buf.index];
|
struct tpg_data *tpg = &dev->tpg;
|
struct vivid_buffer *vid_out_buf = NULL;
|
unsigned vdiv = dev->fmt_out->vdownsampling[p];
|
unsigned twopixsize = tpg_g_twopixelsize(tpg, p);
|
unsigned img_width = tpg_hdiv(tpg, p, dev->compose_cap.width);
|
unsigned img_height = dev->compose_cap.height;
|
unsigned stride_cap = tpg->bytesperline[p];
|
unsigned stride_out = dev->bytesperline_out[p];
|
unsigned stride_osd = dev->display_byte_stride;
|
unsigned hmax = (img_height * tpg->perc_fill) / 100;
|
u8 *voutbuf;
|
u8 *vosdbuf = NULL;
|
unsigned y;
|
bool blend = dev->bitmap_out || dev->clipcount_out || dev->fbuf_out_flags;
|
/* Coarse scaling with Bresenham */
|
unsigned vid_out_int_part;
|
unsigned vid_out_fract_part;
|
unsigned vid_out_y = 0;
|
unsigned vid_out_error = 0;
|
unsigned vid_overlay_int_part = 0;
|
unsigned vid_overlay_fract_part = 0;
|
unsigned vid_overlay_y = 0;
|
unsigned vid_overlay_error = 0;
|
unsigned vid_cap_left = tpg_hdiv(tpg, p, dev->loop_vid_cap.left);
|
unsigned vid_cap_right;
|
bool quick;
|
|
vid_out_int_part = dev->loop_vid_out.height / dev->loop_vid_cap.height;
|
vid_out_fract_part = dev->loop_vid_out.height % dev->loop_vid_cap.height;
|
|
if (!list_empty(&dev->vid_out_active))
|
vid_out_buf = list_entry(dev->vid_out_active.next,
|
struct vivid_buffer, list);
|
if (vid_out_buf == NULL)
|
return -ENODATA;
|
|
vid_cap_buf->vb.field = vid_out_buf->vb.field;
|
|
voutbuf = plane_vaddr(tpg, vid_out_buf, p,
|
dev->bytesperline_out, dev->fmt_out_rect.height);
|
if (p < dev->fmt_out->buffers)
|
voutbuf += vid_out_buf->vb.vb2_buf.planes[p].data_offset;
|
voutbuf += tpg_hdiv(tpg, p, dev->loop_vid_out.left) +
|
(dev->loop_vid_out.top / vdiv) * stride_out;
|
vcapbuf += tpg_hdiv(tpg, p, dev->compose_cap.left) +
|
(dev->compose_cap.top / vdiv) * stride_cap;
|
|
if (dev->loop_vid_copy.width == 0 || dev->loop_vid_copy.height == 0) {
|
/*
|
* If there is nothing to copy, then just fill the capture window
|
* with black.
|
*/
|
for (y = 0; y < hmax / vdiv; y++, vcapbuf += stride_cap)
|
memcpy(vcapbuf, tpg->black_line[p], img_width);
|
return 0;
|
}
|
|
if (dev->overlay_out_enabled &&
|
dev->loop_vid_overlay.width && dev->loop_vid_overlay.height) {
|
vosdbuf = dev->video_vbase;
|
vosdbuf += (dev->loop_fb_copy.left * twopixsize) / 2 +
|
dev->loop_fb_copy.top * stride_osd;
|
vid_overlay_int_part = dev->loop_vid_overlay.height /
|
dev->loop_vid_overlay_cap.height;
|
vid_overlay_fract_part = dev->loop_vid_overlay.height %
|
dev->loop_vid_overlay_cap.height;
|
}
|
|
vid_cap_right = tpg_hdiv(tpg, p, dev->loop_vid_cap.left + dev->loop_vid_cap.width);
|
/* quick is true if no video scaling is needed */
|
quick = dev->loop_vid_out.width == dev->loop_vid_cap.width;
|
|
dev->cur_scaled_line = dev->loop_vid_out.height;
|
for (y = 0; y < hmax; y += vdiv, vcapbuf += stride_cap) {
|
/* osdline is true if this line requires overlay blending */
|
bool osdline = vosdbuf && y >= dev->loop_vid_overlay_cap.top &&
|
y < dev->loop_vid_overlay_cap.top + dev->loop_vid_overlay_cap.height;
|
|
/*
|
* If this line of the capture buffer doesn't get any video, then
|
* just fill with black.
|
*/
|
if (y < dev->loop_vid_cap.top ||
|
y >= dev->loop_vid_cap.top + dev->loop_vid_cap.height) {
|
memcpy(vcapbuf, tpg->black_line[p], img_width);
|
continue;
|
}
|
|
/* fill the left border with black */
|
if (dev->loop_vid_cap.left)
|
memcpy(vcapbuf, tpg->black_line[p], vid_cap_left);
|
|
/* fill the right border with black */
|
if (vid_cap_right < img_width)
|
memcpy(vcapbuf + vid_cap_right, tpg->black_line[p],
|
img_width - vid_cap_right);
|
|
if (quick && !osdline) {
|
memcpy(vcapbuf + vid_cap_left,
|
voutbuf + vid_out_y * stride_out,
|
tpg_hdiv(tpg, p, dev->loop_vid_cap.width));
|
goto update_vid_out_y;
|
}
|
if (dev->cur_scaled_line == vid_out_y) {
|
memcpy(vcapbuf + vid_cap_left, dev->scaled_line,
|
tpg_hdiv(tpg, p, dev->loop_vid_cap.width));
|
goto update_vid_out_y;
|
}
|
if (!osdline) {
|
scale_line(voutbuf + vid_out_y * stride_out, dev->scaled_line,
|
tpg_hdiv(tpg, p, dev->loop_vid_out.width),
|
tpg_hdiv(tpg, p, dev->loop_vid_cap.width),
|
tpg_g_twopixelsize(tpg, p));
|
} else {
|
/*
|
* Offset in bytes within loop_vid_copy to the start of the
|
* loop_vid_overlay rectangle.
|
*/
|
unsigned offset =
|
((dev->loop_vid_overlay.left - dev->loop_vid_copy.left) *
|
twopixsize) / 2;
|
u8 *osd = vosdbuf + vid_overlay_y * stride_osd;
|
|
scale_line(voutbuf + vid_out_y * stride_out, dev->blended_line,
|
dev->loop_vid_out.width, dev->loop_vid_copy.width,
|
tpg_g_twopixelsize(tpg, p));
|
if (blend)
|
blend_line(dev, vid_overlay_y + dev->loop_vid_overlay.top,
|
dev->loop_vid_overlay.left,
|
dev->blended_line + offset, osd,
|
dev->loop_vid_overlay.width, twopixsize / 2);
|
else
|
memcpy(dev->blended_line + offset,
|
osd, (dev->loop_vid_overlay.width * twopixsize) / 2);
|
scale_line(dev->blended_line, dev->scaled_line,
|
dev->loop_vid_copy.width, dev->loop_vid_cap.width,
|
tpg_g_twopixelsize(tpg, p));
|
}
|
dev->cur_scaled_line = vid_out_y;
|
memcpy(vcapbuf + vid_cap_left, dev->scaled_line,
|
tpg_hdiv(tpg, p, dev->loop_vid_cap.width));
|
|
update_vid_out_y:
|
if (osdline) {
|
vid_overlay_y += vid_overlay_int_part;
|
vid_overlay_error += vid_overlay_fract_part;
|
if (vid_overlay_error >= dev->loop_vid_overlay_cap.height) {
|
vid_overlay_error -= dev->loop_vid_overlay_cap.height;
|
vid_overlay_y++;
|
}
|
}
|
vid_out_y += vid_out_int_part;
|
vid_out_error += vid_out_fract_part;
|
if (vid_out_error >= dev->loop_vid_cap.height / vdiv) {
|
vid_out_error -= dev->loop_vid_cap.height / vdiv;
|
vid_out_y++;
|
}
|
}
|
|
if (!blank)
|
return 0;
|
for (; y < img_height; y += vdiv, vcapbuf += stride_cap)
|
memcpy(vcapbuf, tpg->contrast_line[p], img_width);
|
return 0;
|
}
|
|
static void vivid_fillbuff(struct vivid_dev *dev, struct vivid_buffer *buf)
|
{
|
struct tpg_data *tpg = &dev->tpg;
|
unsigned factor = V4L2_FIELD_HAS_T_OR_B(dev->field_cap) ? 2 : 1;
|
unsigned line_height = 16 / factor;
|
bool is_tv = vivid_is_sdtv_cap(dev);
|
bool is_60hz = is_tv && (dev->std_cap[dev->input] & V4L2_STD_525_60);
|
unsigned p;
|
int line = 1;
|
u8 *basep[TPG_MAX_PLANES][2];
|
unsigned ms;
|
char str[100];
|
s32 gain;
|
bool is_loop = false;
|
|
if (dev->loop_video && dev->can_loop_video &&
|
((vivid_is_svid_cap(dev) &&
|
!VIVID_INVALID_SIGNAL(dev->std_signal_mode[dev->input])) ||
|
(vivid_is_hdmi_cap(dev) &&
|
!VIVID_INVALID_SIGNAL(dev->dv_timings_signal_mode[dev->input]))))
|
is_loop = true;
|
|
buf->vb.sequence = dev->vid_cap_seq_count;
|
if (dev->field_cap == V4L2_FIELD_ALTERNATE) {
|
/*
|
* 60 Hz standards start with the bottom field, 50 Hz standards
|
* with the top field. So if the 0-based seq_count is even,
|
* then the field is TOP for 50 Hz and BOTTOM for 60 Hz
|
* standards.
|
*/
|
buf->vb.field = ((dev->vid_cap_seq_count & 1) ^ is_60hz) ?
|
V4L2_FIELD_BOTTOM : V4L2_FIELD_TOP;
|
/*
|
* The sequence counter counts frames, not fields. So divide
|
* by two.
|
*/
|
buf->vb.sequence /= 2;
|
} else {
|
buf->vb.field = dev->field_cap;
|
}
|
tpg_s_field(tpg, buf->vb.field,
|
dev->field_cap == V4L2_FIELD_ALTERNATE);
|
tpg_s_perc_fill_blank(tpg, dev->must_blank[buf->vb.vb2_buf.index]);
|
|
vivid_precalc_copy_rects(dev);
|
|
for (p = 0; p < tpg_g_planes(tpg); p++) {
|
void *vbuf = plane_vaddr(tpg, buf, p,
|
tpg->bytesperline, tpg->buf_height);
|
|
/*
|
* The first plane of a multiplanar format has a non-zero
|
* data_offset. This helps testing whether the application
|
* correctly supports non-zero data offsets.
|
*/
|
if (p < tpg_g_buffers(tpg) && dev->fmt_cap->data_offset[p]) {
|
memset(vbuf, dev->fmt_cap->data_offset[p] & 0xff,
|
dev->fmt_cap->data_offset[p]);
|
vbuf += dev->fmt_cap->data_offset[p];
|
}
|
tpg_calc_text_basep(tpg, basep, p, vbuf);
|
if (!is_loop || vivid_copy_buffer(dev, p, vbuf, buf))
|
tpg_fill_plane_buffer(tpg, vivid_get_std_cap(dev),
|
p, vbuf);
|
}
|
dev->must_blank[buf->vb.vb2_buf.index] = false;
|
|
/* Updates stream time, only update at the start of a new frame. */
|
if (dev->field_cap != V4L2_FIELD_ALTERNATE ||
|
(dev->vid_cap_seq_count & 1) == 0)
|
dev->ms_vid_cap =
|
jiffies_to_msecs(jiffies - dev->jiffies_vid_cap);
|
|
ms = dev->ms_vid_cap;
|
if (dev->osd_mode <= 1) {
|
snprintf(str, sizeof(str), " %02d:%02d:%02d:%03d %u%s",
|
(ms / (60 * 60 * 1000)) % 24,
|
(ms / (60 * 1000)) % 60,
|
(ms / 1000) % 60,
|
ms % 1000,
|
buf->vb.sequence,
|
(dev->field_cap == V4L2_FIELD_ALTERNATE) ?
|
(buf->vb.field == V4L2_FIELD_TOP ?
|
" top" : " bottom") : "");
|
tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
|
}
|
if (dev->osd_mode == 0) {
|
snprintf(str, sizeof(str), " %dx%d, input %d ",
|
dev->src_rect.width, dev->src_rect.height, dev->input);
|
tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
|
|
gain = v4l2_ctrl_g_ctrl(dev->gain);
|
mutex_lock(dev->ctrl_hdl_user_vid.lock);
|
snprintf(str, sizeof(str),
|
" brightness %3d, contrast %3d, saturation %3d, hue %d ",
|
dev->brightness->cur.val,
|
dev->contrast->cur.val,
|
dev->saturation->cur.val,
|
dev->hue->cur.val);
|
tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
|
snprintf(str, sizeof(str),
|
" autogain %d, gain %3d, alpha 0x%02x ",
|
dev->autogain->cur.val, gain, dev->alpha->cur.val);
|
mutex_unlock(dev->ctrl_hdl_user_vid.lock);
|
tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
|
mutex_lock(dev->ctrl_hdl_user_aud.lock);
|
snprintf(str, sizeof(str),
|
" volume %3d, mute %d ",
|
dev->volume->cur.val, dev->mute->cur.val);
|
mutex_unlock(dev->ctrl_hdl_user_aud.lock);
|
tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
|
mutex_lock(dev->ctrl_hdl_user_gen.lock);
|
snprintf(str, sizeof(str), " int32 %d, int64 %lld, bitmask %08x ",
|
dev->int32->cur.val,
|
*dev->int64->p_cur.p_s64,
|
dev->bitmask->cur.val);
|
tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
|
snprintf(str, sizeof(str), " boolean %d, menu %s, string \"%s\" ",
|
dev->boolean->cur.val,
|
dev->menu->qmenu[dev->menu->cur.val],
|
dev->string->p_cur.p_char);
|
tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
|
snprintf(str, sizeof(str), " integer_menu %lld, value %d ",
|
dev->int_menu->qmenu_int[dev->int_menu->cur.val],
|
dev->int_menu->cur.val);
|
mutex_unlock(dev->ctrl_hdl_user_gen.lock);
|
tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
|
if (dev->button_pressed) {
|
dev->button_pressed--;
|
snprintf(str, sizeof(str), " button pressed!");
|
tpg_gen_text(tpg, basep, line++ * line_height, 16, str);
|
}
|
if (dev->osd[0]) {
|
if (vivid_is_hdmi_cap(dev)) {
|
snprintf(str, sizeof(str),
|
" OSD \"%s\"", dev->osd);
|
tpg_gen_text(tpg, basep, line++ * line_height,
|
16, str);
|
}
|
if (dev->osd_jiffies &&
|
time_is_before_jiffies(dev->osd_jiffies + 5 * HZ)) {
|
dev->osd[0] = 0;
|
dev->osd_jiffies = 0;
|
}
|
}
|
}
|
}
|
|
/*
|
* Return true if this pixel coordinate is a valid video pixel.
|
*/
|
static bool valid_pix(struct vivid_dev *dev, int win_y, int win_x, int fb_y, int fb_x)
|
{
|
int i;
|
|
if (dev->bitmap_cap) {
|
/*
|
* Only if the corresponding bit in the bitmap is set can
|
* the video pixel be shown. Coordinates are relative to
|
* the overlay window set by VIDIOC_S_FMT.
|
*/
|
const u8 *p = dev->bitmap_cap;
|
unsigned stride = (dev->compose_cap.width + 7) / 8;
|
|
if (!(p[stride * win_y + win_x / 8] & (1 << (win_x & 7))))
|
return false;
|
}
|
|
for (i = 0; i < dev->clipcount_cap; i++) {
|
/*
|
* Only if the framebuffer coordinate is not in any of the
|
* clip rectangles will be video pixel be shown.
|
*/
|
struct v4l2_rect *r = &dev->clips_cap[i].c;
|
|
if (fb_y >= r->top && fb_y < r->top + r->height &&
|
fb_x >= r->left && fb_x < r->left + r->width)
|
return false;
|
}
|
return true;
|
}
|
|
/*
|
* Draw the image into the overlay buffer.
|
* Note that the combination of overlay and multiplanar is not supported.
|
*/
|
static void vivid_overlay(struct vivid_dev *dev, struct vivid_buffer *buf)
|
{
|
struct tpg_data *tpg = &dev->tpg;
|
unsigned pixsize = tpg_g_twopixelsize(tpg, 0) / 2;
|
void *vbase = dev->fb_vbase_cap;
|
void *vbuf = vb2_plane_vaddr(&buf->vb.vb2_buf, 0);
|
unsigned img_width = dev->compose_cap.width;
|
unsigned img_height = dev->compose_cap.height;
|
unsigned stride = tpg->bytesperline[0];
|
/* if quick is true, then valid_pix() doesn't have to be called */
|
bool quick = dev->bitmap_cap == NULL && dev->clipcount_cap == 0;
|
int x, y, w, out_x = 0;
|
|
/*
|
* Overlay support is only supported for formats that have a twopixelsize
|
* that's >= 2. Warn and bail out if that's not the case.
|
*/
|
if (WARN_ON(pixsize == 0))
|
return;
|
if ((dev->overlay_cap_field == V4L2_FIELD_TOP ||
|
dev->overlay_cap_field == V4L2_FIELD_BOTTOM) &&
|
dev->overlay_cap_field != buf->vb.field)
|
return;
|
|
vbuf += dev->compose_cap.left * pixsize + dev->compose_cap.top * stride;
|
x = dev->overlay_cap_left;
|
w = img_width;
|
if (x < 0) {
|
out_x = -x;
|
w = w - out_x;
|
x = 0;
|
} else {
|
w = dev->fb_cap.fmt.width - x;
|
if (w > img_width)
|
w = img_width;
|
}
|
if (w <= 0)
|
return;
|
if (dev->overlay_cap_top >= 0)
|
vbase += dev->overlay_cap_top * dev->fb_cap.fmt.bytesperline;
|
for (y = dev->overlay_cap_top;
|
y < dev->overlay_cap_top + (int)img_height;
|
y++, vbuf += stride) {
|
int px;
|
|
if (y < 0 || y > dev->fb_cap.fmt.height)
|
continue;
|
if (quick) {
|
memcpy(vbase + x * pixsize,
|
vbuf + out_x * pixsize, w * pixsize);
|
vbase += dev->fb_cap.fmt.bytesperline;
|
continue;
|
}
|
for (px = 0; px < w; px++) {
|
if (!valid_pix(dev, y - dev->overlay_cap_top,
|
px + out_x, y, px + x))
|
continue;
|
memcpy(vbase + (px + x) * pixsize,
|
vbuf + (px + out_x) * pixsize,
|
pixsize);
|
}
|
vbase += dev->fb_cap.fmt.bytesperline;
|
}
|
}
|
|
static void vivid_cap_update_frame_period(struct vivid_dev *dev)
|
{
|
u64 f_period;
|
|
f_period = (u64)dev->timeperframe_vid_cap.numerator * 1000000000;
|
if (WARN_ON(dev->timeperframe_vid_cap.denominator == 0))
|
dev->timeperframe_vid_cap.denominator = 1;
|
do_div(f_period, dev->timeperframe_vid_cap.denominator);
|
if (dev->field_cap == V4L2_FIELD_ALTERNATE)
|
f_period >>= 1;
|
/*
|
* If "End of Frame", then offset the exposure time by 0.9
|
* of the frame period.
|
*/
|
dev->cap_frame_eof_offset = f_period * 9;
|
do_div(dev->cap_frame_eof_offset, 10);
|
dev->cap_frame_period = f_period;
|
}
|
|
static noinline_for_stack void vivid_thread_vid_cap_tick(struct vivid_dev *dev,
|
int dropped_bufs)
|
{
|
struct vivid_buffer *vid_cap_buf = NULL;
|
struct vivid_buffer *vbi_cap_buf = NULL;
|
struct vivid_buffer *meta_cap_buf = NULL;
|
u64 f_time = 0;
|
|
dprintk(dev, 1, "Video Capture Thread Tick\n");
|
|
while (dropped_bufs-- > 1)
|
tpg_update_mv_count(&dev->tpg,
|
dev->field_cap == V4L2_FIELD_NONE ||
|
dev->field_cap == V4L2_FIELD_ALTERNATE);
|
|
/* Drop a certain percentage of buffers. */
|
if (dev->perc_dropped_buffers &&
|
prandom_u32_max(100) < dev->perc_dropped_buffers)
|
goto update_mv;
|
|
spin_lock(&dev->slock);
|
if (!list_empty(&dev->vid_cap_active)) {
|
vid_cap_buf = list_entry(dev->vid_cap_active.next, struct vivid_buffer, list);
|
list_del(&vid_cap_buf->list);
|
}
|
if (!list_empty(&dev->vbi_cap_active)) {
|
if (dev->field_cap != V4L2_FIELD_ALTERNATE ||
|
(dev->vbi_cap_seq_count & 1)) {
|
vbi_cap_buf = list_entry(dev->vbi_cap_active.next,
|
struct vivid_buffer, list);
|
list_del(&vbi_cap_buf->list);
|
}
|
}
|
if (!list_empty(&dev->meta_cap_active)) {
|
meta_cap_buf = list_entry(dev->meta_cap_active.next,
|
struct vivid_buffer, list);
|
list_del(&meta_cap_buf->list);
|
}
|
|
spin_unlock(&dev->slock);
|
|
if (!vid_cap_buf && !vbi_cap_buf && !meta_cap_buf)
|
goto update_mv;
|
|
f_time = dev->cap_frame_period * dev->vid_cap_seq_count +
|
dev->cap_stream_start + dev->time_wrap_offset;
|
|
if (vid_cap_buf) {
|
v4l2_ctrl_request_setup(vid_cap_buf->vb.vb2_buf.req_obj.req,
|
&dev->ctrl_hdl_vid_cap);
|
/* Fill buffer */
|
vivid_fillbuff(dev, vid_cap_buf);
|
dprintk(dev, 1, "filled buffer %d\n",
|
vid_cap_buf->vb.vb2_buf.index);
|
|
/* Handle overlay */
|
if (dev->overlay_cap_owner && dev->fb_cap.base &&
|
dev->fb_cap.fmt.pixelformat == dev->fmt_cap->fourcc)
|
vivid_overlay(dev, vid_cap_buf);
|
|
v4l2_ctrl_request_complete(vid_cap_buf->vb.vb2_buf.req_obj.req,
|
&dev->ctrl_hdl_vid_cap);
|
vb2_buffer_done(&vid_cap_buf->vb.vb2_buf, dev->dqbuf_error ?
|
VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
|
dprintk(dev, 2, "vid_cap buffer %d done\n",
|
vid_cap_buf->vb.vb2_buf.index);
|
|
vid_cap_buf->vb.vb2_buf.timestamp = f_time;
|
if (!dev->tstamp_src_is_soe)
|
vid_cap_buf->vb.vb2_buf.timestamp += dev->cap_frame_eof_offset;
|
}
|
|
if (vbi_cap_buf) {
|
u64 vbi_period;
|
|
v4l2_ctrl_request_setup(vbi_cap_buf->vb.vb2_buf.req_obj.req,
|
&dev->ctrl_hdl_vbi_cap);
|
if (dev->stream_sliced_vbi_cap)
|
vivid_sliced_vbi_cap_process(dev, vbi_cap_buf);
|
else
|
vivid_raw_vbi_cap_process(dev, vbi_cap_buf);
|
v4l2_ctrl_request_complete(vbi_cap_buf->vb.vb2_buf.req_obj.req,
|
&dev->ctrl_hdl_vbi_cap);
|
vb2_buffer_done(&vbi_cap_buf->vb.vb2_buf, dev->dqbuf_error ?
|
VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
|
dprintk(dev, 2, "vbi_cap %d done\n",
|
vbi_cap_buf->vb.vb2_buf.index);
|
|
/* If capturing a VBI, offset by 0.05 */
|
vbi_period = dev->cap_frame_period * 5;
|
do_div(vbi_period, 100);
|
vbi_cap_buf->vb.vb2_buf.timestamp = f_time + dev->cap_frame_eof_offset + vbi_period;
|
}
|
|
if (meta_cap_buf) {
|
v4l2_ctrl_request_setup(meta_cap_buf->vb.vb2_buf.req_obj.req,
|
&dev->ctrl_hdl_meta_cap);
|
vivid_meta_cap_fillbuff(dev, meta_cap_buf, f_time);
|
v4l2_ctrl_request_complete(meta_cap_buf->vb.vb2_buf.req_obj.req,
|
&dev->ctrl_hdl_meta_cap);
|
vb2_buffer_done(&meta_cap_buf->vb.vb2_buf, dev->dqbuf_error ?
|
VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
|
dprintk(dev, 2, "meta_cap %d done\n",
|
meta_cap_buf->vb.vb2_buf.index);
|
meta_cap_buf->vb.vb2_buf.timestamp = f_time + dev->cap_frame_eof_offset;
|
}
|
|
dev->dqbuf_error = false;
|
|
update_mv:
|
/* Update the test pattern movement counters */
|
tpg_update_mv_count(&dev->tpg, dev->field_cap == V4L2_FIELD_NONE ||
|
dev->field_cap == V4L2_FIELD_ALTERNATE);
|
}
|
|
static int vivid_thread_vid_cap(void *data)
|
{
|
struct vivid_dev *dev = data;
|
u64 numerators_since_start;
|
u64 buffers_since_start;
|
u64 next_jiffies_since_start;
|
unsigned long jiffies_since_start;
|
unsigned long cur_jiffies;
|
unsigned wait_jiffies;
|
unsigned numerator;
|
unsigned denominator;
|
int dropped_bufs;
|
|
dprintk(dev, 1, "Video Capture Thread Start\n");
|
|
set_freezable();
|
|
/* Resets frame counters */
|
dev->cap_seq_offset = 0;
|
dev->cap_seq_count = 0;
|
dev->cap_seq_resync = false;
|
dev->jiffies_vid_cap = jiffies;
|
dev->cap_stream_start = ktime_get_ns();
|
vivid_cap_update_frame_period(dev);
|
|
for (;;) {
|
try_to_freeze();
|
if (kthread_should_stop())
|
break;
|
|
if (!mutex_trylock(&dev->mutex)) {
|
schedule_timeout_uninterruptible(1);
|
continue;
|
}
|
|
cur_jiffies = jiffies;
|
if (dev->cap_seq_resync) {
|
dev->jiffies_vid_cap = cur_jiffies;
|
dev->cap_seq_offset = dev->cap_seq_count + 1;
|
dev->cap_seq_count = 0;
|
dev->cap_stream_start += dev->cap_frame_period *
|
dev->cap_seq_offset;
|
vivid_cap_update_frame_period(dev);
|
dev->cap_seq_resync = false;
|
}
|
numerator = dev->timeperframe_vid_cap.numerator;
|
denominator = dev->timeperframe_vid_cap.denominator;
|
|
if (dev->field_cap == V4L2_FIELD_ALTERNATE)
|
denominator *= 2;
|
|
/* Calculate the number of jiffies since we started streaming */
|
jiffies_since_start = cur_jiffies - dev->jiffies_vid_cap;
|
/* Get the number of buffers streamed since the start */
|
buffers_since_start = (u64)jiffies_since_start * denominator +
|
(HZ * numerator) / 2;
|
do_div(buffers_since_start, HZ * numerator);
|
|
/*
|
* After more than 0xf0000000 (rounded down to a multiple of
|
* 'jiffies-per-day' to ease jiffies_to_msecs calculation)
|
* jiffies have passed since we started streaming reset the
|
* counters and keep track of the sequence offset.
|
*/
|
if (jiffies_since_start > JIFFIES_RESYNC) {
|
dev->jiffies_vid_cap = cur_jiffies;
|
dev->cap_seq_offset = buffers_since_start;
|
buffers_since_start = 0;
|
}
|
dropped_bufs = buffers_since_start + dev->cap_seq_offset - dev->cap_seq_count;
|
dev->cap_seq_count = buffers_since_start + dev->cap_seq_offset;
|
dev->vid_cap_seq_count = dev->cap_seq_count - dev->vid_cap_seq_start;
|
dev->vbi_cap_seq_count = dev->cap_seq_count - dev->vbi_cap_seq_start;
|
dev->meta_cap_seq_count = dev->cap_seq_count - dev->meta_cap_seq_start;
|
|
vivid_thread_vid_cap_tick(dev, dropped_bufs);
|
|
/*
|
* Calculate the number of 'numerators' streamed since we started,
|
* including the current buffer.
|
*/
|
numerators_since_start = ++buffers_since_start * numerator;
|
|
/* And the number of jiffies since we started */
|
jiffies_since_start = jiffies - dev->jiffies_vid_cap;
|
|
mutex_unlock(&dev->mutex);
|
|
/*
|
* Calculate when that next buffer is supposed to start
|
* in jiffies since we started streaming.
|
*/
|
next_jiffies_since_start = numerators_since_start * HZ +
|
denominator / 2;
|
do_div(next_jiffies_since_start, denominator);
|
/* If it is in the past, then just schedule asap */
|
if (next_jiffies_since_start < jiffies_since_start)
|
next_jiffies_since_start = jiffies_since_start;
|
|
wait_jiffies = next_jiffies_since_start - jiffies_since_start;
|
schedule_timeout_interruptible(wait_jiffies ? wait_jiffies : 1);
|
}
|
dprintk(dev, 1, "Video Capture Thread End\n");
|
return 0;
|
}
|
|
static void vivid_grab_controls(struct vivid_dev *dev, bool grab)
|
{
|
v4l2_ctrl_grab(dev->ctrl_has_crop_cap, grab);
|
v4l2_ctrl_grab(dev->ctrl_has_compose_cap, grab);
|
v4l2_ctrl_grab(dev->ctrl_has_scaler_cap, grab);
|
}
|
|
int vivid_start_generating_vid_cap(struct vivid_dev *dev, bool *pstreaming)
|
{
|
dprintk(dev, 1, "%s\n", __func__);
|
|
if (dev->kthread_vid_cap) {
|
u32 seq_count = dev->cap_seq_count + dev->seq_wrap * 128;
|
|
if (pstreaming == &dev->vid_cap_streaming)
|
dev->vid_cap_seq_start = seq_count;
|
else if (pstreaming == &dev->vbi_cap_streaming)
|
dev->vbi_cap_seq_start = seq_count;
|
else
|
dev->meta_cap_seq_start = seq_count;
|
*pstreaming = true;
|
return 0;
|
}
|
|
/* Resets frame counters */
|
tpg_init_mv_count(&dev->tpg);
|
|
dev->vid_cap_seq_start = dev->seq_wrap * 128;
|
dev->vbi_cap_seq_start = dev->seq_wrap * 128;
|
dev->meta_cap_seq_start = dev->seq_wrap * 128;
|
|
dev->kthread_vid_cap = kthread_run(vivid_thread_vid_cap, dev,
|
"%s-vid-cap", dev->v4l2_dev.name);
|
|
if (IS_ERR(dev->kthread_vid_cap)) {
|
int err = PTR_ERR(dev->kthread_vid_cap);
|
|
dev->kthread_vid_cap = NULL;
|
v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
|
return err;
|
}
|
*pstreaming = true;
|
vivid_grab_controls(dev, true);
|
|
dprintk(dev, 1, "returning from %s\n", __func__);
|
return 0;
|
}
|
|
void vivid_stop_generating_vid_cap(struct vivid_dev *dev, bool *pstreaming)
|
{
|
dprintk(dev, 1, "%s\n", __func__);
|
|
if (dev->kthread_vid_cap == NULL)
|
return;
|
|
*pstreaming = false;
|
if (pstreaming == &dev->vid_cap_streaming) {
|
/* Release all active buffers */
|
while (!list_empty(&dev->vid_cap_active)) {
|
struct vivid_buffer *buf;
|
|
buf = list_entry(dev->vid_cap_active.next,
|
struct vivid_buffer, list);
|
list_del(&buf->list);
|
v4l2_ctrl_request_complete(buf->vb.vb2_buf.req_obj.req,
|
&dev->ctrl_hdl_vid_cap);
|
vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
|
dprintk(dev, 2, "vid_cap buffer %d done\n",
|
buf->vb.vb2_buf.index);
|
}
|
}
|
|
if (pstreaming == &dev->vbi_cap_streaming) {
|
while (!list_empty(&dev->vbi_cap_active)) {
|
struct vivid_buffer *buf;
|
|
buf = list_entry(dev->vbi_cap_active.next,
|
struct vivid_buffer, list);
|
list_del(&buf->list);
|
v4l2_ctrl_request_complete(buf->vb.vb2_buf.req_obj.req,
|
&dev->ctrl_hdl_vbi_cap);
|
vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
|
dprintk(dev, 2, "vbi_cap buffer %d done\n",
|
buf->vb.vb2_buf.index);
|
}
|
}
|
|
if (pstreaming == &dev->meta_cap_streaming) {
|
while (!list_empty(&dev->meta_cap_active)) {
|
struct vivid_buffer *buf;
|
|
buf = list_entry(dev->meta_cap_active.next,
|
struct vivid_buffer, list);
|
list_del(&buf->list);
|
v4l2_ctrl_request_complete(buf->vb.vb2_buf.req_obj.req,
|
&dev->ctrl_hdl_meta_cap);
|
vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
|
dprintk(dev, 2, "meta_cap buffer %d done\n",
|
buf->vb.vb2_buf.index);
|
}
|
}
|
|
if (dev->vid_cap_streaming || dev->vbi_cap_streaming ||
|
dev->meta_cap_streaming)
|
return;
|
|
/* shutdown control thread */
|
vivid_grab_controls(dev, false);
|
kthread_stop(dev->kthread_vid_cap);
|
dev->kthread_vid_cap = NULL;
|
}
|
