istream.h

Go to the documentation of this file.

#pragma once

#include "GRT/GRT.h"
#include "ofMain.h"
#include "ofxNetwork.h"
#include "ofxOsc.h"
#include "stream.h"

#include <cstdint>

// See more documentation:
// http://openframeworks.cc/documentation/sound/ofSoundStream/#show_setup
const uint32_t kOfSoundStream_SamplingRate = 44100;
const uint32_t kOfSoundStream_BufferSize = 256;
const uint32_t kOfSoundStream_nBuffers = 4;

class InputStream : public virtual Stream {
  public:
    InputStream();
    virtual ~InputStream() = default;

    virtual int getNumInputDimensions() = 0;
    virtual int getNumOutputDimensions() {
        vector<double> input(getNumInputDimensions(), 1.0);
        vector<double> output = normalize(input);
        return output.size();
    }

    using normalizeFunc = std::function<double(double)>;
    using vectorNormalizeFunc = std::function<vector<double>(vector<double>)>;

    // Supply a normalization function: double -> double.
    // Applied to each dimension of each vector of incoming data.
    void useNormalizer(normalizeFunc f) {
        normalizer_ = f;
        vectorNormalizer_ = nullptr;
    }

    // Supply a normalization function: vector<double> -> vector<double>
    // Applied to each vector of incoming data.
    void useNormalizer(vectorNormalizeFunc f) {
        normalizer_ = nullptr;
        vectorNormalizer_ = f;
    }

    typedef std::function<void(GRT::MatrixDouble)> onDataReadyCallback;

    void onDataReadyEvent(onDataReadyCallback callback) {
        data_ready_callback_ = callback;
    }

    template<typename T1, typename arg, class T>
    void onDataReadyEvent(T1* owner, void (T::*listenerMethod)(arg)) {
        using namespace std::placeholders;
        data_ready_callback_ = std::bind(listenerMethod, owner, _1);
    }

    // Set labels on all input dimension. This function takes either a vector of
    // strings, or an initialization list (such as {"left", "right"}).
    void setLabelsForAllDimensions(const vector<string> labels);
    void setLabelsForAllDimensions(std::initializer_list<string> list);

    const vector<string>& getLabels() const;

  protected:
    vector<string> InputStream_labels_;
    onDataReadyCallback data_ready_callback_;
    normalizeFunc normalizer_;
    vectorNormalizeFunc vectorNormalizer_;

    vector<double> normalize(vector<double>);
};

class AudioStream : public ofBaseApp, public InputStream {
  public:
    AudioStream(uint32_t downsample_rate = 1);
    void audioIn(float *input, int buffer_size, int nChannel);
    virtual bool start() final;
    virtual void stop() final;
    virtual int getNumInputDimensions() final;
  private:
    uint32_t downsample_rate_;
    unique_ptr<ofSoundStream> sound_stream_;
    bool setup_successful_;
};

class AudioFileStream : public InputStream {
  public:
    AudioFileStream(char *file, bool loop = false);
    virtual bool start() final;
    virtual void stop() final;
    virtual int getNumInputDimensions() final;
  private:
    void readSpectrum();

    ofSoundPlayer player_;
    unique_ptr<std::thread> update_thread_;
};

class BaseSerialInputStream : public virtual InputStream {
  public:
    BaseSerialInputStream(uint32_t usb_port_num, uint32_t baud, int numDimensions);

    BaseSerialInputStream(uint32_t baud, int numDimensions);

    virtual bool start() final;
    virtual void stop() final;
    virtual int getNumInputDimensions() final;

    vector<string> getSerialDeviceList() {
        serial_->listDevices();
        vector<string> retval;
        vector<ofSerialDeviceInfo> device_list = serial_->getDeviceList();
        retval.reserve(device_list.size());
        for (auto& d : device_list) {
            retval.push_back(d.getDevicePath());
        }
        return retval;
    }

    bool selectSerialDevice(uint32_t port) {
        assert(has_started_ == false
               && "Should only reach here if ASCIISerialStream hasn't started");

        port_ = port;
        if (!serial_->setup(port_, baud_)) {
            return false;
        }

        reading_thread_.reset(new std::thread(&BaseSerialInputStream::readSerial, this));
        has_started_ = true;
        return true;
    }

  protected:
    virtual void parseSerial(vector<unsigned char> &buffer) = 0;
    unique_ptr<ofSerial> serial_;

  private:
    uint32_t port_ = -1;
    uint32_t baud_;
    int dimensions_;

    vector<unsigned char> buffer_;

    // A separate reading thread to read data from Serial.
    unique_ptr<std::thread> reading_thread_;
    void readSerial();
};

class SerialStream : public InputStream {
  public:
    SerialStream(uint32_t usb_port_num, uint32_t baud);
    virtual bool start() final;
    virtual void stop() final;
    virtual int getNumInputDimensions() final;
  private:
    uint32_t port_ = -1;
    uint32_t baud_;
    // Serial buffer size
    uint32_t kBufferSize_ = 64;

    unique_ptr<ofSerial> serial_;

    // A separate reading thread to read data from Serial.
    unique_ptr<std::thread> reading_thread_;
    void readSerial();
};

class FirmataStream : public InputStream {
  public:
    FirmataStream(uint32_t port);
    virtual bool start() final;
    virtual void stop() final;
    virtual int getNumInputDimensions() final;

    void useAnalogPin(int i);
  private:
    uint32_t port_;

    vector<int> pins_;

    bool configured_arduino_;

    ofArduino arduino_;
    unique_ptr<std::thread> update_thread_;
    void update();
};

// Forward declaration.
class ofxTCPServer;

class TcpInputStream : public InputStream {
  public:
    TcpInputStream(int port_num, int dimension)
        : port_num_(port_num), dim_(dimension) {
    }

    virtual bool start() final;
    virtual void stop() final;
    virtual int getNumInputDimensions() final;

  private:
    void parseInput(const string& buffer);
    ofxTCPServer server_;
    unique_ptr<std::thread> reading_thread_;
    int port_num_;
    int dim_;
};

class OscInputStream : public InputStream {
  public:
    OscInputStream(int port_num, string addr, int dimension)
        : port_num_(port_num), addr_(addr), dim_(dimension) {
    }

    void handleMessage(ofxOscMessage& m);
    virtual bool start() final;
    virtual void stop() final;
    virtual int getNumInputDimensions() final;

  private:
    void parseInput(const string& buffer);
    ofxOscReceiver receiver_;
    unique_ptr<std::thread> reading_thread_;
    int port_num_;
    string addr_;
    int dim_;
};