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 #include <algorithm>
  22
  23 using namespace std;
  24 using namespace bmusb;
  25
  26 BMUSBCapture *usb;
  27 int video_fd;
  28
  29 void frame_callback(uint16_t timecode,
  30                     FrameAllocator::Frame video_frame, size_t video_offset, VideoFormat video_format,
  31                     FrameAllocator::Frame audio_frame, size_t audio_offset, AudioFormat audio_format)
  32 {
  33         printf("0x%04x: %zu video bytes (format 0x%04x, %d x %d)\n",
  34                 timecode,
  35                 video_frame.len - video_offset, video_format.id, video_format.width, video_format.height);
  36
  37         static unsigned last_width = 0, last_height = 0, last_stride = 0;
  38
  39         if (video_format.width != last_width ||
  40             video_format.height != last_height ||
  41             video_format.stride != last_stride) {
  42                 v4l2_format fmt;
  43                 memset(&fmt, 0, sizeof(fmt));
  44                 fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
  45                 fmt.fmt.pix.width = video_format.width;
  46                 fmt.fmt.pix.height = video_format.height;
  47
  48                 // Chrome accepts YUYV, but not our native UYVY. We byteswap below.
  49                 fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
  50
  51                 fmt.fmt.pix.field = V4L2_FIELD_NONE;
  52                 fmt.fmt.pix.bytesperline = video_format.stride;
  53                 fmt.fmt.pix.sizeimage = video_format.stride * video_format.height;
  54                 fmt.fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
  55                 int err = ioctl(video_fd, VIDIOC_S_FMT, &fmt);
  56                 if (err == -1) {
  57                         perror("ioctl(VIDIOC_S_FMT)");
  58                         usb->get_video_frame_allocator()->release_frame(video_frame);
  59                         usb->get_audio_frame_allocator()->release_frame(audio_frame);
  60                         return;
  61                 } else {
  62                         last_width = video_format.width;
  63                         last_height = video_format.height;
  64                         last_stride = video_format.stride;
  65                 }
  66         }
  67
  68         if (video_frame.data != nullptr) {
  69                 uint8_t *origptr = video_frame.data + video_offset + video_format.extra_lines_top * video_format.stride;
  70 #if __SSE2__
  71                 __m128i *ptr = (__m128i *)origptr;
  72                 for (unsigned i = 0; i < video_format.stride * video_format.height / 16; ++i) {
  73                         __m128i val = _mm_loadu_si128(ptr);
  74                         val = _mm_slli_epi16(val, 8) | _mm_srli_epi16(val, 8);
  75                         _mm_storeu_si128(ptr, val);
  76                         ++ptr;
  77                 }
  78 #else
  79                 uint8_t *ptr = origptr;
  80                 for (unsigned i = 0; i < video_format.stride * video_format.height / 4; ++i) {
  81                         swap(ptr[0], ptr[1]);
  82                         swap(ptr[2], ptr[3]);
  83                         ptr += 4;
  84                 }
  85 #endif
  86
  87                 write(video_fd, origptr, video_frame.len);
  88         }
  89
  90         usb->get_video_frame_allocator()->release_frame(video_frame);
  91         usb->get_audio_frame_allocator()->release_frame(audio_frame);
  92 }
  93
  94 int main(int argc, char **argv)
  95 {
  96         const char *filename = (argc >= 2) ? argv[1] : "/dev/video2";
  97         video_fd = open(filename, O_RDWR);
  98         if (video_fd == -1) {
  99                 perror(filename);
 100                 exit(1);
 101         }
 102
 103         usb = new BMUSBCapture(0);  // First card.
 104         usb->set_frame_callback(frame_callback);
 105         usb->configure_card();
 106         BMUSBCapture::start_bm_thread();
 107         usb->start_bm_capture();
 108         sleep(1000000);
 109 }
 110