OpenCV-Utils学习日志：VideoWriter使用样例

1.VideoWriter可将数据流保存为指定格式的视频或图像序列：

         (1)录制为视频数据，需要指定视频的完整路径，如/root/data/vtest.avi；同时需要指定fourcc、帧率、图像尺寸及是否保存为彩色，fourcc值参见OpenCV官网指定的链接。

         (2)保存为图像序列，需要指定图像序列的完整路径，其中路径中的文件名的格式同C言语中prinf的格式，可参见《CV学习日志：C语言中文件IO使用要点》。如/root/data/ima%d.png；如/root/data/ima%03d.png，这里%03d表示图像名序列号是整数、占宽三位、不足三位的高位是零填充。同时，需要设置fourcc或帧率为0。

2.VideoWriter常用的函数是构造和write：

         (1)构造函数：用于创建数据流。

         (2)write函数：写一帧数据流。

3.类AboutVideoIO是VideoCapture和VideoWriter的综合使用样例，其功能如下：

         (1)打开数据流功能：可打开相机、视频或图像序列，相机指定设备号、视频和图像序列指定完整路径。

         (2)保存数据流功能：按空格保存图像到给定的目录或默认的workDir/data，图像名是时间戳，单位纳秒。

         (3)帧显示时间设置功能：默认每帧显示30毫秒，可指定为期望显示的时间，其中设为零表示一直显示直到按下任意键。

         (4)帧高度宽度设置功能：对于相机数据流，可指定相机支持的尺寸，否则为相机默认的输出尺寸。

         (5)录制数据流功能：按1开始或继续录制图像到给定的目录或默认的workDir/data，按2暂停录制。

         (6)录制时帧率设置功能：当帧率设置为0时，录制为图像序列videoio*.png，否则录制为视频videoio.avi。

         (7)录制时编码设置功能：即VideoWriter::fourcc码，当帧率设置为0时，此设置无效，内部自动置为0。

         (8)录制时色彩设置功能：当设置为0时录制为灰度流，否则录制为彩色流，默认录制为彩色流。

         (9)自动生成配置文件功能：首次运行或配置文件不存在将自动生成workDir/videoio.yml，然后修改配置项为期望值后重启。

         可在https://github.com/opencv/opencv/tree/master/samples/data下载vtest.avi和left*.jpg测试视频流和图像序列。

         也可参见关于VedioCapture的使用样例《OpenCV-Utils学习日志：VideoCapture使用样例》

         以下是详细代码，依赖于C++14、OpenCV4.x和Spdlog。

#include <opencv2/opencv.hpp>
#include <opencv2/core/utils/filesystem.hpp>
#include <spdlog/spdlog.h>
using namespace std;
using namespace cv;

#ifndef StrPairKey
#define StrPairKey(key) make_pair(#key, key)
#define StrPairVal(val) make_pair(val, #val)
#endif

class AboutVideoIO
{
public:
    map<int, pair<int, string>> capProps =
    {
        make_pair(0, StrPairVal(CAP_PROP_POS_MSEC)),
        make_pair(1, StrPairVal(CAP_PROP_POS_FRAMES)),
        make_pair(2, StrPairVal(CAP_PROP_FRAME_COUNT)),
        make_pair(3, StrPairVal(CAP_PROP_POS_AVI_RATIO)),

        make_pair(4, StrPairVal(CAP_PROP_FRAME_WIDTH)),
        make_pair(5, StrPairVal(CAP_PROP_FRAME_HEIGHT)),
        make_pair(6, StrPairVal(CAP_PROP_FPS)),
        make_pair(7, StrPairVal(CAP_PROP_FOURCC)),
        make_pair(8, StrPairVal(CAP_PROP_FORMAT)),
        make_pair(9, StrPairVal(CAP_PROP_MODE)),

        make_pair(10, StrPairVal(CAP_PROP_BRIGHTNESS)),
        make_pair(11, StrPairVal(CAP_PROP_HUE)),
        make_pair(12, StrPairVal(CAP_PROP_SATURATION)),
        make_pair(13, StrPairVal(CAP_PROP_CONTRAST)),
        make_pair(14, StrPairVal(CAP_PROP_GAIN)),
        make_pair(15, StrPairVal(CAP_PROP_EXPOSURE))
    };

public:
    struct VideoIO
    {
        char imaFrom[512] = "0";
        char saveDir[512] = "./data";
        int waitTime = 30;
        int deviceRows = 0;
        int deviceCols = 0;
        int writeFPS = 24;
        char writeFourcc[8] = "DX50";
        bool writeColor = true;
        void write(FileStorage& fs)
        {
            fs << "imaFrom" << imaFrom; fs.writeComment("deviceId like"0" or videoPath like"/root/data/vtest.avi" or imaListPath like"/root/data/left%03d.jpg)"", true);
            fs << "saveDir" << saveDir; fs.writeComment("auto created if not existing", true);
            fs << "waitTime" << waitTime; fs.writeComment("0-wait for pressing any key", true);
            fs << "deviceRows" << deviceRows; fs.writeComment("0-auto size", true);
            fs << "deviceCols" << deviceCols; fs.writeComment("0-auto size", true);
            fs << "writeFPS" << writeFPS; fs.writeComment("0-save as videoio*.png or else videoio.avi", true);
            fs << "writeFourcc" << writeFourcc;
            fs << "writeColor" << writeColor;
        }
        void read(FileStorage& fs)
        {
            strcpy(imaFrom, fs["imaFrom"].string().c_str());
            strcpy(saveDir, fs["saveDir"].string().c_str());
            fs["waitTime"] >> waitTime;
            fs["deviceRows"] >> deviceRows;
            fs["deviceCols"] >> deviceCols;
            fs["writeFPS"] >> writeFPS;
            strcpy(writeFourcc, fs["writeFourcc"].string().c_str());
            fs["writeColor"] >> writeColor;
        }
        string print(string savePath = "")
        {
            string str;
            str += fmt::format("imaFrom: {}
", imaFrom);
            str += fmt::format("saveDir: {}
", saveDir);
            str += fmt::format("waitTime: {}
", waitTime);
            str += fmt::format("deviceRows: {}
", deviceRows);
            str += fmt::format("deviceCols: {}
", deviceCols);
            str += fmt::format("writeFPS: {}
", writeFPS);
            str += fmt::format("writeFourcc: {}
", writeFourcc);
            str += fmt::format("writeColor: {}
", writeColor);
            if (savePath.empty() == false) { FILE* out = fopen(savePath.c_str(), "w"); fprintf(out, str.c_str()); fclose(out); }
            return str;
        }
        static VideoIO GetOne(string fsPath, bool doPrint = true)
        {
            VideoIO videoIO;
            if (cv::utils::fs::exists(fsPath) == false)
            {
                cv::utils::fs::createDirectories(getFilePathInfo(fsPath));
                FileStorage fs(fsPath, FileStorage::WRITE);
                videoIO.write(fs);
                fs.release();
                //memset(&videoIO, 0, sizeof(videoIO));
                spdlog::critical("No exist: {}", fsPath);
                spdlog::info("Created file: {}", fsPath);
                spdlog::info("Modify default values and relaunch");
            }
            else
            {
                FileStorage fs(fsPath, FileStorage::READ);
                videoIO.read(fs);
                fs.release();
            }
            if (doPrint) spdlog::info(videoIO.print());
            return videoIO;
        }
        static string getFilePathInfo(string path, int mode = 0/*0=dir 1=basename 2=extname 3=dirbasename 4=filename*/)
        {
            int ind1 = (int)path.find_last_of('/');
            int ind2 = (int)path.find_last_of('.');
            if (mode == 0) return path.substr(0, ind1);
            else if (mode == 1) return path.substr(ind1 + 1, ind2 - ind1 - 1);
            else if (mode == 2) return path.substr(ind2 + 1);
            else if (mode == 3) return path.substr(0, ind2);
            else return path.substr(ind1 + 1);
        }
    };

public:
    void TestMe(int argc = 0, char** argv = 0)
    {
        //0.GetParams
        string videoioCfgPath = "./videoio.yml";
        VideoIO videoIO = VideoIO::GetOne(videoioCfgPath);

        //1.CreatDirectory
        utils::fs::createDirectories(videoIO.saveDir);
        spdlog::set_pattern("%v"); spdlog::info(videoIO.print());

        //2.OpenStream
        VideoCapture cap;
        if (std::strlen(videoIO.imaFrom) == 1)
            if (cap.open(atoi(videoIO.imaFrom)) == false) { spdlog::critical("Failed to open device: {}", videoIO.imaFrom); return; }
        if (std::strlen(videoIO.imaFrom) > 1)
            if (cap.open(videoIO.imaFrom) == false) { spdlog::critical("Failed to open file: {}", videoIO.imaFrom); return; }

        //3.SetDevice
        if (videoIO.deviceRows != 0) cap.set(CAP_PROP_FRAME_HEIGHT, videoIO.deviceRows);
        if (videoIO.deviceCols != 0) cap.set(CAP_PROP_FRAME_WIDTH, videoIO.deviceCols);

        //4.GetDevice
        spdlog::info("cap.isOpened(): {}", cap.isOpened());
        spdlog::info("cap.getBackendName(): ", cap.getBackendName());
        for (map<int, pair<int, string>>::iterator it = capProps.begin(); it != capProps.end(); ++it)
            spdlog::info("cap.get({}): {}", it->second.second, cap.get(it->second.first));

        //5.CreatStream
        string path = fmt::format("{}/{}", videoIO.saveDir, videoIO.writeFPS == 0 ? "videoid%04d.png" : "videoio.avi");
        int fourcc = videoIO.writeFPS == 0 ? 0 : VideoWriter::fourcc(videoIO.writeFourcc[0], videoIO.writeFourcc[1], videoIO.writeFourcc[2], videoIO.writeFourcc[3]);
        VideoWriter wrt(path, fourcc, videoIO.writeFPS, Size((int)cap.get(CAP_PROP_FRAME_WIDTH), (int)cap.get(CAP_PROP_FRAME_HEIGHT)), videoIO.writeColor);
        spdlog::info("wrt.isOpened(): {}", wrt.isOpened());
        spdlog::info("wrt.getBackendName(): ", wrt.getBackendName());
        spdlog::info("wrt.get(VIDEOWRITER_PROP_QUALITY): {}", wrt.get(VIDEOWRITER_PROP_QUALITY));
        spdlog::info("wrt.get(VIDEOWRITER_PROP_FRAMEBYTES): {}", wrt.get(VIDEOWRITER_PROP_FRAMEBYTES));
        spdlog::info("wrt.get(VIDEOWRITER_PROP_NSTRIPES): {}", wrt.get(VIDEOWRITER_PROP_NSTRIPES));
        spdlog::info("wrt.get(VIDEOWRITER_PROP_IS_COLOR ): {}", wrt.get(VIDEOWRITER_PROP_IS_COLOR));

        //6.ReadWriteStream
        cv::namedWindow(__FUNCTION__, WINDOW_NORMAL);
        spdlog::info("Press space to save one and q/Q to exit");
        spdlog::info("press 1 to start/continue and 2 to stop recording");
        Mat frame; int flag = 0;
        while (cap.read(frame))
        {
            //6.1 ShowImage
            cv::imshow(__FUNCTION__, frame);
            int c = cv::waitKey(videoIO.waitTime);
            if (c == 'q' || c == 'Q') break;

            //6.2 SaveImage
            if (c == ' ')
            {
                string savePath = videoIO.saveDir + fmt::format("/{}.png", chrono::time_point_cast<chrono::nanoseconds>(chrono::system_clock::now()).time_since_epoch().count());
                cv::imwrite(savePath, frame);
                spdlog::info("Saved to: " + savePath);
            }

            //6.3 RecordImage
            if (c == '1' || c == '2') flag = c;
            if (flag == '1') { wrt.write(frame); spdlog::info("Record timestamp: {}", chrono::time_point_cast<chrono::nanoseconds>(chrono::system_clock::now()).time_since_epoch().count()); }
        }
        cv::destroyWindow(__FUNCTION__);
    }
};

int main(int argc, char** argv) { AboutVideoIO me; me.TestMe(argc, argv); return 0; }