videofilebuffer.h

Go to the documentation of this file.

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

---

libcvd
Author(s): Edward Rosten, Paul Smith, Tom Drummond, Gerhard Reitmayr, Ethan Eade, Timothy Gan, Chris Kemp, Georg Klein
autogenerated on Fri Jan 11 09:13:10 2013