cvd/diskbuffer2.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_DISKBUFFER2_H
#define CVD_DISKBUFFER2_H

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

#include <cvd/localvideobuffer.h>
#include <cvd/videobufferflags.h>
#include <cvd/diskbuffer2_frame.h>
#include <cvd/image_io.h>
#include <cvd/config.h>

namespace CVD
{
    //
    // GLOBLIST
    #ifdef CVD_HAVE_GLOB
    std::vector<std::string> globlist(const std::string& gl);
    #endif

    namespace Exceptions
    {
        namespace DiskBuffer2
        {
            struct All: public CVD::Exceptions::VideoBuffer::All { };
            struct NoFiles: public All { NoFiles(); };
            struct BadFile: public All { BadFile(const std::string&, int); 
            }; 
            struct BadImage: public All { BadImage(const std::string& file, const std::string& error); 
            };
            struct BadImageSize: public All { BadImageSize(const std::string& file); 
            };
            struct EndOfBuffer: public All { EndOfBuffer(); };
            struct BadSeek: public All { BadSeek(double t);
             }; 
            
        }
    }

    template<typename T> 
    class DiskBuffer2: public CVD::LocalVideoBuffer<T>
    {
        public:
            DiskBuffer2(const std::vector<std::string>& names, double fps, VideoBufferFlags::OnEndOfBuffer eob = VideoBufferFlags::RepeatLastFrame);

            virtual ImageRef size() {return my_size;}
            
            virtual bool frame_pending() {return frame_ready;}

            virtual DiskBuffer2Frame<T>* get_frame();
            virtual void put_frame(VideoFrame<T>* f);
            virtual void seek_to(double t);
        
            virtual void on_end_of_buffer(VideoBufferFlags::OnEndOfBuffer eob) 
                {end_of_buffer_behaviour = eob;}

            virtual double frame_rate() 
            {
                return frames_per_sec;
            }

        protected:
            ImageRef my_size;
            int      next_frame;
            double   start_time;
            double   time_per_frame, frames_per_sec;
            bool frame_ready;
            std::vector<std::string> file_names;
            VideoBufferFlags::OnEndOfBuffer end_of_buffer_behaviour;
    };

    //
    // CONSTRUCTOR
    //
    template<typename T>
    inline DiskBuffer2<T>::DiskBuffer2(const std::vector<std::string>& names, double fps, VideoBufferFlags::OnEndOfBuffer eob) 
    :LocalVideoBuffer<T>(VideoBufferType::NotLive),end_of_buffer_behaviour(eob)
    {
        frames_per_sec = fps;

        start_time = 0;
        next_frame=0;
        time_per_frame = 1/fps; 

        file_names = names;

        if(file_names.size() == 0)
            throw Exceptions::DiskBuffer2::NoFiles();

        Image<T> foo;
        std::ifstream im;
        im.open(names[0].c_str(), std::ios::in|std::ios::binary);

        if(!im.good())
            throw Exceptions::DiskBuffer2::BadFile(names[0], errno);
        
        try
        {
            img_load(foo, im);
        }
        catch(Exceptions::Image_IO::All err)
        {
            throw Exceptions::DiskBuffer2::BadImage(names[0], err.what);
        }

        my_size = foo.size();
        frame_ready = true;
    }

    //
    // GET FRAME
    //
    template<typename T>
    inline DiskBuffer2Frame<T>* DiskBuffer2<T>::get_frame()
    {
        if(next_frame < 0)
            next_frame = 0;

        if(!frame_pending())
            throw Exceptions::DiskBuffer2::EndOfBuffer();

        Image<T> foo(my_size);
        
        std::ifstream im_file(file_names[next_frame].c_str(), std::ios::in|std::ios::binary);

        if(!im_file.good())
            throw Exceptions::DiskBuffer2::BadFile(file_names[next_frame], errno);

        try{
          img_load(foo, im_file);
        }
        catch(CVD::Exceptions::Image_IO::All err)
        {
            throw Exceptions::DiskBuffer2::BadImage(file_names[next_frame], err.what);
        }

        DiskBuffer2Frame<T>* vf = new DiskBuffer2Frame<T>(next_frame * time_per_frame + start_time, foo, file_names[next_frame]);

        next_frame++;
        
        if(next_frame > (int)file_names.size()-1)
        {
            switch(end_of_buffer_behaviour)
            {
                case VideoBufferFlags::RepeatLastFrame:
                    next_frame = file_names.size()-1;
                    break;
                
                case VideoBufferFlags::UnsetPending:
                    frame_ready = false;
                   break;
                
                case VideoBufferFlags::Loop:
                    next_frame = 0;
                    break;
            }
        }

        return vf;  
    }

    //
    // PUT FRAME
    //
    template<typename T>
    inline void DiskBuffer2<T>::put_frame(VideoFrame<T>* f)
    {
        //Check that the type is correct...
        DiskBuffer2Frame<T>* db2f = dynamic_cast<DiskBuffer2Frame<T>*>(f);

        if(db2f == NULL)
            throw CVD::Exceptions::VideoBuffer::BadPutFrame();
        else 
            delete db2f;
    }

    //
    // SEEK TO
    //
    template<typename T>
    inline void DiskBuffer2<T>::seek_to(double t)
    {
        // t is in ms, but work in seconds
        // round the answer to the nearest whole frame
        int frameno = static_cast<int>((t - start_time) / time_per_frame + 0.5);
        if(frameno < 0 || static_cast<unsigned int>(frameno) > (file_names.size() - 1))
            throw Exceptions::DiskBuffer2::BadSeek(t);
        next_frame = frameno;
        frame_ready = true;
    }
}


#endif