cam_config.h

Go to the documentation of this file.

/*
 * \file    cam_gst.h
 *  
 * \brief   Allows to create a default GStreamer pipeline, which requests images using v4l2, 
 *          converts them to jpegs and gives access to the image data. 
 *          
 *          German Research Center for Artificial Intelligence\n
 *          Project: Rimres
 *
 * \date    23.11.11
 *
 * \author  Stefan.Haase@dfki.de
 */

#ifndef _CAM_V4L2_CONFIG_H_
#define _CAM_V4L2_CONFIG_H_

// for v4l2 api (everything required?)
#include <errno.h>
#include <fcntl.h> // for open()
#include <linux/videodev2.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/time.h>
#include <stdlib.h>

// e-CAM32 v4l2 controls
#include "omap_v4l2.h"

#include <map>
#include <stdexcept>
#include <string>
#include <vector>
#include <set>
#include <iostream>

#include <base-logging/Logging.hpp>

#include <base/samples/Frame.hpp>

#include "helpers.h"

namespace camera 
{

class CamConfigException : public std::runtime_error {
 public:
    CamConfigException(const std::string& what_arg) : std::runtime_error(what_arg) {}
};

class CamConfig
{
 public: // STRUCTURES
    struct CamCtrl {
     public:
        CamCtrl() : mCtrl(), mMenuItems(), mValue(0), 
                mWriteable(true), mReadable(true) {
            memset(&mCtrl, 0, sizeof(struct v4l2_queryctrl));
        }        
        
        ~CamCtrl() {
        }

        struct v4l2_queryctrl mCtrl;
        std::vector<std::string> mMenuItems;
        int32_t mValue;
        bool mWriteable; // Above values are set to zero.
        bool mReadable;
    }; 

 public: // CAMCONFIG
    CamConfig(std::string const& device);

    ~CamConfig();

     inline int getFd() {
        return mFd;
     }

 public: // CAPABILITY
    void readCapability();

    void listCapabilities();

    std::string getCapabilityDriver();

    std::string getCapabilityCard();

    std::string getCapabilityBusInfo();

    std::string getCapabilityVersion();

    bool hasCapability(uint32_t capability_field);

 public: // CONTROL
    void readControl();

    void readControl(struct v4l2_queryctrl& queryctrl_tmp);

    int32_t readControlValue(uint32_t const id);

    void writeControlValue(uint32_t const id, int32_t value, bool just_write=false);

    std::vector<uint32_t> getControlValidIDs();

    std::vector<struct CamConfig::CamCtrl> getControlList();

    void listControls();

    bool isControlIdValid(uint32_t const id) const;

    bool isControlIdWritable(uint32_t const id) const;

    bool getControlValue(uint32_t const id, int32_t* value);

    bool getControlType(uint32_t const id, uint32_t* type);

    bool getControlName(uint32_t const id, std::string* name);

    bool getControlMinimum(uint32_t const id, int32_t* minimum);

    bool getControlMaximum(uint32_t const id, int32_t* maximum);

    bool getControlStep(uint32_t const id, int32_t* step);

    bool getControlDefaultValue(uint32_t const id, int32_t* default_value);

    bool getControlFlag(uint32_t const id, uint32_t const flag, bool* set);

    void setControlValuesToDefault();

 public: // IMAGE
    void readImageFormat();

    void writeImagePixelFormat(uint32_t const width=0, uint32_t const height=0, 
            uint32_t const pixelformat=0);

    void listImageFormat();

    bool getImageWidth(uint32_t* width);

    bool getImageHeight(uint32_t* height);

    bool getImagePixelformat(uint32_t* pixelformat);

    bool getImagePixelformatString(std::string* pixelformat_str);

    bool getImageField(uint32_t* field);

    bool getImageBytesperline(uint32_t* bytesperline);

    bool getImageSizeimage(uint32_t* sizeimage);

    bool getImageColorspace(uint32_t* colorspace);
    
    uint32_t toV4L2ImageFormat(base::samples::frame::frame_mode_t mode);

 public: // STREAMPARM, not suoported by e-CAM32!
    void readStreamparm();

    void writeStreamparm(uint32_t const numerator, uint32_t const denominator);

    void listStreamparm();

    bool readFPS(float* fps);

    void writeFPS(uint32_t const fps);

    bool getFPS(float* fps);

    bool hasCapabilityStreamparm(uint32_t capability_field);

    bool hasCapturemodeStreamparm(uint32_t capturemode);
    
 public: // REQUEST IMAGE
     
    void initRequesting();
    
    bool isImageAvailable(int32_t timeout_ms);
    
    bool getBuffer(std::vector<uint8_t>& buffer, bool blocking_read, int32_t timeout_ms);
    
    void cleanupRequesting();

 private:
    int mFd; 

    // Capability
    struct v4l2_capability mCapability;
    // Control
    std::map<uint32_t, struct CamCtrl> mCamCtrls;
    // Image
    struct v4l2_format mFormat;
    struct v4l2_cropcap mCropcap;
    std::vector<struct v4l2_fmtdesc> mFormatDescriptions;
    // Stream
    struct v4l2_streamparm mStreamparm;
    // Used to collect all controls depending on another control.
    // E.g. V4L2_CID_FOCUS_ABSOLUTE and V4L2_CID_FOCUS_RELATIVE can only be changed
    // if V4L2_CID_FOCUS_AUTO is set to 0 (manual).
    std::set<uint32_t> mAutoManualDependentControlIds;
    // Points to the image which has been requested via ioctl.
    uint8_t* mmapBuffer;
    bool mStreamingActivated;
    bool mConversionRequiredYUYV2RGB; // YUVU is not yet supported by Rock.
    Helpers helpers;

    CamConfig() {}
    
    void getQueryBuffer(struct v4l2_buffer& query_buffer);
    
    int xioctl(int fd, int request, void *arg);

};

} // end namespace camera

#endif