N900/Sensor.cpp

#include "Sensor.h"
#include "ButtonListener.h"
#include "../Action.h"
#include <pthread.h>

namespace FCam { namespace N900 {

    Sensor::Sensor() : FCam::Sensor(), shotsPending_(0) {
    // make sure the N900 button listener is running

    // TODO: put this somewhere better?
    ButtonListener::instance();

    pthread_mutex_init(&requestMutex, NULL);

    }

    Sensor::~Sensor() {
    pthread_mutex_lock(&requestMutex);
    daemon.setRequestGenerator(NULL);
    pthread_mutex_unlock(&requestMutex);
    pthread_mutex_destroy(&requestMutex);
    }

    void Sensor::capture(const FCam::Shot &shot) {
    Frame *f = new Frame;

    // make a deep copy of the shot to attach to the request
    f->request = new FCam::Shot(shot);

    // clone the shot ID
    f->request->id = shot.id;

    // push the frame to the daemon
    pthread_mutex_lock(&requestMutex);
    shotsPending_++;
    daemon.requestFrame(f);
    pthread_mutex_unlock(&requestMutex);
    }

    void Sensor::capture(const std::vector<FCam::Shot> &burst) {
    std::vector<Frame *> frames;

    for (size_t i = 0; i < burst.size(); i++) {
        Frame *f = new Frame;
        f->request = new FCam::Shot(burst[i]);

        // clone the shot ID
        f->request->id = burst[i].id;

        frames.push_back(f);
    }

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

    void Sensor::stream(const FCam::Shot &shot) {
    pthread_mutex_lock(&requestMutex);
    streamingShot.clear();
    // this makes a deep copy of the shot
    streamingShot.push_back(shot);
    streamingShot[0].id = shot.id;
    pthread_mutex_unlock(&requestMutex);
    daemon.setRequestGenerator(this);
    }
    
    void Sensor::stream(const std::vector<FCam::Shot> &burst) {
    pthread_mutex_lock(&requestMutex);

    // do a deep copy of the burst
    streamingShot = burst;

    // clone the ids
    for (size_t i = 0; i < burst.size(); i++) {
        streamingShot[i].id = burst[i].id;
    }
    pthread_mutex_unlock(&requestMutex);
    daemon.setRequestGenerator(this);
    }

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

    void Sensor::stopStreaming() {
    pthread_mutex_lock(&requestMutex);
    streamingShot.clear();
    pthread_mutex_unlock(&requestMutex);
    }

    Frame::Ptr Sensor::getFrame() {
    Frame *f = daemon.getNextFrame();
    for (size_t i = 0; i < devices.size(); i++) {
        devices[i]->tagFrame(f);
    }
    f->sensor = this;
    Frame::Ptr fp(f);   
    shotsPending_--;
    return fp; 
    }
    
    int Sensor::getRollingShutterTime(const Shot &s) const {
    // TODO: put better numbers here
    if (s.image.size.height > 960) return 77000;
    else return 33000;
    }

    // the Daemon calls this when it's time for new frames to be queued up
    void Sensor::generateRequest() {
    if (streamingShot.size()) {
        capture(streamingShot);
    }
    }

    void Sensor::enforceDropPolicy() {
    daemon.setDropPolicy(dropPolicy, frameLimit);
    }

    int Sensor::framesPending() const {
    return daemon.framesPending();
    }

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

    /*
    float Sensor::XYZToRawColorMatrix[] = {
    
    1.3708f, -0.5471f, -0.2924f,
    0.0559f,  0.9656f, -0.0261f,
    0.3684f, -0.0236f,  0.6594f
    };
    */

    float Sensor::XYZToRawColorMatrixTungsten[] = {
    3.8135, -2.1259, -0.6033,
    0.5792,  0.6603, -0.2288,
    0.4120,  0.0049,  0.1688
    };

    float Sensor::XYZToRawColorMatrixDaylight[] = {
    1.3577, -0.5369, -0.2804,
    0.0001,  0.9539, -0.0027,
    0.4495, -0.0253,  0.7017
    };

    std::string Sensor::manufacturer = "Nokia";
    std::string Sensor::model = "Nokia N900";


}}

---