src/F2/Sensor.cpp

#include <pthread.h>

#include "FCam/Action.h"
#include "FCam/F2/Sensor.h"

#include "FCam/F2/Platform.h"
#include "Daemon.h"
#include "linux/mt9p031.h"
#include "../Debug.h"



namespace FCam {
namespace F2 {


Sensor::Sensor() : FCam::Sensor(), daemon(NULL), shotsPending_(0) {
    pthread_mutex_init(&requestMutex, NULL);
}

Sensor::~Sensor() {
    stop();
    pthread_mutex_destroy(&requestMutex);
}

void Sensor::start() {
    if (daemon) { return; }
    daemon = new Daemon(this);
    daemon->launchThreads();
}

void Sensor::stop() {
    if (!daemon) { return; }
    delete daemon;
    daemon = NULL;
}

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

void Sensor::capture(const Shot &shot) {
    start();

    // Construct initial fields of \ref F2::_Frame
    _Frame *f = new _Frame;
    f->_shot = shot;        // make a deep copy here as well
    f->_shot.id = shot.id;

    // push the frame to the daemon
    pthread_mutex_lock(&requestMutex);
    shotsPending_++;
    daemon->requestQueue.push(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) {
    start();

    std::vector<_Frame *> frames;

    for (size_t i = 0; i < burst.size(); i++) {

        // Construct initial fields of \ref F2::_Frame
        _Frame *f = new _Frame;
        f->_shot = burst[i];        // make a deep copy here as well
        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);
}

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

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

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 = burst;

    // Now to copy the IDs
    for (unsigned int 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() {
    pthread_mutex_lock(&requestMutex);
    streamingShot.clear();
    pthread_mutex_unlock(&requestMutex);
}

FCam::F2::Frame Sensor::getFrame() {
    // TODO: How should we handle getFrame when the sensor is stopped?
    start();

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

    Frame frame(_f);
    FCam::Sensor::tagFrame(frame);
    for (size_t i=0; i< devices.size(); i++) {
        devices[i]->tagFrame(frame);
    }
    pthread_mutex_lock(&requestMutex);
    shotsPending_--;
    pthread_mutex_unlock(&requestMutex);

    return frame;
}


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::rollingShutterTime(const Shot &s) const {
    // TODO: put better numbers here
    if (s.image.height() > 960) { return 77000; }
    else { return 33000; }
}

int Sensor::rollingShutterTime(const FCam::Shot &s) const {
    // TODO: put better numbers here
    if (s.image.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() {
    pthread_mutex_lock(&requestMutex);
    if (streamingShot.size()) {
        std::vector<_Frame *> frames;

        for (size_t i = 0; i < streamingShot.size(); i++) {

            // Construct initial sections of F2::_Frame
            _Frame *f = new _Frame;
            f->_shot = streamingShot[i];        // make a deep copy here as well
            f->_shot.id = streamingShot[i].id;

            frames.push_back(f);
        }

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

void Sensor::enforceDropPolicy() {
    if (!daemon) { return; }
    daemon->setDropPolicy(dropPolicy, frameLimit);
}

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

int Sensor::shotsPending() const {
    if (!daemon) { return 0; }
    return shotsPending_;
}

void Sensor::debugTiming(bool enable) {
    start();
    daemon->debugTiming(enable);
}

}
}