dvbuffer.h

// -*- c++ -*-
#ifndef __DVBUFFER_H
#define __DVBUFFER_H

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

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