cvd/Linux/v4l1buffer.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
*/
//-*- c++ -*-
#ifndef __CVD_V4L1BUFFER_H
#define __CVD_V4L1BUFFER_H

#include <vector>

#include <cvd/Linux/v4l1frame.h>
#include <cvd/videobuffer.h>
#include <cvd/byte.h>
#include <cvd/rgb.h>
#include <cvd/timer.h>
#include <cvd/colourspaces.h>

namespace CVD {

namespace Exceptions
{
    namespace V4L1Buffer
    {
        struct All: public CVD::Exceptions::VideoBuffer::All{};
        struct DeviceOpen: public All {DeviceOpen(std::string dev); 
        };
        struct DeviceSetup: public All {DeviceSetup(std::string dev, std::string action);  
        };
        struct PutFrame: public All {PutFrame(std::string dev, unsigned int number); 
        };
        struct GetFrame: public All {GetFrame(std::string dev, unsigned int number); 
        };
    }
}

namespace V4L1
{
    #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;
    };

    template<> struct cam_type<byte>
    {
        static const unsigned int mode = VIDEO_PALETTE_GREY;
    };

    template<> struct cam_type<bayer>
    {
        static const unsigned int mode = VIDEO_PALETTE_RAW;
    };

    template<> struct cam_type<yuv422>
    {
        static const unsigned int mode = VIDEO_PALETTE_YUV422;
    };

    template<> struct cam_type<yuv420p>
    {
        static const unsigned int mode = VIDEO_PALETTE_YUV420P;
    };


    template<> struct cam_type<Rgb<byte> >
    {
        static const unsigned int mode = VIDEO_PALETTE_RGB24;
    };
    #endif

    class RawV4L1
    {
    public:
        RawV4L1(const std::string & dev, unsigned int mode, const ImageRef&);
        virtual ~RawV4L1();
        const ImageRef& get_size() const;
        void set_size(const ImageRef& size);
        void set_palette(unsigned int palette);
        void set_brightness(double brightness);
        double get_brightness(void) { return myBrightness; };
        void set_whiteness(double whiteness);
        double get_whiteness(void) { return myWhiteness; };
        void set_hue(double hue);
        double get_hue(void) { return myHue; };
        void set_contrast(double contrast);
        double get_contrast(void) { return myContrast; };
        void set_saturation(double saturation);
        double get_saturation(void) { return mySaturation; };
        void set_auto_exp(bool on);
        bool get_auto_exp(void);
        void retrieveSettings();
        void commitSettings();
        void captureFrame(unsigned int buffer);
        unsigned char* get_frame();
        void put_frame( unsigned char * );
        double frame_rate();
        bool frame_pending();
        int get_handle() const { return myDevice; };

    private:
        std::string deviceName;
        int myDevice;
        ImageRef mySize;
        unsigned int myPalette;
        double myBrightness, myWhiteness, myContrast, myHue, mySaturation;
        unsigned int myBpp;
        int autoexp;

        void *mmaped_memory;
        size_t mmaped_len;

        std::vector<unsigned char*> myFrameBuf;
        std::vector<bool> myFrameBufState;
        unsigned int myNextRetrieveBuf;
    };
};

template <class T> class V4L1Buffer : public VideoBuffer<T>, public V4L1::RawV4L1
{
public:
    V4L1Buffer(const std::string & dev) 
    :VideoBuffer<T>(VideoBufferType::Flushable),
     RawV4L1( dev, V4L1::cam_type<T>::mode, ImageRef(0,0)) 
    {}

    V4L1Buffer(const std::string & dev, ImageRef size) 
    :VideoBuffer<T>(VideoBufferType::Flushable),
     RawV4L1( dev, V4L1::cam_type<T>::mode,size ) 
    {}

    virtual ImageRef size()
    {
        return RawV4L1::get_size();
    }
    virtual VideoFrame<T> * get_frame()
    {
        return new V4L1Frame<T>(timer.get_time(), (T *)RawV4L1::get_frame(), RawV4L1::get_size());
    }
    virtual void put_frame(VideoFrame<T>* f)
    {
        RawV4L1::put_frame((unsigned char *)f->data());
        delete reinterpret_cast<V4L1Frame<T> *>(f);
    }
    virtual bool frame_pending()
    {
        return RawV4L1::frame_pending();
    }
    virtual double frame_rate()
    {
        return RawV4L1::frame_rate();
    }

    virtual ~V4L1Buffer()
    {
    }

private:
    V4L1Buffer( V4L1Buffer& copyof );
    int operator = ( V4L1Buffer& copyof );
};

typedef V4L1Buffer<byte> V4L1BufferByte;

};
#endif