#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
|
};
|
|
}
|
