videobuffer.h

#ifndef CVD_VIDEOBUFFER_H
#define CVD_VIDEOBUFFER_H

#include <cvd/exceptions.h>
#include <cvd/videoframe.h>
#include <memory>

namespace CVD
{

struct VideoBufferType
{
    enum Type
    {
        NotLive,
        Live,
        Flushable
    };
};

class RawVideoBuffer
{
    public:
    virtual RawVideoBuffer* source_buffer()
    {
        return this;
    }

    RawVideoBuffer* root_buffer()
    {
        RawVideoBuffer* b = this;
        while(b->source_buffer() != b)
            b = b->source_buffer();
        return b;
    }

    virtual ~RawVideoBuffer() { }

    virtual ImageRef size() = 0;

    virtual bool frame_pending() = 0;

    virtual double frame_rate() = 0;
    virtual void seek_to(double)
    {
    }

    virtual void flush() = 0;
};

template <class T>
class VideoBuffer : public virtual RawVideoBuffer
{
    public:
    VideoBuffer(VideoBufferType::Type _type)
        : m_type(_type)
    {
    }

    virtual ~VideoBuffer()
    {
    }

    virtual VideoFrame<T>* get_frame() = 0;

    virtual void put_frame(VideoFrame<T>* f) = 0;

    virtual void flush()
    {
        if(type() == VideoBufferType::Flushable)
            while(frame_pending())
                put_frame(get_frame());
    }

    VideoBufferType::Type type()
    {
        return m_type;
    }

    private:
    VideoBufferType::Type m_type;
};

namespace Exceptions
{
    namespace VideoBuffer
    {
        struct All : public CVD::Exceptions::All
        {
            using CVD::Exceptions::All::All;
        };

        struct BadPutFrame : public All
        {
            BadPutFrame();
        };

        struct BadColourSpace : public All
        {
            BadColourSpace(const std::string& colourspace, const std::string& b);
        };
    }
}

}

#endif