peak_ipl_video_writer.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_ipl/backend/peak_ipl_backend.h>
#include <peak_ipl/exception/peak_ipl_exception.hpp>
#include <peak_ipl/types/peak_ipl_pixel_format.hpp>
#include <peak_ipl/types/peak_ipl_range.hpp>
#include <peak_ipl/types/peak_ipl_simple_types.hpp>
 
#include <cstdint>
#include <memory>
#include <string>
#include <utility>
 
namespace peak
{
namespace ipl
{
 
class VideoWriter;
 
namespace encoder
{
 
class IEncoder
{
    friend class peak::ipl::VideoWriter;
 
protected:
    PEAK_IPL_VIDEO_HANDLE m_handle{nullptr};
 
    void SetHandle(PEAK_IPL_VIDEO_HANDLE handle)
    {
        this->m_handle = handle;
    }
 
public:
    IEncoder() = default;
    virtual ~IEncoder() = default;
    virtual PEAK_IPL_VIDEO_ENCODER Id() = 0;
 
    void SetOption(PEAK_IPL_VIDEO_ENCODER_OPTION option, const void* value, size_t count)
    {
        ExecuteAndMapReturnCodes(
            [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_Encoder_SetOption(m_handle, option, value, count); });
    }
 
    void GetOption(PEAK_IPL_VIDEO_ENCODER_OPTION option, void* value, size_t count, size_t* outCount)
    {
        ExecuteAndMapReturnCodes([&] {
            return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_Encoder_GetOption(m_handle, option, value, count, outCount);
        });
    }
 
    void OptionRange(PEAK_IPL_VIDEO_ENCODER_OPTION option, void* min, void* max, void* inc)
    {
        ExecuteAndMapReturnCodes([&] {
            return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_Encoder_OptionRange(m_handle, option, min, max, inc);
        });
    }
};
 
static std::unique_ptr<IEncoder> Create(PEAK_IPL_VIDEO_ENCODER encoder);
 
class MJPEGEncoder : public IEncoder
{
    friend std::unique_ptr<IEncoder> Create(PEAK_IPL_VIDEO_ENCODER encoder);
 
    MJPEGEncoder() = default;
 
public:
    MJPEGEncoder(const MJPEGEncoder&) = delete;
    MJPEGEncoder(MJPEGEncoder&&) = default;
 
    MJPEGEncoder& operator=(const MJPEGEncoder&) = delete;
    MJPEGEncoder& operator=(MJPEGEncoder&&) = default;
 
    PEAK_IPL_VIDEO_ENCODER Id() override
    {
        return PEAK_IPL_VIDEO_ENCODER_MJPEG;
    }
 
    void SetQuality(uint32_t quality)
    {
        SetOption(PEAK_IPL_VIDEO_ENCODER_OPTION_QUALITY, &quality, sizeof(quality));
    }
 
    uint32_t GetQuality()
    {
        uint32_t quality = 0;
        GetOption(PEAK_IPL_VIDEO_ENCODER_OPTION_QUALITY, &quality, sizeof(quality), nullptr);
        return quality;
    }
 
    Range<double> QualityRange()
    {
        double min = 0, max = 0, inc = 0;
        OptionRange(PEAK_IPL_VIDEO_ENCODER_OPTION_QUALITY, &min, &max, &inc);
        return { min, max, inc };
    }
};
 
static inline std::vector<PEAK_IPL_VIDEO_ENCODER> GetSupportedEncodersForAContainer(PEAK_IPL_VIDEO_CONTAINER container)
{
    size_t length{};
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_GetSupportedEncodersForAContainer(container, nullptr, &length);
    });
    std::vector<PEAK_IPL_VIDEO_ENCODER> encoders(length);
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_GetSupportedEncodersForAContainer(
            container, encoders.data(), &length);
    });
    return encoders;
}
 
static inline std::vector<PixelFormatName> GetSupportedPixelFormats(PEAK_IPL_VIDEO_ENCODER encoder)
{
    size_t sizeOfData{};
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_Encoder_GetSupportedPixelFormats(encoder, nullptr, &sizeOfData);
    });
    std::vector<PixelFormatName> formats(sizeOfData);
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_Encoder_GetSupportedPixelFormats(
            encoder, reinterpret_cast<PEAK_IPL_PIXEL_FORMAT*>(formats.data()), &sizeOfData);
    });
    return formats;
}
 
static inline std::unique_ptr<IEncoder> Create(PEAK_IPL_VIDEO_ENCODER encoder)
{
    switch (encoder)
    {
    case PEAK_IPL_VIDEO_ENCODER_MJPEG:
        return std::unique_ptr<MJPEGEncoder>(new MJPEGEncoder());
    default:
        throw InvalidArgumentException("The supplied encoder is not a valid value!");
    }
 
}
 
} // namespace encoder
 
namespace container
{
 
class IContainer
{
    friend class peak::ipl::VideoWriter;
 
protected:
    PEAK_IPL_VIDEO_HANDLE m_handle{ nullptr };
    void SetHandle(PEAK_IPL_VIDEO_HANDLE handle)
    {
        this->m_handle = handle;
    }
 
public:
    IContainer() = default;
    virtual ~IContainer() = default;
    virtual PEAK_IPL_VIDEO_CONTAINER Id() = 0;
 
    void SetOption(PEAK_IPL_VIDEO_CONTAINER_OPTION option, const void* value, size_t count)
    {
        ExecuteAndMapReturnCodes([&] {
            return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_Container_SetOption(m_handle, option, value, count);
        });
    }
 
    void GetOption(PEAK_IPL_VIDEO_CONTAINER_OPTION option, void* value, size_t count, size_t* outCount)
    {
        ExecuteAndMapReturnCodes([&] {
            return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_Container_GetOption(
                m_handle, option, value, count, outCount);
        });
    }
 
    void OptionRange(PEAK_IPL_VIDEO_CONTAINER_OPTION option, void* min, void* max, void* inc)
    {
        ExecuteAndMapReturnCodes([&] {
            return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_Container_OptionRange(m_handle, option, min, max, inc);
        });
    }
};
 
static std::unique_ptr<IContainer> Create(PEAK_IPL_VIDEO_CONTAINER container);
 
class AVIContainer : public IContainer
{
    friend std::unique_ptr<IContainer> Create(PEAK_IPL_VIDEO_CONTAINER container);
    AVIContainer() = default;
 
public:
    AVIContainer(const AVIContainer&) = delete;
    AVIContainer(AVIContainer&&) = default;
 
    AVIContainer& operator=(const AVIContainer&) = delete;
    AVIContainer& operator=(AVIContainer&&) = default;
 
    PEAK_IPL_VIDEO_CONTAINER Id() override
    {
        return PEAK_IPL_VIDEO_CONTAINER_AVI;
    }
 
    void SetFramerate(double fps)
    {
        SetOption(PEAK_IPL_VIDEO_CONTAINER_OPTION_FRAMERATE, &fps, sizeof(fps));
    }
 
    double GetFramerate()
    {
        double fps = 0;
        GetOption(PEAK_IPL_VIDEO_CONTAINER_OPTION_FRAMERATE, &fps, sizeof(fps), nullptr);
        return fps;
    }
};
 
static inline std::vector<PEAK_IPL_VIDEO_CONTAINER> GetSupportedContainersForAnEncoder(PEAK_IPL_VIDEO_ENCODER encoder)
{
    size_t length{};
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_GetSupportedContainersForAnEncoder(encoder, nullptr, &length);
    });
    std::vector<PEAK_IPL_VIDEO_CONTAINER> containers(length);
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_GetSupportedContainersForAnEncoder(
            encoder, containers.data(), &length);
    });
    return containers;
}
 
static std::unique_ptr<IContainer> Create(PEAK_IPL_VIDEO_CONTAINER container)
{
    switch (container)
    {
    case PEAK_IPL_VIDEO_CONTAINER_AVI:
        return std::unique_ptr<AVIContainer>(new AVIContainer());
    default:
        throw InvalidArgumentException("The supplied container is not a valid value!");
    }
}
 
} // namespace container
 
class Image;
 
class VideoWriter final
{
public:
    VideoWriter() = default;
    ~VideoWriter()
    {
        if(IsOpen())
        {
            Close();
        }
    }
    VideoWriter(const VideoWriter&) = delete;
    VideoWriter(VideoWriter&& other) noexcept
    {
        m_handle = other.m_handle;
        other.m_handle = nullptr;
        m_encoder = std::move(other.m_encoder);
        m_container = std::move(other.m_container);
    }
    VideoWriter& operator=(const VideoWriter&) = delete;
    VideoWriter& operator=(VideoWriter&& other) noexcept
    {
        m_handle = other.m_handle;
        other.m_handle = nullptr;
        m_encoder = std::move(other.m_encoder);
        m_container = std::move(other.m_container);
 
        return *this;
    }
 
    void Open(const std::string& fileName, std::shared_ptr<container::IContainer> container,
        std::shared_ptr<encoder::IEncoder> encoder)
    {
        if (!container || !encoder)
        {
            throw InvalidArgumentException("The given pointer is a null pointer!");
        }
 
        ExecuteAndMapReturnCodes([&] {
            return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_Video_Open(
                &m_handle, fileName.c_str(), container->Id(), encoder->Id());
        });
        m_encoder = encoder;
        m_container = container;
 
        m_encoder->SetHandle(m_handle);
        m_container->SetHandle(m_handle);
    }
 
    void Open(const std::string& fileName)
    {
        auto container = container::Create(PEAK_IPL_VIDEO_CONTAINER_AVI);
        auto encoder = encoder::Create(PEAK_IPL_VIDEO_ENCODER_MJPEG);
        Open(fileName, std::move(container), std::move(encoder));
    }
 
    PEAK_IPL_NO_DISCARD bool IsOpen() const
    {
        PEAK_IPL_BOOL8 isOpen = 0;
        ExecuteAndMapReturnCodes(
            [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_Video_IsOpen(m_handle, &isOpen); });
        return isOpen != 0;
    }
 
    void Close()
    {
        ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_Video_Close(m_handle); });
 
        m_handle = nullptr;
    }
 
    void Append(const Image& image)
    {
        if (m_encoder == nullptr)
        {
            throw InvalidArgumentException("The open method must be called before append!");
        }
        ExecuteAndMapReturnCodes([&] {
            return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_Video_Append(
                m_handle, ImageBackendAccessor::BackendHandle(image));
        });
    }
 
    VideoWriter& operator<<(const Image& image)
    {
        Append(image);
        return *this;
    }
 
    PEAK_IPL_NO_DISCARD std::shared_ptr<encoder::IEncoder> Encoder() const
    {
        return m_encoder;
    }
 
    PEAK_IPL_NO_DISCARD std::shared_ptr<container::IContainer> Container() const
    {
        return m_container;
    }
 
    PEAK_IPL_NO_DISCARD uint64_t NumFramesEncoded() const
    {
        uint64_t numFramesEncoded{};
        ExecuteAndMapReturnCodes(
            [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_Video_GetEncodedFrames(m_handle, &numFramesEncoded); });
        return numFramesEncoded;
    }
 
    PEAK_IPL_NO_DISCARD uint64_t NumFramesDropped() const
    {
        uint64_t numFramesDropped{};
        ExecuteAndMapReturnCodes(
            [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_Video_GetDroppedFrames(m_handle, &numFramesDropped); });
        return numFramesDropped;
    }
 
    PEAK_IPL_NO_DISCARD uint64_t FileSize() const
    {
        uint64_t s{};
        ExecuteAndMapReturnCodes(
            [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_Video_GetFileSize(m_handle, &s); });
        return s;
    }
 
    void ResetFrameCounters()
    {
        ExecuteAndMapReturnCodes([&] {
            return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_Video_ResetFrameCounters(m_handle);
        });
    }
 
    void SetQueueSize(int32_t queueSize)
    {
        ExecuteAndMapReturnCodes([&] {
            return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_Queue_SetSize(m_handle, queueSize);
        });
    }
 
    PEAK_IPL_NO_DISCARD int32_t QueueSize()
    {
        int32_t queueSize{};
        ExecuteAndMapReturnCodes([&] {
            return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_Queue_GetSize(m_handle, &queueSize);
        });
 
        return queueSize;
    }
 
    PEAK_IPL_NO_DISCARD Range<int32_t> QueueSizeRange()
    {
        int32_t minQueueSize{}, maxQueueSize{};
        ExecuteAndMapReturnCodes([&] {
            return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_Queue_GetRange(m_handle, &minQueueSize, &maxQueueSize);
        });
 
        return {minQueueSize, maxQueueSize, 1};
    }
 
    PEAK_IPL_NO_DISCARD int32_t NumBuffersQueued()
    {
        int32_t queued{};
        ExecuteAndMapReturnCodes([&] {
            return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_Queue_GetQueued(m_handle, &queued);
        });
 
        return queued;
    }
 
    void WaitUntilFrameDone(int32_t timeout_ms)
    {
        ExecuteAndMapReturnCodes([&] {
          return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_Video_WaitUntilFrameDone(m_handle, timeout_ms);
        });
    }
 
    void WaitUntilQueueEmpty(int32_t timeout_ms)
    {
        ExecuteAndMapReturnCodes([&] {
            return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_VideoWriter_Video_WaitUntilQueueEmpty(m_handle, timeout_ms);
        });
    }
 
private:
    PEAK_IPL_VIDEO_HANDLE m_handle{nullptr};
    std::shared_ptr<encoder::IEncoder> m_encoder{};
    std::shared_ptr<container::IContainer> m_container{};
};
 
} /* namespace ipl */
} /* namespace peak */