Lines Matching refs:dev
44 static inline v4l2_std_id vivid_get_std_cap(const struct vivid_dev *dev)
46 if (vivid_is_sdtv_cap(dev))
47 return dev->std_cap[dev->input];
51 static void copy_pix(struct vivid_dev *dev, int win_y, int win_x,
55 int left = dev->overlay_out_left;
56 int top = dev->overlay_out_top;
63 if (dev->bitmap_out) {
64 const u8 *p = dev->bitmap_out;
65 unsigned stride = (dev->compose_out.width + 7) / 8;
67 win_x -= dev->compose_out.left;
68 win_y -= dev->compose_out.top;
73 for (i = 0; i < dev->clipcount_out; i++) {
74 struct v4l2_rect *r = &dev->clips_out[i].c;
80 if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_CHROMAKEY) &&
81 *osd != dev->chromakey_out)
83 if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_SRC_CHROMAKEY) &&
84 out == dev->chromakey_out)
86 if (dev->fmt_cap->alpha_mask) {
87 if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) &&
88 dev->global_alpha_out)
90 if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_LOCAL_ALPHA) &&
91 *cap & dev->fmt_cap->alpha_mask)
93 if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_LOCAL_INV_ALPHA) &&
94 !(*cap & dev->fmt_cap->alpha_mask))
100 static void blend_line(struct vivid_dev *dev, unsigned y_offset, unsigned x_offset,
107 copy_pix(dev, y_offset, x_offset + x,
165 static void vivid_precalc_copy_rects(struct vivid_dev *dev)
169 0, 0, dev->display_width, dev->display_height
173 dev->overlay_out_left, dev->overlay_out_top,
174 dev->compose_out.width, dev->compose_out.height
177 v4l2_rect_intersect(&dev->loop_vid_copy, &dev->crop_cap, &dev->compose_out);
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;
184 dev->loop_vid_cap = dev->loop_vid_copy;
185 v4l2_rect_scale(&dev->loop_vid_cap, &dev->crop_cap, &dev->compose_cap);
187 dprintk(dev, 1,
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);
199 r_overlay.left += dev->compose_out.left - dev->overlay_out_left;
200 r_overlay.top += dev->compose_out.top - dev->overlay_out_top;
202 v4l2_rect_intersect(&dev->loop_vid_overlay, &r_overlay, &dev->loop_vid_copy);
203 dev->loop_fb_copy = dev->loop_vid_overlay;
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;
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);
212 dprintk(dev, 1,
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);
236 static noinline_for_stack int vivid_copy_buffer(struct vivid_dev *dev, unsigned p,
239 bool blank = dev->must_blank[vid_cap_buf->vb.vb2_buf.index];
240 struct tpg_data *tpg = &dev->tpg;
242 unsigned vdiv = dev->fmt_out->vdownsampling[p];
244 unsigned img_width = tpg_hdiv(tpg, p, dev->compose_cap.width);
245 unsigned img_height = dev->compose_cap.height;
247 unsigned stride_out = dev->bytesperline_out[p];
248 unsigned stride_osd = dev->display_byte_stride;
253 bool blend = dev->bitmap_out || dev->clipcount_out || dev->fbuf_out_flags;
263 unsigned vid_cap_left = tpg_hdiv(tpg, p, dev->loop_vid_cap.left);
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;
270 if (!list_empty(&dev->vid_out_active))
271 vid_out_buf = list_entry(dev->vid_out_active.next,
279 dev->bytesperline_out, dev->fmt_out_rect.height);
280 if (p < dev->fmt_out->buffers)
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;
287 if (dev->loop_vid_copy.width == 0 || dev->loop_vid_copy.height == 0) {
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;
308 vid_cap_right = tpg_hdiv(tpg, p, dev->loop_vid_cap.left + dev->loop_vid_cap.width);
310 quick = dev->loop_vid_out.width == dev->loop_vid_cap.width;
312 dev->cur_scaled_line = dev->loop_vid_out.height;
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;
322 if (y < dev->loop_vid_cap.top ||
323 y >= dev->loop_vid_cap.top + dev->loop_vid_cap.height) {
329 if (dev->loop_vid_cap.left)
340 tpg_hdiv(tpg, p, dev->loop_vid_cap.width));
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));
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),
359 ((dev->loop_vid_overlay.left - dev->loop_vid_copy.left) *
363 scale_line(voutbuf + vid_out_y * stride_out, dev->blended_line,
364 dev->loop_vid_out.width, dev->loop_vid_copy.width,
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);
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,
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));
386 if (vid_overlay_error >= dev->loop_vid_overlay_cap.height) {
387 vid_overlay_error -= dev->loop_vid_overlay_cap.height;
393 if (vid_out_error >= dev->loop_vid_cap.height / vdiv) {
394 vid_out_error -= dev->loop_vid_cap.height / vdiv;
406 static void vivid_fillbuff(struct vivid_dev *dev, struct vivid_buffer *buf)
408 struct tpg_data *tpg = &dev->tpg;
409 unsigned factor = V4L2_FIELD_HAS_T_OR_B(dev->field_cap) ? 2 : 1;
411 bool is_tv = vivid_is_sdtv_cap(dev);
412 bool is_60hz = is_tv && (dev->std_cap[dev->input] & V4L2_STD_525_60);
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]))))
428 buf->vb.sequence = dev->vid_cap_seq_count;
429 if (dev->field_cap == V4L2_FIELD_ALTERNATE) {
436 buf->vb.field = ((dev->vid_cap_seq_count & 1) ^ is_60hz) ?
444 buf->vb.field = dev->field_cap;
447 dev->field_cap == V4L2_FIELD_ALTERNATE);
448 tpg_s_perc_fill_blank(tpg, dev->must_blank[buf->vb.vb2_buf.index]);
450 vivid_precalc_copy_rects(dev);
461 if (p < tpg_g_buffers(tpg) && dev->fmt_cap->data_offset[p]) {
462 memset(vbuf, dev->fmt_cap->data_offset[p] & 0xff,
463 dev->fmt_cap->data_offset[p]);
464 vbuf += dev->fmt_cap->data_offset[p];
467 if (!is_loop || vivid_copy_buffer(dev, p, vbuf, buf))
468 tpg_fill_plane_buffer(tpg, vivid_get_std_cap(dev),
471 dev->must_blank[buf->vb.vb2_buf.index] = false;
474 if (dev->field_cap != V4L2_FIELD_ALTERNATE ||
475 (dev->vid_cap_seq_count & 1) == 0)
476 dev->ms_vid_cap =
477 jiffies_to_msecs(jiffies - dev->jiffies_vid_cap);
479 ms = dev->ms_vid_cap;
480 if (dev->osd_mode <= 1) {
487 (dev->field_cap == V4L2_FIELD_ALTERNATE) ?
492 if (dev->osd_mode == 0) {
494 dev->src_rect.width, dev->src_rect.height, dev->input);
497 gain = v4l2_ctrl_g_ctrl(dev->gain);
498 mutex_lock(dev->ctrl_hdl_user_vid.lock);
501 dev->brightness->cur.val,
502 dev->contrast->cur.val,
503 dev->saturation->cur.val,
504 dev->hue->cur.val);
508 dev->autogain->cur.val, gain, dev->alpha->cur.val);
509 mutex_unlock(dev->ctrl_hdl_user_vid.lock);
511 mutex_lock(dev->ctrl_hdl_user_aud.lock);
514 dev->volume->cur.val, dev->mute->cur.val);
515 mutex_unlock(dev->ctrl_hdl_user_aud.lock);
517 mutex_lock(dev->ctrl_hdl_user_gen.lock);
519 dev->int32->cur.val,
520 *dev->int64->p_cur.p_s64,
521 dev->bitmask->cur.val);
524 dev->boolean->cur.val,
525 dev->menu->qmenu[dev->menu->cur.val],
526 dev->string->p_cur.p_char);
529 dev->int_menu->qmenu_int[dev->int_menu->cur.val],
530 dev->int_menu->cur.val);
531 mutex_unlock(dev->ctrl_hdl_user_gen.lock);
533 if (dev->button_pressed) {
534 dev->button_pressed--;
538 if (dev->osd[0]) {
539 if (vivid_is_hdmi_cap(dev)) {
541 " OSD \"%s\"", dev->osd);
545 if (dev->osd_jiffies &&
546 time_is_before_jiffies(dev->osd_jiffies + 5 * HZ)) {
547 dev->osd[0] = 0;
548 dev->osd_jiffies = 0;
557 static bool valid_pix(struct vivid_dev *dev, int win_y, int win_x, int fb_y, int fb_x)
561 if (dev->bitmap_cap) {
567 const u8 *p = dev->bitmap_cap;
568 unsigned stride = (dev->compose_cap.width + 7) / 8;
574 for (i = 0; i < dev->clipcount_cap; i++) {
579 struct v4l2_rect *r = &dev->clips_cap[i].c;
592 static void vivid_overlay(struct vivid_dev *dev, struct vivid_buffer *buf)
594 struct tpg_data *tpg = &dev->tpg;
596 void *vbase = dev->fb_vbase_cap;
598 unsigned img_width = dev->compose_cap.width;
599 unsigned img_height = dev->compose_cap.height;
602 bool quick = dev->bitmap_cap == NULL && dev->clipcount_cap == 0;
611 if ((dev->overlay_cap_field == V4L2_FIELD_TOP ||
612 dev->overlay_cap_field == V4L2_FIELD_BOTTOM) &&
613 dev->overlay_cap_field != buf->vb.field)
616 vbuf += dev->compose_cap.left * pixsize + dev->compose_cap.top * stride;
617 x = dev->overlay_cap_left;
624 w = dev->fb_cap.fmt.width - x;
630 if (dev->overlay_cap_top >= 0)
631 vbase += dev->overlay_cap_top * dev->fb_cap.fmt.bytesperline;
632 for (y = dev->overlay_cap_top;
633 y < dev->overlay_cap_top + (int)img_height;
637 if (y < 0 || y > dev->fb_cap.fmt.height)
642 vbase += dev->fb_cap.fmt.bytesperline;
646 if (!valid_pix(dev, y - dev->overlay_cap_top,
653 vbase += dev->fb_cap.fmt.bytesperline;
657 static void vivid_cap_update_frame_period(struct vivid_dev *dev)
661 f_period = (u64)dev->timeperframe_vid_cap.numerator * 1000000000;
662 if (WARN_ON(dev->timeperframe_vid_cap.denominator == 0))
663 dev->timeperframe_vid_cap.denominator = 1;
664 do_div(f_period, dev->timeperframe_vid_cap.denominator);
665 if (dev->field_cap == V4L2_FIELD_ALTERNATE)
671 dev->cap_frame_eof_offset = f_period * 9;
672 do_div(dev->cap_frame_eof_offset, 10);
673 dev->cap_frame_period = f_period;
676 static noinline_for_stack void vivid_thread_vid_cap_tick(struct vivid_dev *dev,
684 dprintk(dev, 1, "Video Capture Thread Tick\n");
687 tpg_update_mv_count(&dev->tpg,
688 dev->field_cap == V4L2_FIELD_NONE ||
689 dev->field_cap == V4L2_FIELD_ALTERNATE);
692 if (dev->perc_dropped_buffers &&
693 prandom_u32_max(100) < dev->perc_dropped_buffers)
696 spin_lock(&dev->slock);
697 if (!list_empty(&dev->vid_cap_active)) {
698 vid_cap_buf = list_entry(dev->vid_cap_active.next, struct vivid_buffer, list);
701 if (!list_empty(&dev->vbi_cap_active)) {
702 if (dev->field_cap != V4L2_FIELD_ALTERNATE ||
703 (dev->vbi_cap_seq_count & 1)) {
704 vbi_cap_buf = list_entry(dev->vbi_cap_active.next,
709 if (!list_empty(&dev->meta_cap_active)) {
710 meta_cap_buf = list_entry(dev->meta_cap_active.next,
715 spin_unlock(&dev->slock);
720 f_time = dev->cap_frame_period * dev->vid_cap_seq_count +
721 dev->cap_stream_start + dev->time_wrap_offset;
725 &dev->ctrl_hdl_vid_cap);
727 vivid_fillbuff(dev, vid_cap_buf);
728 dprintk(dev, 1, "filled buffer %d\n",
732 if (dev->overlay_cap_owner && dev->fb_cap.base &&
733 dev->fb_cap.fmt.pixelformat == dev->fmt_cap->fourcc)
734 vivid_overlay(dev, vid_cap_buf);
737 &dev->ctrl_hdl_vid_cap);
738 vb2_buffer_done(&vid_cap_buf->vb.vb2_buf, dev->dqbuf_error ?
740 dprintk(dev, 2, "vid_cap buffer %d done\n",
744 if (!dev->tstamp_src_is_soe)
745 vid_cap_buf->vb.vb2_buf.timestamp += dev->cap_frame_eof_offset;
752 &dev->ctrl_hdl_vbi_cap);
753 if (dev->stream_sliced_vbi_cap)
754 vivid_sliced_vbi_cap_process(dev, vbi_cap_buf);
756 vivid_raw_vbi_cap_process(dev, vbi_cap_buf);
758 &dev->ctrl_hdl_vbi_cap);
759 vb2_buffer_done(&vbi_cap_buf->vb.vb2_buf, dev->dqbuf_error ?
761 dprintk(dev, 2, "vbi_cap %d done\n",
765 vbi_period = dev->cap_frame_period * 5;
767 vbi_cap_buf->vb.vb2_buf.timestamp = f_time + dev->cap_frame_eof_offset + vbi_period;
772 &dev->ctrl_hdl_meta_cap);
773 vivid_meta_cap_fillbuff(dev, meta_cap_buf, f_time);
775 &dev->ctrl_hdl_meta_cap);
776 vb2_buffer_done(&meta_cap_buf->vb.vb2_buf, dev->dqbuf_error ?
778 dprintk(dev, 2, "meta_cap %d done\n",
780 meta_cap_buf->vb.vb2_buf.timestamp = f_time + dev->cap_frame_eof_offset;
783 dev->dqbuf_error = false;
787 tpg_update_mv_count(&dev->tpg, dev->field_cap == V4L2_FIELD_NONE ||
788 dev->field_cap == V4L2_FIELD_ALTERNATE);
793 struct vivid_dev *dev = data;
804 dprintk(dev, 1, "Video Capture Thread Start\n");
809 dev->cap_seq_offset = 0;
810 dev->cap_seq_count = 0;
811 dev->cap_seq_resync = false;
812 dev->jiffies_vid_cap = jiffies;
813 dev->cap_stream_start = ktime_get_ns();
814 vivid_cap_update_frame_period(dev);
821 if (!mutex_trylock(&dev->mutex)) {
827 if (dev->cap_seq_resync) {
828 dev->jiffies_vid_cap = cur_jiffies;
829 dev->cap_seq_offset = dev->cap_seq_count + 1;
830 dev->cap_seq_count = 0;
831 dev->cap_stream_start += dev->cap_frame_period *
832 dev->cap_seq_offset;
833 vivid_cap_update_frame_period(dev);
834 dev->cap_seq_resync = false;
836 numerator = dev->timeperframe_vid_cap.numerator;
837 denominator = dev->timeperframe_vid_cap.denominator;
839 if (dev->field_cap == V4L2_FIELD_ALTERNATE)
843 jiffies_since_start = cur_jiffies - dev->jiffies_vid_cap;
856 dev->jiffies_vid_cap = cur_jiffies;
857 dev->cap_seq_offset = buffers_since_start;
860 dropped_bufs = buffers_since_start + dev->cap_seq_offset - dev->cap_seq_count;
861 dev->cap_seq_count = buffers_since_start + dev->cap_seq_offset;
862 dev->vid_cap_seq_count = dev->cap_seq_count - dev->vid_cap_seq_start;
863 dev->vbi_cap_seq_count = dev->cap_seq_count - dev->vbi_cap_seq_start;
864 dev->meta_cap_seq_count = dev->cap_seq_count - dev->meta_cap_seq_start;
866 vivid_thread_vid_cap_tick(dev, dropped_bufs);
875 jiffies_since_start = jiffies - dev->jiffies_vid_cap;
877 mutex_unlock(&dev->mutex);
893 dprintk(dev, 1, "Video Capture Thread End\n");
897 static void vivid_grab_controls(struct vivid_dev *dev, bool grab)
899 v4l2_ctrl_grab(dev->ctrl_has_crop_cap, grab);
900 v4l2_ctrl_grab(dev->ctrl_has_compose_cap, grab);
901 v4l2_ctrl_grab(dev->ctrl_has_scaler_cap, grab);
904 int vivid_start_generating_vid_cap(struct vivid_dev *dev, bool *pstreaming)
906 dprintk(dev, 1, "%s\n", __func__);
908 if (dev->kthread_vid_cap) {
909 u32 seq_count = dev->cap_seq_count + dev->seq_wrap * 128;
911 if (pstreaming == &dev->vid_cap_streaming)
912 dev->vid_cap_seq_start = seq_count;
913 else if (pstreaming == &dev->vbi_cap_streaming)
914 dev->vbi_cap_seq_start = seq_count;
916 dev->meta_cap_seq_start = seq_count;
922 tpg_init_mv_count(&dev->tpg);
924 dev->vid_cap_seq_start = dev->seq_wrap * 128;
925 dev->vbi_cap_seq_start = dev->seq_wrap * 128;
926 dev->meta_cap_seq_start = dev->seq_wrap * 128;
928 dev->kthread_vid_cap = kthread_run(vivid_thread_vid_cap, dev,
929 "%s-vid-cap", dev->v4l2_dev.name);
931 if (IS_ERR(dev->kthread_vid_cap)) {
932 int err = PTR_ERR(dev->kthread_vid_cap);
934 dev->kthread_vid_cap = NULL;
935 v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
939 vivid_grab_controls(dev, true);
941 dprintk(dev, 1, "returning from %s\n", __func__);
945 void vivid_stop_generating_vid_cap(struct vivid_dev *dev, bool *pstreaming)
947 dprintk(dev, 1, "%s\n", __func__);
949 if (dev->kthread_vid_cap == NULL)
953 if (pstreaming == &dev->vid_cap_streaming) {
955 while (!list_empty(&dev->vid_cap_active)) {
958 buf = list_entry(dev->vid_cap_active.next,
962 &dev->ctrl_hdl_vid_cap);
964 dprintk(dev, 2, "vid_cap buffer %d done\n",
969 if (pstreaming == &dev->vbi_cap_streaming) {
970 while (!list_empty(&dev->vbi_cap_active)) {
973 buf = list_entry(dev->vbi_cap_active.next,
977 &dev->ctrl_hdl_vbi_cap);
979 dprintk(dev, 2, "vbi_cap buffer %d done\n",
984 if (pstreaming == &dev->meta_cap_streaming) {
985 while (!list_empty(&dev->meta_cap_active)) {
988 buf = list_entry(dev->meta_cap_active.next,
992 &dev->ctrl_hdl_meta_cap);
994 dprintk(dev, 2, "meta_cap buffer %d done\n",
999 if (dev->vid_cap_streaming || dev->vbi_cap_streaming ||
1000 dev->meta_cap_streaming)
1004 vivid_grab_controls(dev, false);
1005 kthread_stop(dev->kthread_vid_cap);
1006 dev->kthread_vid_cap = NULL;