dvbuffer.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
*/
// -*- c++ -*-
#ifndef __DVBUFFER_H
#define __DVBUFFER_H

#include <cvd/videobuffer.h>
#include <cvd/byte.h>
#include <cvd/rgb.h>
#include <cvd/colourspaces.h>
#include <cvd/exceptions.h>
#include <libraw1394/raw1394.h>
#include <libdc1394/dc1394_control.h>
#include <vector>
#include <string>
#include <utility>

namespace CVD {

namespace Exceptions
{
        namespace DVBuffer
        {
                struct All: public CVD::Exceptions::VideoBuffer::All{};
                
                struct Raw1394Setup: public All {Raw1394Setup(std::string action); 
                };

                struct DC1394Setup: public All {DC1394Setup(std::string action); 
                };

                struct BadCameraSelection: public All { BadCameraSelection(int num_cameras, int camera_no); 
                };

                struct BusReset: public All {BusReset(); 
                };
                
                struct DeviceOpen: public All {DeviceOpen(std::string dev); 
                };
                struct DeviceSetup: public All {DeviceSetup(std::string action);  
                };
                struct PutFrame: public All {PutFrame(std::string dev); 
                };
                struct GetFrame: public All {GetFrame(std::string dev); 
                };
        }
}


namespace DC
{
        #ifndef DOXYGEN_IGNORE_INTERNAL
        template<class C> struct cam_type
        {
                static const int mode = C::Error__type_not_valid_for_camera___Use_byte_or_yuv411_or_rgb_of_byte;
                // We can't really set the frame rate, but the alternative is to give the above error twice
                static const double fps; 
        };
        
        template<> struct cam_type<yuv411>
        {
                static const int mode = MODE_640x480_YUV411;
                static const double fps; //30
        };

        template<> struct cam_type<byte>
        {
                static const int mode = MODE_640x480_MONO;
                static const double fps; //30
        };
        
        template<> struct cam_type<Rgb<byte> >
        {
                static const int mode = MODE_640x480_RGB;
                static const double  fps; //15
        };

        struct raw_frame
        {
                unsigned char* data;
                double timestamp;
                int buffer;
        };
        #endif

        class RawDCVideo
        {
                public:
                        RawDCVideo(int camera_no, int num_dma_buffers, int bright, int exposure, int mode, double frame_rate);
                        ~RawDCVideo();
                        
                        ImageRef size();
                        VideoFrame<byte>* get_frame();
                        void put_frame(VideoFrame<byte>* f);
                        bool frame_pending();

                        void set_shutter(unsigned int s);
                        unsigned int get_shutter();

                        void set_iris(unsigned int i );
                        unsigned int get_iris();
                        
                        void set_sharpness(unsigned int s );
                        unsigned int get_sharpness();                   

                        void set_gain(unsigned int g);
                        unsigned int get_gain();

                        void set_exposure(unsigned int e);
                        unsigned int get_exposure();

                        void set_brightness(unsigned int b);
                        unsigned int get_brightness();


                        void set_feature_value(unsigned int feature, unsigned int value);

                        unsigned int get_feature_value(unsigned int feature);

                        std::pair<unsigned int, unsigned int> get_feature_min_max(unsigned int feature);
                        
                        void auto_on_off(unsigned int feature, unsigned int auto_value);

                        double frame_rate();

                        
                        raw1394handle_t& handle();
                        nodeid_t&                node();

                private:

                        // components needed for the DMA based video capture
                        int my_channel;
                        unsigned char* my_ring_buffer;
                        int my_frame_size;
                        int my_num_buffers;
                        // int my_most_recent_frame; // the most recently filled buffer
                        int my_fd; // fd of the mmaped dma ring buffer
                        raw1394handle_t my_handle;
                        nodeid_t * my_camera_nodes; // member variable I guess unless we can make it be released
                        nodeid_t my_node;
                        ImageRef my_size;

                        std::vector<int> my_frame_sequence;
                        int my_next_frame;
                        int my_last_in_sequence;
                        double true_fps;
        };
                
}

template<class T> class DVBuffer2: public VideoBuffer<T>, public DC::RawDCVideo
{
        public:
                DVBuffer2(int cam_no, int num_dma_buffers, int bright=-1, int exposure=-1, double fps=DC::cam_type<T>::fps)
                :VideoBuffer<T>(VideoBufferType::Live),RawDCVideo(cam_no, num_dma_buffers, bright, exposure, DC::cam_type<T>::mode, fps)
                {
                        //Apparently, DVBuffer isn't flushable.
                        //This should probably be fixed.
                }

                virtual ~DVBuffer2()
                {
                }

                double frame_rate()
                {
                        return RawDCVideo::frame_rate();
                }

                virtual ImageRef size()
                {
                        return RawDCVideo::size();
                }

                virtual VideoFrame<T>* get_frame()
                {
                        return reinterpret_cast<VideoFrame<T>*>(RawDCVideo::get_frame());
                }
                
                virtual void put_frame(VideoFrame<T>* f)
                {
                        RawDCVideo::put_frame(reinterpret_cast<VideoFrame<byte>*>(f));
                }

                virtual bool frame_pending()
                {
                        return RawDCVideo::frame_pending();
                }
        
                virtual void seek_to(double){}
};

typedef DVBuffer2<byte> DVBuffer;

}

#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:09 2013