videoframe.h

Go to the documentation of this file.

#pragma once

#ifdef USE_OPENCV
#include <opencv2/core/core.hpp>
#include <opencv/cv.h>
#include <opencv/highgui.h>
#include <opencv2/core/version.hpp>
#if CV_MAJOR_VERSION == 3
#include <opencv2/imgproc/imgproc.hpp>
namespace cv
{
    using std::vector;
}
#endif
#endif // USE_OPENCV

#include <memory>
#include "maskframe.h"
#include "except.h"

namespace gg
{

enum ColourSpace
{
    BGRA
    , I420
    , UYVY
};

class VideoFrame
{
protected:
    VideoFrame();

public:
    VideoFrame(enum ColourSpace colour, bool manage_data = false);

    VideoFrame(enum ColourSpace colour, size_t cols, size_t rows,
               size_t stereo_count = 1);

    VideoFrame(const VideoFrame & rhs);

#ifdef USE_OPENCV
    std::unique_ptr<MaskFrame> compute_image_mask(int x, int y, int width,
                                                  int height);
#endif // USE_OPENCV

    virtual ~VideoFrame();

    void operator=(const VideoFrame & rhs);

    void init_from_specs(unsigned char * data, size_t data_length,
                         size_t cols, size_t rows, size_t stereo_count = 1);

    const size_t data_length(size_t stereo_index = 0) const;

    size_t stereo_count() const
    {
        return _stereo_count;
    }

    size_t rows() const
    {
        return _rows;
    }

    size_t cols() const
    {
        return _cols;
    }

    bool manages_own_data() const
    {
        return _manage_data;
    }

    unsigned char * const data(size_t stereo_index = 0) const;

    const enum ColourSpace colour() const
    {
        return _colour;
    }

    static size_t required_data_length(enum ColourSpace colour,
                                       size_t cols, size_t rows);

    static size_t required_pixel_length(enum ColourSpace colour);

protected:
    enum ColourSpace _colour;

    unsigned char * _data;

    size_t _data_length;

    size_t _stereo_count;

    size_t _rows;

    size_t _cols;

    bool _manage_data;

protected:
    void clone(const VideoFrame & rhs);

    void set_dimensions(size_t cols, size_t rows);

    void allocate_memory(size_t data_length);

    void free_memory();

    void set_pixels_black();

    inline void validate_stereo_index(size_t stereo_index) const
    {
        if (stereo_index >= _stereo_count)
        {
            std::string msg = "This frame has ";
            msg.append(std::to_string(_stereo_count))
               .append(" stereo frames (requested ")
               .append(std::to_string(stereo_index + 1))
               .append(". stereo frame)");
            throw std::out_of_range(msg);
        }
    }
};

}