void MessageSwap::processMessage(int inletIndex, PdMessage *message) {
switch (inletIndex) {
case 0: {
MessageElement *messageElement = message->getElement(0);
switch (messageElement->getType()) {
case FLOAT: {
left = messageElement->getFloat();
PdMessage *outgoingMessageRight = getNextOutgoingMessage(0);
outgoingMessageRight->getElement(0)->setFloat(left);
outgoingMessageRight->setTimestamp(message->getTimestamp());
sendMessage(1, outgoingMessageRight); // send a message from outlet 1
PdMessage *outgoingMessageLeft = getNextOutgoingMessage(1);
outgoingMessageLeft->getElement(0)->setFloat(right);
outgoingMessageLeft->setTimestamp(message->getTimestamp());
sendMessage(0, outgoingMessageLeft); // send a message from outlet 0
break;
}
case BANG: {
PdMessage *outgoingMessageRight = getNextOutgoingMessage(0);
outgoingMessageRight->getElement(0)->setFloat(left);
outgoingMessageRight->setTimestamp(message->getTimestamp());
sendMessage(0, outgoingMessageRight); // send a message from outlet 1
PdMessage *outgoingMessageLeft = getNextOutgoingMessage(1);
outgoingMessageLeft->getElement(0)->setFloat(right);
outgoingMessageLeft->setTimestamp(message->getTimestamp());
sendMessage(1, outgoingMessageLeft); // send a message from outlet 0
break;
}
default: {
break;
}
}
break;
}
case 1: {
MessageElement *messageElement = message->getElement(0);
if (messageElement->getType() == FLOAT) {
right = messageElement->getFloat();
}
break;
}
default: {
break;
}
}
}
void MessagePipe::processMessage(int inletIndex, PdMessage *message) {
switch (inletIndex) {
case 0: {
MessageElement *messageElement = message->getElement(0);
switch (messageElement->getType()) {
case SYMBOL: {
if (strcmp(messageElement->getSymbol(), "flush") == 0) {
// TODO(mhroth): output all stored messages immediately
break;
} else if (strcmp(messageElement->getSymbol(), "clear") == 0) {
// TODO(mhroth): forget all stored messages
break;
}
// allow fall-through
}
case FLOAT:
case BANG: {
message->setTimestamp(message->getTimestamp() + delayMs);
graph->scheduleMessage(this, 0, message);
break;
}
default: {
break;
}
}
}
default: {
break;
}
}
}
void MessageLine::processMessage(int inletIndex, PdMessage *message) {
switch (inletIndex) {
case 0: {
MessageElement *messageElement = message->getElement(0);
switch (messageElement->getType()) {
case FLOAT: {
MessageElement *messageElement1 = message->getElement(1);
if (messageElement1 != NULL && messageElement1->getType() == FLOAT) {
// start a new line
processDspToIndex(message->getBlockIndex());
float delayInMs = StaticUtils::millisecondsToSamples(
messageElement1->getFloat(), sampleRate);
samplesToTarget = lrintf(delayInMs);
target = messageElement->getFloat();
slope = (target - lastValue) / delayInMs;
} else {
// set the current value
processDspToIndex(message->getBlockIndex());
target = messageElement->getFloat();
lastValue = target;
slope = 0.0f;
samplesToTarget = -1;
}
PdMessage *outgoingMessage = getNextOutgoingMessage(0);
outgoingMessage->getElement(0)->setFloat(lastValue);
outgoingMessage->setBlockIndex(message->getBlockIndex());
break;
}
case SYMBOL: {
MessageElement *messageElement = message->getElement(0);
if (strcmp(messageElement->getSymbol(), "stop") == 0) {
processDspToIndex(message->getBlockIndex());
samplesToTarget = -1;
} else if (strcmp(messageElement->getSymbol(), "set") == 0) {
MessageElement *messageElement1 = message->getElement(0);
if (messageElement1 != NULL && messageElement1->getType() == FLOAT) {
processDspToIndex(message->getBlockIndex());
target = messageElement1->getFloat();
lastValue = target;
samplesToTarget = -1;
}
}
break;
}
default: {
break;
}
}
break;
}
case 1: {
// not sure what to do in this case
break;
}
default: {
break;
}
}
}
inline void DspSig::processMessage(int inletIndex, PdMessage *message) {
if (inletIndex == 0) {
MessageElement *messageElement = message->getElement(0);
if (messageElement != NULL && messageElement->getType() == FLOAT) {
processDspToIndex(message->getBlockIndex());
constWasReset = constant != messageElement->getFloat();
constant = messageElement->getFloat();
}
}
}
inline void MessageAbsoluteValue::processMessage(int inletIndex, PdMessage *message) {
if (inletIndex == 0) {
MessageElement *messageElement = message->getElement(0);
if (messageElement != NULL && messageElement->getType() == FLOAT) {
PdMessage *outgoingMessage = getNextOutgoingMessage(0);
outgoingMessage->setBlockIndex(message->getBlockIndex());
outgoingMessage->getElement(0)->setFloat(fabsf(messageElement->getFloat()));
}
}
}
void MessageUnaryOperationObject::processMessage(int inletIndex, PdMessage *message) {
if (inletIndex == 0) {
// TODO(mhroth): do we need to be able to handle a list of numbers?
MessageElement *messageElement = message->getElement(0);
if (messageElement->getType() == FLOAT) {
PdMessage *outgoingMessage = getNextOutgoingMessage(0);
outgoingMessage->setBlockIndex(message->getBlockIndex());
outgoingMessage->getElement(0)->setFloat(performUnaryOperation(messageElement->getFloat()));
}
}
}
void MessageArcTangent::processMessage(int inletIndex, PdMessage *message) {
if (inletIndex == 0) {
MessageElement *messageElement = message->getElement(0);
if (messageElement->getType() == FLOAT) {
PdMessage *outgoingMessage = getNextOutgoingMessage(0);
outgoingMessage->getElement(0)->setFloat(atanf(messageElement->getFloat()));
outgoingMessage->setTimestamp(message->getTimestamp());
sendMessage(0, outgoingMessage); // send a message from outlet 0
}
}
}
inline void MessagePack::processMessage(int inletIndex, PdMessage *message) {
MessageElement *messageElement = message->getElement(0);
MessageElement *outgoingMessageElement = (MessageElement *) messageElementList->get(inletIndex);
switch (outgoingMessageElement->getType()) {
case FLOAT: {
outgoingMessageElement->setFloat(messageElement->getFloat());
break;
}
case SYMBOL: {
outgoingMessageElement->setSymbol(messageElement->getSymbol());
break;
}
default: {
break;
}
}
if (inletIndex == 0) {
PdMessage *outgoingMessage = getNextOutgoingMessage(0);
outgoingMessage->setBlockIndex(message->getBlockIndex());
for (int i = 0; i < messageElementList->getNumElements(); i++) {
messageElement = (MessageElement *) messageElementList->get(i);
switch (messageElement->getType()) {
case FLOAT: {
outgoingMessage->getElement(i)->setFloat(messageElement->getFloat());
break;
}
case SYMBOL: {
outgoingMessage->getElement(i)->setSymbol(messageElement->getSymbol());
break;
}
default: {
break;
}
}
}
}
}
void MessageSubtract::processMessage(int inletIndex, PdMessage *message) {
switch (inletIndex) {
case 0: {
MessageElement *messageElement = message->getElement(0);
if (messageElement->getType() == FLOAT) {
PdMessage *outgoingMessage = getNextOutgoingMessage(0);
outgoingMessage->getElement(0)->setFloat(messageElement->getFloat() - constant);
outgoingMessage->setTimestamp(message->getTimestamp());
sendMessage(0, outgoingMessage); // send a message from outlet 0
}
break;
}
case 1: {
MessageElement *messageElement = message->getElement(0);
if (messageElement->getType() == FLOAT) {
constant = messageElement->getFloat();
}
break;
}
default: {
break;
}
}
}
MessagePack::MessagePack(List *messageElementList, char *initString) :
MessageInputMessageOutputObject(messageElementList->getNumElements(), 1, initString) {
this->messageElementList = messageElementList;
for (int i = 0; i < messageElementList->getNumElements(); i++) {
MessageElement *messageElement = (MessageElement *) messageElementList->get(i);
if (messageElement->getType() == SYMBOL) {
if (StaticUtils::isNumeric(messageElement->getSymbol())) {
float constant = (float) atof(messageElement->getSymbol());
messageElement->setFloat(constant);
} else if (strcmp(messageElement->getSymbol(), "float") == 0 ||
strcmp(messageElement->getSymbol(), "f") == 0) {
messageElement->setFloat(0.0f);
} else if (strcmp(messageElement->getSymbol(), "bang") == 0 ||
strcmp(messageElement->getSymbol(), "b") == 0) {
messageElement->setBang();
}
}
}
}
void DspPhasor::processMessage(int inletIndex, PdMessage *message) {
switch (inletIndex) {
case 0: { // update the frequency
MessageElement *messageElement = message->getElement(0);
if (messageElement->getType() == FLOAT) {
processDspToIndex(message->getBlockIndex(graph->getBlockStartTimestamp(), graph->getSampleRate()));
frequency = messageElement->getFloat();
}
break;
}
case 1: { // update the phase
// TODO(mhroth)
break;
}
default: {
break;
}
}
}
inline void MessageFloat::processMessage(int inletIndex, PdMessage *message) {
if (inletIndex == 0) {
MessageElement *messageElement = message->getElement(0);
switch (messageElement->getType()) {
case FLOAT: {
constant = messageElement->getFloat();
// allow fallthrough
}
case BANG: {
PdMessage *outgoingMessage = getNextOutgoingMessage(0);
outgoingMessage->getElement(0)->setFloat(constant);
outgoingMessage->setBlockIndex(message->getBlockIndex());
break;
}
default: {
break;
}
}
}
}
inline void DspLine::processMessage(int inletIndex, PdMessage *message) {
if (inletIndex == 0) { // not sure what the right inlet is for
switch (message->getNumElements()) {
case 0: {
break; // nothing to do
}
case 1: {
// jump to value
MessageElement *messageElement = message->getElement(0);
if (messageElement->getType() == FLOAT) {
processDspToIndex(message->getBlockIndex());
blockIndexOfLastMessage = message->getBlockIndex();
target = messageElement->getFloat();
lastOutputSample = target;
slope = 0.0f;
numSamplesToTarget = 0;
}
break;
}
default: { // at least two inputs
// new ramp
MessageElement *messageElement0 = message->getElement(0);
MessageElement *messageElement1 = message->getElement(1);
if (messageElement0 != NULL && messageElement0->getType() == FLOAT &&
messageElement1 != NULL && messageElement1->getType() == FLOAT) {
processDspToIndex(message->getBlockIndex());
blockIndexOfLastMessage = message->getBlockIndex();
target = messageElement0->getFloat();
float timeToTargetMs = messageElement1->getFloat(); // no negative time to targets!
float fractionalSamplesToTarget = StaticUtils::millisecondsToSamples(
(timeToTargetMs < 1.0f) ? 1.0f : timeToTargetMs, sampleRate);
slope = (target - lastOutputSample) / fractionalSamplesToTarget;
numSamplesToTarget = (int) fractionalSamplesToTarget;
}
break;
}
}
}
}
void MessageTimer::processMessage(int inletIndex, PdMessage *message) {
switch (inletIndex) {
case 0: {
MessageElement *messageElement = message->getElement(0);
if (messageElement->getType() == BANG) {
processDspToIndex(message->getBlockIndex());
elapsedSamples = 0.0f;
}
break;
}
case 1: {
// return the elapsed number milliseconds
processDspToIndex(message->getBlockIndex());
PdMessage *outgoingMessage = getNextOutgoingMessage(0);
outgoingMessage->getElement(0)->setFloat(1000.0f * elapsedSamples / sampleRate);
outgoingMessage->setBlockIndexAsFloat(message->getBlockIndexAsFloat());
break;
}
default: {
break;
}
}
}
void MessageSoundfiler::processMessage(int inletIndex, PdMessage *message) {
if (message->isSymbol(0) && strcmp(message->getSymbol(0), "read") == 0) {
int currentElementIndex = 1;
bool shouldResizeTable = false;
while (currentElementIndex < message->getNumElements()) {
MessageElement *messageElement = message->getElement(currentElementIndex++);
if (messageElement->getType() == SYMBOL) {
// only the -resize flag is supported for now
if (strcmp(messageElement->getSymbol(), "-resize") == 0) {
shouldResizeTable = true;
} else {
// all of the flags should have been seen now and now we expect the last two parameters,
// which are file location and destination table name
MessageElement *tableNameElement = message->getElement(currentElementIndex++);
if (messageElement != NULL && messageElement->getType() == SYMBOL &&
tableNameElement != NULL && tableNameElement->getType() == SYMBOL) {
MessageTable *table = graph->getTable(tableNameElement->getSymbol());
if (table != NULL) {
// use libsndfile to load and read the file (also converting the samples to [-1,1] float)
SF_INFO sfInfo;
char *fullPath = graph->resolveFullPath(messageElement->getSymbol());
SNDFILE *sndFile = sf_open(fullPath, SFM_READ, &sfInfo);
if (sndFile == NULL) {
graph->printErr("soundfiler can't open %s.", fullPath);
free(fullPath);
return; // there was an error reading the file. Move on with life.
}
free(fullPath);
// It is assumed that the channels are interleaved.
int samplesPerChannel = sfInfo.frames;
int bufferLength = samplesPerChannel * sfInfo.channels;
// create a buffer in memory for the file data
float *buffer = (float *) malloc(bufferLength * sizeof(float));
sf_read_float(sndFile, buffer, bufferLength); // read the whole file into memory
sf_close(sndFile); // release the handle to the file
if (sfInfo.channels > 0) { // sanity check
// get the table's buffer. Resize the buffer if necessary.
int tableLength = samplesPerChannel;
float *tableBuffer = shouldResizeTable ? table->resizeBuffer(samplesPerChannel) :
table->getBuffer(&tableLength);
if (tableLength > samplesPerChannel) {
// avoid trying to read more into the table buffer than is available
tableLength = samplesPerChannel;
}
// extract the first channel
for (int i = 0, j = 0; i < bufferLength; i+=sfInfo.channels, j++) {
tableBuffer[j] = buffer[i];
}
// extract the second channel (if it exists and if there is a table to write it to)
if (sfInfo.channels > 1 &&
(tableNameElement = message->getElement(currentElementIndex++)) != NULL &&
tableNameElement->getType() == SYMBOL &&
(table = graph->getTable(tableNameElement->getSymbol())) != NULL) {
tableLength = samplesPerChannel;
tableBuffer = shouldResizeTable ? table->resizeBuffer(samplesPerChannel) :
table->getBuffer(&tableLength);
if (tableLength > samplesPerChannel) {
// avoid trying to read more into the table buffer than is available
tableLength = samplesPerChannel;
}
for (int i = 1, j = 0; i < bufferLength; i+=sfInfo.channels, j++) {
tableBuffer[j] = buffer[i];
}
}
}
free(buffer);
// send message with sample length when all tables have been filled
PdMessage *outgoingMessage = getNextOutgoingMessage(0);
outgoingMessage->setFloat(0, (float) samplesPerChannel);
outgoingMessage->setTimestamp(message->getTimestamp());
sendMessage(0, outgoingMessage);
}
}
}
}
}
} else if (message->isSymbol(0) && strcmp(message->getSymbol(0), "write") == 0) {
// TODO(mhroth): not supported yet
graph->printErr("The \"write\" command to soundfiler is not supported.");
}
}
