include/FCam/F2/Sensor.h

Go to the documentation of this file.

#ifndef FCAM_F2_SENSOR_H
#define FCAM_F2_SENSOR_H


#include "../Sensor.h"
#include "Frame.h"
#include "Shot.h"
#include <vector>
#include <pthread.h>

namespace FCam { namespace F2 {

    class Daemon;

    class Sensor : public FCam::Sensor {
    public:
            
        Sensor();
        ~Sensor();

        void capture(const FCam::Shot &);
        void capture(const Shot &);

        void capture(const std::vector<FCam::Shot> &);
        void capture(const std::vector<Shot> &);

        void stream(const FCam::Shot &);
        void stream(const Shot &);

        void stream(const std::vector<FCam::Shot> &);
        void stream(const std::vector<Shot> &);

        bool streaming();
        void stopStreaming();
        void start();
        void stop();

        virtual int maxExposure() const {return 2489140;} 

        virtual int minExposure() const {return 38;}       

        virtual int maxFrameTime() const {return 2490072;}

        virtual int minFrameTime() const {return 33414;}      

        virtual float maxGain() const {return 32.0f;}     

        virtual float minGain() const {return 1.0f;}      


        Size minImageSize() const; 
        Size maxImageSize() const; 
        static Size pixelArraySize(); 
        static Rect activeArrayRect();
        static Rect pixelArrayRect(); 

        int rollingShutterTime(const Shot&) const;

        int rollingShutterTime(const FCam::Shot&) const;

        int framesPending() const;
        int shotsPending() const;

        unsigned short minRawValue() const;
        unsigned short maxRawValue() const;
    
        BayerPattern bayerPattern() const;
            
        const std::string &manufacturer() const;
        const std::string &model() const;

        void rawToRGBColorMatrix(int kelvin, float *matrix) const;

        
        FCam::F2::Frame getFrame();
        

        void debugTiming(bool);

    protected:
        
        FCam::Frame getBaseFrame() {return getFrame();}

    private:
        // The currently streaming shot         
        std::vector<Shot> streamingShot;        

        // The daemon that manages the F2's sensor
        friend class Daemon;
        Daemon *daemon;
            
        // the Daemon calls this when it's time for new frames to be queued up
        void generateRequest();

        pthread_mutex_t requestMutex;
          
        // enforce the specified drop policy
        void enforceDropPolicy();

    // allow tagFrames to get at color matrix information
        const std::vector<int> &getColorTemps() const;
        const float *getColorMatrix(int i) const;

        // the number of outstanding shots
        int shotsPending_;
    };
        
    }
}


#endif