videocapture.hpp

Go to the documentation of this file.

//
// Copyright (c) 2021, STEREOLABS.
//
// All rights reserved.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
 
#ifndef VIDEOCAPTURE_HPP
#define VIDEOCAPTURE_HPP
 
#include "defines.hpp"
#include <thread>
#include <mutex>
#include <fstream>      // std::ofstream
#include <iomanip>
 
#define LOG_SEP ","
 
#ifdef VIDEO_MOD_AVAILABLE
 
#include "videocapture_def.hpp"
 
namespace sl_oc {
 
 
 
#ifdef SENSORS_MOD_AVAILABLE
namespace sensors {
class SensorCapture;
}
#endif
 
namespace video {
 
struct SL_OC_EXPORT Frame
{
    uint64_t frame_id = 0;          
    uint64_t timestamp = 0;         
    uint8_t* data = nullptr;        
    uint16_t width = 0;             
    uint16_t height = 0;            
    uint8_t channels = 0;           
};
 
class SL_OC_EXPORT VideoCapture
{
    ZED_OC_VERSION_ATTRIBUTE;
 
public:
    VideoCapture( VideoParams params = VideoParams() );
 
    virtual ~VideoCapture();
 
    bool initializeVideo( int devId=-1 );
 
    const Frame& getLastFrame(uint64_t timeout_msec=100);
 
    inline void getFrameSize( int& width, int& height ){width=mWidth;height=mHeight;}
 
    // ----> Led Control
    int setLEDstatus(bool status);
 
    int getLEDstatus(bool *status);
 
    int toggleLED(bool *value);
    // <---- Led Control
 
    // ----> Camera Settings control
    void setBrightness(int brightness);
 
    int getBrightness();
 
    void resetBrightness();
 
    void setSharpness(int sharpness);
 
    int getSharpness();
 
    void resetSharpness();
 
    void setContrast(int contrast);
 
    int getContrast();
 
    void resetContrast();
 
    void setHue(int hue);
 
    int getHue();
 
    void resetHue();
 
    void setSaturation(int saturation);
 
    int getSaturation();
 
    void resetSaturation();
 
    void setWhiteBalance(int wb);
 
    int getWhiteBalance();
 
    void setAutoWhiteBalance(bool active);
 
    bool getAutoWhiteBalance();
 
    void resetAutoWhiteBalance();
 
    void setGamma(int gamma);
 
    int getGamma();
 
    void resetGamma();
 
    int setAECAGC(bool active);
 
    bool getAECAGC();
 
    void resetAECAGC();
 
    bool setROIforAECAGC(CAM_SENS_POS side, uint16_t x, uint16_t y, uint16_t w, uint16_t h);
 
    bool resetROIforAECAGC(CAM_SENS_POS side);
 
    bool getROIforAECAGC(CAM_SENS_POS side,uint16_t& x, uint16_t& y, uint16_t& w, uint16_t& h);
 
    void setGain(CAM_SENS_POS cam, int gain);
 
    int getGain(CAM_SENS_POS cam);
 
    void setExposure(CAM_SENS_POS cam, int exposure);
 
    int getExposure(CAM_SENS_POS cam);
    // <---- Camera Settings control
 
    int getSerialNumber();
 
    void setColorBars(int side, bool c);
 
    inline std::string getDeviceName(){return mDevName;}
 
    inline int getDeviceId(){return mDevId;}
 
#ifdef SENSOR_LOG_AVAILABLE
    bool enableAecAgcSensLogging(bool enable, int frame_skip=10);
 
    void saveAllISPRegisters(std::string filename);
 
    void saveAllSensorsRegisters(std::string filename);
#endif
 
 
#ifdef SENSORS_MOD_AVAILABLE
    bool enableSensorSync( sensors::SensorCapture* sensCap=nullptr );
 
    inline void setReadyToSync(){ mSensReadyToSync=true; }
#endif
 
        bool resetAGCAECregisters();
 
private:
    void grabThreadFunc();  
 
    // ----> Low level functions
    int ll_VendorControl(uint8_t *buf, int len, int readMode, bool safe = false, bool force=false);
    int ll_get_gpio_value(int gpio_number, uint8_t* value);
    int ll_set_gpio_value(int gpio_number, uint8_t value);
    int ll_set_gpio_direction(int gpio_number, int direction);
    int ll_read_system_register(uint64_t address, uint8_t* value);
    int ll_write_system_register(uint64_t address, uint8_t value);
    int ll_read_sensor_register(int side, int sscb_id, uint64_t address, uint8_t *value);
    int ll_write_sensor_register(int side, int sscb_id, uint64_t address, uint8_t value);
 
    int ll_SPI_FlashProgramRead(uint8_t *pBuf, int Adr, int len, bool force=false);
 
    int ll_isp_aecagc_enable(int side, bool enable);
    int ll_isp_is_aecagc(int side);
 
    uint8_t ll_read_reg(uint64_t addr);
 
    int ll_isp_get_gain(uint8_t *val, uint8_t sensorID);
    int ll_isp_set_gain(unsigned char ucGainH, unsigned char ucGainM, unsigned char ucGainL, int sensorID);
    int ll_isp_get_exposure(unsigned char *val, unsigned char sensorID);
    int ll_isp_set_exposure(unsigned char ucExpH, unsigned char ucExpM, unsigned char ucExpL, int sensorID);
 
    void ll_activate_sync(); // Activate low level sync signal between Camera and MCU
    // <---- Low level functions
 
    // ----> Mid level functions
    void setCameraControlSettings(int ctrl_id, int ctrl_val);
    void resetCameraControlSettings(int ctrl_id);
    int getCameraControlSettings(int ctrl_id);
 
    int setGammaPreset(int side, int value);
 
    int calcRawGainValue(int gain); // Convert "user gain" to "ISP gain"
    int calcGainValue(int rawGain); // Convert "ISP Gain" to "User gain"
    // <---- Mid level functions
 
    // ----> Connection control functions
    bool openCamera( uint8_t devId );                           
    bool startCapture();                                        
    void reset();                                               
    inline void stopCapture(){mStopCapture=true;}               
    int input_set_framerate(int fps);                           
    int xioctl(int fd, uint64_t IOCTL_X, void *arg);            
    void checkResFps();                                         
    SL_DEVICE getCameraModel(std::string dev_name);     
    // <---- Connection control functions
 
    typedef enum _date_time
    {
        FULL,
        DATE,
        TIME
    } DateTime;
 
    static inline std::string getCurrentDateTime( DateTime type ){
        time_t now = time(0);
        struct tm  tstruct;
        char  buf[80];
        tstruct = *localtime(&now);
        if(type==FULL)
            strftime(buf, sizeof(buf), "%Y-%m-%d %X", &tstruct);
        else if(type==DATE)
            strftime(buf, sizeof(buf), "%Y-%m-%d", &tstruct);
        else if(type==TIME)
            strftime(buf, sizeof(buf), "%X", &tstruct);
        return std::string(buf);
    }
 
#ifdef SENSOR_LOG_AVAILABLE
    void saveLogDataLeft();
    void saveLogDataRight();
#endif
 
private:
    // Flags
    bool mNewFrame=false;               
    bool mInitialized=false;            
    bool mStopCapture=true;             
    bool mGrabRunning=false;            
 
    VideoParams mParams;                
 
    int mDevId = 0;                     
    std::string mDevName;               
    int mFileDesc=-1;                   
 
    std::mutex mBufMutex;               
    std::mutex mComMutex;               
 
    int mWidth = 0;                     
    int mHeight = 0;                    
    int mChannels = 0;                  
    int mFps=0;                         
 
    SL_DEVICE mCameraModel = SL_DEVICE::NONE; 
 
    Frame mLastFrame;                   
    uint8_t mBufCount = 2;              
    uint8_t mCurrentIndex = 0;          
    struct UVCBuffer *mBuffers = nullptr;  
 
    uint64_t mStartTs=0;                
    uint64_t mInitTs=0;                 
 
    int mGainSegMax=0;                  
    int mExpoureRawMax;                 
 
    std::thread mGrabThread;            
 
    bool mFirstFrame=true;              
 
#ifdef SENSOR_LOG_AVAILABLE
    // ----> Registers logging
    bool mLogEnable=false;
    std::string mLogFilenameLeft;
    std::string mLogFilenameRight;
    std::ofstream mLogFileLeft;
    std::ofstream mLogFileRight;
    int mLogFrameSkip=10;
    // <---- Registers logging
#endif
 
 
#ifdef SENSORS_MOD_AVAILABLE
    bool mSyncEnabled=false;            
    sensors::SensorCapture* mSensPtr;   
 
    bool mSensReadyToSync=false;        
#endif
};
 
}
 
}
#endif
 
#endif // VIDEOCAPTURE_HPP