feat: add a record mode flag

Author: TzuHuanTai

src/args.h

@@ -99,6 +99,8 @@ struct Args {
     bool set_default_lens_position = false;
 
     // recording
+    std::string record = "both";
+    int record_mode = -1;
     std::string record_path = "";
     int file_duration = 60;
 

src/parser.cpp

@@ -1,4 +1,5 @@
 #include "parser.h"
+#include "recorder/recorder_manager.h"
 #include "rtc/rtc_peer.h"
 
 #include <algorithm>
@@ -16,6 +17,12 @@ static const std::unordered_map<std::string, int> v4l2_fmt_table = {
     {"yuyv", V4L2_PIX_FMT_YUYV},
 };
 
+static const std::unordered_map<std::string, int> record_mode_table = {
+    {"both", -1},
+    {"video", RecordMode::Video},
+    {"snapshot", RecordMode::Snapshot},
+};
+
 static const std::unordered_map<std::string, int> ipc_mode_table = {
     {"both", -1},
     {"lossy", ChannelMode::Lossy},
@@ -133,11 +140,14 @@ void Parser::ParseArgs(int argc, char *argv[], Args &args) {
             "Autofocus window as x,y,width,height. e.g. '0.3,0.3,0.4,0.4'")
         ("lens-position", bpo::value<std::string>(&args.lens_position_)->default_value(args.lens_position_),
             "Set the lens to a particular focus position, \"0\" moves the lens to infinity, or \"default\" for the hyperfocal distance")
+        ("record-mode", bpo::value<std::string>(&args.record)->default_value(args.record),
+            "Recording mode: 'video' to record MP4 files, 'snapshot' to save periodic JPEG images, "
+            "or 'both' to do both simultaneously.")
         ("record-path", bpo::value<std::string>(&args.record_path)->default_value(args.record_path),
             "Set the path where recording video files will be saved. "
             "If the value is empty or unavailable, the recorder will not start.")
         ("file-duration", bpo::value<int>(&args.file_duration)->default_value(args.file_duration),
-            "The length (in seconds) of each MP4 recording.")
+            "The duration (in seconds) of each video file, or the interval between snapshots.")
         ("jpeg-quality", bpo::value<int>(&args.jpeg_quality)->default_value(args.jpeg_quality),
             "Set the quality of the snapshot and thumbnail images in range 0 to 100.")
         ("peer-timeout", bpo::value<int>(&args.peer_timeout)->default_value(args.peer_timeout),
@@ -262,6 +272,7 @@ void Parser::ParseArgs(int argc, char *argv[], Args &args) {
 
     args.jpeg_quality = std::clamp(args.jpeg_quality, 0, 100);
 
+    args.record_mode = ParseEnum(record_mode_table, args.record);
     args.ipc_channel_mode = ParseEnum(ipc_mode_table, args.ipc_channel);
 
     ParseDevice(args);

src/recorder/recorder_manager.cpp

@@ -85,8 +85,10 @@ void RecorderManager::CreateVideoRecorder(std::shared_ptr<VideoCapturer> capture
     fps = capturer->fps();
     width = capturer->width();
     height = capturer->height();
-    video_recorder = ([capturer]() -> std::unique_ptr<VideoRecorder> {
-        if (capturer->format() == V4L2_PIX_FMT_H264) {
+    video_recorder = ([this, capturer]() -> std::unique_ptr<VideoRecorder> {
+        if (config.record_mode == RecordMode::Snapshot) {
+            return nullptr;
+        } else if (capturer->format() == V4L2_PIX_FMT_H264) {
             return RawH264Recorder::Create(capturer->config());
         } else {
             return H264Recorder::Create(capturer->config());
@@ -95,8 +97,12 @@ void RecorderManager::CreateVideoRecorder(std::shared_ptr<VideoCapturer> capture
 }
 
 void RecorderManager::CreateAudioRecorder(std::shared_ptr<PaCapturer> capturer) {
-    audio_recorder = ([capturer]() -> std::unique_ptr<AudioRecorder> {
-        return AudioRecorder::Create(capturer->config());
+    audio_recorder = ([this, capturer]() -> std::unique_ptr<AudioRecorder> {
+        if (config.record_mode == RecordMode::Snapshot) {
+            return nullptr;
+        } else {
+            return AudioRecorder::Create(capturer->config());
+        }
     })();
 }
 
@@ -126,20 +132,27 @@ void RecorderManager::SubscribeVideoSource(std::shared_ptr<VideoCapturer> video_
 
         if (has_first_keyframe && video_recorder) {
             video_recorder->OnBuffer(buffer);
-            elapsed_time_ = (buffer->timestamp().tv_sec - last_created_time_.tv_sec) +
-                            (buffer->timestamp().tv_usec - last_created_time_.tv_usec) / 1000000.0;
         }
-    });
 
-    video_recorder->OnPacketed([this](AVPacket *pkt) {
-        this->WriteIntoFile(pkt);
+        elapsed_time_ = (buffer->timestamp().tv_sec - last_created_time_.tv_sec) +
+                        (buffer->timestamp().tv_usec - last_created_time_.tv_usec) / 1000000.0;
     });
+
+    if (video_recorder) {
+        video_recorder->OnPacketed([this](AVPacket *pkt) {
+            this->WriteIntoFile(pkt);
+        });
+    }
 }
 
 void RecorderManager::SubscribeAudioSource(std::shared_ptr<PaCapturer> audio_src) {
+    if (!audio_recorder) {
+        return;
+    }
+
     audio_observer = audio_src->AsObservable();
     audio_observer->Subscribe([this](PaBuffer buffer) {
-        if (has_first_keyframe && audio_recorder) {
+        if (has_first_keyframe) {
             audio_recorder->OnBuffer(buffer);
         }
     });
@@ -171,7 +184,7 @@ void RecorderManager::Start() {
     auto folder = new_file.GetFolderPath();
     Utils::CreateFolder(folder);
 
-    {
+    if (config.record_mode != RecordMode::Snapshot) {
         std::lock_guard<std::mutex> lock(ctx_mux);
         fmt_ctx = RecUtil::CreateContainer(new_file.GetFullPath());
         if (fmt_ctx == nullptr) {
@@ -198,7 +211,10 @@ void RecorderManager::Start() {
         audio_recorder->Start();
     }
 
-    MakePreviewImage();
+    if (config.record_mode != RecordMode::Video) {
+        auto image_path = ReplaceExtension(new_file.GetFullPath(), PREVIEW_IMAGE_EXTENSION);
+        MakePreviewImage(image_path);
+    }
 
     has_first_keyframe = true;
 }
@@ -228,15 +244,14 @@ RecorderManager::~RecorderManager() {
     audio_observer.reset();
 }
 
-void RecorderManager::MakePreviewImage() {
-    std::thread([this]() {
+void RecorderManager::MakePreviewImage(std::string path) {
+    std::thread([this, path]() {
         std::this_thread::sleep_for(std::chrono::seconds(3));
         if (video_src_ == nullptr) {
             return;
         }
         auto i420buff = video_src_->GetI420Frame();
-        Utils::CreateJpegImage(i420buff->DataY(), i420buff->width(), i420buff->height(),
-                               ReplaceExtension(fmt_ctx->url, PREVIEW_IMAGE_EXTENSION),
+        Utils::CreateJpegImage(i420buff->DataY(), i420buff->width(), i420buff->height(), path,
                                config.jpeg_quality);
     }).detach();
 }

src/recorder/recorder_manager.h

@@ -16,6 +16,11 @@ extern "C" {
 #include "recorder/audio_recorder.h"
 #include "recorder/video_recorder.h"
 
+enum RecordMode {
+    Video,
+    Snapshot
+};
+
 class RecUtil {
   public:
     static AVFormatContext *CreateContainer(const std::string &full_path);
@@ -60,7 +65,7 @@ class RecorderManager {
     struct timeval last_created_time_;
     std::shared_ptr<VideoCapturer> video_src_;
 
-    void MakePreviewImage();
+    void MakePreviewImage(std::string path);
     std::string ReplaceExtension(const std::string &url, const std::string &new_extension);
 };