cvd/colourspacebuffer.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
*/
// PAS 17/6/04 (revised 16/2/05)

#ifndef CVD_INCLUDE_COLOURSPACEBUFFER_H
#define CVD_INCLUDE_COLOURSPACEBUFFER_H

#include <cvd/localvideobuffer.h>
#include <cvd/image_convert.h>
#include <cvd/colourspace_convert.h>
#include <cvd/colourspace_frame.h>

namespace CVD
{
template <class T, class From> class ColourspaceBuffer : public CVD::LocalVideoBuffer<T>
{
    public:
        ColourspaceBuffer(CVD::VideoBuffer<From>& buf)
        :LocalVideoBuffer<T>(buf.type()),m_vidbuf(buf),m_size(buf.size())
        {
        }
        
        virtual RawVideoBuffer* source_buffer()
        {
            return &m_vidbuf;
        }
 
        ImageRef size()
        {
            return m_size;  
        }
        
        virtual bool frame_pending()
        {   
            return m_vidbuf.frame_pending();
        }
            
        virtual void seek_to(double t)
        {
            m_vidbuf.seek_to(t);
        }
            
        virtual double frame_rate()
        {
            return m_vidbuf.frame_rate();
        }

        virtual CVD::ColourspaceFrame<T>* get_frame()
        {
            VideoFrame<From>* fr = m_vidbuf.get_frame();
            Image<T> cv = convert_image<T>(*fr);

            ColourspaceFrame<T>* ret = new ColourspaceFrame<T>(fr->timestamp(), cv);

            m_vidbuf.put_frame(fr);

            return ret;
        }

        virtual void put_frame(CVD::VideoFrame<T>* f)
        {
            //Check that the type is correct...
            ColourspaceFrame<T>* csf = dynamic_cast<ColourspaceFrame<T>*>(f);

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

   private:
        CVD::VideoBuffer<From>& m_vidbuf;
        ImageRef m_size;
};


template <class T, class From> class ColourspaceBuffer_managed : public ColourspaceBuffer<T, From>
{
    public:
        ColourspaceBuffer_managed(CVD::VideoBuffer<From>* buf)
        :ColourspaceBuffer<T,From>(*buf),vb(buf)
        {
        }

        ~ColourspaceBuffer_managed()
        {
            delete  vb;
        }

    private:
        VideoBuffer<From>* vb;

};

} 
#endif