Lines Matching refs:dev
45 static inline v4l2_std_id vivid_get_std_cap(const struct vivid_dev *dev)
47 if (vivid_is_sdtv_cap(dev))
48 return dev->std_cap[dev->input];
52 static void copy_pix(struct vivid_dev *dev, int win_y, int win_x,
60 if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_CHROMAKEY) &&
61 *osd != dev->chromakey_out)
63 if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_SRC_CHROMAKEY) &&
64 out == dev->chromakey_out)
66 if (dev->fmt_cap->alpha_mask) {
67 if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_GLOBAL_ALPHA) &&
68 dev->global_alpha_out)
70 if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_LOCAL_ALPHA) &&
71 *cap & dev->fmt_cap->alpha_mask)
73 if ((dev->fbuf_out_flags & V4L2_FBUF_FLAG_LOCAL_INV_ALPHA) &&
74 !(*cap & dev->fmt_cap->alpha_mask))
80 static void blend_line(struct vivid_dev *dev, unsigned y_offset, unsigned x_offset,
87 copy_pix(dev, y_offset, x_offset + x,
145 static void vivid_precalc_copy_rects(struct vivid_dev *dev)
149 0, 0, dev->display_width, dev->display_height
153 dev->overlay_out_left, dev->overlay_out_top,
154 dev->compose_out.width, dev->compose_out.height
157 v4l2_rect_intersect(&dev->loop_vid_copy, &dev->crop_cap, &dev->compose_out);
159 dev->loop_vid_out = dev->loop_vid_copy;
160 v4l2_rect_scale(&dev->loop_vid_out, &dev->compose_out, &dev->crop_out);
161 dev->loop_vid_out.left += dev->crop_out.left;
162 dev->loop_vid_out.top += dev->crop_out.top;
164 dev->loop_vid_cap = dev->loop_vid_copy;
165 v4l2_rect_scale(&dev->loop_vid_cap, &dev->crop_cap, &dev->compose_cap);
167 dprintk(dev, 1,
169 dev->loop_vid_copy.width, dev->loop_vid_copy.height,
170 dev->loop_vid_copy.left, dev->loop_vid_copy.top,
171 dev->loop_vid_out.width, dev->loop_vid_out.height,
172 dev->loop_vid_out.left, dev->loop_vid_out.top,
173 dev->loop_vid_cap.width, dev->loop_vid_cap.height,
174 dev->loop_vid_cap.left, dev->loop_vid_cap.top);
179 r_overlay.left += dev->compose_out.left - dev->overlay_out_left;
180 r_overlay.top += dev->compose_out.top - dev->overlay_out_top;
182 v4l2_rect_intersect(&dev->loop_vid_overlay, &r_overlay, &dev->loop_vid_copy);
183 dev->loop_fb_copy = dev->loop_vid_overlay;
185 /* shift dev->loop_fb_copy back again to the fb origin */
186 dev->loop_fb_copy.left -= dev->compose_out.left - dev->overlay_out_left;
187 dev->loop_fb_copy.top -= dev->compose_out.top - dev->overlay_out_top;
189 dev->loop_vid_overlay_cap = dev->loop_vid_overlay;
190 v4l2_rect_scale(&dev->loop_vid_overlay_cap, &dev->crop_cap, &dev->compose_cap);
192 dprintk(dev, 1,
194 dev->loop_fb_copy.width, dev->loop_fb_copy.height,
195 dev->loop_fb_copy.left, dev->loop_fb_copy.top,
196 dev->loop_vid_overlay.width, dev->loop_vid_overlay.height,
197 dev->loop_vid_overlay.left, dev->loop_vid_overlay.top,
198 dev->loop_vid_overlay_cap.width, dev->loop_vid_overlay_cap.height,
199 dev->loop_vid_overlay_cap.left, dev->loop_vid_overlay_cap.top);
216 static noinline_for_stack int vivid_copy_buffer(struct vivid_dev *dev, unsigned p,
219 bool blank = dev->must_blank[vid_cap_buf->vb.vb2_buf.index];
220 struct tpg_data *tpg = &dev->tpg;
222 unsigned vdiv = dev->fmt_out->vdownsampling[p];
224 unsigned img_width = tpg_hdiv(tpg, p, dev->compose_cap.width);
225 unsigned img_height = dev->compose_cap.height;
227 unsigned stride_out = dev->bytesperline_out[p];
228 unsigned stride_osd = dev->display_byte_stride;
233 bool blend = dev->fbuf_out_flags;
243 unsigned vid_cap_left = tpg_hdiv(tpg, p, dev->loop_vid_cap.left);
247 vid_out_int_part = dev->loop_vid_out.height / dev->loop_vid_cap.height;
248 vid_out_fract_part = dev->loop_vid_out.height % dev->loop_vid_cap.height;
250 if (!list_empty(&dev->vid_out_active))
251 vid_out_buf = list_entry(dev->vid_out_active.next,
259 dev->bytesperline_out, dev->fmt_out_rect.height);
260 if (p < dev->fmt_out->buffers)
262 voutbuf += tpg_hdiv(tpg, p, dev->loop_vid_out.left) +
263 (dev->loop_vid_out.top / vdiv) * stride_out;
264 vcapbuf += tpg_hdiv(tpg, p, dev->compose_cap.left) +
265 (dev->compose_cap.top / vdiv) * stride_cap;
267 if (dev->loop_vid_copy.width == 0 || dev->loop_vid_copy.height == 0) {
277 if (dev->overlay_out_enabled &&
278 dev->loop_vid_overlay.width && dev->loop_vid_overlay.height) {
279 vosdbuf = dev->video_vbase;
280 vosdbuf += (dev->loop_fb_copy.left * twopixsize) / 2 +
281 dev->loop_fb_copy.top * stride_osd;
282 vid_overlay_int_part = dev->loop_vid_overlay.height /
283 dev->loop_vid_overlay_cap.height;
284 vid_overlay_fract_part = dev->loop_vid_overlay.height %
285 dev->loop_vid_overlay_cap.height;
288 vid_cap_right = tpg_hdiv(tpg, p, dev->loop_vid_cap.left + dev->loop_vid_cap.width);
290 quick = dev->loop_vid_out.width == dev->loop_vid_cap.width;
292 dev->cur_scaled_line = dev->loop_vid_out.height;
295 bool osdline = vosdbuf && y >= dev->loop_vid_overlay_cap.top &&
296 y < dev->loop_vid_overlay_cap.top + dev->loop_vid_overlay_cap.height;
302 if (y < dev->loop_vid_cap.top ||
303 y >= dev->loop_vid_cap.top + dev->loop_vid_cap.height) {
309 if (dev->loop_vid_cap.left)
320 tpg_hdiv(tpg, p, dev->loop_vid_cap.width));
323 if (dev->cur_scaled_line == vid_out_y) {
324 memcpy(vcapbuf + vid_cap_left, dev->scaled_line,
325 tpg_hdiv(tpg, p, dev->loop_vid_cap.width));
329 scale_line(voutbuf + vid_out_y * stride_out, dev->scaled_line,
330 tpg_hdiv(tpg, p, dev->loop_vid_out.width),
331 tpg_hdiv(tpg, p, dev->loop_vid_cap.width),
339 ((dev->loop_vid_overlay.left - dev->loop_vid_copy.left) *
343 scale_line(voutbuf + vid_out_y * stride_out, dev->blended_line,
344 dev->loop_vid_out.width, dev->loop_vid_copy.width,
347 blend_line(dev, vid_overlay_y + dev->loop_vid_overlay.top,
348 dev->loop_vid_overlay.left,
349 dev->blended_line + offset, osd,
350 dev->loop_vid_overlay.width, twopixsize / 2);
352 memcpy(dev->blended_line + offset,
353 osd, (dev->loop_vid_overlay.width * twopixsize) / 2);
354 scale_line(dev->blended_line, dev->scaled_line,
355 dev->loop_vid_copy.width, dev->loop_vid_cap.width,
358 dev->cur_scaled_line = vid_out_y;
359 memcpy(vcapbuf + vid_cap_left, dev->scaled_line,
360 tpg_hdiv(tpg, p, dev->loop_vid_cap.width));
366 if (vid_overlay_error >= dev->loop_vid_overlay_cap.height) {
367 vid_overlay_error -= dev->loop_vid_overlay_cap.height;
373 if (vid_out_error >= dev->loop_vid_cap.height / vdiv) {
374 vid_out_error -= dev->loop_vid_cap.height / vdiv;
386 static void vivid_fillbuff(struct vivid_dev *dev, struct vivid_buffer *buf)
388 struct tpg_data *tpg = &dev->tpg;
389 unsigned factor = V4L2_FIELD_HAS_T_OR_B(dev->field_cap) ? 2 : 1;
391 bool is_tv = vivid_is_sdtv_cap(dev);
392 bool is_60hz = is_tv && (dev->std_cap[dev->input] & V4L2_STD_525_60);
401 if (dev->loop_video && dev->can_loop_video &&
402 ((vivid_is_svid_cap(dev) &&
403 !VIVID_INVALID_SIGNAL(dev->std_signal_mode[dev->input])) ||
404 (vivid_is_hdmi_cap(dev) &&
405 !VIVID_INVALID_SIGNAL(dev->dv_timings_signal_mode[dev->input]))))
408 buf->vb.sequence = dev->vid_cap_seq_count;
409 v4l2_ctrl_s_ctrl(dev->ro_int32, buf->vb.sequence & 0xff);
410 if (dev->field_cap == V4L2_FIELD_ALTERNATE) {
417 buf->vb.field = ((dev->vid_cap_seq_count & 1) ^ is_60hz) ?
425 buf->vb.field = dev->field_cap;
428 dev->field_cap == V4L2_FIELD_ALTERNATE);
429 tpg_s_perc_fill_blank(tpg, dev->must_blank[buf->vb.vb2_buf.index]);
431 vivid_precalc_copy_rects(dev);
442 if (p < tpg_g_buffers(tpg) && dev->fmt_cap->data_offset[p]) {
443 memset(vbuf, dev->fmt_cap->data_offset[p] & 0xff,
444 dev->fmt_cap->data_offset[p]);
445 vbuf += dev->fmt_cap->data_offset[p];
448 if (!is_loop || vivid_copy_buffer(dev, p, vbuf, buf))
449 tpg_fill_plane_buffer(tpg, vivid_get_std_cap(dev),
452 dev->must_blank[buf->vb.vb2_buf.index] = false;
455 if (dev->field_cap != V4L2_FIELD_ALTERNATE ||
456 (dev->vid_cap_seq_count & 1) == 0)
457 dev->ms_vid_cap =
458 jiffies_to_msecs(jiffies - dev->jiffies_vid_cap);
460 ms = dev->ms_vid_cap;
461 if (dev->osd_mode <= 1) {
468 (dev->field_cap == V4L2_FIELD_ALTERNATE) ?
473 if (dev->osd_mode == 0) {
475 dev->src_rect.width, dev->src_rect.height, dev->input);
478 gain = v4l2_ctrl_g_ctrl(dev->gain);
479 mutex_lock(dev->ctrl_hdl_user_vid.lock);
482 dev->brightness->cur.val,
483 dev->contrast->cur.val,
484 dev->saturation->cur.val,
485 dev->hue->cur.val);
489 dev->autogain->cur.val, gain, dev->alpha->cur.val);
490 mutex_unlock(dev->ctrl_hdl_user_vid.lock);
492 mutex_lock(dev->ctrl_hdl_user_aud.lock);
495 dev->volume->cur.val, dev->mute->cur.val);
496 mutex_unlock(dev->ctrl_hdl_user_aud.lock);
498 mutex_lock(dev->ctrl_hdl_user_gen.lock);
500 dev->int32->cur.val,
501 dev->ro_int32->cur.val,
502 *dev->int64->p_cur.p_s64,
503 dev->bitmask->cur.val);
506 dev->boolean->cur.val,
507 dev->menu->qmenu[dev->menu->cur.val],
508 dev->string->p_cur.p_char);
511 dev->int_menu->qmenu_int[dev->int_menu->cur.val],
512 dev->int_menu->cur.val);
513 mutex_unlock(dev->ctrl_hdl_user_gen.lock);
515 if (dev->button_pressed) {
516 dev->button_pressed--;
520 if (dev->osd[0]) {
521 if (vivid_is_hdmi_cap(dev)) {
523 " OSD \"%s\"", dev->osd);
527 if (dev->osd_jiffies &&
528 time_is_before_jiffies(dev->osd_jiffies + 5 * HZ)) {
529 dev->osd[0] = 0;
530 dev->osd_jiffies = 0;
536 static void vivid_cap_update_frame_period(struct vivid_dev *dev)
540 f_period = (u64)dev->timeperframe_vid_cap.numerator * 1000000000;
541 if (WARN_ON(dev->timeperframe_vid_cap.denominator == 0))
542 dev->timeperframe_vid_cap.denominator = 1;
543 do_div(f_period, dev->timeperframe_vid_cap.denominator);
544 if (dev->field_cap == V4L2_FIELD_ALTERNATE)
550 dev->cap_frame_eof_offset = f_period * 9;
551 do_div(dev->cap_frame_eof_offset, 10);
552 dev->cap_frame_period = f_period;
555 static noinline_for_stack void vivid_thread_vid_cap_tick(struct vivid_dev *dev,
563 dprintk(dev, 1, "Video Capture Thread Tick\n");
566 tpg_update_mv_count(&dev->tpg,
567 dev->field_cap == V4L2_FIELD_NONE ||
568 dev->field_cap == V4L2_FIELD_ALTERNATE);
571 if (dev->perc_dropped_buffers &&
572 get_random_u32_below(100) < dev->perc_dropped_buffers)
575 spin_lock(&dev->slock);
576 if (!list_empty(&dev->vid_cap_active)) {
577 vid_cap_buf = list_entry(dev->vid_cap_active.next, struct vivid_buffer, list);
580 if (!list_empty(&dev->vbi_cap_active)) {
581 if (dev->field_cap != V4L2_FIELD_ALTERNATE ||
582 (dev->vbi_cap_seq_count & 1)) {
583 vbi_cap_buf = list_entry(dev->vbi_cap_active.next,
588 if (!list_empty(&dev->meta_cap_active)) {
589 meta_cap_buf = list_entry(dev->meta_cap_active.next,
594 spin_unlock(&dev->slock);
599 f_time = ktime_get_ns() + dev->time_wrap_offset;
603 &dev->ctrl_hdl_vid_cap);
605 vivid_fillbuff(dev, vid_cap_buf);
606 dprintk(dev, 1, "filled buffer %d\n",
610 &dev->ctrl_hdl_vid_cap);
611 vb2_buffer_done(&vid_cap_buf->vb.vb2_buf, dev->dqbuf_error ?
613 dprintk(dev, 2, "vid_cap buffer %d done\n",
617 if (!dev->tstamp_src_is_soe)
618 vid_cap_buf->vb.vb2_buf.timestamp += dev->cap_frame_eof_offset;
625 &dev->ctrl_hdl_vbi_cap);
627 vivid_sliced_vbi_cap_process(dev, vbi_cap_buf);
629 vivid_raw_vbi_cap_process(dev, vbi_cap_buf);
631 &dev->ctrl_hdl_vbi_cap);
632 vb2_buffer_done(&vbi_cap_buf->vb.vb2_buf, dev->dqbuf_error ?
634 dprintk(dev, 2, "vbi_cap %d done\n",
638 vbi_period = dev->cap_frame_period * 5;
640 vbi_cap_buf->vb.vb2_buf.timestamp = f_time + dev->cap_frame_eof_offset + vbi_period;
645 &dev->ctrl_hdl_meta_cap);
646 vivid_meta_cap_fillbuff(dev, meta_cap_buf, f_time);
648 &dev->ctrl_hdl_meta_cap);
649 vb2_buffer_done(&meta_cap_buf->vb.vb2_buf, dev->dqbuf_error ?
651 dprintk(dev, 2, "meta_cap %d done\n",
653 meta_cap_buf->vb.vb2_buf.timestamp = f_time + dev->cap_frame_eof_offset;
656 dev->dqbuf_error = false;
660 tpg_update_mv_count(&dev->tpg, dev->field_cap == V4L2_FIELD_NONE ||
661 dev->field_cap == V4L2_FIELD_ALTERNATE);
666 struct vivid_dev *dev = data;
677 dprintk(dev, 1, "Video Capture Thread Start\n");
682 dev->cap_seq_offset = 0;
683 dev->cap_seq_count = 0;
684 dev->cap_seq_resync = false;
685 dev->jiffies_vid_cap = jiffies;
686 dev->cap_stream_start = ktime_get_ns();
687 if (dev->time_wrap)
688 dev->time_wrap_offset = dev->time_wrap - dev->cap_stream_start;
690 dev->time_wrap_offset = 0;
691 vivid_cap_update_frame_period(dev);
698 if (!mutex_trylock(&dev->mutex)) {
704 if (dev->cap_seq_resync) {
705 dev->jiffies_vid_cap = cur_jiffies;
706 dev->cap_seq_offset = dev->cap_seq_count + 1;
707 dev->cap_seq_count = 0;
708 dev->cap_stream_start += dev->cap_frame_period *
709 dev->cap_seq_offset;
710 vivid_cap_update_frame_period(dev);
711 dev->cap_seq_resync = false;
713 numerator = dev->timeperframe_vid_cap.numerator;
714 denominator = dev->timeperframe_vid_cap.denominator;
716 if (dev->field_cap == V4L2_FIELD_ALTERNATE)
720 jiffies_since_start = cur_jiffies - dev->jiffies_vid_cap;
733 dev->jiffies_vid_cap = cur_jiffies;
734 dev->cap_seq_offset = buffers_since_start;
737 dropped_bufs = buffers_since_start + dev->cap_seq_offset - dev->cap_seq_count;
738 dev->cap_seq_count = buffers_since_start + dev->cap_seq_offset;
739 dev->vid_cap_seq_count = dev->cap_seq_count - dev->vid_cap_seq_start;
740 dev->vbi_cap_seq_count = dev->cap_seq_count - dev->vbi_cap_seq_start;
741 dev->meta_cap_seq_count = dev->cap_seq_count - dev->meta_cap_seq_start;
743 vivid_thread_vid_cap_tick(dev, dropped_bufs);
752 jiffies_since_start = jiffies - dev->jiffies_vid_cap;
754 mutex_unlock(&dev->mutex);
772 dprintk(dev, 1, "Video Capture Thread End\n");
776 static void vivid_grab_controls(struct vivid_dev *dev, bool grab)
778 v4l2_ctrl_grab(dev->ctrl_has_crop_cap, grab);
779 v4l2_ctrl_grab(dev->ctrl_has_compose_cap, grab);
780 v4l2_ctrl_grab(dev->ctrl_has_scaler_cap, grab);
783 int vivid_start_generating_vid_cap(struct vivid_dev *dev, bool *pstreaming)
785 dprintk(dev, 1, "%s\n", __func__);
787 if (dev->kthread_vid_cap) {
788 u32 seq_count = dev->cap_seq_count + dev->seq_wrap * 128;
790 if (pstreaming == &dev->vid_cap_streaming)
791 dev->vid_cap_seq_start = seq_count;
792 else if (pstreaming == &dev->vbi_cap_streaming)
793 dev->vbi_cap_seq_start = seq_count;
795 dev->meta_cap_seq_start = seq_count;
801 tpg_init_mv_count(&dev->tpg);
803 dev->vid_cap_seq_start = dev->seq_wrap * 128;
804 dev->vbi_cap_seq_start = dev->seq_wrap * 128;
805 dev->meta_cap_seq_start = dev->seq_wrap * 128;
807 dev->kthread_vid_cap = kthread_run(vivid_thread_vid_cap, dev,
808 "%s-vid-cap", dev->v4l2_dev.name);
810 if (IS_ERR(dev->kthread_vid_cap)) {
811 int err = PTR_ERR(dev->kthread_vid_cap);
813 dev->kthread_vid_cap = NULL;
814 v4l2_err(&dev->v4l2_dev, "kernel_thread() failed\n");
818 vivid_grab_controls(dev, true);
820 dprintk(dev, 1, "returning from %s\n", __func__);
824 void vivid_stop_generating_vid_cap(struct vivid_dev *dev, bool *pstreaming)
826 dprintk(dev, 1, "%s\n", __func__);
828 if (dev->kthread_vid_cap == NULL)
832 if (pstreaming == &dev->vid_cap_streaming) {
834 while (!list_empty(&dev->vid_cap_active)) {
837 buf = list_entry(dev->vid_cap_active.next,
841 &dev->ctrl_hdl_vid_cap);
843 dprintk(dev, 2, "vid_cap buffer %d done\n",
848 if (pstreaming == &dev->vbi_cap_streaming) {
849 while (!list_empty(&dev->vbi_cap_active)) {
852 buf = list_entry(dev->vbi_cap_active.next,
856 &dev->ctrl_hdl_vbi_cap);
858 dprintk(dev, 2, "vbi_cap buffer %d done\n",
863 if (pstreaming == &dev->meta_cap_streaming) {
864 while (!list_empty(&dev->meta_cap_active)) {
867 buf = list_entry(dev->meta_cap_active.next,
871 &dev->ctrl_hdl_meta_cap);
873 dprintk(dev, 2, "meta_cap buffer %d done\n",
878 if (dev->vid_cap_streaming || dev->vbi_cap_streaming ||
879 dev->meta_cap_streaming)
883 vivid_grab_controls(dev, false);
884 kthread_stop(dev->kthread_vid_cap);
885 dev->kthread_vid_cap = NULL;