Port.hpp

Go to the documentation of this file.

#pragma once
#include <common.hpp>
#include <engine/Light.hpp>
 
 
namespace rack {
namespace engine {
 

static const int PORT_MAX_CHANNELS = 16;
 
 
struct Port {
    union {
        float voltages[PORT_MAX_CHANNELS] = {};
        float value;
    };
    union {
        uint8_t channels = 0;
        uint8_t active;
    };
    Light plugLights[3];
 
    enum Type {
        INPUT,
        OUTPUT,
    };

    void setVoltage(float voltage, uint8_t channel = 0) {
        voltages[channel] = voltage;
    }

    float getVoltage(uint8_t channel = 0) {
        return voltages[channel];
    }

    float getPolyVoltage(uint8_t channel) {
        return isMonophonic() ? getVoltage(0) : getVoltage(channel);
    }

    float getNormalVoltage(float normalVoltage, uint8_t channel = 0) {
        return isConnected() ? getVoltage(channel) : normalVoltage;
    }
 
    float getNormalPolyVoltage(float normalVoltage, uint8_t channel) {
        return isConnected() ? getPolyVoltage(channel) : normalVoltage;
    }

    float* getVoltages(uint8_t firstChannel = 0) {
        return &voltages[firstChannel];
    }

    void readVoltages(float* v) {
        for (uint8_t c = 0; c < channels; c++) {
            v[c] = voltages[c];
        }
    }

    void writeVoltages(const float* v) {
        for (uint8_t c = 0; c < channels; c++) {
            voltages[c] = v[c];
        }
    }

    void clearVoltages() {
        for (uint8_t c = 0; c < channels; c++) {
            voltages[c] = 0.f;
        }
    }

    float getVoltageSum() {
        float sum = 0.f;
        for (uint8_t c = 0; c < channels; c++) {
            sum += voltages[c];
        }
        return sum;
    }

    float getVoltageRMS() {
        if (channels == 0) {
            return 0.f;
        }
        else if (channels == 1) {
            return std::fabs(voltages[0]);
        }
        else {
            float sum = 0.f;
            for (uint8_t c = 0; c < channels; c++) {
                sum += std::pow(voltages[c], 2);
            }
            return std::sqrt(sum);
        }
    }
 
    template <typename T>
    T getVoltageSimd(uint8_t firstChannel) {
        return T::load(&voltages[firstChannel]);
    }
 
    template <typename T>
    T getPolyVoltageSimd(uint8_t firstChannel) {
        return isMonophonic() ? getVoltage(0) : getVoltageSimd<T>(firstChannel);
    }
 
    template <typename T>
    T getNormalVoltageSimd(T normalVoltage, uint8_t firstChannel) {
        return isConnected() ? getVoltageSimd<T>(firstChannel) : normalVoltage;
    }
 
    template <typename T>
    T getNormalPolyVoltageSimd(T normalVoltage, uint8_t firstChannel) {
        return isConnected() ? getPolyVoltageSimd<T>(firstChannel) : normalVoltage;
    }
 
    template <typename T>
    void setVoltageSimd(T voltage, uint8_t firstChannel) {
        voltage.store(&voltages[firstChannel]);
    }

    void setChannels(uint8_t channels) {
        // If disconnected, keep the number of channels at 0.
        if (this->channels == 0) {
            return;
        }
        // Set higher channel voltages to 0
        for (uint8_t c = channels; c < this->channels; c++) {
            voltages[c] = 0.f;
        }
        // Don't allow caller to set port as disconnected
        if (channels == 0) {
            channels = 1;
        }
        this->channels = channels;
    }

    int getChannels() {
        return channels;
    }

    bool isConnected() {
        return channels > 0;
    }

    bool isMonophonic() {
        return channels == 1;
    }

    bool isPolyphonic() {
        return channels > 1;
    }

    DEPRECATED float normalize(float normalVoltage) {
        return getNormalVoltage(normalVoltage);
    }
};
 
 
struct Output : Port {};
 
struct Input : Port {};
 
 
} // namespace engine
} // namespace rack