F2/Sensor.cpp

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

#include "linux/mt9p031.h"

namespace FCam { namespace F2 {


    Sensor::Sensor() : FCam::Sensor(), shotsPending_(0) {
    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 &s) {
    Shot F2s(s);
    F2s.id = s.id;
    capture(F2s);
    }

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

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

    // Connect the base Frame class Shot pointer to where it should go
    f->request = static_cast<FCam::Shot *>(f->f2Request);

    // clone the shot ID
    f->f2Request->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<Shot> F2Burst;
    F2Burst.reserve(burst.size());
    for (unsigned int i=0; i < burst.size(); i++ ) {
        F2Burst.push_back(Shot(burst[i])); // Does this make an unneccessary copy?
        F2Burst[i].id = burst[i].id;
    }
    capture(F2Burst);
    }
    
    void Sensor::capture(const std::vector<Shot> &burst) {
    std::vector<Frame *> frames;

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

        // clone the shot ID
        f->f2Request->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 &s) {
    Shot F2s(s);
    F2s.id = s.id;
    stream(F2s);
    }

    void Sensor::stream(const 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) {
    std::vector<Shot> F2Burst;
    F2Burst.reserve(burst.size());
    for (unsigned int i=0; i < burst.size(); i++ ) {
        F2Burst.push_back(Shot(burst[i])); // Does this make an unneccessary copy?
        F2Burst[i].id = burst[i].id;
    }
    stream(F2Burst);
    }

    void Sensor::stream(const std::vector<Shot> &burst) {
    pthread_mutex_lock(&requestMutex);
    // do a deep copy of the burst

    streamingShot.clear();
    streamingShot.reserve(burst.size());
    // Now to copy the IDs
    for (unsigned int i=0; i<burst.size(); i++) {
        streamingShot.push_back(burst[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);
    }

    FCam::Frame::Ptr Sensor::getFrame() {
    FCam::Frame *f = static_cast<FCam::Frame *>(daemon.getNextFrame());
    for (size_t i=0; i< devices.size(); i++) {
        devices[i]->tagFrame(f);
    }
    f->sensor = this;
    FCam::Frame::Ptr fp(f);
    shotsPending_--;
    return fp;
    }
    
    Frame::Ptr Sensor::getF2Frame() {
    Frame *f = daemon.getNextFrame();
    for (size_t i=0; i< devices.size(); i++) {
        devices[i]->tagFrame(f);
    }
    f->sensor = this;
    Frame::Ptr fp(f);
    return fp;
    }
    
    Size Sensor::minImageSize() const {
    return Size(640, 480);
    } 
    Size Sensor::maxImageSize() const {
    return Size(MT9P031_ACTIVE_WIDTH, MT9P031_ACTIVE_HEIGHT);
    }
    Size Sensor::pixelArraySize() {
    return Size(MT9P031_ARRAY_WIDTH, MT9P031_ARRAY_HEIGHT);
    }
    
    Rect Sensor::activeArrayRect() {
    return Rect(0,0, 
            MT9P031_ACTIVE_WIDTH, MT9P031_ACTIVE_HEIGHT);
    }   
    Rect Sensor::pixelArrayRect() {
    return Rect(MT9P031_MIN_COL, 
            MT9P031_MIN_ROW, 
            MT9P031_ARRAY_WIDTH, 
            MT9P031_ARRAY_HEIGHT);
    } 
    
    int Sensor::getRollingShutterTime(const Shot &s) const {
    // TODO: put better numbers here
    if (s.image.size.height > 960) return 77000;
    else return 33000;
    }

    int Sensor::getRollingShutterTime(const FCam::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_;
    }

    void Sensor::debugTiming(bool enable) {
    daemon.debugTiming(enable);
    }

    // TODO: this was just copied over the N900
    float Sensor::XYZToRawColorMatrixTungsten[] = {
    3.8135, -2.1259, -0.6033,
    0.5792,  0.6603, -0.2288,
    0.4120,  0.0049,  0.1688
    };

    // TODO: This hasn't been validated.
    float Sensor::XYZToRawColorMatrixDaylight[] = {
     0.9811, -0.0465, -0.2289,
    -1.2482,  1.9812,  0.1418,
    -0.7267,  0.8387,  0.6373
    };

    std::string Sensor::manufacturer = "Stanford University";
    std::string Sensor::model = "Aptina MT9P031 - F2 Frankencamera";

}}

---