Created
July 16, 2019 15:44
-
-
Save giuliomoro/f8b38bb53f81e63dfb69e292b611b43d to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* | |
* Default render file for Bela projects running Pd patches | |
* using libpd. | |
*/ | |
#include <Bela.h> | |
#include <DigitalChannelManager.h> | |
#include <cmath> | |
#include <stdio.h> | |
#define PD_THREADED_IO | |
#include <libpd/z_libpd.h> | |
extern "C" { | |
#include <libpd/s_stuff.h> | |
}; | |
#include <UdpServer.h> | |
#include <Midi.h> | |
#include <Scope.h> | |
#include <string> | |
#include <sstream> | |
#include <algorithm> | |
#include <stdlib.h> | |
#include <PulseIn.h> | |
enum { minFirstDigitalChannel = 10 }; | |
static unsigned int gAnalogChannelsInUse; | |
static unsigned int gDigitalChannelsInUse; | |
static unsigned int gScopeChannelsInUse = 4; | |
static unsigned int gLibpdBlockSize; | |
static unsigned int gChannelsInUse; | |
//static const unsigned int gFirstAudioChannel = 0; | |
static unsigned int gFirstAnalogInChannel; | |
static unsigned int gFirstAnalogOutChannel; | |
static unsigned int gFirstDigitalChannel; | |
static unsigned int gLibpdDigitalChannelOffset; | |
static unsigned int gFirstScopeChannel; | |
PulseIn pulseIn; | |
PulseIn pulseIn2; | |
Scope scope; | |
int gTriggerInterval = 1323; // how often to send out a trigger. 2646 samples are 60ms | |
int gMinPulseLength = 7; //to avoid spurious readings | |
float gRescale = 58; // taken from the datasheet | |
unsigned int gTriggerDigitalOutChannel = 0; //channel to be connected to the module's TRIGGER (digital) pin | |
unsigned int gTriggerDigitalOutChannel2 = 2; | |
unsigned int gEchoDigitalInPin = 1; //channel to be connected to the modules's ECHO pin (digital pin 1) - check the pin diagram in the IDE | |
unsigned int gEchoDigitalInPin2 = 3; | |
int gTriggerCount = 0; | |
int gTriggerCount2 = 0; | |
int gPrintfCount = 0; | |
int gPrintfCount2 = 0; | |
float* gScopeOut; | |
void* gPatch; | |
bool gDigitalEnabled = 0; | |
void Bela_userSettings(BelaInitSettings *settings) | |
{ | |
settings->uniformSampleRate = 1; | |
settings->interleave = 0; | |
settings->analogOutputsPersist = 0; | |
} | |
float* gInBuf; | |
float* gOutBuf; | |
#define PARSE_MIDI | |
static std::vector<Midi*> midi; | |
std::vector<std::string> gMidiPortNames; | |
void dumpMidi() | |
{ | |
if(midi.size() == 0) | |
{ | |
printf("No MIDI device enabled\n"); | |
return; | |
} | |
printf("The following MIDI devices are enabled:\n"); | |
printf("%4s%20s %3s %3s %s\n", | |
"Num", | |
"Name", | |
"In", | |
"Out", | |
"Pd channels" | |
); | |
for(unsigned int n = 0; n < midi.size(); ++n) | |
{ | |
printf("[%2d]%20s %3s %3s (%d-%d)\n", | |
n, | |
gMidiPortNames[n].c_str(), | |
midi[n]->isInputEnabled() ? "x" : "_", | |
midi[n]->isOutputEnabled() ? "x" : "_", | |
n * 16, | |
n * 16 + 15 | |
); | |
} | |
} | |
Midi* openMidiDevice(std::string name, bool verboseSuccess = false, bool verboseError = false) | |
{ | |
Midi* newMidi; | |
newMidi = new Midi(); | |
newMidi->readFrom(name.c_str()); | |
newMidi->writeTo(name.c_str()); | |
#ifdef PARSE_MIDI | |
newMidi->enableParser(true); | |
#else | |
newMidi->enableParser(false); | |
#endif /* PARSE_MIDI */ | |
if(newMidi->isOutputEnabled()) | |
{ | |
if(verboseSuccess) | |
printf("Opened MIDI device %s as output\n", name.c_str()); | |
} | |
if(newMidi->isInputEnabled()) | |
{ | |
if(verboseSuccess) | |
printf("Opened MIDI device %s as input\n", name.c_str()); | |
} | |
if(!newMidi->isInputEnabled() && !newMidi->isOutputEnabled()) | |
{ | |
if(verboseError) | |
fprintf(stderr, "Failed to open MIDI device %s\n", name.c_str()); | |
return nullptr; | |
} else { | |
return newMidi; | |
} | |
} | |
static unsigned int getPortChannel(int* channel){ | |
unsigned int port = 0; | |
while(*channel > 16){ | |
*channel -= 16; | |
port += 1; | |
} | |
return port; | |
} | |
void Bela_MidiOutNoteOn(int channel, int pitch, int velocity) { | |
int port = getPortChannel(&channel); | |
rt_printf("noteout _ port: %d, channel: %d, pitch: %d, velocity %d\n", port, channel, pitch, velocity); | |
port < midi.size() && midi[port]->writeNoteOn(channel, pitch, velocity); | |
} | |
void Bela_MidiOutControlChange(int channel, int controller, int value) { | |
int port = getPortChannel(&channel); | |
rt_printf("ctlout _ port: %d, channel: %d, controller: %d, value: %d\n", port, channel, controller, value); | |
port < midi.size() && midi[port]->writeControlChange(channel, controller, value); | |
} | |
void Bela_MidiOutProgramChange(int channel, int program) { | |
int port = getPortChannel(&channel); | |
rt_printf("pgmout _ port: %d, channel: %d, program: %d\n", port, channel, program); | |
port < midi.size() && midi[port]->writeProgramChange(channel, program); | |
} | |
void Bela_MidiOutPitchBend(int channel, int value) { | |
int port = getPortChannel(&channel); | |
rt_printf("bendout _ port: %d, channel: %d, value: %d\n", port, channel, value); | |
port < midi.size() && midi[port]->writePitchBend(channel, value); | |
} | |
void Bela_MidiOutAftertouch(int channel, int pressure){ | |
int port = getPortChannel(&channel); | |
rt_printf("touchout _ port: %d, channel: %d, pressure: %d\n", port, channel, pressure); | |
port < midi.size() && midi[port]->writeChannelPressure(channel, pressure); | |
} | |
void Bela_MidiOutPolyAftertouch(int channel, int pitch, int pressure){ | |
int port = getPortChannel(&channel); | |
rt_printf("polytouchout _ port: %d, channel: %d, pitch: %d, pressure: %d\n", port, channel, pitch, pressure); | |
port < midi.size() && midi[port]->writePolyphonicKeyPressure(channel, pitch, pressure); | |
} | |
void Bela_MidiOutByte(int port, int byte){ | |
rt_printf("port: %d, byte: %d\n", port, byte); | |
if(port > (int)midi.size()){ | |
// if the port is out of range, redirect to the first port. | |
rt_fprintf(stderr, "Port out of range, using port 0 instead\n"); | |
port = 0; | |
} | |
port < midi.size() && midi[port]->writeOutput(byte); | |
} | |
void Bela_printHook(const char *received){ | |
rt_printf("%s", received); | |
} | |
static DigitalChannelManager dcm; | |
void sendDigitalMessage(bool state, unsigned int delay, void* receiverName){ | |
libpd_float((const char*)receiverName, (float)state); | |
// rt_printf("%s: %d\n", (char*)receiverName, state); | |
} | |
void Bela_messageHook(const char *source, const char *symbol, int argc, t_atom *argv){ | |
if(strcmp(source, "bela_setMidi") == 0){ | |
int num[3] = {0, 0, 0}; | |
for(int n = 0; n < argc && n < 3; ++n) | |
{ | |
if(!libpd_is_float(&argv[n])) | |
{ | |
fprintf(stderr, "Wrong format for Bela_setMidi, expected:[hw 1 0 0("); | |
return; | |
} | |
num[n] = libpd_get_float(&argv[n]); | |
} | |
std::ostringstream deviceName; | |
deviceName << symbol << ":" << num[0] << "," << num[1] << "," << num[2]; | |
printf("Adding Midi device: %s\n", deviceName.str().c_str()); | |
Midi* newMidi = openMidiDevice(deviceName.str(), false, true); | |
if(newMidi) | |
{ | |
midi.push_back(newMidi); | |
gMidiPortNames.push_back(deviceName.str()); | |
} | |
dumpMidi(); | |
return; | |
} | |
if(strcmp(source, "bela_setDigital") == 0){ | |
// symbol is the direction, argv[0] is the channel, argv[1] (optional) | |
// is signal("sig" or "~") or message("message", default) rate | |
bool isMessageRate = true; // defaults to message rate | |
bool direction = 0; // initialize it just to avoid the compiler's warning | |
bool disable = false; | |
if(strcmp(symbol, "in") == 0){ | |
direction = INPUT; | |
} else if(strcmp(symbol, "out") == 0){ | |
direction = OUTPUT; | |
} else if(strcmp(symbol, "disable") == 0){ | |
disable = true; | |
} else { | |
return; | |
} | |
if(argc == 0){ | |
return; | |
} else if (libpd_is_float(&argv[0]) == false){ | |
return; | |
} | |
int channel = libpd_get_float(&argv[0]) - gLibpdDigitalChannelOffset; | |
if(disable == true){ | |
dcm.unmanage(channel); | |
return; | |
} | |
if(argc >= 2){ | |
t_atom* a = &argv[1]; | |
if(libpd_is_symbol(a)){ | |
char *s = libpd_get_symbol(a); | |
if(strcmp(s, "~") == 0 || strncmp(s, "sig", 3) == 0){ | |
isMessageRate = false; | |
} | |
} | |
} | |
dcm.manage(channel, direction, isMessageRate); | |
return; | |
} | |
} | |
void Bela_floatHook(const char *source, float value){ | |
// let's make this as optimized as possible for built-in digital Out parsing | |
// the built-in digital receivers are of the form "bela_digitalOutXX" where XX is between gLibpdDigitalChannelOffset and (gLibpdDigitalCHannelOffset+gDigitalChannelsInUse) | |
static int prefixLength = 15; // strlen("bela_digitalOut") | |
if(strncmp(source, "bela_digitalOut", prefixLength)==0){ | |
if(source[prefixLength] != 0){ //the two ifs are used instead of if(strlen(source) >= prefixLength+2) | |
if(source[prefixLength + 1] != 0){ | |
// quickly convert the suffix to integer, assuming they are numbers, avoiding to call atoi | |
int receiver = ((source[prefixLength] - 48) * 10); | |
receiver += (source[prefixLength+1] - 48); | |
unsigned int channel = receiver - gLibpdDigitalChannelOffset; // go back to the actual Bela digital channel number | |
if(channel < gDigitalChannelsInUse){ //number of digital channels | |
dcm.setValue(channel, value); | |
} | |
} | |
} | |
} | |
} | |
std::vector<std::string> gReceiverInputNames; | |
std::vector<std::string> gReceiverOutputNames; | |
void generateDigitalNames(unsigned int numDigitals, unsigned int libpdOffset, std::vector<std::string>& receiverInputNames, std::vector<std::string>& receiverOutputNames) | |
{ | |
std::string inBaseString = "bela_digitalIn"; | |
std::string outBaseString = "bela_digitalOut"; | |
for(unsigned int i = 0; i<numDigitals; i++) | |
{ | |
receiverInputNames.push_back(inBaseString + std::to_string(i+libpdOffset)); | |
receiverOutputNames.push_back(outBaseString + std::to_string(i+libpdOffset)); | |
} | |
} | |
void printDigitalNames(std::vector<std::string>& receiverInputNames, std::vector<std::string>& receiverOutputNames) | |
{ | |
printf("DIGITAL INPUTS\n"); | |
for(unsigned int i=0; i<gDigitalChannelsInUse; i++) | |
printf("%s\n", receiverInputNames[i].c_str()); | |
printf("DIGITAL OUTPUTS\n"); | |
for(unsigned int i=0; i<gDigitalChannelsInUse; i++) | |
printf("%s\n", receiverOutputNames[i].c_str()); | |
} | |
static char multiplexerArray[] = {"bela_multiplexer"}; | |
static int multiplexerArraySize = 0; | |
static bool pdMultiplexerActive = false; | |
#ifdef PD_THREADED_IO | |
void fdLoop(void* arg){ | |
while(!gShouldStop){ | |
sys_doio(); | |
usleep(3000); | |
} | |
} | |
#endif /* PD_THREADED_IO */ | |
bool setup(BelaContext *context, void *userData) | |
{ | |
// Set the mode of digital pins | |
pinMode(context, 0, gTriggerDigitalOutChannel, OUTPUT); //sending TRIGGER from digital out | |
pulseIn.init(context, gEchoDigitalInPin, HIGH); //detect HIGH pulses on this pin | |
pinMode(context, 0, gTriggerDigitalOutChannel2, OUTPUT); //sending TRIGGER from digital out | |
pulseIn2.init(context, gEchoDigitalInPin2, HIGH); //detect HIGH pulses on this pin | |
if(context->analogInChannels != 8){ | |
fprintf(stderr, "This project has to be run with 8 analog channels\n"); | |
return false; | |
} | |
// Check Pd's version | |
int major, minor, bugfix; | |
sys_getversion(&major, &minor, &bugfix); | |
printf("Running Pd %d.%d-%d\n", major, minor, bugfix); | |
// We requested in Bela_userSettings() to have uniform sampling rate for audio | |
// and analog and non-interleaved buffers. | |
// So let's check this actually happened | |
if(context->analogSampleRate != context->audioSampleRate) | |
{ | |
fprintf(stderr, "The sample rate of analog and audio must match. Try running with --uniform-sample-rate\n"); | |
return false; | |
} | |
if(context->flags & BELA_FLAG_INTERLEAVED) | |
{ | |
fprintf(stderr, "The audio and analog channels must be interleaved.\n"); | |
return false; | |
} | |
if(context->digitalFrames > 0 && context->digitalChannels > 0) | |
gDigitalEnabled = 1; | |
// add here other devices you need | |
gMidiPortNames.push_back("hw:1,0,0"); | |
//gMidiPortNames.push_back("hw:0,0,0"); | |
//gMidiPortNames.push_back("hw:1,0,1"); | |
scope.setup(2, 44100); | |
gScopeOut = new float[gScopeChannelsInUse]; | |
// Check first of all if the patch file exists. Will actually open it later. | |
char file[] = "_main.pd"; | |
char folder[] = "./"; | |
unsigned int strSize = strlen(file) + strlen(folder) + 1; | |
char* str = (char*)malloc(sizeof(char) * strSize); | |
snprintf(str, strSize, "%s%s", folder, file); | |
if(access(str, F_OK) == -1 ) { | |
printf("Error file %s/%s not found. The %s file should be your main patch.\n", folder, file, file); | |
return false; | |
} | |
free(str); | |
// analog setup | |
gAnalogChannelsInUse = context->analogInChannels; | |
gDigitalChannelsInUse = context->digitalChannels; | |
printf("Audio channels in use: %d\n", context->audioOutChannels); | |
printf("Analog channels in use: %d\n", gAnalogChannelsInUse); | |
printf("Digital channels in use: %d\n", gDigitalChannelsInUse); | |
// Channel distribution | |
gFirstAnalogInChannel = std::max(context->audioInChannels, context->audioOutChannels); | |
gFirstAnalogOutChannel = gFirstAnalogInChannel; | |
gFirstDigitalChannel = gFirstAnalogInChannel + std::max(context->analogInChannels, context->analogOutChannels); | |
if(gFirstDigitalChannel < minFirstDigitalChannel) | |
gFirstDigitalChannel = minFirstDigitalChannel; //for backwards compatibility | |
gLibpdDigitalChannelOffset = gFirstDigitalChannel + 1; | |
gFirstScopeChannel = gFirstDigitalChannel + gDigitalChannelsInUse; | |
gChannelsInUse = gFirstScopeChannel + gScopeChannelsInUse; | |
// Create receiverNames for digital channels | |
generateDigitalNames(gDigitalChannelsInUse, gLibpdDigitalChannelOffset, gReceiverInputNames, gReceiverOutputNames); | |
// digital setup | |
if(gDigitalEnabled) | |
{ | |
dcm.setCallback(sendDigitalMessage); | |
if(gDigitalChannelsInUse > 0){ | |
for(unsigned int ch = 0; ch < gDigitalChannelsInUse; ++ch){ | |
dcm.setCallbackArgument(ch, (void*) gReceiverInputNames[ch].c_str()); | |
} | |
} | |
} | |
unsigned int n = 0; | |
while(n < gMidiPortNames.size()) | |
{ | |
Midi* newMidi = openMidiDevice(gMidiPortNames[n], false, false); | |
if(newMidi) | |
{ | |
midi.push_back(newMidi); | |
++n; | |
} else { | |
gMidiPortNames.erase(gMidiPortNames.begin() + n); | |
} | |
} | |
dumpMidi(); | |
// check that we are not running with a blocksize smaller than gLibPdBlockSize | |
gLibpdBlockSize = libpd_blocksize(); | |
if(context->audioFrames < gLibpdBlockSize){ | |
fprintf(stderr, "Error: minimum block size must be %d\n", gLibpdBlockSize); | |
return false; | |
} | |
// set hooks before calling libpd_init | |
libpd_set_printhook(Bela_printHook); | |
libpd_set_floathook(Bela_floatHook); | |
libpd_set_messagehook(Bela_messageHook); | |
libpd_set_noteonhook(Bela_MidiOutNoteOn); | |
libpd_set_controlchangehook(Bela_MidiOutControlChange); | |
libpd_set_programchangehook(Bela_MidiOutProgramChange); | |
libpd_set_pitchbendhook(Bela_MidiOutPitchBend); | |
libpd_set_aftertouchhook(Bela_MidiOutAftertouch); | |
libpd_set_polyaftertouchhook(Bela_MidiOutPolyAftertouch); | |
libpd_set_midibytehook(Bela_MidiOutByte); | |
//initialize libpd. This clears the search path | |
libpd_init(); | |
//Add the current folder to the search path for externals | |
libpd_add_to_search_path("."); | |
libpd_add_to_search_path("../pd-externals"); | |
libpd_init_audio(gChannelsInUse, gChannelsInUse, context->audioSampleRate); | |
gInBuf = get_sys_soundin(); | |
gOutBuf = get_sys_soundout(); | |
// start DSP: | |
// [; pd dsp 1( | |
libpd_start_message(1); | |
libpd_add_float(1.0f); | |
libpd_finish_message("pd", "dsp"); | |
// Bind your receivers here | |
for(unsigned int i = 0; i < gDigitalChannelsInUse; i++) | |
libpd_bind(gReceiverOutputNames[i].c_str()); | |
libpd_bind("bela_setDigital"); | |
libpd_bind("bela_setMidi"); | |
// open patch: | |
gPatch = libpd_openfile(file, folder); | |
if(gPatch == NULL){ | |
printf("Error: file %s/%s is corrupted.\n", folder, file); | |
return false; | |
} | |
// If the user wants to use the multiplexer capelet, | |
// the patch will have to contain an array called "bela_multiplexer" | |
// and a receiver [r bela_multiplexerChannels] | |
if(context->multiplexerChannels > 0 && libpd_arraysize(multiplexerArray) >= 0){ | |
pdMultiplexerActive = true; | |
multiplexerArraySize = context->multiplexerChannels * context->analogInChannels; | |
// [; bela_multiplexer ` multiplexerArraySize` resize( | |
libpd_start_message(1); | |
libpd_add_float(multiplexerArraySize); | |
libpd_finish_message(multiplexerArray, "resize"); | |
// [; bela_multiplexerChannels `context->multiplexerChannels`( | |
libpd_float("bela_multiplexerChannels", context->multiplexerChannels); | |
} | |
// Tell Pd that we will manage the io loop, | |
// and we do so in an Auxiliary Task | |
#ifdef PD_THREADED_IO | |
sys_dontmanageio(1); | |
AuxiliaryTask fdTask; | |
fdTask = Bela_createAuxiliaryTask(fdLoop, 50, "libpd-fdTask", NULL); | |
Bela_scheduleAuxiliaryTask(fdTask); | |
#endif /* PD_THREADED_IO */ | |
dcm.setVerbose(false); | |
return true; | |
} | |
void render(BelaContext *context, void *userData) | |
{ | |
for(unsigned int n = 0; n<context->digitalFrames; n++){ | |
gTriggerCount++; | |
if(gTriggerCount == gTriggerInterval){ | |
gTriggerCount = 0; | |
digitalWriteOnce(context, n, gTriggerDigitalOutChannel, HIGH); //write the status to the trig pin | |
} else { | |
digitalWriteOnce(context, n, gTriggerDigitalOutChannel, LOW); //write the status to the trig pin | |
} | |
int pulseLength = pulseIn.hasPulsed(context, n); // will return the pulse duration(in samples) if a pulse just ended | |
float duration = 1e6 * pulseLength / context->digitalSampleRate; // pulse duration in microseconds | |
static float distance = 0; | |
if(pulseLength >= gMinPulseLength){ | |
static int count = 0; | |
// rescaling according to the datasheet | |
distance = duration / gRescale; | |
libpd_float("distance1", distance); | |
libpd_bang("foo"); | |
//rt_printf("Sending distance to pd\n"); | |
if(count > 5000){ // we do not want to print the value every time we read it | |
rt_printf("pulseLength: %d, distance: %fcm\n", pulseLength, distance); | |
count -= 5000; | |
} | |
++count; | |
} | |
// Logging to the scope the pulse inputs (gEchoDigitalInPin) and the distance | |
scope.log(digitalRead(context, n, gEchoDigitalInPin), distance/100); | |
} | |
for(unsigned int n = 0; n<context->digitalFrames; n++){ | |
gTriggerCount2++; | |
if(gTriggerCount2 == gTriggerInterval){ | |
gTriggerCount2 = 0; | |
digitalWriteOnce(context, n, gTriggerDigitalOutChannel2, HIGH); //write the status to the trig pin | |
} else { | |
digitalWriteOnce(context, n, gTriggerDigitalOutChannel2, LOW); //write the status to the trig pin | |
} | |
int pulseLength = pulseIn2.hasPulsed(context, n); // will return the pulse duration(in samples) if a pulse just ended | |
float duration = 1e6 * pulseLength / context->digitalSampleRate; // pulse duration in microseconds | |
static float distance2 = 0; | |
if(pulseLength >= gMinPulseLength){ | |
static int count = 0; | |
// rescaling according to the datasheet | |
distance2 = duration / gRescale; | |
libpd_float("distance2", distance2); | |
libpd_bang("foo"); | |
//rt_printf("Sending distance2 to pd\n"); | |
if(count > 5000){ // we do not want to print the value every time we read it | |
rt_printf("pulseLength: %d, distance2: %fcm\n", pulseLength, distance2); | |
count -= 5000; | |
} | |
++count; | |
} | |
// Logging to the scope the pulse2 inputs (gEchoDigitalInPin2) and the distance2 | |
scope.log(digitalRead(context, n, gEchoDigitalInPin2), distance2/100); | |
} | |
int num; | |
#ifdef PARSE_MIDI | |
for(unsigned int port = 0; port < midi.size(); ++port){ | |
while((num = midi[port]->getParser()->numAvailableMessages()) > 0){ | |
static MidiChannelMessage message; | |
message = midi[port]->getParser()->getNextChannelMessage(); | |
rt_printf("On port %d (%s): ", port, gMidiPortNames[port].c_str()); | |
message.prettyPrint(); // use this to print beautified message (channel, data bytes) | |
switch(message.getType()){ | |
case kmmNoteOn: | |
{ | |
int noteNumber = message.getDataByte(0); | |
int velocity = message.getDataByte(1); | |
int channel = message.getChannel(); | |
libpd_noteon(channel + port * 16, noteNumber, velocity); | |
break; | |
} | |
case kmmNoteOff: | |
{ | |
/* PureData does not seem to handle noteoff messages as per the MIDI specs, | |
* so that the noteoff velocity is ignored. Here we convert them to noteon | |
* with a velocity of 0. | |
*/ | |
int noteNumber = message.getDataByte(0); | |
// int velocity = message.getDataByte(1); // would be ignored by Pd | |
int channel = message.getChannel(); | |
libpd_noteon(channel + port * 16, noteNumber, 0); | |
break; | |
} | |
case kmmControlChange: | |
{ | |
int channel = message.getChannel(); | |
int controller = message.getDataByte(0); | |
int value = message.getDataByte(1); | |
libpd_controlchange(channel + port * 16, controller, value); | |
break; | |
} | |
case kmmProgramChange: | |
{ | |
int channel = message.getChannel(); | |
int program = message.getDataByte(0); | |
libpd_programchange(channel + port * 16, program); | |
break; | |
} | |
case kmmPolyphonicKeyPressure: | |
{ | |
int channel = message.getChannel(); | |
int pitch = message.getDataByte(0); | |
int value = message.getDataByte(1); | |
libpd_polyaftertouch(channel + port * 16, pitch, value); | |
break; | |
} | |
case kmmChannelPressure: | |
{ | |
int channel = message.getChannel(); | |
int value = message.getDataByte(0); | |
libpd_aftertouch(channel + port * 16, value); | |
break; | |
} | |
case kmmPitchBend: | |
{ | |
int channel = message.getChannel(); | |
int value = ((message.getDataByte(1) << 7)| message.getDataByte(0)) - 8192; | |
libpd_pitchbend(channel + port * 16, value); | |
break; | |
} | |
case kmmSystem: | |
// currently Bela only handles sysrealtime, and it does so pretending it is a channel message with no data bytes, so we have to re-assemble the status byte | |
{ | |
int channel = message.getChannel(); | |
int status = message.getStatusByte(); | |
int byte = channel | status; | |
libpd_sysrealtime(port, byte); | |
break; | |
} | |
case kmmNone: | |
case kmmAny: | |
break; | |
} | |
} | |
} | |
#else | |
int input; | |
for(unsigned int port = 0; port < NUM_MIDI_PORTS; ++port){ | |
while((input = midi[port].getInput()) >= 0){ | |
libpd_midibyte(port, input); | |
} | |
} | |
#endif /* PARSE_MIDI */ | |
unsigned int numberOfPdBlocksToProcess = context->audioFrames / gLibpdBlockSize; | |
// Remember: we have non-interleaved buffers and the same sampling rate for | |
// analogs, audio and digitals | |
for(unsigned int tick = 0; tick < numberOfPdBlocksToProcess; ++tick) | |
{ | |
//audio input | |
for(int n = 0; n < context->audioInChannels; ++n) | |
{ | |
memcpy( | |
gInBuf + n * gLibpdBlockSize, | |
context->audioIn + tick * gLibpdBlockSize + n * context->audioFrames, | |
sizeof(context->audioIn[0]) * gLibpdBlockSize | |
); | |
} | |
// analog input | |
for(int n = 0; n < context->analogInChannels; ++n) | |
{ | |
memcpy( | |
gInBuf + gLibpdBlockSize * gFirstAnalogInChannel + n * gLibpdBlockSize, | |
context->analogIn + tick * gLibpdBlockSize + n * context->analogFrames, | |
sizeof(context->analogIn[0]) * gLibpdBlockSize | |
); | |
} | |
// multiplexed analog input | |
if(pdMultiplexerActive) | |
{ | |
// we do not disable regular analog inputs if muxer is active, because user may have bridged them on the board and | |
// they may be using half of them at a high sampling-rate | |
static int lastMuxerUpdate = 0; | |
if(++lastMuxerUpdate == multiplexerArraySize){ | |
lastMuxerUpdate = 0; | |
libpd_write_array(multiplexerArray, 0, (float *const)context->multiplexerAnalogIn, multiplexerArraySize); | |
} | |
} | |
unsigned int digitalFrameBase = gLibpdBlockSize * tick; | |
unsigned int j; | |
unsigned int k; | |
float* p0; | |
float* p1; | |
// digital input | |
if(gDigitalEnabled) | |
{ | |
// digital in at message-rate | |
dcm.processInput(&context->digital[digitalFrameBase], gLibpdBlockSize); | |
// digital in at signal-rate | |
for (j = 0, p0 = gInBuf; j < gLibpdBlockSize; j++, p0++) { | |
unsigned int digitalFrame = digitalFrameBase + j; | |
for (k = 0, p1 = p0 + gLibpdBlockSize * gFirstDigitalChannel; | |
k < 16; ++k, p1 += gLibpdBlockSize) { | |
if(dcm.isSignalRate(k) && dcm.isInput(k)){ // only process input channels that are handled at signal rate | |
*p1 = digitalRead(context, digitalFrame, k); | |
} | |
} | |
} | |
} | |
libpd_process_sys(); // process the block | |
// digital outputs | |
if(gDigitalEnabled) | |
{ | |
// digital out at signal-rate | |
for (j = 0, p0 = gOutBuf; j < gLibpdBlockSize; ++j, ++p0) { | |
unsigned int digitalFrame = (digitalFrameBase + j); | |
for (k = 0, p1 = p0 + gLibpdBlockSize * gFirstDigitalChannel; | |
k < context->digitalChannels; k++, p1 += gLibpdBlockSize) | |
{ | |
if(dcm.isSignalRate(k) && dcm.isOutput(k)){ // only process output channels that are handled at signal rate | |
digitalWriteOnce(context, digitalFrame, k, *p1 > 0.5); | |
} | |
} | |
} | |
// digital out at message-rate | |
dcm.processOutput(&context->digital[digitalFrameBase], gLibpdBlockSize); | |
} | |
// audio output | |
for(int n = 0; n < context->audioOutChannels; ++n) | |
{ | |
memcpy( | |
context->audioOut + tick * gLibpdBlockSize + n * context->audioFrames, | |
gOutBuf + n * gLibpdBlockSize, | |
sizeof(context->audioOut[0]) * gLibpdBlockSize | |
); | |
} | |
//analog output | |
for(int n = 0; n < context->analogOutChannels; ++n) | |
{ | |
memcpy( | |
context->analogOut + tick * gLibpdBlockSize + n * context->analogFrames, | |
gOutBuf + gLibpdBlockSize * gFirstAnalogOutChannel + n * gLibpdBlockSize, | |
sizeof(context->analogOut[0]) * gLibpdBlockSize | |
); | |
} | |
} | |
} | |
void cleanup(BelaContext *context, void *userData) | |
{ | |
for(auto a : midi) | |
{ | |
delete a; | |
} | |
libpd_closefile(gPatch); | |
delete [] gScopeOut; | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment