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 <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>

extern "C" {
#ifdef CVD_INTERNAL_HAVE_FFMPEG_OLD_HEADERS
    #include <ffmpeg/avcodec.h>
    #include <ffmpeg/avformat.h>
    #include <ffmpeg/swscale.h>
#else
    #include <libavcodec/avcodec.h>
    #include <libavformat/avformat.h>
    #include <libswscale/swscale.h>
#endif
}

struct AVFormatContext;
struct AVFrame; 

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 RawVideoFileBuffer 
    {
        public:
            RawVideoFileBuffer(const std::string& file, bool is_rgb);
            ~RawVideoFileBuffer();
        
            ImageRef size()
            {
                return my_size;
            }

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

            bool frame_pending()
            {
                return frame_ready;
            }

            void seek_to(double t);
            
            void on_end_of_buffer(VideoBufferFlags::OnEndOfBuffer behaviour) 
            {
                end_of_buffer_behaviour = behaviour;
            }
        
            double frames_per_second() 
            {
                        #if LIBAVCODEC_BUILD >= 4754
              return pCodecContext->time_base.den / static_cast<double>(pCodecContext->time_base.num);
                        #else
                    return pCodecContext->frame_rate / static_cast<double>(pCodecContext->frame_rate_base);
            #endif
            };
            
            std::string file_name() 
            {
                return pFormatContext->filename;
            }
            
            std::string codec_name() 
            {
                return pCodecContext->codec_name;
            }
        
        private:
            bool read_next_frame();
                
        private:
            ImageRef my_size;
            VideoBufferFlags::OnEndOfBuffer end_of_buffer_behaviour;
            double start_time;
            bool frame_ready;

            AVFormatContext* pFormatContext;
            int video_stream;
            AVCodecContext* pCodecContext;
            AVFrame* pFrame; 
            AVFrame* pFrameRGB;
            SwsContext *img_convert_ctx;
            
            CVD::Image<CVD::Rgb<byte> > next_frame_rgb;
            CVD::Image<CVD::byte> next_frame;
            
            double frame_time;
            bool is_rgb;
    };
    }

    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

---