cvd/videofilebuffer.h

/*                       
    This file is part of the CVD Library.

    Copyright (C) 2005 The Authors

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 
    51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef CVD_VIDEOFILEBUFFER_H
#define CVD_VIDEOFILEBUFFER_H

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

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

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

#include <cvd/config.h>
namespace CVD
{
    namespace Exceptions
    {
        namespace VideoFileBuffer
        {
            struct All: public CVD::Exceptions::VideoBuffer::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); 
            };
            struct EndOfFile: public All { EndOfFile(); };
            struct BadSeek: public All { BadSeek(double t); 
            };
        }
    }

    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, bool is_rgb);
            ~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();
            
            std::string codec_name();
        
        private:
            std::auto_ptr<RawVideoFileBufferPIMPL> p;
    };
    }

    template<typename T> 
    class VideoFileBuffer : public CVD::LocalVideoBuffer<T>
    {
        private:
            VFB::RawVideoFileBuffer vf;
            
    
        public:
            VideoFileBuffer(const std::string& file)
            :LocalVideoBuffer<T>(VideoBufferType::NotLive),vf(file, VFB::rgb<T>::p)
            {
            }

            ~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();
            }

            std::string codec_name() 
            {
                return vf.codec_name();
            }
        
        private:
    };
}

#endif