FrameGrabber.hpp

//
// Class to interface with a frame grabber
// Copyright 2008-2010 AQSENSE, S.L.
//
#if !defined (AQSENSE_SAL3DPP_FRAME_GRABBER_HPP)
#define AQSENSE_SAL3DPP_FRAME_GRABBER_HPP

#if defined (_MSC_VER) && (_MSC_VER >= 1020)
#pragma once
#endif

#include <sal3d/framegrabber.h>
#include <sal3dpp/Frame.hpp>
#include <stdexcept>
#include <string>

namespace sal3d
{

    class Timeout: public std::runtime_error
    {
        public:
            Timeout ():
                std::runtime_error ("timeout")
            {
            }
    };

    class FrameGrabber
    {
        public:
            explicit FrameGrabber (const std::string &fileName,
                    const std::string &param)
            {
                _grabber.p = 0;
                init (fileName, param);
            }

            explicit FrameGrabber (const std::string &fileName)
            {
                init (fileName, "");
            }

            FrameGrabber (const FrameGrabber &grabber):
                _grabber (grabber._grabber)
            {
                Error e;
                sal3d_frame_grabber_share (_grabber, &e.e);
                if ( 0 > e.e.value )
                    throw e;
            }

            virtual ~FrameGrabber ()
            {
                sal3d_frame_grabber_release (_grabber);
            }

            virtual Frame
            frame ()
            {
                Error e;
                sal3d_frame frame;
                sal3d_frame_grabber_get_frame (_grabber, &frame, &e.e);
                if ( 0 > e.e.value )
                    throw e;

                return Frame (frame);
            }

            virtual void
            freeze ()
            {
                Error e;
                sal3d_frame_grabber_freeze (_grabber, &e.e);
                if ( 0 > e.e.value )
                    throw e;
            }

            virtual void
            grab ()
            {
                Error e;
                sal3d_frame_grabber_grab (_grabber, &e.e);
                if ( 0 > e.e.value )
                    throw e;
            }

            virtual int
            lostCount ()
            {
                Error e;
                int count = sal3d_frame_grabber_get_lost_frames_counter (_grabber,
                        &e.e);
                if ( 0 > e.e.value )
                    throw e;
                return count;
            }

            FrameGrabber &
            operator= (const FrameGrabber &rhs)
            {
                Error e;
                sal3d_frame_grabber_share (rhs._grabber, &e.e);
                if ( 0 > e.e.value )
                    throw e;

                sal3d_frame_grabber_release (_grabber);

                _grabber = rhs._grabber;

                return *this;
            }

            virtual void
            reconfig (const std::string &param)
            {
                Error e;
                sal3d_frame_grabber_reconfig (_grabber,
                        param.c_str(), &e.e);
                if ( 0 > e.e.value )
                    throw e;
            }

            void
            setSize (int width, int height)
            {
                Error e;
                sal3d_frame_grabber_set_size (_grabber, width,
                        height, &e.e);
                if ( 0 > e.e.value )
                    throw e;
            }

            virtual void
            wait (int timeout = -1)
            {
                Error e;
                sal3d_frame_grabber_wait (_grabber, timeout, &e.e);
                if ( 0 > e.e.value )
                {
                    if (e.e.value == SAL3D_ERROR_TIMEOUT)
                        throw Timeout();
                    throw e;
                }
            }

        protected:
            void *
            getDriverData ()
            {
                Error e;
                void * result = sal3d_frame_grabber_get_driver_data (_grabber,
                        &e.e);
                if ( 0 > e.e.value )
                    throw e;
                return result;
            }

            void *
            getFunctionPointer (const std::string &name)
            {
                Error e;
                void * result = sal3d_frame_grabber_get_function_pointer (_grabber, name.c_str(),
                        &e.e);
                if ( 0 > e.e.value )
                    throw e;
                return result;
            }
            

        private:
            void init (const std::string &fileName,
                    const std::string &param)
            {
                Error e;
                    sal3d_frame_grabber_new_from_file (fileName.c_str (),
                            param.c_str (), &_grabber, &e.e);
                if ( 0 > e.e.value )
                    throw e;
            }

            sal3d_frame_grabber _grabber;
    };
}

#endif // !AQSENSE_SAL3DPP_FRAME_GRABBER_HPP