F2/Sensor.h

Go to the documentation of this file.

#ifndef FCAM_F2_SENSOR_H
#define FCAM_F2_SENSOR_H


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

namespace FCam {
    namespace F2 {

    class Sensor : public FCam::Sensor, public Daemon::RequestGenerator {
      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();

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

        int getRollingShutterTime(const Shot&) const;

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

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

        BayerPattern getBayerPattern() const {return GRBG;}
        
        const float *getXYZToRawColorMatrixTungsten() const {
        return XYZToRawColorMatrixTungsten;
        }
        const float *getXYZToRawColorMatrixDaylight() const {
        return XYZToRawColorMatrixDaylight;
        }

        const std::string &getManufacturer() {return manufacturer;}
        const std::string &getModel() {return model;}

        FCam::Frame::Ptr getFrame();
        Frame::Ptr getF2Frame();

        void debugTiming(bool);

      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();

        // the color matrices for this sensor
        static float XYZToRawColorMatrixDaylight[];
        static float XYZToRawColorMatrixTungsten[];

        static std::string manufacturer;
        static std::string model;  

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


#endif

---