src/Dummy/Sensor.cpp

#include <pthread.h>
#include <semaphore.h>
#include <time.h>

#include <FCam/Event.h>
#include <FCam/Action.h>
#include <FCam/Dummy/Sensor.h>

#include "Daemon.h"
#include "Platform.h"
#include "../Debug.h"


namespace FCam { namespace Dummy {

    Sensor::Sensor(): FCam::Sensor(), daemon(NULL), shotsPending_(0) {
        dprintf(DBG_MINOR, "Initializing dummy simulator sensor.\n");
        pthread_mutex_init(&requestMutex, NULL);
    }

    Sensor::~Sensor() {
        dprintf(DBG_MINOR, "Destroying dummy simulator sensor.\n");
        stop();
        pthread_mutex_destroy(&requestMutex);
    }

    void Sensor::capture(const FCam::Shot &s) {
        Shot dummyShot(s);
        dummyShot.id = s.id;
        capture(dummyShot);
    }

    void Sensor::capture(const Shot &shot) {
        dprintf(DBG_MINOR, "Queuing capture request.\n");
        start();

        _Frame *f = new _Frame;
        f->_shot = shot;
        f->_shot.id = shot.id;

        pthread_mutex_lock(&requestMutex);
        shotsPending_++;
        daemon->requestQueue.push(f);
        pthread_mutex_unlock(&requestMutex);

        daemon->launchThreads();
    }

    void Sensor::capture(const std::vector<FCam::Shot> &burst) {
        std::vector<Shot> dummyBurst;
        dummyBurst.reserve(burst.size());
        for (unsigned int i=0; i < burst.size(); i++ ) {
            dummyBurst.push_back(Shot(burst[i]));
            dummyBurst[i].id = burst[i].id;
        }
        capture(dummyBurst);
    }

    void Sensor::capture(const std::vector<Shot> &burst) {
        dprintf(DBG_MINOR, "Queuing capture request burst.\n");
        start();

        std::vector<_Frame *> frames;

        for (size_t i=0; i < burst.size(); i++) {
            _Frame *f = new _Frame;
            f->_shot = burst[i];
            f->_shot.id = burst[i].id;

            frames.push_back(f);
        }

        pthread_mutex_lock(&requestMutex);
        for (size_t i=0; i < frames.size(); i++) {
            shotsPending_++;
            daemon->requestQueue.push(frames[i]);
        }
        pthread_mutex_unlock(&requestMutex);

        daemon->launchThreads();
    }

    void Sensor::stream(const FCam::Shot &s) {
        Shot dummyShot(s);
        dummyShot.id = s.id;
        stream(dummyShot);
    }

    void Sensor::stream(const Shot &shot) {
        dprintf(DBG_MINOR, "Configuring streaming shot.\n");
        pthread_mutex_lock(&requestMutex);
        streamingShot.clear();
        streamingShot.push_back(shot);
        streamingShot[0].id = shot.id;
        pthread_mutex_unlock(&requestMutex);

        start();
        if (daemon->requestQueue.size() == 0) capture(streamingShot);
    }

    void Sensor::stream(const std::vector<FCam::Shot> &burst) {
        std::vector<Shot> dummyBurst;
        dummyBurst.reserve(burst.size());
        for (unsigned int i=0; i < burst.size(); i++ ) {
            dummyBurst.push_back(burst[i]);
            dummyBurst[i].id = burst[i].id;
        }
        stream(dummyBurst);
    }

    void Sensor::stream(const std::vector<Shot> &burst) {
        dprintf(DBG_MINOR, "Configuring streaming burst.\n");
        pthread_mutex_lock(&requestMutex);
        streamingShot = burst;
        for (size_t i=0; i < burst.size(); i++) {
            streamingShot[i].id = burst[i].id;
        }
        pthread_mutex_unlock(&requestMutex);

        start();
        if (daemon->requestQueue.size() == 0) capture(streamingShot);
    }

    bool Sensor::streaming() {
        return streamingShot.size() > 0;
    }

    void Sensor::stopStreaming() {
        dprintf(DBG_MINOR, "Stopping streaming.\n");
        pthread_mutex_lock(&requestMutex);
        streamingShot.clear();
        pthread_mutex_unlock(&requestMutex);
    }

    void Sensor::start() {
        dprintf(4, "Creating and launching daemon.\n");
        if (daemon) return;
        daemon = new Daemon(this);
        if (streamingShot.size()) daemon->launchThreads();
        dprintf(4, "Daemon created.\n");
    }

    void Sensor::stop() {
        dprintf(4, "Destroying daemon.\n");
        if (!daemon) return;
        delete daemon;
        daemon = NULL;
    }

    FCam::Dummy::Frame Sensor::getFrame() {
        dprintf(DBG_MINOR, "Getting a frame.\n");
        if (!daemon) {
            Frame invalid;
            error(Event::SensorStoppedError, this, "Can't request frame before calling capture or stream\n");
            return invalid;
        }

        _Frame *_f;
        _f = daemon->frameQueue.pull();

        Frame frame(_f);

        shotsPending_--;

        dprintf(DBG_MINOR, "Frame received.\n");
        return frame;
    }

    int Sensor::rollingShutterTime(const FCam::Shot &s) const {
        return 0;
    }
    
    void Sensor::generateRequest() {
        dprintf(4, "GenerateRequest called by daemon.\n");
        pthread_mutex_lock(&requestMutex);
        if (streamingShot.size() ) {
            for (size_t i = 0; i < streamingShot.size(); i++) {
                _Frame *f = new _Frame;
                f->_shot = streamingShot[i];        
                f->_shot.id = streamingShot[i].id;                
                shotsPending_++;
                daemon->requestQueue.push(f);
            }
        }
        pthread_mutex_unlock(&requestMutex);
    }


    void Sensor::enforceDropPolicy() {
        
    }

    int Sensor::framesPending() const {
        if (!daemon) return 0;
        return daemon->frameQueue.size();
    }

    int Sensor::shotsPending() const {
        return shotsPending_;
    }

    unsigned short Sensor::minRawValue() const {return Platform::minRawValue;}
    unsigned short Sensor::maxRawValue() const {return Platform::maxRawValue;}
        
    BayerPattern Sensor::bayerPattern() const {return Platform::bayerPattern;}        

    const std::string &Sensor::manufacturer() const {return Platform::manufacturer;}

    const std::string &Sensor::model() const {return Platform::model;}        

    void Sensor::rawToRGBColorMatrix(int kelvin, float *matrix) const {
        // call the static platform implementation
        Platform::rawToRGBColorMatrix(kelvin, matrix);
    }

}}