git.sesse.net Git - bmusb/blob - v4l2proxy.cpp

   1 //
   2 // A helper proxy to send data from bmusb to a V4L2 output.
   3 // To get it as a V4L2 _input_, you can use v4l2loopback:
   4 //
   5 //   sudo apt install v4l2loopback-dkms v4l2loopback-utils
   6 //   sudo modprobe v4l2loopback video_nr=2 card_label='Intensity Shuttle (bmusb)' max_width=1280 max_height=720 exclusive_caps=1
   7 //   ./bmusb-v4l2proxy /dev/video2
   8 //
   9 // There is currently no audio support.
  10
  11 #include <stdio.h>
  12 #include <string.h>
  13 #include <unistd.h>
  14 #include <fcntl.h>
  15 #include <sys/ioctl.h>
  16 #include <linux/videodev2.h>
  17 #include <bmusb/bmusb.h>
  18 #if __SSE2__
  19 #include <immintrin.h>
  20 #endif
  21
  22 using namespace bmusb;
  23
  24 BMUSBCapture *usb;
  25 int video_fd;
  26
  27 void frame_callback(uint16_t timecode,
  28                     FrameAllocator::Frame video_frame, size_t video_offset, VideoFormat video_format,
  29                     FrameAllocator::Frame audio_frame, size_t audio_offset, AudioFormat audio_format)
  30 {
  31         printf("0x%04x: %zu video bytes (format 0x%04x, %d x %d)\n",
  32                 timecode,
  33                 video_frame.len - video_offset, video_format.id, video_format.width, video_format.height);
  34
  35         static unsigned last_width = 0, last_height = 0, last_stride = 0;
  36
  37         if (video_format.width != last_width ||
  38             video_format.height != last_height ||
  39             video_format.stride != last_stride) {
  40                 v4l2_format fmt;
  41                 memset(&fmt, 0, sizeof(fmt));
  42                 fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
  43                 fmt.fmt.pix.width = video_format.width;
  44                 fmt.fmt.pix.height = video_format.height;
  45
  46                 // Chrome accepts YUYV, but not our native UYVY. We byteswap below.
  47                 fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
  48
  49                 fmt.fmt.pix.field = V4L2_FIELD_NONE;
  50                 fmt.fmt.pix.bytesperline = video_format.stride;
  51                 fmt.fmt.pix.sizeimage = video_format.stride * video_format.height;
  52                 fmt.fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
  53                 int err = ioctl(video_fd, VIDIOC_S_FMT, &fmt);
  54                 if (err == -1) {
  55                         perror("ioctl(VIDIOC_S_FMT)");
  56                         usb->get_video_frame_allocator()->release_frame(video_frame);
  57                         usb->get_audio_frame_allocator()->release_frame(audio_frame);
  58                         return;
  59                 } else {
  60                         last_width = video_format.width;
  61                         last_height = video_format.height;
  62                         last_stride = video_format.stride;
  63                 }
  64         }
  65
  66         if (video_frame.data != nullptr) {
  67                 uint8_t *origptr = video_frame.data + video_offset + video_format.extra_lines_top * video_format.stride;
  68 #if __SSE2__
  69                 __m128i *ptr = (__m128i *)origptr;
  70                 for (unsigned i = 0; i < video_format.width * video_format.height / 8; ++i) {
  71                         __m128i val = _mm_loadu_si128(ptr);
  72                         val = _mm_slli_epi16(val, 8) | _mm_srli_epi16(val, 8);
  73                         _mm_storeu_si128(ptr, val);
  74                         ++ptr;
  75                 }
  76 #else
  77                 uint8_t *ptr = origptr;
  78                 for (unsigned i = 0; i < video_format.width * video_format.height; ++i) {
  79                         swap(ptr[0], ptr[1]);
  80                         swap(ptr[2], ptr[3]);
  81                         ptr += 4;
  82                 }
  83 #endif
  84
  85                 write(video_fd, origptr, video_frame.len);
  86         }
  87
  88         usb->get_video_frame_allocator()->release_frame(video_frame);
  89         usb->get_audio_frame_allocator()->release_frame(audio_frame);
  90 }
  91
  92 int main(int argc, char **argv)
  93 {
  94         const char *filename = (argc >= 2) ? argv[1] : "/dev/video2";
  95         video_fd = open(filename, O_RDWR);
  96         if (video_fd == -1) {
  97                 perror(filename);
  98                 exit(1);
  99         }
 100
 101         usb = new BMUSBCapture(0);  // First card.
 102         usb->set_frame_callback(frame_callback);
 103         usb->configure_card();
 104         BMUSBCapture::start_bm_thread();
 105         usb->start_bm_capture();
 106         sleep(1000000);
 107 }
 108