EGrabberRecorder.h

Go to the documentation of this file.

/* Copyright Euresys 2020 */
 
#ifndef ERECORDERLIBRARY_H
#define ERECORDERLIBRARY_H
 
#include "ERecorder.h"
#include "internal/dynamicLibrary.h"
#include "internal/defaultPath.h"
 
#include <string>
#include <vector>
#include <sstream>
 
#ifndef ERECORDERLIBRARY_WITH_PROGRESS_REPORT
#if __cplusplus >= 201103L
#define ERECORDERLIBRARY_WITH_PROGRESS_REPORT 1
#else
#define ERECORDERLIBRARY_WITH_PROGRESS_REPORT 0
#endif
#endif
 
#if ERECORDERLIBRARY_WITH_PROGRESS_REPORT
#include <atomic>
#endif
 
namespace Euresys {
namespace EGrabberRecorder {
 
class RecorderError: public std::runtime_error {
public:
    RECORDER_STATUS status;
    explicit RecorderError(RECORDER_STATUS status, const std::string &description);
    static void check(RECORDER_STATUS status);
};
 
class UnknownError: public RecorderError {
public:
    UnknownError();
};
 
class UnknownParameter: public RecorderError {
public:
    UnknownParameter();
};
 
class InvalidParameterType: public RecorderError {
public:
    InvalidParameterType();
};
 
class InvalidParameterValue: public RecorderError {
public:
    InvalidParameterValue();
};
 
class BufferTooSmall: public RecorderError {
public:
    BufferTooSmall();
};
 
class ParameterIsReadOnly: public RecorderError {
public:
    ParameterIsReadOnly();
};
 
class SystemError: public RecorderError {
public:
    SystemError();
};
 
class InvalidContainerPath: public RecorderError {
public:
    InvalidContainerPath();
};
 
class DataFileFull: public RecorderError {
public:
    DataFileFull();
};
 
class OperationNotAllowed: public RecorderError {
public:
    OperationNotAllowed();
};
 
class IndexOutOfRange: public RecorderError {
public:
    IndexOutOfRange();
};
 
class InvalidIndexData: public RecorderError {
public:
    InvalidIndexData();
};
 
class InvalidIndexSize: public RecorderError {
public:
    InvalidIndexSize();
};
 
class UnsupportedDatabaseVersion: public RecorderError {
public:
    UnsupportedDatabaseVersion();
};
 
class InvalidIndexHeader: public RecorderError {
public:
    InvalidIndexHeader();
};
 
class InvalidLengthWritten: public RecorderError {
public:
    InvalidLengthWritten();
};
 
class NotInitialized: public RecorderError {
public:
    NotInitialized();
};
 
class InvalidHandle: public RecorderError {
public:
    InvalidHandle();
};
 
class ResourceInUse: public RecorderError {
public:
    ResourceInUse();
};
 
class EndOfData: public RecorderError {
public:
    EndOfData();
};
 
class InvalidArgument: public RecorderError {
public:
    InvalidArgument();
};
 
class NoContainer: public RecorderError {
public:
    NoContainer();
};
 
class LicenseManagerError: public RecorderError {
public:
    LicenseManagerError();
};
 
class NoLicense: public RecorderError {
public:
    NoLicense();
};
 
class ImageConversionError: public RecorderError {
public:
    ImageConversionError();
};
 
class UnsupportedImageFormatError : public RecorderError {
public:
    UnsupportedImageFormatError();
};
 
class Aborted : public RecorderError {
public:
    Aborted();
};
 
class InvalidDataSize : public RecorderError {
public:
    InvalidDataSize();
};
 
class InvalidChapterCharacter : public RecorderError {
public:
    InvalidChapterCharacter();
};
 
class ReservedChapterName : public RecorderError {
public:
    ReservedChapterName();
};
 
class ChapterNameAlreadyUsed : public RecorderError {
public:
    ChapterNameAlreadyUsed();
};
 
class ChapterNameTooLong : public RecorderError {
public:
    ChapterNameTooLong();
};
 
class RecorderLibrary;
 
class Recorder {
public:
#if __cplusplus >= 201103L
    Recorder(const Recorder &) = delete;
    Recorder(Recorder &&);
    Recorder &operator=(const Recorder &) = delete;
    Recorder &operator=(Recorder &&);
#else
    Recorder(const Recorder &);
    Recorder &operator=(const Recorder &);
#endif
    explicit Recorder(RecorderLibrary &recorderLibrary, RECORDER_HANDLE handle,
                      RECORDER_CLOSE_MODE closeMode);
    virtual ~Recorder();
    operator bool() const;
    void close();
    void close(RECORDER_CLOSE_MODE closeMode);
    std::string getParameterString(RECORDER_PARAMETER parameter);
    void setParameterString(RECORDER_PARAMETER parameter, const std::string &value);
    int64_t getParameterInteger(RECORDER_PARAMETER parameter);
    void setParameterInteger(RECORDER_PARAMETER parameter, int64_t value);
    void write(const RECORDER_BUFFER_INFO *info, const void *buffer);
    // read data from the container into a user buffer (@ref RecorderRead)
    size_t read(RECORDER_BUFFER_INFO *info, void *buffer, size_t bufferSize);
    // read data from the container (@ref RecorderRead)
    std::vector<char> read(RECORDER_BUFFER_INFO *info = 0);
    // export images from the container (@ref RecorderExport)
    size_t exportImages(const std::string &path, size_t count, uint32_t exportPixelFormat = 0);
    // start a new chapter (@ref RecorderStartChapter)
    void startChapter(const std::string &name = "", const std::string &info = "");
 
#if ERECORDERLIBRARY_WITH_PROGRESS_REPORT
    struct Progress {
        size_t index;
        size_t count;
        bool working;
    };
    Progress getProgress() const;
    void abort();
#endif
 
private:
    RecorderLibrary *recorderLibrary;
    RECORDER_HANDLE handle;
    RECORDER_CLOSE_MODE closeMode;
#if ERECORDERLIBRARY_WITH_PROGRESS_REPORT
    static int progressCallback(void *context, RECORDER_PROGRESS_STATE state, size_t index, size_t count);
    std::atomic<Progress> currentProgress;
    std::atomic<bool> abortFlag;
#endif
};
 
class RecorderLibrary {
public:
    explicit RecorderLibrary(const std::string &path = getDefaultPath())
        : dynlib(path)
        , initLib(reinterpret_cast<FnRecorderInitLib>(dynlib.getSymbol("RecorderInitLib")))
        , closeLib(reinterpret_cast<FnRecorderCloseLib>(dynlib.getSymbol("RecorderCloseLib")))
        , open(reinterpret_cast<FnRecorderOpen>(dynlib.getSymbol("RecorderOpen")))
        , close(reinterpret_cast<FnRecorderClose>(dynlib.getSymbol("RecorderClose")))
        , setParameterString(reinterpret_cast<FnRecorderSetParameterString>(dynlib.getSymbol("RecorderSetParameterString")))
        , getParameterString(reinterpret_cast<FnRecorderGetParameterString>(dynlib.getSymbol("RecorderGetParameterString")))
        , setParameterInteger(reinterpret_cast<FnRecorderSetParameterInteger>(dynlib.getSymbol("RecorderSetParameterInteger")))
        , getParameterInteger(reinterpret_cast<FnRecorderGetParameterInteger>(dynlib.getSymbol("RecorderGetParameterInteger")))
        , read(reinterpret_cast<FnRecorderRead>(dynlib.getSymbol("RecorderRead")))
        , write(reinterpret_cast<FnRecorderWrite>(dynlib.getSymbol("RecorderWrite")))
        , exportImages(reinterpret_cast<FnRecorderExport>(dynlib.getSymbol("RecorderExport")))
        , startChapter(reinterpret_cast<FnRecorderStartChapter>(dynlib.getSymbol("RecorderStartChapter"))) {
        initLibrary();
    }
    virtual ~RecorderLibrary() {
        closeLib();
    }
 
    void initLibrary() {
        RecorderError::check(initLib());
    }
 
    void closeLibrary() {
        RecorderError::check(closeLib());
    }
 
    Recorder openRecorder(const std::string &path, RECORDER_OPEN_MODE mode,
                          RECORDER_CLOSE_MODE closeMode = RECORDER_CLOSE_MODE_TRIM, uint32_t *fileVersion = 0) {
        RECORDER_HANDLE handle = 0;
        RecorderError::check(open(path.c_str(), mode, &handle, fileVersion));
        return Recorder(*this, handle, closeMode);
    }
 
    static std::string getDefaultPath() {
        std::string path(Internal::getDefaultLibraryPath());
        if (path.empty()) {
            throw std::runtime_error("No default recorder library path");
        }
        return path;
    }
 
private:
    Internal::DynamicLibrary dynlib;
    FnRecorderInitLib initLib;
    FnRecorderCloseLib closeLib;
public:
    FnRecorderOpen open;
    FnRecorderClose close;
    FnRecorderSetParameterString setParameterString;
    FnRecorderGetParameterString getParameterString;
    FnRecorderSetParameterInteger setParameterInteger;
    FnRecorderGetParameterInteger getParameterInteger;
    FnRecorderRead read;
    FnRecorderWrite write;
    FnRecorderExport exportImages;
    FnRecorderStartChapter startChapter;
};
 
inline void RecorderError::check(RECORDER_STATUS status) {
    switch (status) {
        case RECORDER_STATUS_OK:
            break;
        case RECORDER_STATUS_UNKNOWN_ERROR:
            throw UnknownError();
        case RECORDER_STATUS_UNKNOWN_PARAMETER:
            throw UnknownParameter();
        case RECORDER_STATUS_INVALID_PARAMETER_TYPE:
            throw InvalidParameterType();
        case RECORDER_STATUS_INVALID_PARAMETER_VALUE:
            throw InvalidParameterValue();
        case RECORDER_STATUS_BUFFER_TOO_SMALL:
            throw BufferTooSmall();
        case RECORDER_STATUS_PARAMETER_IS_READ_ONLY:
            throw ParameterIsReadOnly();
        case RECORDER_STATUS_SYSTEM_ERROR:
            throw SystemError();
        case RECORDER_STATUS_INVALID_CONTAINER_PATH:
            throw InvalidContainerPath();
        case RECORDER_STATUS_DATA_FILE_FULL:
            throw DataFileFull();
        case RECORDER_STATUS_OPERATION_NOT_ALLOWED:
            throw OperationNotAllowed();
        case RECORDER_STATUS_INDEX_OUT_OF_RANGE:
            throw IndexOutOfRange();
        case RECORDER_STATUS_INVALID_INDEX_DATA:
            throw InvalidIndexData();
        case RECORDER_STATUS_INVALID_INDEX_SIZE:
            throw InvalidIndexSize();
        case RECORDER_STATUS_UNSUPPORTED_DATABASE_VERSION:
            throw UnsupportedDatabaseVersion();
        case RECORDER_STATUS_INVALID_INDEX_HEADER:
            throw InvalidIndexHeader();
        case RECORDER_STATUS_INVALID_LENGTH_WRITTEN:
            throw InvalidLengthWritten();
        case RECORDER_STATUS_NOT_INITIALIZED:
            throw NotInitialized();
        case RECORDER_STATUS_INVALID_HANDLE:
            throw InvalidHandle();
        case RECORDER_STATUS_RESOURCE_IN_USE:
            throw ResourceInUse();
        case RECORDER_STATUS_END_OF_DATA:
            throw EndOfData();
        case RECORDER_STATUS_INVALID_ARGUMENT:
            throw InvalidArgument();
        case RECORDER_STATUS_NO_CONTAINER:
            throw NoContainer();
        case RECORDER_STATUS_LICENSE_MANAGER_ERROR:
            throw LicenseManagerError();
        case RECORDER_STATUS_NO_LICENSE:
            throw NoLicense();
        case RECORDER_STATUS_IMAGE_CONVERSION_ERROR:
            throw ImageConversionError();
        case RECORDER_STATUS_UNSUPPORTED_IMAGE_FORMAT:
            throw UnsupportedImageFormatError();
        case RECORDER_STATUS_ABORTED:
            throw Aborted();
        case RECORDER_STATUS_INVALID_DATA_SIZE:
            throw InvalidDataSize();
        case RECORDER_STATUS_INVALID_CHAPTER_CHARACTER:
            throw InvalidChapterCharacter();
        case RECORDER_STATUS_RESERVED_CHAPTER_NAME:
            throw ReservedChapterName();
        case RECORDER_STATUS_CHAPTER_NAME_ALREADY_USED:
            throw ChapterNameAlreadyUsed();
        case RECORDER_STATUS_CHAPTER_NAME_TOO_LONG:
            throw ChapterNameTooLong();
        default: {
            std::stringstream ss;
            ss << "RecorderError(RECORDER_STATUS=" << status << ")";
            throw RecorderError(status, ss.str());
        }
    }
}
 
inline RecorderError::RecorderError(RECORDER_STATUS status, const std::string &description)
    : std::runtime_error(description)
    , status(status)
{}
 
#define EGRABBER_RECORDER_ERROR_CTOR(error, status) \
    inline error::error(): RecorderError(status, #error){}
 
EGRABBER_RECORDER_ERROR_CTOR(UnknownError,               RECORDER_STATUS_UNKNOWN_ERROR);
EGRABBER_RECORDER_ERROR_CTOR(UnknownParameter,           RECORDER_STATUS_UNKNOWN_PARAMETER);
EGRABBER_RECORDER_ERROR_CTOR(InvalidParameterType,       RECORDER_STATUS_INVALID_PARAMETER_TYPE);
EGRABBER_RECORDER_ERROR_CTOR(InvalidParameterValue,      RECORDER_STATUS_INVALID_PARAMETER_VALUE);
EGRABBER_RECORDER_ERROR_CTOR(BufferTooSmall,             RECORDER_STATUS_BUFFER_TOO_SMALL);
EGRABBER_RECORDER_ERROR_CTOR(ParameterIsReadOnly,        RECORDER_STATUS_PARAMETER_IS_READ_ONLY);
EGRABBER_RECORDER_ERROR_CTOR(SystemError,                RECORDER_STATUS_SYSTEM_ERROR);
EGRABBER_RECORDER_ERROR_CTOR(InvalidContainerPath,       RECORDER_STATUS_INVALID_CONTAINER_PATH);
EGRABBER_RECORDER_ERROR_CTOR(DataFileFull,               RECORDER_STATUS_DATA_FILE_FULL);
EGRABBER_RECORDER_ERROR_CTOR(OperationNotAllowed,        RECORDER_STATUS_OPERATION_NOT_ALLOWED);
EGRABBER_RECORDER_ERROR_CTOR(IndexOutOfRange,            RECORDER_STATUS_INDEX_OUT_OF_RANGE);
EGRABBER_RECORDER_ERROR_CTOR(InvalidIndexData,           RECORDER_STATUS_INVALID_INDEX_DATA);
EGRABBER_RECORDER_ERROR_CTOR(InvalidIndexSize,           RECORDER_STATUS_INVALID_INDEX_SIZE);
EGRABBER_RECORDER_ERROR_CTOR(UnsupportedDatabaseVersion, RECORDER_STATUS_UNSUPPORTED_DATABASE_VERSION);
EGRABBER_RECORDER_ERROR_CTOR(InvalidIndexHeader,         RECORDER_STATUS_INVALID_INDEX_HEADER);
EGRABBER_RECORDER_ERROR_CTOR(InvalidLengthWritten,       RECORDER_STATUS_INVALID_LENGTH_WRITTEN);
EGRABBER_RECORDER_ERROR_CTOR(NotInitialized,             RECORDER_STATUS_NOT_INITIALIZED);
EGRABBER_RECORDER_ERROR_CTOR(InvalidHandle,              RECORDER_STATUS_INVALID_HANDLE);
EGRABBER_RECORDER_ERROR_CTOR(ResourceInUse,              RECORDER_STATUS_RESOURCE_IN_USE);
EGRABBER_RECORDER_ERROR_CTOR(EndOfData,                  RECORDER_STATUS_END_OF_DATA);
EGRABBER_RECORDER_ERROR_CTOR(InvalidArgument,            RECORDER_STATUS_INVALID_ARGUMENT);
EGRABBER_RECORDER_ERROR_CTOR(NoContainer,                RECORDER_STATUS_NO_CONTAINER);
EGRABBER_RECORDER_ERROR_CTOR(LicenseManagerError,        RECORDER_STATUS_LICENSE_MANAGER_ERROR);
EGRABBER_RECORDER_ERROR_CTOR(NoLicense,                  RECORDER_STATUS_NO_LICENSE);
EGRABBER_RECORDER_ERROR_CTOR(ImageConversionError,       RECORDER_STATUS_IMAGE_CONVERSION_ERROR);
EGRABBER_RECORDER_ERROR_CTOR(UnsupportedImageFormatError, RECORDER_STATUS_UNSUPPORTED_IMAGE_FORMAT);
EGRABBER_RECORDER_ERROR_CTOR(Aborted,                    RECORDER_STATUS_ABORTED);
EGRABBER_RECORDER_ERROR_CTOR(InvalidDataSize,            RECORDER_STATUS_INVALID_DATA_SIZE);
EGRABBER_RECORDER_ERROR_CTOR(InvalidChapterCharacter,    RECORDER_STATUS_INVALID_CHAPTER_CHARACTER);
EGRABBER_RECORDER_ERROR_CTOR(ReservedChapterName,        RECORDER_STATUS_RESERVED_CHAPTER_NAME);
EGRABBER_RECORDER_ERROR_CTOR(ChapterNameAlreadyUsed,     RECORDER_STATUS_CHAPTER_NAME_ALREADY_USED);
EGRABBER_RECORDER_ERROR_CTOR(ChapterNameTooLong,         RECORDER_STATUS_CHAPTER_NAME_TOO_LONG);
 
#if __cplusplus >= 201103L
inline Recorder::Recorder(Recorder &&other)
    : recorderLibrary(other.recorderLibrary)
    , handle(other.handle)
    , closeMode(other.closeMode)
#if ERECORDERLIBRARY_WITH_PROGRESS_REPORT
    , currentProgress(other.currentProgress.load())
    , abortFlag(other.abortFlag.load())
#endif
{
    other.handle = 0;
}
 
inline Recorder &Recorder::operator=(Recorder &&other) {
    if (&other == this) {
        return *this;
    }
 
    std::swap(recorderLibrary, other.recorderLibrary);
    std::swap(handle, other.handle);
    std::swap(closeMode, other.closeMode);
 
#if ERECORDERLIBRARY_WITH_PROGRESS_REPORT
    currentProgress = other.currentProgress.load();
    abortFlag = other.abortFlag.load();
#endif
 
    return *this;
}
#endif
 
inline Recorder::Recorder(RecorderLibrary &recorderLibrary, RECORDER_HANDLE handle,
                          RECORDER_CLOSE_MODE closeMode)
    : recorderLibrary(&recorderLibrary)
    , handle(handle)
    , closeMode(closeMode)
#if ERECORDERLIBRARY_WITH_PROGRESS_REPORT
    , currentProgress({0, 0, false})
    , abortFlag(false)
#endif
{}
inline Recorder::~Recorder() {
    try {
        close();
    } catch (...) {
    }
}
inline void Recorder::close() {
    close(closeMode);
}
inline void Recorder::close(RECORDER_CLOSE_MODE mode) {
    if (handle) {
        RecorderError::check(recorderLibrary->close(handle, mode));
        handle = 0;
    }
}
inline Recorder::operator bool() const {
    return handle != 0;
}
inline std::string Recorder::getParameterString(RECORDER_PARAMETER parameter) {
    std::vector<char> value(128);
    size_t size = value.size();
    RECORDER_STATUS status = recorderLibrary->getParameterString(handle, parameter, &value[0], &size);
    if (status == RECORDER_STATUS_BUFFER_TOO_SMALL) {
        RecorderError::check(recorderLibrary->getParameterString(handle, parameter, 0, &size));
        value.resize(size);
        status = recorderLibrary->getParameterString(handle, parameter, &value[0], &size);
    }
    RecorderError::check(status);
    return (size) ? std::string(&value[0]) : std::string();
}
inline void Recorder::setParameterString(RECORDER_PARAMETER parameter, const std::string &value) {
    RecorderError::check(recorderLibrary->setParameterString(handle, parameter, value.c_str()));
}
inline int64_t Recorder::getParameterInteger(RECORDER_PARAMETER parameter) {
    int64_t value = 0;
    RecorderError::check(recorderLibrary->getParameterInteger(handle, parameter, &value));
    return value;
}
inline void Recorder::setParameterInteger(RECORDER_PARAMETER parameter, int64_t value) {
    RecorderError::check(recorderLibrary->setParameterInteger(handle, parameter, value));
}
inline void Recorder::write(const RECORDER_BUFFER_INFO *info, const void *buffer) {
    RecorderError::check(recorderLibrary->write(handle, info, buffer, 0, 0, 0));
}
inline size_t Recorder::read(RECORDER_BUFFER_INFO *info, void *buffer, size_t bufferSize) {
    size_t size = bufferSize;
    RecorderError::check(recorderLibrary->read(handle, info, buffer, &size, 0));
    return size;
}
inline std::vector<char> Recorder::read(RECORDER_BUFFER_INFO *info) {
    size_t size = 0;
    RecorderError::check(recorderLibrary->read(handle, 0, 0, &size, 0));
    std::vector<char> data(size ? size : 1);
    RecorderError::check(recorderLibrary->read(handle, info, &data[0], &size, 0));
    data.resize(size);
    return data;
}
inline size_t Recorder::exportImages(const std::string &path, size_t count, uint32_t exportPixelFormat) {
#if ERECORDERLIBRARY_WITH_PROGRESS_REPORT
    RecorderError::check(recorderLibrary->exportImages(handle, path.c_str(), &count, exportPixelFormat, 0, &progressCallback, this));
#else
    RecorderError::check(recorderLibrary->exportImages(handle, path.c_str(), &count, exportPixelFormat, 0, 0, 0));
#endif
    return count;
}
inline void Recorder::startChapter(const std::string &name, const std::string &info) {
    RecorderError::check(recorderLibrary->startChapter(handle, name.c_str(), info.c_str()));
}
 
 
#if ERECORDERLIBRARY_WITH_PROGRESS_REPORT
inline int Recorder::progressCallback(void *context, RECORDER_PROGRESS_STATE state, size_t index, size_t count) {
    Recorder *recorder = reinterpret_cast<Recorder *>(context);
    if (recorder) {
        if (state == RECORDER_PROGRESS_STATE_STARTING) {
            recorder->currentProgress.store({0, 0, true});
            recorder->abortFlag.store(false);
        } else if (state == RECORDER_PROGRESS_STATE_ONGOING) {
            recorder->currentProgress.store({index, count, true});
            if (recorder->abortFlag.load()) {
                return -1;
            }
        } else if (state == RECORDER_PROGRESS_STATE_ENDING) {
            Progress finished(recorder->currentProgress.load());
            finished.working = false;
            recorder->currentProgress.store(finished);
        }
    }
    return 0;
}
inline Recorder::Progress Recorder::getProgress() const {
    return currentProgress.load();
}
inline void Recorder::abort() {
    abortFlag.store(true);
}
#endif
 
} // namespace EGrabberRecorder
} // namespace Euresys
 
#endif