videofilebuffer.h

#ifndef CVD_VIDEOFILEBUFFER_H
#define CVD_VIDEOFILEBUFFER_H

#include <errno.h>
#include <fstream>
#include <memory>
#include <string>
#include <vector>

#include <cvd/image_io.h>
#include <cvd/localvideobuffer.h>
#include <cvd/videobufferflags.h>
#include <cvd/videofilebuffer_frame.h>

#include <cvd/byte.h>
#include <cvd/rgb.h>

namespace CVD
{
namespace Exceptions
{
    namespace VideoFileBuffer
    {
        struct All : public CVD::Exceptions::VideoBuffer::All
        {
            using CVD::Exceptions::VideoBuffer::All::All;
        };
        struct FileOpen : public All
        {
            FileOpen(const std::string& file, const std::string& error); 
        };
        struct BadFrameAlloc : public All
        {
            BadFrameAlloc();
        };
        struct BadDecode : public All
        {
            BadDecode(double t, const std::string& = ""); 
        };
        struct EndOfFile : public All
        {
            EndOfFile();
        };
        struct BadSeek : public All
        {
            BadSeek(double t, const std::string& = ""); 
        };
    }
}

namespace VFB
{

#ifndef DOXYGEN_IGNORE_INTERNAL
    template <class C>
    struct rgb
    {
        static const bool p = C::Error__type_not_valid___Use_byte_or_rgb_of_byte;
    };

    template <>
    struct rgb<CVD::byte>
    {
        static const bool p = false;
    };

    template <>
    struct rgb<CVD::Rgb<CVD::byte>>
    {
        static const bool p = true;
    };
#endif

    class A_Frame;
    class RawVideoFileBufferPIMPL;

    class RawVideoFileBuffer
    {
        public:
        RawVideoFileBuffer(const std::string& file, const std::string& formatname, bool is_rgb, bool verbose, const std::map<std::string, std::string>&);
        ~RawVideoFileBuffer();

        ImageRef size();

        void* get_frame();
        void put_frame(void* f);

        bool frame_pending();

        void seek_to(double t);

        void on_end_of_buffer(VideoBufferFlags::OnEndOfBuffer behaviour);

        double frames_per_second();

        std::string file_name();

        private:
        std::unique_ptr<RawVideoFileBufferPIMPL> p;
    };
}

template <typename T>
class VideoFileBuffer : public CVD::LocalVideoBuffer<T>
{
    private:
    VFB::RawVideoFileBuffer vf;

    public:
    VideoFileBuffer(const std::string& file, bool verbose = false)
        : LocalVideoBuffer<T>(VideoBufferType::NotLive)
        , vf(file, "", VFB::rgb<T>::p, verbose, std::map<std::string, std::string> {})
    {
    }

    VideoFileBuffer(const std::string& file, const std::string& fmt, bool verbose = false)
        : LocalVideoBuffer<T>(VideoBufferType::NotLive)
        , vf(file, fmt, VFB::rgb<T>::p, verbose, std::map<std::string, std::string> {})
    {
    }

    VideoFileBuffer(const std::string& file, const std::string& fmt, bool verbose, const std::map<std::string, std::string>& o)
        : LocalVideoBuffer<T>(VideoBufferType::NotLive)
        , vf(file, fmt, VFB::rgb<T>::p, verbose, o)
    {
    }

    ~VideoFileBuffer()
    {
    }

    virtual ImageRef size()
    {
        return vf.size();
    }

    virtual bool frame_pending()
    {
        return vf.frame_pending();
    }

    virtual void on_end_of_buffer(VideoBufferFlags::OnEndOfBuffer behaviour)
    {
        vf.on_end_of_buffer(behaviour);
    }

    virtual void seek_to(double t)
    {
        vf.seek_to(t);
    }

    virtual VideoFileFrame<T>* get_frame()
    {
        return reinterpret_cast<VideoFileFrame<T>*>(vf.get_frame());
    }

    virtual void put_frame(VideoFrame<T>* f)
    {
        vf.put_frame(f);
    }

    // This class additions

    double frame_rate()
    {
        return vf.frames_per_second();
    }

    std::string file_name()
    {
        return vf.file_name();
    }

    private:
};
}

#endif