first commit

nodes/record/vp_record_task.h

@@ -0,0 +1,111 @@
+#pragma once
+
+#include <deque>
+#include <thread>
+#include <memory>
+#include <functional>
+// compile tips:
+// remove experimental/ if gcc >= 8.0
+#include <experimental/filesystem>
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/imgcodecs.hpp>
+
+#include "../../objects/vp_frame_meta.h"
+#include "../../utils/vp_utils.h"
+#include "../../utils/vp_semaphore.h"
+#include "../../utils/logger/vp_logger.h"
+
+namespace vp_nodes {
+    // record type
+    enum vp_record_type {
+        IMAGE,
+        VIDEO
+    };
+
+    // record information, used to notify others.
+    struct vp_record_info {
+        int channel_index;
+        vp_record_type record_type = vp_record_type::IMAGE;
+        std::string file_name_without_ext;
+        std::string full_record_path;
+        bool osd;
+
+        int pre_record_video_duration = 0;   // ignore for image
+        int record_video_duration = 0;       // ignore for image
+    };
+
+    // hooker for recording complete
+    typedef std::function<void(int, vp_record_info)> vp_record_task_complete_hooker;
+
+    // status of record task
+    enum vp_record_task_status {
+        NOSTRAT,   // task initialized but have not called start()
+        STARTED,   // called start() and task is working (writing/saving data to file)
+        COMPLETE   // record task is complete. task instance is un-reusable
+    };
+
+    // base class for record task (video & image), works asynchronously and mainly responsible for:
+    // 1. preprocess frame before recording
+    // 2. generate valid full record path, including path, name with extension
+    // 3. run working thread
+    // 4. notify caller when recording complete
+    class vp_record_task {
+    private:
+        int channel_index;
+        std::string file_name_without_ext;
+        std::string save_dir;
+        bool auto_sub_dir;
+        vp_objects::vp_size resolution_w_h;
+        bool osd;
+        
+        std::string full_record_path = "";
+        vp_record_task_complete_hooker task_complete_hooker;
+    protected:
+        // record thread
+        std::thread record_task_th;
+        // record thread func, implemented by child class
+        virtual void record_task_run() = 0;
+        // wait thread exit in vp_record_task
+        void stop_task();
+        // preprocess, choose frame type (osd or not) and resize
+        void preprocess(std::shared_ptr<vp_objects::vp_frame_meta>& frame_to_record, cv::Mat& data);
+        // get file extension override by specific class (for example, .mp4 for video and .jpg for image)
+        virtual std::string get_file_ext() = 0;
+
+        // notify to host when task complete
+        void notify_task_complete(vp_record_info record_info);
+
+        // cache frames to be recorded (video or image)
+        // 1. include pre-record frames for video
+        // 2. just one frame enough for image
+        std::deque<std::shared_ptr<vp_objects::vp_frame_meta>>  frames_to_record;
+
+        // synchronize for cache
+        vp_utils::vp_semaphore cache_semaphore;
+        std::string host_node_name;   // the node name of host, vp_record_task is mainly used inside node.
+    public:
+        // status
+        vp_record_task_status status = vp_record_task_status::NOSTRAT;
+        // get full record path for file, include path, name with extension
+        std::string get_full_record_path();
+        // register hooker for recording complete
+        void set_task_complete_hooker(vp_record_task_complete_hooker task_complete_hooker);
+        // start task async
+        void start();
+   
+        // append asynchronously, just write frame to cache
+        void append_async(std::shared_ptr<vp_objects::vp_frame_meta> frame_meta);
+
+        vp_record_task(int channel_index,
+                        std::string file_name_without_ext, 
+                        std::string save_dir, 
+                        bool auto_sub_dir, 
+                        vp_objects::vp_size resolution_w_h, 
+                        bool osd,
+                        std::string host_node_name);
+        virtual ~vp_record_task();   // keep virtual since we need destruct child class via base pointer
+    };
+
+}