/home/fayn/OpenKraken-dev/OpenKN-controller/src/LIN_V4L2Webcam.hpp

Go to the documentation of this file.

/***************************************************************************\
 * Copyright (C) by University Paris-Est - MISS team   
 * LIN_V4L2Webcam.hpp created in 10 2008.
 * Mail : biri@univ-mlv.fr                                        
 *                                                                                                         
 * This file is part of the OpenKraken-controller.
 *
 * The OpenKraken-controller 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 3 of the License, or
 * (at your option) any later version.
 *
 * The OpenKraken-controller 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 program.      If not, see <http://www.gnu.org/licenses/>.
 *
\***************************************************************************/

/*
 * Anti-doublon
 */
#ifndef __OPENKN_CONTROLLER__LIN_V4L2WEBCAM_HPP__
#define __OPENKN_CONTROLLER__LIN_V4L2WEBCAM_HPP__


/*
 * Internal Includes
 */
#include "CameraController.hpp"
#include "webcamstools/uvcvideo.h"

/*
 * External Includes
 */
#include <linux/videodev2.h>

/*
 * Namespace
 */
namespace kn{

        enum WebcamControl { WEBCAM_BRIGHTNESS = V4L2_CID_BRIGHTNESS,
                                                 WEBCAM_CONTRAST = V4L2_CID_CONTRAST,
                                                 WEBCAM_SATURATION = V4L2_CID_SATURATION,
                                                 WEBCAM_GAIN = V4L2_CID_GAIN,
                                                 WEBCAM_SHARPNESS = V4L2_CID_SHARPNESS,
                                                 WEBCAM_GAMMA = V4L2_CID_GAMMA,
                                                 WEBCAM_EXPOSURE = V4L2_CID_EXPOSURE_ABSOLUTE,
                                                 WEBCAM_EXPOSURE_AUTO = V4L2_CID_EXPOSURE_AUTO,
                                                 WEBCAM_WB_AUTO = V4L2_CID_WHITE_BALANCE_TEMPERATURE_AUTO,
                                                 WEBCAM_WB = V4L2_CID_WHITE_BALANCE_TEMPERATURE};
    
        enum WebcamToggleControl {WEBCAM_EXPOSURE_ON = 3, WEBCAM_EXPOSURE_OFF = 2, WEBCAM_WB_ON = 1, WEBCAM_WB_OFF = 0};

        enum WebcamFormat{FMT_MJPEG,FMT_YUYV};

        enum GrabMethod { READ_METHOD, MMAP_METHOD};


        struct V4L2WebcamParams : CameraParams
        {
        
                WebcamFormat fmt;
        
                GrabMethod grab;
        
                unsigned int framerate;
        
                bool force;
        
                V4L2WebcamParams(const std::string& dn = "/dev/video0", 
                         const size_t& expectedwidth = 320, 
                         const size_t& expectedheight = 240,
                         const WebcamFormat& wf = FMT_YUYV,
                         const GrabMethod& gm = MMAP_METHOD,
                         const unsigned int& fps = 30,
                         const bool& f = false)
                        :CameraParams(dn,expectedwidth,expectedheight),fmt(wf),grab(gm),framerate(fps),force(f) {}
        
        };
    
        static const V4L2WebcamParams defaultV4L2WebcamParams;

    /*
     * Functions definitions
     */
   
    class V4L2Webcam : public CameraController {
          
    private:
                        
        
        struct V4L2_Buffer {
            void * start;
            size_t length;
        };
        

        struct v4l2_capability cap;

        struct v4l2_format fmt;

        struct v4l2_buffer buf;

        struct v4l2_requestbuffers rb;

                GrabMethod gb;

                int filedescriptor;
          

        void** buffersmmap;

        V4L2_Buffer* buffersread;

        // Arrays to reconstruct the image
        unsigned char *tmpbuffer;

        unsigned char *framebuffer;
          
        unsigned char *outputbuffer;

        bool isgrabbing;        

        bool isenable;

        struct v4l2_control control_s;

        struct v4l2_queryctrl queryctrl;

    public:

        V4L2Webcam(void):CameraController(){
            outputbuffer = 0;
            framebuffer = 0;
            tmpbuffer = 0;
            buffersread = 0;
            buffersmmap = 0;
            isenable = false;
            isgrabbing = false;
            filedescriptor = -1;
        };

        ~V4L2Webcam(void){closeDevice();};

    private:
        bool checkAvailability(std::string& message);

        void initMMAP(void);

        void initREAD(void);

        bool isControlSupportedQuery(const WebcamControl& control, struct v4l2_queryctrl* queryctrl);
          

    public:

        void openDevice(const V4L2WebcamParams& params);

                void openDevice(void){openDevice(V4L2WebcamParams());}

        void closeDevice(void);
        
        void start(void);

        void stop(void);

        bool isStarted(void) const {return isgrabbing;}

        bool isOpened(void) const {return isenable;}

        unsigned char* getImage(void);

        size_t width(void) const;

        size_t height(void) const;

        bool isControlSupported(const WebcamControl& control);

        int getControlValue(const WebcamControl& control);

        bool resetControlValue(const WebcamControl& control);

        int getControlMinValue(const WebcamControl& control);

        int getControlMaxValue(const WebcamControl& control);

        int getControlStepValue(const WebcamControl& control);

        bool setControlUpValue(const WebcamControl& control);

        bool setControlDownValue(const WebcamControl& control);

        bool setControlValue(const WebcamControl& control, const int& value);

        bool toggleControlValue(const WebcamControl& control, const WebcamToggleControl& value);
    };
 
    /*
     * End of Namespace
     */
}

#endif

---