CscCaptureEngine.h

Go to the documentation of this file.

//
//  CscCaptureEngine.hpp
//  ConscienceRobotManager
//
//  Created by Iliès Zaoui on 14/07/2019.
//  Copyright © 2019 IliesZaoui. All rights reserved.
//
 
#ifndef CscCaptureEngine_h
#define CscCaptureEngine_h
 
#include <mutex>
#include <thread>
#include <opencv2/opencv.hpp>
 
#include "CscCommon.h"
 
using cv::Mat, cv::VideoCapture, cv::CAP_PROP_FPS, cv::CAP_PROP_FRAME_WIDTH, cv::CAP_PROP_FRAME_HEIGHT;
using std::pair, std::mutex, std::recursive_mutex, std::exception, std::thread, std::lock_guard;
namespace fs = std::filesystem;
namespace conscience_utils::JSON {
class CscJsonObjectReader;
class CscJsonObject;
}
using namespace conscience_utils::JSON;
using namespace conscience_utils::logging;
 
namespace conscience_core::media_capture {
 
ENUM(CscEntityVideoSourceType,
         NoStream,
         LocalFile,
         LocalDevice,
         BytesStream,
         NetworkStream);
 
struct Resolution {
    int width;
    int height;
    Resolution(int width, int height) : width(width), height(height) {
    }
 
    cv::Size toSize() const {
        return cv::Size(width, height);
    }
 
    operator string() const {
        return to_string(width) + "x" + to_string(height);
    }
};
 
class CscEntityVideoSource {
 
public:
    static ptr<CscEntityVideoSource> none();
 
    static ptr<CscEntityVideoSource> localFileStream(const string &footagePath);
 
    static ptr<CscEntityVideoSource> localDeviceStream(
        const int &deviceId,
        const optional<Resolution> &resolution = {},
        const optional<unsigned> &fps = {});
 
    static ptr<CscEntityVideoSource> networkStream(
        const string &streamUrl,
        const optional<Resolution> &resolution = {},
        const optional<int> &fps = {},
        const map<string, string> &additionalParams = {});
 
    bool equals(ptr<CscEntityVideoSource> other);
 
    operator string() {
        return "VideoSource(" + to_string(type) + ", parameters=" + mapToString(parameters) + ")";
    }
 
    string toString();
 
    string serialize() const;
    CscJsonObject *serializeJson() const;
    static ptr<CscEntityVideoSource> fromSerializedJson(CscJsonObjectReader &serialized);
    static ptr<CscEntityVideoSource> fromSerialized(const string &serializedVideoSource);
 
    const CscEntityVideoSourceType &getType();
 
    bool isNone() const;
 
    int getIntParameter(const string &parameterName);
 
    optional<int> getOptionalIntParameter(const string &parameterName);
 
    string getParameter(const string &parameterName);
 
    CscEntityVideoSource(const CscEntityVideoSourceType &type, const map<string, string> &parameters = {});
 
    const string &getId() const;
 
    optional<string> getNetworkStreamUrl();
    optional<string> getOptionalParam(const string &parameterName);
 
private:
    const CscEntityVideoSourceType type;
    const std::map<string, string> parameters;
    const string id;
    string generateId() const;
};
 
class CannotOpenVideoStreamException : public exception {
public:
    CannotOpenVideoStreamException(ptr<CscEntityVideoSource> videoSource) noexcept : errorMessage("cannot open video stream from source: " + string(*videoSource)){};
 
    const char *what() const noexcept override {
        return errorMessage.c_str();
    }
 
    ~CannotOpenVideoStreamException() noexcept override = default;
 
private:
    const string errorMessage;
};
 
class CscCaptureEngine {
public:
    CscCaptureEngine(const string &logPrefix = "");
    virtual ~CscCaptureEngine();
 
    void open(ptr<CscEntityVideoSource> videoSource);
 
    Mat &getCurrentFrame();
 
    Mat getCurrentFrameClone();
 
    Mat &getProcessedFrame();
 
    Mat getProcessedFrameClone();
    Mat &getProcessedFrameMini();
 
    void close();
 
    bool isOpened() const;
 
    bool isOpening() const;
 
    bool isClosed() const;
 
    void populateProcessedImage(Mat image);
    void updateCaptureProp(int prop, float value);
    float getCapturePropValue(int prop);
 
    static void writeImage(string path, Mat &image);
 
    optional<Resolution> getRequestedResolution() const {
        return requestedResolution;
    }
 
    optional<Resolution> getActualResolution() const {
        return actualResolution;
    }
 
    CscEntityVideoSourceType getSourceType() const;
 
private:
    enum Status {
        OPENING,
        OPENED,
        CLOSED,
        DESTROYING,
        DESTROYED
    };
 
    ptr<CscEntityVideoSource> videoSource = nullptr;
    VideoCapture videoCapture;
 
    bool conscienceVisionStreamCurrentlyOpening = false;
 
    recursive_mutex grabMutex;
    mutex currentImageMutex;
    mutex processedImageMutex;
 
    int currentOpenRequestId = 0;
 
    optional<unsigned long long> grabFailureStartTimestamp = {};
    bool grabWarningLogged = false;
 
    optional<Resolution> requestedResolution = {};
    optional<Resolution> actualResolution = {};
 
    optional<int> requestedFps = {};
    optional<int> actualFps = {};
 
    void updateActualMetrics();
 
    int deviceId = 0;
 
    Mat currentFrame;
    Mat processedFrame;
    Mat processedFrameMini;
 
    thread *captureThread = nullptr;
    void initThread();
    Status status = Status::CLOSED;
 
    const int timeStepMillis = 250;
    const int maxTimeAttemptMillis = 30000;
    int actualTimeAttemptMillis = 0;
    int actualAttempts = 0;
    mutex requestOpenMutex;
 
    void doOpen(ptr<CscEntityVideoSource> videoSource);
    void openStreamFromDevice(int deviceId, const optional<int> &frameWidth, const optional<int> &frameHeight, const optional<int> &requestedFps = {});
    void openStreamFromFile(string filePath);
    void openStreamFromNetwork(string streamUrl, optional<Resolution> resolution = {}, optional<int> fps = {});
    void onOpened(optional<Resolution> requestedResolution = {}, optional<int> requestedFps = {});
 
    unique_ptr<CscLogger> logger = nullptr;
 
    void updateFrame();
    bool isNoSleepStream() const;
    void sleepUntilFrame();
    void tryOpen();
    
    bool isMediaFile() const;
 
    void setCurrentFrame(Mat currentFrame);
 
    void captureThreadLoop();
};
 
}
 
#endif