feat: enable libcamera selection in addition to v4l2

Author: TzuHuanTai

src/args.h

@@ -10,6 +10,7 @@ struct Args {
     int fps = 30;
     int width = 640;
     int height = 480;
+    int cameraId = 0;
     int jpeg_quality = 30;
     int rotation_angle = 0;
     int sample_rate = 44100;
@@ -21,7 +22,7 @@ struct Args {
     bool fixed_resolution = false;
     uint32_t format = V4L2_PIX_FMT_MJPEG;
     std::string v4l2_format = "mjpeg";
-    std::string device = "/dev/video0";
+    std::string camera = "libcamera:0";
     std::string uid = "";
     std::string stun_url = "stun:stun.l.google.com:19302";
     std::string turn_url = "";

src/capturer/libcamera_capturer.cpp

@@ -6,7 +6,7 @@
 
 std::shared_ptr<LibcameraCapturer> LibcameraCapturer::Create(Args args) {
     auto ptr = std::make_shared<LibcameraCapturer>(args);
-    ptr->Init(args.device);
+    ptr->Init(args.cameraId);
     ptr->SetFps(args.fps)
         .SetRotation(args.rotation_angle)
         .SetFormat(args.width, args.height)
@@ -19,18 +19,25 @@ LibcameraCapturer::LibcameraCapturer(Args args)
       format_(args.format),
       config_(args) {}
 
-void LibcameraCapturer::Init(std::string device) {
+void LibcameraCapturer::Init(int deviceId) {
     cm_ = std::make_unique<libcamera::CameraManager>();
-    cm_->start();
+    int ret = cm_->start();
+    if (ret) {
+        throw std::runtime_error("Failed to start camera manager");
+    }
 
-    if (cm_->cameras().size() == 0) {
-        ERROR_PRINT("No camera is available via libcamera.");
-        exit(1);
+    auto cameras = cm_->cameras();
+    if (cameras.size() == 0) {
+        throw std::runtime_error("No camera is available via libcamera.");
+    }
+
+    if (config_.cameraId >= cameras.size()) {
+        throw std::runtime_error("Selected camera is not available.");
     }
 
-    std::string cameraId = cm_->cameras()[0]->id();
-    INFO_PRINT("camera id: %s", cameraId.c_str());
-    camera_ = cm_->get(cameraId);
+    std::string const &cam_id = cameras[config_.cameraId]->id();
+    INFO_PRINT("camera id: %s", cam_id.c_str());
+    camera_ = cm_->get(cam_id);
     camera_->acquire();
     camera_config_ = camera_->generateConfiguration({libcamera::StreamRole::VideoRecording});
 }

src/capturer/libcamera_capturer.h

@@ -56,7 +56,7 @@ class LibcameraCapturer : public VideoCapturer {
     LibcameraCapturer &SetFps(int fps);
     LibcameraCapturer &SetRotation(int angle);
 
-    void Init(std::string device);
+    void Init(int deviceId);
     void AllocateBuffer();
     void RequestComplete(libcamera::Request *request);
 };

src/capturer/v4l2_capturer.cpp

@@ -13,7 +13,7 @@
 
 std::shared_ptr<V4l2Capturer> V4l2Capturer::Create(Args args) {
     auto ptr = std::make_shared<V4l2Capturer>(args);
-    ptr->Init(args.device);
+    ptr->Init(args.cameraId);
     ptr->SetFps(args.fps)
         .SetRotation(args.rotation_angle)
         .SetFormat(args.width, args.height)
@@ -28,8 +28,9 @@ V4l2Capturer::V4l2Capturer(Args args)
       has_first_keyframe_(false),
       config_(args) {}
 
-void V4l2Capturer::Init(std::string device) {
-    fd_ = V4l2Util::OpenDevice(device.c_str());
+void V4l2Capturer::Init(int deviceId) {
+    std::string devicePath = "/dev/video" + std::to_string(deviceId);
+    fd_ = V4l2Util::OpenDevice(devicePath.c_str());
 
     if (!V4l2Util::InitBuffer(fd_, &capture_, V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_MEMORY_MMAP)) {
         exit(0);

src/capturer/v4l2_capturer.h

@@ -47,7 +47,7 @@ class V4l2Capturer : public VideoCapturer {
     V4l2Capturer &SetFps(int fps = 30);
     V4l2Capturer &SetRotation(int angle);
 
-    void Init(std::string device);
+    void Init(int deviceId);
     bool IsCompressedFormat() const;
     void CaptureImage();
     bool CheckMatchingDevice(std::string unique_name);

src/conductor.cpp

@@ -50,7 +50,7 @@ void Conductor::InitializeTracks() {
         audio_track_ = peer_connection_factory_->CreateAudioTrack("audio_track", options.get());
     }
 
-    if (video_track_ == nullptr && !args.device.empty()) {
+    if (video_track_ == nullptr && !args.camera.empty()) {
         video_capture_source_ = ([this]() -> std::shared_ptr<VideoCapturer> {
             if (args.use_libcamera) {
                 return LibcameraCapturer::Create(args);

src/parser.cpp

@@ -35,11 +35,9 @@ void Parser::ParseArgs(int argc, char *argv[], Args &args) {
             "The connection timeout, in seconds, after receiving a remote offer")
         ("segment_duration", bpo::value<int>()->default_value(args.segment_duration),
             "The length (in seconds) of each MP4 recording.")
-        ("device", bpo::value<std::string>()->default_value(args.device),
-            "Read the specific camera file via V4L2, default is /dev/video0")
-        ("use_libcamera", bpo::bool_switch()->default_value(args.use_libcamera),
-            "Read YUV420 from the camera via libcamera, the `device` and `v4l2_format` "
-            "flags will be suspended")
+        ("camera", bpo::value<std::string>()->default_value(args.camera),
+            "Specify the camera using V4L2 or Libcamera. "
+            "Examples: \"libcamera:0\" for Libcamera, \"v4l2:/dev/video0\" for V4L2.")
         ("fixed_resolution", bpo::bool_switch()->default_value(args.fixed_resolution),
             "Disable adaptive resolution scaling and keep a fixed resolution.")
         ("no_audio", bpo::bool_switch()->default_value(args.no_audio), "Run without audio source")
@@ -95,7 +93,7 @@ void Parser::ParseArgs(int argc, char *argv[], Args &args) {
     SetIfExists(vm, "rotation_angle", args.rotation_angle);
     SetIfExists(vm, "peer_timeout", args.peer_timeout);
     SetIfExists(vm, "segment_duration", args.segment_duration);
-    SetIfExists(vm, "device", args.device);
+    SetIfExists(vm, "camera", args.camera);
     SetIfExists(vm, "v4l2_format", args.v4l2_format);
     SetIfExists(vm, "uid", args.uid);
     SetIfExists(vm, "stun_url", args.stun_url);
@@ -109,7 +107,6 @@ void Parser::ParseArgs(int argc, char *argv[], Args &args) {
     SetIfExists(vm, "http_port", args.http_port);
     SetIfExists(vm, "record_path", args.record_path);
 
-    args.use_libcamera = vm["use_libcamera"].as<bool>();
     args.fixed_resolution = vm["fixed_resolution"].as<bool>();
     args.no_audio = vm["no_audio"].as<bool>();
     args.hw_accel = vm["hw_accel"].as<bool>();
@@ -134,16 +131,38 @@ void Parser::ParseArgs(int argc, char *argv[], Args &args) {
         }
     }
 
-    if (args.use_libcamera) {
+    ParseDevice(args);
+}
+
+void Parser::ParseDevice(Args &args) {
+    size_t pos = args.camera.find(':');
+    if (pos == std::string::npos) {
+        throw std::runtime_error("Unknown device format: " + args.camera);
+    }
+
+    std::string prefix = args.camera.substr(0, pos);
+    std::string id = args.camera.substr(pos + 1);
+
+    try {
+        args.cameraId = std::stoi(id);
+    } catch (const std::exception &e) {
+        throw std::runtime_error("Invalid camera ID: " + id);
+    }
+
+    if (prefix == "libcamera") {
+        args.use_libcamera = true;
         args.format = V4L2_PIX_FMT_YUV420;
-    } else {
+        std::cout << "Using Libcamera, ID: " << args.cameraId << std::endl;
+    } else if (prefix == "v4l2") {
         auto it = format_map.find(args.v4l2_format);
         if (it != format_map.end()) {
             args.format = it->second;
-            printf("Use %s format source in v4l2\n", args.v4l2_format.c_str());
+            std::cout << "Using V4L2: " << args.v4l2_format << std::endl;
         } else {
-            std::cerr << "Unsupported format: " << args.v4l2_format << std::endl;
-            exit(1);
+            throw std::runtime_error("Unsupported format: " + args.v4l2_format);
         }
+        std::cout << "Using V4L2, ID: " << args.cameraId << std::endl;
+    } else {
+        throw std::runtime_error("Unknown device format: " + prefix);
     }
 }

src/parser.h

@@ -6,6 +6,7 @@
 class Parser {
   public:
     static void ParseArgs(int argc, char *argv[], Args &args);
+    static void ParseDevice(Args &args);
 };
 
 #endif // PARSER_H_