N900/Daemon.h

#ifndef FCAM_N900_DAEMON_H
#define FCAM_N900_DAEMON_H

#include <queue>
#include <pthread.h>
#include <semaphore.h>
#include "../Frame.h"
#include "V4L2Sensor.h"
#include "../Sensor.h"
#include "Frame.h"

namespace FCam { 
    namespace N900 {

    // The daemon acts as a layer over /dev/video0. It accepts frame
    // requests and returns frames that (hopefully) meet those requests.
    class Daemon {
      public:
        // A class for actions slaved to a frame
        class Action {
          public:
        // When should this action run?
        // The run-time will set this value when it knows when the
        // start of the associated exposure is
        Time time;
        FCam::Action *action;
        
        bool operator<(const Action &other) const {
            // I'm lower priority than another action if I occur later
            return time > other.time;
        }
        
        bool operator>(const Action &other) const {
            // I'm higher priority than another action if I occur earlier
            return time < other.time;
        }
        };
        
        
        Daemon();
        ~Daemon();
        
        class RequestGenerator {
          public:
        virtual void generateRequest() = 0;
        };
        
        void setRequestGenerator(RequestGenerator *gen);
        RequestGenerator *getRequestGenerator();

        int requestFrame(Frame *);

        // enforce a drop policy on the frame queue
        void setDropPolicy(Sensor::DropPolicy p, int f);

        Frame *getNextFrame();
        int framesPending() const {return frameQueue.size();}

      private:

        // Access to the V4L2 layer of the sensor
        V4L2Sensor *sensor;

        bool stop;

        // The user-space puts requests on this queue. It is consumed by
        // the setter thread.
        std::queue<Frame *> requestQueue;
        pthread_mutex_t requestQueueMutex;

        // If the request queue is empty, the daemon can try calling this
        // guy to put more stuff in it
        RequestGenerator *generator;

        // The handler thread puts frames on this queue. It is consumed by
        // user-space
        std::queue<Frame *> frameQueue;
        pthread_mutex_t frameQueueMutex;
        sem_t frameQueueSemaphore;
        // The frameQueue may not grow beyond this limit
        size_t frameLimit;
        // What should I do if the frame policy tries to grow beyond the limit
        Sensor::DropPolicy dropPolicy;
        void enforceDropPolicy();   

        // The setter thread puts in flight requests on this queue, which
        // is consumed by the handler thread
        std::queue<Frame *> inFlightQueue;
        pthread_mutex_t inFlightQueueMutex;

        // Sometimes the setter needs to access the camera exclusively
        // (e.g. to do a pipeline flush). This mutex and flag are used for
        // coordinating such things.
        pthread_mutex_t cameraMutex;
        // The setter thread requests a pipeline flush by setting this
        // flag high and waiting on the above mutex.
        bool pipelineFlush;

        // The setter thread also queues up RT actions on this priority
        // queue, which is consumed by the actions thread
        std::priority_queue<Action> actionQueue;
        pthread_mutex_t actionQueueMutex;
        sem_t actionQueueSemaphore;

        void launchThreads();

        // The component of the daemon that sets exposure and gain
        void runSetter();   
        pthread_t setterThread;
        void tickSetter(Time hs_vs);
        bool setterRunning;
        // The current state of the camera
        Frame current;

        // The component that handles frames returned by V4L2
        void runHandler();
        pthread_t handlerThread;
        bool handlerRunning;

        // The component that executes RT actions
        void runAction();
        pthread_t actionThread;
        bool actionRunning;

        int daemon_fd;

        bool waitingForFirstRequest;

        friend void *daemon_setter_thread_(void *arg);
        friend void *daemon_handler_thread_(void *arg);
        friend void *daemon_action_thread_(void *arg);
    };

    }
}

#endif

---