Lines Matching refs:stream
89 static void uvc_fixup_video_ctrl(struct uvc_streaming *stream,
96 for (i = 0; i < stream->nformats; ++i) {
97 if (stream->format[i].index == ctrl->bFormatIndex) {
98 format = &stream->format[i];
118 stream->dev->uvc_version < 0x0110))
123 stream->dev->quirks & UVC_QUIRK_FIX_BANDWIDTH &&
124 stream->intf->num_altsetting > 1) {
141 if (stream->dev->udev->speed == USB_SPEED_HIGH)
158 static int uvc_get_video_ctrl(struct uvc_streaming *stream,
165 size = stream->dev->uvc_version >= 0x0110 ? 34 : 26;
166 if ((stream->dev->quirks & UVC_QUIRK_PROBE_DEF) &&
174 ret = __uvc_query_ctrl(stream->dev, query, 0, stream->intfnum,
183 uvc_warn_once(stream->dev, UVC_WARN_MINMAX, "UVC non "
195 uvc_warn_once(stream->dev, UVC_WARN_PROBE_DEF, "UVC non "
227 ctrl->dwClockFrequency = stream->dev->clock_frequency;
238 uvc_fixup_video_ctrl(stream, ctrl);
246 static int uvc_set_video_ctrl(struct uvc_streaming *stream,
253 size = stream->dev->uvc_version >= 0x0110 ? 34 : 26;
278 ret = __uvc_query_ctrl(stream->dev, UVC_SET_CUR, 0, stream->intfnum,
292 int uvc_probe_video(struct uvc_streaming *stream,
307 ret = uvc_set_video_ctrl(stream, probe, 1);
312 if (!(stream->dev->quirks & UVC_QUIRK_PROBE_MINMAX)) {
313 ret = uvc_get_video_ctrl(stream, &probe_min, 1, UVC_GET_MIN);
316 ret = uvc_get_video_ctrl(stream, &probe_max, 1, UVC_GET_MAX);
324 ret = uvc_set_video_ctrl(stream, probe, 1);
327 ret = uvc_get_video_ctrl(stream, probe, 1, UVC_GET_CUR);
331 if (stream->intf->num_altsetting == 1)
335 if (bandwidth <= stream->maxpsize)
338 if (stream->dev->quirks & UVC_QUIRK_PROBE_MINMAX) {
354 static int uvc_commit_video(struct uvc_streaming *stream,
357 return uvc_set_video_ctrl(stream, probe, 0);
365 uvc_video_clock_decode(struct uvc_streaming *stream, struct uvc_buffer *buf,
417 if (dev_sof == stream->clock.last_sof)
420 stream->clock.last_sof = dev_sof;
422 host_sof = usb_get_current_frame_number(stream->dev->udev);
444 if (stream->clock.sof_offset == (u16)-1) {
447 stream->clock.sof_offset = delta_sof;
449 stream->clock.sof_offset = 0;
452 dev_sof = (dev_sof + stream->clock.sof_offset) & 2047;
454 spin_lock_irqsave(&stream->clock.lock, flags);
456 sample = &stream->clock.samples[stream->clock.head];
463 stream->clock.head = (stream->clock.head + 1) % stream->clock.size;
465 if (stream->clock.count < stream->clock.size)
466 stream->clock.count++;
468 spin_unlock_irqrestore(&stream->clock.lock, flags);
471 static void uvc_video_clock_reset(struct uvc_streaming *stream)
473 struct uvc_clock *clock = &stream->clock;
481 static int uvc_video_clock_init(struct uvc_streaming *stream)
483 struct uvc_clock *clock = &stream->clock;
493 uvc_video_clock_reset(stream);
498 static void uvc_video_clock_cleanup(struct uvc_streaming *stream)
500 kfree(stream->clock.samples);
501 stream->clock.samples = NULL;
592 void uvc_video_clock_update(struct uvc_streaming *stream,
596 struct uvc_clock *clock = &stream->clock;
638 stream->dev->name, buf->pts,
680 stream->dev->name,
692 spin_unlock_irqrestore(&stream->clock.lock, flags);
699 static void uvc_video_stats_decode(struct uvc_streaming *stream,
709 if (stream->stats.stream.nb_frames == 0 &&
710 stream->stats.frame.nb_packets == 0)
711 ktime_get_ts(&stream->stats.stream.start_ts);
734 stream->stats.frame.nb_invalid++;
748 if (has_pts && stream->stats.frame.nb_pts) {
749 if (stream->stats.frame.pts != pts) {
750 stream->stats.frame.nb_pts_diffs++;
751 stream->stats.frame.last_pts_diff =
752 stream->stats.frame.nb_packets;
757 stream->stats.frame.nb_pts++;
758 stream->stats.frame.pts = pts;
764 if (stream->stats.frame.size == 0) {
766 stream->stats.frame.has_initial_pts = has_pts;
768 stream->stats.frame.has_early_pts = true;
772 if (has_scr && stream->stats.frame.nb_scr) {
773 if (stream->stats.frame.scr_stc != scr_stc)
774 stream->stats.frame.nb_scr_diffs++;
779 if (stream->stats.stream.nb_frames > 0 ||
780 stream->stats.frame.nb_scr > 0)
781 stream->stats.stream.scr_sof_count +=
782 (scr_sof - stream->stats.stream.scr_sof) % 2048;
783 stream->stats.stream.scr_sof = scr_sof;
785 stream->stats.frame.nb_scr++;
786 stream->stats.frame.scr_stc = scr_stc;
787 stream->stats.frame.scr_sof = scr_sof;
789 if (scr_sof < stream->stats.stream.min_sof)
790 stream->stats.stream.min_sof = scr_sof;
791 if (scr_sof > stream->stats.stream.max_sof)
792 stream->stats.stream.max_sof = scr_sof;
796 if (stream->stats.frame.size == 0 && len > header_size)
797 stream->stats.frame.first_data = stream->stats.frame.nb_packets;
800 stream->stats.frame.size += len - header_size;
803 stream->stats.frame.nb_packets++;
805 stream->stats.frame.nb_empty++;
808 stream->stats.frame.nb_errors++;
811 static void uvc_video_stats_update(struct uvc_streaming *stream)
813 struct uvc_stats_frame *frame = &stream->stats.frame;
818 stream->sequence, frame->first_data,
826 stream->stats.stream.nb_frames++;
827 stream->stats.stream.nb_packets += stream->stats.frame.nb_packets;
828 stream->stats.stream.nb_empty += stream->stats.frame.nb_empty;
829 stream->stats.stream.nb_errors += stream->stats.frame.nb_errors;
830 stream->stats.stream.nb_invalid += stream->stats.frame.nb_invalid;
833 stream->stats.stream.nb_pts_early++;
835 stream->stats.stream.nb_pts_initial++;
837 stream->stats.stream.nb_pts_constant++;
839 stream->stats.stream.nb_scr_count_ok++;
841 stream->stats.stream.nb_scr_diffs_ok++;
843 memset(&stream->stats.frame, 0, sizeof(stream->stats.frame));
846 size_t uvc_video_stats_dump(struct uvc_streaming *stream, char *buf,
854 ts.tv_sec = stream->stats.stream.stop_ts.tv_sec
855 - stream->stats.stream.start_ts.tv_sec;
856 ts.tv_nsec = stream->stats.stream.stop_ts.tv_nsec
857 - stream->stats.stream.start_ts.tv_nsec;
868 scr_sof_freq = stream->stats.stream.scr_sof_count * 1000
876 stream->stats.stream.nb_frames,
877 stream->stats.stream.nb_packets,
878 stream->stats.stream.nb_empty,
879 stream->stats.stream.nb_errors,
880 stream->stats.stream.nb_invalid);
883 stream->stats.stream.nb_pts_early,
884 stream->stats.stream.nb_pts_initial,
885 stream->stats.stream.nb_pts_constant);
888 stream->stats.stream.nb_scr_count_ok,
889 stream->stats.stream.nb_scr_diffs_ok);
892 stream->stats.stream.min_sof,
893 stream->stats.stream.max_sof,
899 static void uvc_video_stats_start(struct uvc_streaming *stream)
901 memset(&stream->stats, 0, sizeof(stream->stats));
902 stream->stats.stream.min_sof = 2048;
905 static void uvc_video_stats_stop(struct uvc_streaming *stream)
907 ktime_get_ts(&stream->stats.stream.stop_ts);
949 static int uvc_video_decode_start(struct uvc_streaming *stream,
960 stream->stats.frame.nb_invalid++;
969 if (stream->last_fid != fid) {
970 stream->sequence++;
971 if (stream->sequence)
972 uvc_video_stats_update(stream);
975 uvc_video_clock_decode(stream, buf, data, len);
976 uvc_video_stats_decode(stream, data, len);
982 stream->last_fid = fid;
993 /* Synchronize to the input stream by waiting for the FID bit to be
995 * stream->last_fid is initialized to -1, so the first isochronous
998 * If the device doesn't toggle the FID bit, invert stream->last_fid
1004 if (fid == stream->last_fid) {
1007 if ((stream->dev->quirks & UVC_QUIRK_STREAM_NO_FID) &&
1009 stream->last_fid ^= UVC_STREAM_FID;
1018 buf->buf.v4l2_buf.sequence = stream->sequence;
1034 * stream->last_fid is initialized to -1, so the first isochronous
1042 if (fid != stream->last_fid && buf->bytesused != 0) {
1049 stream->last_fid = fid;
1054 static void uvc_video_decode_data(struct uvc_streaming *stream,
1077 static void uvc_video_decode_end(struct uvc_streaming *stream,
1086 if (stream->dev->quirks & UVC_QUIRK_STREAM_NO_FID)
1087 stream->last_fid ^= UVC_STREAM_FID;
1102 static int uvc_video_encode_header(struct uvc_streaming *stream,
1107 | (stream->last_fid & UVC_STREAM_FID);
1111 static int uvc_video_encode_data(struct uvc_streaming *stream,
1114 struct uvc_video_queue *queue = &stream->queue;
1121 nbytes = min(stream->bulk.max_payload_size - stream->bulk.payload_size,
1137 static void uvc_video_decode_isoc(struct urb *urb, struct uvc_streaming *stream,
1156 ret = uvc_video_decode_start(stream, buf, mem,
1159 buf = uvc_queue_next_buffer(&stream->queue,
1167 uvc_video_decode_data(stream, buf, mem + ret,
1171 uvc_video_decode_end(stream, buf, mem,
1176 !(stream->cur_format->flags &
1180 buf = uvc_queue_next_buffer(&stream->queue, buf);
1185 static void uvc_video_decode_bulk(struct urb *urb, struct uvc_streaming *stream,
1196 stream->bulk.payload_size += len;
1201 if (stream->bulk.header_size == 0 && !stream->bulk.skip_payload) {
1203 ret = uvc_video_decode_start(stream, buf, mem, len);
1205 buf = uvc_queue_next_buffer(&stream->queue,
1211 stream->bulk.skip_payload = 1;
1213 memcpy(stream->bulk.header, mem, ret);
1214 stream->bulk.header_size = ret;
1227 if (!stream->bulk.skip_payload && buf != NULL)
1228 uvc_video_decode_data(stream, buf, mem, len);
1234 stream->bulk.payload_size >= stream->bulk.max_payload_size) {
1235 if (!stream->bulk.skip_payload && buf != NULL) {
1236 uvc_video_decode_end(stream, buf, stream->bulk.header,
1237 stream->bulk.payload_size);
1239 buf = uvc_queue_next_buffer(&stream->queue,
1243 stream->bulk.header_size = 0;
1244 stream->bulk.skip_payload = 0;
1245 stream->bulk.payload_size = 0;
1249 static void uvc_video_encode_bulk(struct urb *urb, struct uvc_streaming *stream,
1253 int len = stream->urb_size, ret;
1261 if (stream->bulk.header_size == 0) {
1262 ret = uvc_video_encode_header(stream, buf, mem, len);
1263 stream->bulk.header_size = ret;
1264 stream->bulk.payload_size += ret;
1270 ret = uvc_video_encode_data(stream, buf, mem, len);
1272 stream->bulk.payload_size += ret;
1275 if (buf->bytesused == stream->queue.buf_used ||
1276 stream->bulk.payload_size == stream->bulk.max_payload_size) {
1277 if (buf->bytesused == stream->queue.buf_used) {
1278 stream->queue.buf_used = 0;
1280 buf->buf.v4l2_buf.sequence = ++stream->sequence;
1281 uvc_queue_next_buffer(&stream->queue, buf);
1282 stream->last_fid ^= UVC_STREAM_FID;
1285 stream->bulk.header_size = 0;
1286 stream->bulk.payload_size = 0;
1289 urb->transfer_buffer_length = stream->urb_size - len;
1294 struct uvc_streaming *stream = urb->context;
1295 struct uvc_video_queue *queue = &stream->queue;
1309 if (stream->frozen)
1324 stream->decode(urb, stream, buf);
1335 static void uvc_free_urb_buffers(struct uvc_streaming *stream)
1340 if (stream->urb_buffer[i]) {
1342 usb_free_coherent(stream->dev->udev, stream->urb_size,
1343 stream->urb_buffer[i], stream->urb_dma[i]);
1345 kfree(stream->urb_buffer[i]);
1347 stream->urb_buffer[i] = NULL;
1351 stream->urb_size = 0;
1365 static int uvc_alloc_urb_buffers(struct uvc_streaming *stream,
1372 if (stream->urb_size)
1373 return stream->urb_size / psize;
1385 stream->urb_size = psize * npackets;
1387 stream->urb_buffer[i] = usb_alloc_coherent(
1388 stream->dev->udev, stream->urb_size,
1389 gfp_flags | __GFP_NOWARN, &stream->urb_dma[i]);
1391 stream->urb_buffer[i] =
1392 kmalloc(stream->urb_size, gfp_flags | __GFP_NOWARN);
1394 if (!stream->urb_buffer[i]) {
1395 uvc_free_urb_buffers(stream);
1416 static void uvc_uninit_video(struct uvc_streaming *stream, int free_buffers)
1421 uvc_video_stats_stop(stream);
1424 urb = stream->urb[i];
1430 stream->urb[i] = NULL;
1434 uvc_free_urb_buffers(stream);
1441 static int uvc_init_video_isoc(struct uvc_streaming *stream,
1451 size = stream->ctrl.dwMaxVideoFrameSize;
1453 npackets = uvc_alloc_urb_buffers(stream, size, psize, gfp_flags);
1462 uvc_uninit_video(stream, 1);
1466 urb->dev = stream->dev->udev;
1467 urb->context = stream;
1468 urb->pipe = usb_rcvisocpipe(stream->dev->udev,
1472 urb->transfer_dma = stream->urb_dma[i];
1477 urb->transfer_buffer = stream->urb_buffer[i];
1487 stream->urb[i] = urb;
1497 static int uvc_init_video_bulk(struct uvc_streaming *stream,
1506 size = stream->ctrl.dwMaxPayloadTransferSize;
1507 stream->bulk.max_payload_size = size;
1509 npackets = uvc_alloc_urb_buffers(stream, size, psize, gfp_flags);
1516 pipe = usb_rcvbulkpipe(stream->dev->udev,
1519 pipe = usb_sndbulkpipe(stream->dev->udev,
1522 if (stream->type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
1528 uvc_uninit_video(stream, 1);
1532 usb_fill_bulk_urb(urb, stream->dev->udev, pipe,
1533 stream->urb_buffer[i], size, uvc_video_complete,
1534 stream);
1537 urb->transfer_dma = stream->urb_dma[i];
1540 stream->urb[i] = urb;
1549 static int uvc_init_video(struct uvc_streaming *stream, gfp_t gfp_flags)
1551 struct usb_interface *intf = stream->intf;
1556 stream->sequence = -1;
1557 stream->last_fid = -1;
1558 stream->bulk.header_size = 0;
1559 stream->bulk.skip_payload = 0;
1560 stream->bulk.payload_size = 0;
1562 uvc_video_stats_start(stream);
1569 int intfnum = stream->intfnum;
1572 bandwidth = stream->ctrl.dwMaxPayloadTransferSize;
1589 stream->header.bEndpointAddress);
1612 ret = usb_set_interface(stream->dev->udev, intfnum, altsetting);
1616 ret = uvc_init_video_isoc(stream, best_ep, gfp_flags);
1620 stream->header.bEndpointAddress);
1624 ret = uvc_init_video_bulk(stream, ep, gfp_flags);
1632 ret = usb_submit_urb(stream->urb[i], gfp_flags);
1636 uvc_uninit_video(stream, 1);
1655 int uvc_video_suspend(struct uvc_streaming *stream)
1657 if (!uvc_queue_streaming(&stream->queue))
1660 stream->frozen = 1;
1661 uvc_uninit_video(stream, 0);
1662 usb_set_interface(stream->dev->udev, stream->intfnum, 0);
1674 int uvc_video_resume(struct uvc_streaming *stream, int reset)
1684 usb_set_interface(stream->dev->udev, stream->intfnum, 0);
1686 stream->frozen = 0;
1688 uvc_video_clock_reset(stream);
1690 ret = uvc_commit_video(stream, &stream->ctrl);
1692 uvc_queue_enable(&stream->queue, 0);
1696 if (!uvc_queue_streaming(&stream->queue))
1699 ret = uvc_init_video(stream, GFP_NOIO);
1701 uvc_queue_enable(&stream->queue, 0);
1720 int uvc_video_init(struct uvc_streaming *stream)
1722 struct uvc_streaming_control *probe = &stream->ctrl;
1728 if (stream->nformats == 0) {
1733 atomic_set(&stream->active, 0);
1736 uvc_queue_init(&stream->queue, stream->type, !uvc_no_drop_param);
1743 usb_set_interface(stream->dev->udev, stream->intfnum, 0);
1750 if (uvc_get_video_ctrl(stream, probe, 1, UVC_GET_DEF) == 0)
1751 uvc_set_video_ctrl(stream, probe, 1);
1758 ret = uvc_get_video_ctrl(stream, probe, 1, UVC_GET_CUR);
1765 for (i = stream->nformats; i > 0; --i) {
1766 format = &stream->format[i-1];
1791 stream->cur_format = format;
1792 stream->cur_frame = frame;
1795 if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1796 if (stream->dev->quirks & UVC_QUIRK_BUILTIN_ISIGHT)
1797 stream->decode = uvc_video_decode_isight;
1798 else if (stream->intf->num_altsetting > 1)
1799 stream->decode = uvc_video_decode_isoc;
1801 stream->decode = uvc_video_decode_bulk;
1803 if (stream->intf->num_altsetting == 1)
1804 stream->decode = uvc_video_encode_bulk;
1816 * Enable or disable the video stream.
1818 int uvc_video_enable(struct uvc_streaming *stream, int enable)
1823 uvc_uninit_video(stream, 1);
1824 usb_set_interface(stream->dev->udev, stream->intfnum, 0);
1825 uvc_queue_enable(&stream->queue, 0);
1826 uvc_video_clock_cleanup(stream);
1830 ret = uvc_video_clock_init(stream);
1834 ret = uvc_queue_enable(&stream->queue, 1);
1839 ret = uvc_commit_video(stream, &stream->ctrl);
1843 ret = uvc_init_video(stream, GFP_KERNEL);
1850 usb_set_interface(stream->dev->udev, stream->intfnum, 0);
1852 uvc_queue_enable(&stream->queue, 0);
1854 uvc_video_clock_cleanup(stream);