Linux系统下如何实现视频设备的并发读取与多读取者访问？

Hey there! Let's tackle your two questions about concurrent access to Linux video devices—this is a super common scenario when you need to both stream video and run computer vision processing at the same time. Let's break it down step by step.

By default, Linux V4L2 video devices (like /dev/video0) enforce exclusive access—if one process opens the device, any other process trying to open it will fail. Here are the most reliable solutions:

Option 1: Use the v4l2loopback Virtual Video Device #

This is the easiest, most widely used approach. We create a virtual video device, forward the real camera's stream to it, and let multiple processes read from the virtual device.

• Install the module: On Debian/Ubuntu-based systems:

  sudo apt install v4l2loopback-dkms v4l2loopback-utils
  

• Create the virtual device: Load the module and define your virtual device:

  sudo modprobe v4l2loopback devices=1 video_nr=10 card_label="VirtualCam"
  

  This generates /dev/video10 as your shared virtual device.
• Forward the real stream to the virtual device: Use ffmpeg or gstreamer to pipe the real camera's feed to the virtual device:

  # With ffmpeg
  ffmpeg -f v4l2 -i /dev/video0 -f v4l2 /dev/video10
  
  # With gstreamer
  gst-launch-1.0 v4l2src device=/dev/video0 ! v4l2sink device=/dev/video10
  

  Now any number of processes can safely read from /dev/video10.

Option 2: Build a Producer-Consumer Model in Your Application #

If you need full customization, write a dedicated producer process to read from the real camera, then distribute frames to multiple consumer processes using:

• Shared Memory: Create a shared memory segment where the producer writes frames, and consumers read from it (use semaphores to sync access and avoid data races).
• UNIX Domain Sockets: The producer acts as a server, sending frames to connected consumer processes (one for streaming, one for CV processing).

A simplified workflow:

1. Producer: Opens /dev/video0, initializes V4L2 settings, then loops reading frames and sending them to consumers via shared memory/sockets.
2. Consumers: Connect to the producer's shared memory/socket, then read frames to handle streaming or CV tasks.

Option 3: Use V4L2 Multi-Stream API (Device-Dependent) #

Some modern USB cameras support V4L2's multi-stream feature, which allows multiple file descriptors to be opened for the same device (each with its own stream settings like resolution/format). Check if your device supports this with:

v4l2-ctl --list-streams

If supported, simply open the device in multiple processes and configure different stream parameters for each.

This is a specific use case of concurrent access—here are tailored solutions:

Option 1: v4l2loopback + Dual Consumers #

Leverage the virtual device setup from Option 1 above, then run two separate consumer processes:

• Streaming Consumer: Use ffmpeg to push the virtual device's stream to a server:

  ffmpeg -f v4l2 -i /dev/video10 -c:v libx264 -f flv rtmp://your-stream-server/live/feed
  

• CV Processing Consumer: Use OpenCV to read frames and run your computer vision logic (Python example):

  import cv2
  
  cap = cv2.VideoCapture('/dev/video10')
  while cap.isOpened():
      ret, frame = cap.read()
      if not ret:
          break
      # Add your CV logic here (e.g., face detection, object recognition)
      gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
      cv2.imshow('CV Processing Output', gray_frame)
      if cv2.waitKey(1) & 0xFF == ord('q'):
          break
  cap.release()
  cv2.destroyAllWindows()
  

Option 2: Custom Producer with Dual Consumer Distribution #

If you need tighter integration, build a producer process that sends frames to two dedicated consumers:

• The producer reads frames from /dev/video0, then sends a copy of each frame to both the streaming consumer (e.g., via RTMP socket) and the CV consumer (via shared memory or local socket).
• Use synchronization primitives like semaphores or message queues to ensure consumers receive complete frames without data corruption.

内容的提问来源于stack exchange，提问作者Bharat Khatri